diff --git a/codegen/preprocessor/preprocessor_schema_generated.h b/codegen/preprocessor/preprocessor_schema_generated.h index e59ea9067ce..c483dd5db53 100644 --- a/codegen/preprocessor/preprocessor_schema_generated.h +++ b/codegen/preprocessor/preprocessor_schema_generated.h @@ -8,9 +8,9 @@ // Ensure the included flatbuffers.h is the same version as when this file was // generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 2 && - FLATBUFFERS_VERSION_MINOR == 0 && - FLATBUFFERS_VERSION_REVISION == 6, +static_assert(FLATBUFFERS_VERSION_MAJOR == 23 && + FLATBUFFERS_VERSION_MINOR == 5 && + FLATBUFFERS_VERSION_REVISION == 26, "Non-compatible flatbuffers version included"); namespace tflm { @@ -21,59 +21,59 @@ struct Data; struct DataBuilder; struct DataT; -struct DataT : public flatbuffers::NativeTable { +struct DataT : public ::flatbuffers::NativeTable { typedef Data TableType; std::string input_model_path{}; }; -struct Data FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Data FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DataT NativeTableType; typedef DataBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT_MODEL_PATH = 4 }; - const flatbuffers::String *input_model_path() const { - return GetPointer(VT_INPUT_MODEL_PATH); + const ::flatbuffers::String *input_model_path() const { + return GetPointer(VT_INPUT_MODEL_PATH); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_INPUT_MODEL_PATH) && verifier.VerifyString(input_model_path()) && verifier.EndTable(); } - DataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DataT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DataT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct DataBuilder { typedef Data Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_input_model_path(flatbuffers::Offset input_model_path) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_input_model_path(::flatbuffers::Offset<::flatbuffers::String> input_model_path) { fbb_.AddOffset(Data::VT_INPUT_MODEL_PATH, input_model_path); } - explicit DataBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit DataBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateData( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset input_model_path = 0) { +inline ::flatbuffers::Offset CreateData( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::String> input_model_path = 0) { DataBuilder builder_(_fbb); builder_.add_input_model_path(input_model_path); return builder_.Finish(); } -inline flatbuffers::Offset CreateDataDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateDataDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const char *input_model_path = nullptr) { auto input_model_path__ = input_model_path ? _fbb.CreateString(input_model_path) : 0; return tflm::codegen::preprocessor::CreateData( @@ -81,28 +81,28 @@ inline flatbuffers::Offset CreateDataDirect( input_model_path__); } -flatbuffers::Offset CreateData(flatbuffers::FlatBufferBuilder &_fbb, const DataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateData(::flatbuffers::FlatBufferBuilder &_fbb, const DataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -inline DataT *Data::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DataT *Data::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DataT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Data::UnPackTo(DataT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Data::UnPackTo(DataT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = input_model_path(); if (_e) _o->input_model_path = _e->str(); } } -inline flatbuffers::Offset Data::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DataT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Data::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateData(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateData(flatbuffers::FlatBufferBuilder &_fbb, const DataT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateData(::flatbuffers::FlatBufferBuilder &_fbb, const DataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DataT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _input_model_path = _o->input_model_path.empty() ? 0 : _fbb.CreateString(_o->input_model_path); return tflm::codegen::preprocessor::CreateData( _fbb, @@ -110,44 +110,44 @@ inline flatbuffers::Offset CreateData(flatbuffers::FlatBufferBuilder &_fbb } inline const tflm::codegen::preprocessor::Data *GetData(const void *buf) { - return flatbuffers::GetRoot(buf); + return ::flatbuffers::GetRoot(buf); } inline const tflm::codegen::preprocessor::Data *GetSizePrefixedData(const void *buf) { - return flatbuffers::GetSizePrefixedRoot(buf); + return ::flatbuffers::GetSizePrefixedRoot(buf); } inline bool VerifyDataBuffer( - flatbuffers::Verifier &verifier) { + ::flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer(nullptr); } inline bool VerifySizePrefixedDataBuffer( - flatbuffers::Verifier &verifier) { + ::flatbuffers::Verifier &verifier) { return verifier.VerifySizePrefixedBuffer(nullptr); } inline void FinishDataBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + ::flatbuffers::FlatBufferBuilder &fbb, + ::flatbuffers::Offset root) { fbb.Finish(root); } inline void FinishSizePrefixedDataBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + ::flatbuffers::FlatBufferBuilder &fbb, + ::flatbuffers::Offset root) { fbb.FinishSizePrefixed(root); } inline std::unique_ptr UnPackData( const void *buf, - const flatbuffers::resolver_function_t *res = nullptr) { + const ::flatbuffers::resolver_function_t *res = nullptr) { return std::unique_ptr(GetData(buf)->UnPack(res)); } inline std::unique_ptr UnPackSizePrefixedData( const void *buf, - const flatbuffers::resolver_function_t *res = nullptr) { + const ::flatbuffers::resolver_function_t *res = nullptr) { return std::unique_ptr(GetSizePrefixedData(buf)->UnPack(res)); } diff --git a/codegen/preprocessor/preprocessor_schema_py_generated.py b/codegen/preprocessor/preprocessor_schema_py_generated.py index e484f26bcc3..2394bbf53be 100644 --- a/codegen/preprocessor/preprocessor_schema_py_generated.py +++ b/codegen/preprocessor/preprocessor_schema_py_generated.py @@ -32,15 +32,16 @@ def InputModelPath(self): return self._tab.String(o + self._tab.Pos) return None -def DataStart(builder): builder.StartObject(1) -def Start(builder): - return DataStart(builder) -def DataAddInputModelPath(builder, inputModelPath): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(inputModelPath), 0) -def AddInputModelPath(builder, inputModelPath): - return DataAddInputModelPath(builder, inputModelPath) -def DataEnd(builder): return builder.EndObject() -def End(builder): - return DataEnd(builder) +def DataStart(builder): + builder.StartObject(1) + +def DataAddInputModelPath(builder, inputModelPath): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(inputModelPath), 0) + +def DataEnd(builder): + return builder.EndObject() + + class DataT(object): @@ -54,6 +55,11 @@ def InitFromBuf(cls, buf, pos): data.Init(buf, pos) return cls.InitFromObj(data) + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + @classmethod def InitFromObj(cls, data): x = DataT() @@ -75,3 +81,5 @@ def Pack(self, builder): DataAddInputModelPath(builder, inputModelPath) data = DataEnd(builder) return data + + diff --git a/tensorflow/lite/micro/tools/make/Makefile b/tensorflow/lite/micro/tools/make/Makefile index beffcec9453..6fb4fd0081f 100644 --- a/tensorflow/lite/micro/tools/make/Makefile +++ b/tensorflow/lite/micro/tools/make/Makefile @@ -522,20 +522,31 @@ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/array.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/base.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/buffer.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/buffer_ref.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/code_generator.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/code_generators.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/default_allocator.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/detached_buffer.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/file_manager.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/flatbuffer_builder.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/flatbuffers.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/flex_flat_util.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/flexbuffers.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/grpc.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/hash.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/idl.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/minireflect.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/reflection.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/reflection_generated.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/registry.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/stl_emulation.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/string.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/struct.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/table.h \ +$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/util.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/vector.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/vector_downward.h \ $(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/verifier.h \ -$(DOWNLOADS_DIR)/flatbuffers/include/flatbuffers/util.h \ -$(DOWNLOADS_DIR)/flatbuffers/LICENSE.txt \ +$(DOWNLOADS_DIR)/flatbuffers/LICENSE \ $(DOWNLOADS_DIR)/gemmlowp/fixedpoint/fixedpoint.h \ $(DOWNLOADS_DIR)/gemmlowp/fixedpoint/fixedpoint_neon.h \ $(DOWNLOADS_DIR)/gemmlowp/fixedpoint/fixedpoint_sse.h \ diff --git a/tensorflow/lite/micro/tools/make/flatbuffers.patch b/tensorflow/lite/micro/tools/make/flatbuffers.patch index cb22cf0b1af..2017775aaca 100644 --- a/tensorflow/lite/micro/tools/make/flatbuffers.patch +++ b/tensorflow/lite/micro/tools/make/flatbuffers.patch @@ -1,5 +1,5 @@ diff --git a/include/flatbuffers/base.h b/include/flatbuffers/base.h -index a5ac10d..371b6fd 100644 +index 5c4cae79..1a631641 100644 --- a/include/flatbuffers/base.h +++ b/include/flatbuffers/base.h @@ -1,6 +1,16 @@ @@ -20,10 +20,10 @@ index a5ac10d..371b6fd 100644 // If activate should be declared and included first. diff --git a/include/flatbuffers/default_allocator.h b/include/flatbuffers/default_allocator.h -index 8b173af..975d938 100644 +index d4724122..975d9380 100644 --- a/include/flatbuffers/default_allocator.h +++ b/include/flatbuffers/default_allocator.h -@@ -39,26 +39,20 @@ class DefaultAllocator : public Allocator { +@@ -39,24 +39,18 @@ class DefaultAllocator : public Allocator { // This is to avoid having a statically or dynamically allocated default // allocator, or having to move it between the classes that may own it. inline uint8_t *Allocate(Allocator *allocator, size_t size) { @@ -52,15 +52,11 @@ index 8b173af..975d938 100644 } } // namespace flatbuffers - --#endif // FLATBUFFERS_DEFAULT_ALLOCATOR_H_ -\ No newline at end of file -+#endif // FLATBUFFERS_DEFAULT_ALLOCATOR_H_ diff --git a/include/flatbuffers/flexbuffers.h b/include/flatbuffers/flexbuffers.h -index 89f3f30..6e6d0b3 100644 +index 8e8cac14..52dae316 100644 --- a/include/flatbuffers/flexbuffers.h +++ b/include/flatbuffers/flexbuffers.h -@@ -496,9 +496,24 @@ class Reference { +@@ -495,9 +495,24 @@ class Reference { return static_cast(ReadUInt64(Indirect(), byte_width_)); case FBT_NULL: return 0.0; case FBT_STRING: { @@ -86,10 +82,10 @@ index 89f3f30..6e6d0b3 100644 case FBT_VECTOR: return static_cast(AsVector().size()); case FBT_BOOL: diff --git a/include/flatbuffers/util.h b/include/flatbuffers/util.h -index 93a39de..1cd4e8f 100644 +index 1ccf3517..34a75193 100644 --- a/include/flatbuffers/util.h +++ b/include/flatbuffers/util.h -@@ -24,6 +24,12 @@ +@@ -23,6 +23,12 @@ #include "flatbuffers/base.h" #include "flatbuffers/stl_emulation.h" @@ -102,4 +98,3 @@ index 93a39de..1cd4e8f 100644 #ifndef FLATBUFFERS_PREFER_PRINTF # include # include - \ No newline at end of file diff --git a/tensorflow/lite/micro/tools/make/flatbuffers_download.sh b/tensorflow/lite/micro/tools/make/flatbuffers_download.sh index af5e80f6f88..52accccd243 100755 --- a/tensorflow/lite/micro/tools/make/flatbuffers_download.sh +++ b/tensorflow/lite/micro/tools/make/flatbuffers_download.sh @@ -54,9 +54,9 @@ DOWNLOADED_FLATBUFFERS_PATH=${DOWNLOADS_DIR}/flatbuffers if [ -d ${DOWNLOADED_FLATBUFFERS_PATH} ]; then echo >&2 "${DOWNLOADED_FLATBUFFERS_PATH} already exists, skipping the download." else - ZIP_PREFIX="a66de58af9565586832c276fbb4251fc416bf07f" + ZIP_PREFIX="v23.5.26" FLATBUFFERS_URL="https://github.com/google/flatbuffers/archive/${ZIP_PREFIX}.zip" - FLATBUFFERS_MD5="51a7a96747e1c33eb4aac6d52513a02f" + FLATBUFFERS_MD5="e87e8acd8e2d53653387ad78720316e2" TEMPDIR="$(mktemp -d)" TEMPFILE="${TEMPDIR}/${ZIP_PREFIX}.zip" @@ -64,7 +64,7 @@ else check_md5 "${TEMPFILE}" ${FLATBUFFERS_MD5} unzip -qo "$TEMPFILE" -d "${TEMPDIR}" >&2 - mv "${TEMPDIR}/flatbuffers-${ZIP_PREFIX}" ${DOWNLOADED_FLATBUFFERS_PATH} + mv "${TEMPDIR}/flatbuffers-${ZIP_PREFIX#v}" ${DOWNLOADED_FLATBUFFERS_PATH} rm -rf "${TEMPDIR}" pushd ${DOWNLOADED_FLATBUFFERS_PATH} > /dev/null diff --git a/tensorflow/lite/python/schema_py_generated.py b/tensorflow/lite/python/schema_py_generated.py index 87d2b87986a..994ab39d7ab 100755 --- a/tensorflow/lite/python/schema_py_generated.py +++ b/tensorflow/lite/python/schema_py_generated.py @@ -7,1726 +7,401 @@ from flatbuffers.compat import import_numpy np = import_numpy() -class ATan2Options(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ATan2Options() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsATan2Options(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def ATan2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # ATan2Options - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def ATan2OptionsStart(builder): builder.StartObject(0) -def Start(builder): - return ATan2OptionsStart(builder) -def ATan2OptionsEnd(builder): return builder.EndObject() -def End(builder): - return ATan2OptionsEnd(builder) - -class ATan2OptionsT(object): - - # ATan2OptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - atan2options = ATan2Options() - atan2options.Init(buf, pos) - return cls.InitFromObj(atan2options) - - @classmethod - def InitFromObj(cls, atan2options): - x = ATan2OptionsT() - x._UnPack(atan2options) - return x - - # ATan2OptionsT - def _UnPack(self, atan2options): - if atan2options is None: - return - - # ATan2OptionsT - def Pack(self, builder): - ATan2OptionsStart(builder) - atan2options = ATan2OptionsEnd(builder) - return atan2options -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class AbsOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = AbsOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsAbsOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def AbsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # AbsOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def AbsOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return AbsOptionsStart(builder) -def AbsOptionsEnd(builder): return builder.EndObject() -def End(builder): - return AbsOptionsEnd(builder) - -class AbsOptionsT(object): - - # AbsOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - absOptions = AbsOptions() - absOptions.Init(buf, pos) - return cls.InitFromObj(absOptions) - - @classmethod - def InitFromObj(cls, absOptions): - x = AbsOptionsT() - x._UnPack(absOptions) - return x - - # AbsOptionsT - def _UnPack(self, absOptions): - if absOptions is None: - return - - # AbsOptionsT - def Pack(self, builder): - AbsOptionsStart(builder) - absOptions = AbsOptionsEnd(builder) - return absOptions -# automatically generated by the FlatBuffers compiler, do not modify +class TensorType(object): + FLOAT32 = 0 + FLOAT16 = 1 + INT32 = 2 + UINT8 = 3 + INT64 = 4 + STRING = 5 + BOOL = 6 + INT16 = 7 + COMPLEX64 = 8 + INT8 = 9 + FLOAT64 = 10 + COMPLEX128 = 11 + UINT64 = 12 + RESOURCE = 13 + VARIANT = 14 + UINT32 = 15 + UINT16 = 16 + INT4 = 17 -# namespace: tflite -class ActivationFunctionType(object): +class QuantizationDetails(object): NONE = 0 - RELU = 1 - RELU_N1_TO_1 = 2 - RELU6 = 3 - TANH = 4 - SIGN_BIT = 5 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class AddNOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = AddNOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsAddNOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def AddNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # AddNOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def AddNOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return AddNOptionsStart(builder) -def AddNOptionsEnd(builder): return builder.EndObject() -def End(builder): - return AddNOptionsEnd(builder) - -class AddNOptionsT(object): - - # AddNOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - addNoptions = AddNOptions() - addNoptions.Init(buf, pos) - return cls.InitFromObj(addNoptions) - - @classmethod - def InitFromObj(cls, addNoptions): - x = AddNOptionsT() - x._UnPack(addNoptions) - return x - - # AddNOptionsT - def _UnPack(self, addNoptions): - if addNoptions is None: - return - - # AddNOptionsT - def Pack(self, builder): - AddNOptionsStart(builder) - addNoptions = AddNOptionsEnd(builder) - return addNoptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class AddOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = AddOptions() - x.Init(buf, n + offset) - return x + CustomQuantization = 1 - @classmethod - def GetRootAsAddOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def AddOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def QuantizationDetailsCreator(unionType, table): + from flatbuffers.table import Table + if not isinstance(table, Table): + return None + if unionType == QuantizationDetails().CustomQuantization: + return CustomQuantizationT.InitFromBuf(table.Bytes, table.Pos) + return None - # AddOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - # AddOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +class DimensionType(object): + DENSE = 0 + SPARSE_CSR = 1 - # AddOptions - def PotScaleInt16(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return True -def AddOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return AddOptionsStart(builder) -def AddOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return AddOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def AddOptionsAddPotScaleInt16(builder, potScaleInt16): builder.PrependBoolSlot(1, potScaleInt16, 1) -def AddPotScaleInt16(builder, potScaleInt16): - return AddOptionsAddPotScaleInt16(builder, potScaleInt16) -def AddOptionsEnd(builder): return builder.EndObject() -def End(builder): - return AddOptionsEnd(builder) +class SparseIndexVector(object): + NONE = 0 + Int32Vector = 1 + Uint16Vector = 2 + Uint8Vector = 3 -class AddOptionsT(object): +def SparseIndexVectorCreator(unionType, table): + from flatbuffers.table import Table + if not isinstance(table, Table): + return None + if unionType == SparseIndexVector().Int32Vector: + return Int32VectorT.InitFromBuf(table.Bytes, table.Pos) + if unionType == SparseIndexVector().Uint16Vector: + return Uint16VectorT.InitFromBuf(table.Bytes, table.Pos) + if unionType == SparseIndexVector().Uint8Vector: + return Uint8VectorT.InitFromBuf(table.Bytes, table.Pos) + return None - # AddOptionsT - def __init__(self): - self.fusedActivationFunction = 0 # type: int - self.potScaleInt16 = True # type: bool - @classmethod - def InitFromBuf(cls, buf, pos): - addOptions = AddOptions() - addOptions.Init(buf, pos) - return cls.InitFromObj(addOptions) - - @classmethod - def InitFromObj(cls, addOptions): - x = AddOptionsT() - x._UnPack(addOptions) - return x - - # AddOptionsT - def _UnPack(self, addOptions): - if addOptions is None: - return - self.fusedActivationFunction = addOptions.FusedActivationFunction() - self.potScaleInt16 = addOptions.PotScaleInt16() - - # AddOptionsT - def Pack(self, builder): - AddOptionsStart(builder) - AddOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - AddOptionsAddPotScaleInt16(builder, self.potScaleInt16) - addOptions = AddOptionsEnd(builder) - return addOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class ArgMaxOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ArgMaxOptions() - x.Init(buf, n + offset) - return x +class BuiltinOperator(object): + ADD = 0 + AVERAGE_POOL_2D = 1 + CONCATENATION = 2 + CONV_2D = 3 + DEPTHWISE_CONV_2D = 4 + DEPTH_TO_SPACE = 5 + DEQUANTIZE = 6 + EMBEDDING_LOOKUP = 7 + FLOOR = 8 + FULLY_CONNECTED = 9 + HASHTABLE_LOOKUP = 10 + L2_NORMALIZATION = 11 + L2_POOL_2D = 12 + LOCAL_RESPONSE_NORMALIZATION = 13 + LOGISTIC = 14 + LSH_PROJECTION = 15 + LSTM = 16 + MAX_POOL_2D = 17 + MUL = 18 + RELU = 19 + RELU_N1_TO_1 = 20 + RELU6 = 21 + RESHAPE = 22 + RESIZE_BILINEAR = 23 + RNN = 24 + SOFTMAX = 25 + SPACE_TO_DEPTH = 26 + SVDF = 27 + TANH = 28 + CONCAT_EMBEDDINGS = 29 + SKIP_GRAM = 30 + CALL = 31 + CUSTOM = 32 + EMBEDDING_LOOKUP_SPARSE = 33 + PAD = 34 + UNIDIRECTIONAL_SEQUENCE_RNN = 35 + GATHER = 36 + BATCH_TO_SPACE_ND = 37 + SPACE_TO_BATCH_ND = 38 + TRANSPOSE = 39 + MEAN = 40 + SUB = 41 + DIV = 42 + SQUEEZE = 43 + UNIDIRECTIONAL_SEQUENCE_LSTM = 44 + STRIDED_SLICE = 45 + BIDIRECTIONAL_SEQUENCE_RNN = 46 + EXP = 47 + TOPK_V2 = 48 + SPLIT = 49 + LOG_SOFTMAX = 50 + DELEGATE = 51 + BIDIRECTIONAL_SEQUENCE_LSTM = 52 + CAST = 53 + PRELU = 54 + MAXIMUM = 55 + ARG_MAX = 56 + MINIMUM = 57 + LESS = 58 + NEG = 59 + PADV2 = 60 + GREATER = 61 + GREATER_EQUAL = 62 + LESS_EQUAL = 63 + SELECT = 64 + SLICE = 65 + SIN = 66 + TRANSPOSE_CONV = 67 + SPARSE_TO_DENSE = 68 + TILE = 69 + EXPAND_DIMS = 70 + EQUAL = 71 + NOT_EQUAL = 72 + LOG = 73 + SUM = 74 + SQRT = 75 + RSQRT = 76 + SHAPE = 77 + POW = 78 + ARG_MIN = 79 + FAKE_QUANT = 80 + REDUCE_PROD = 81 + REDUCE_MAX = 82 + PACK = 83 + LOGICAL_OR = 84 + ONE_HOT = 85 + LOGICAL_AND = 86 + LOGICAL_NOT = 87 + UNPACK = 88 + REDUCE_MIN = 89 + FLOOR_DIV = 90 + REDUCE_ANY = 91 + SQUARE = 92 + ZEROS_LIKE = 93 + FILL = 94 + FLOOR_MOD = 95 + RANGE = 96 + RESIZE_NEAREST_NEIGHBOR = 97 + LEAKY_RELU = 98 + SQUARED_DIFFERENCE = 99 + MIRROR_PAD = 100 + ABS = 101 + SPLIT_V = 102 + UNIQUE = 103 + CEIL = 104 + REVERSE_V2 = 105 + ADD_N = 106 + GATHER_ND = 107 + COS = 108 + WHERE = 109 + RANK = 110 + ELU = 111 + REVERSE_SEQUENCE = 112 + MATRIX_DIAG = 113 + QUANTIZE = 114 + MATRIX_SET_DIAG = 115 + ROUND = 116 + HARD_SWISH = 117 + IF = 118 + WHILE = 119 + NON_MAX_SUPPRESSION_V4 = 120 + NON_MAX_SUPPRESSION_V5 = 121 + SCATTER_ND = 122 + SELECT_V2 = 123 + DENSIFY = 124 + SEGMENT_SUM = 125 + BATCH_MATMUL = 126 + PLACEHOLDER_FOR_GREATER_OP_CODES = 127 + CUMSUM = 128 + CALL_ONCE = 129 + BROADCAST_TO = 130 + RFFT2D = 131 + CONV_3D = 132 + IMAG = 133 + REAL = 134 + COMPLEX_ABS = 135 + HASHTABLE = 136 + HASHTABLE_FIND = 137 + HASHTABLE_IMPORT = 138 + HASHTABLE_SIZE = 139 + REDUCE_ALL = 140 + CONV_3D_TRANSPOSE = 141 + VAR_HANDLE = 142 + READ_VARIABLE = 143 + ASSIGN_VARIABLE = 144 + BROADCAST_ARGS = 145 + RANDOM_STANDARD_NORMAL = 146 + BUCKETIZE = 147 + RANDOM_UNIFORM = 148 + MULTINOMIAL = 149 + GELU = 150 + DYNAMIC_UPDATE_SLICE = 151 + RELU_0_TO_1 = 152 + UNSORTED_SEGMENT_PROD = 153 + UNSORTED_SEGMENT_MAX = 154 + UNSORTED_SEGMENT_SUM = 155 + ATAN2 = 156 + UNSORTED_SEGMENT_MIN = 157 + SIGN = 158 + BITCAST = 159 + BITWISE_XOR = 160 + RIGHT_SHIFT = 161 + STABLEHLO_LOGISTIC = 162 + STABLEHLO_ADD = 163 + STABLEHLO_DIVIDE = 164 + STABLEHLO_MULTIPLY = 165 + STABLEHLO_MAXIMUM = 166 + STABLEHLO_RESHAPE = 167 + STABLEHLO_CLAMP = 168 + STABLEHLO_CONCATENATE = 169 + STABLEHLO_BROADCAST_IN_DIM = 170 + STABLEHLO_CONVOLUTION = 171 + STABLEHLO_SLICE = 172 + STABLEHLO_CUSTOM_CALL = 173 + STABLEHLO_REDUCE = 174 + STABLEHLO_ABS = 175 + STABLEHLO_AND = 176 + STABLEHLO_COSINE = 177 + STABLEHLO_EXPONENTIAL = 178 + STABLEHLO_FLOOR = 179 + STABLEHLO_LOG = 180 + STABLEHLO_MINIMUM = 181 + STABLEHLO_NEGATE = 182 + STABLEHLO_OR = 183 + STABLEHLO_POWER = 184 + STABLEHLO_REMAINDER = 185 + STABLEHLO_RSQRT = 186 + STABLEHLO_SELECT = 187 + STABLEHLO_SUBTRACT = 188 + STABLEHLO_TANH = 189 + STABLEHLO_SCATTER = 190 + STABLEHLO_COMPARE = 191 + STABLEHLO_CONVERT = 192 + STABLEHLO_DYNAMIC_SLICE = 193 + STABLEHLO_DYNAMIC_UPDATE_SLICE = 194 + STABLEHLO_PAD = 195 + STABLEHLO_IOTA = 196 + STABLEHLO_DOT_GENERAL = 197 + STABLEHLO_REDUCE_WINDOW = 198 + STABLEHLO_SORT = 199 + STABLEHLO_WHILE = 200 + STABLEHLO_GATHER = 201 + STABLEHLO_TRANSPOSE = 202 + DILATE = 203 + STABLEHLO_RNG_BIT_GENERATOR = 204 + REDUCE_WINDOW = 205 - @classmethod - def GetRootAsArgMaxOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def ArgMaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ArgMaxOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # ArgMaxOptions - def OutputType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 - -def ArgMaxOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return ArgMaxOptionsStart(builder) -def ArgMaxOptionsAddOutputType(builder, outputType): builder.PrependInt8Slot(0, outputType, 0) -def AddOutputType(builder, outputType): - return ArgMaxOptionsAddOutputType(builder, outputType) -def ArgMaxOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ArgMaxOptionsEnd(builder) - -class ArgMaxOptionsT(object): - - # ArgMaxOptionsT - def __init__(self): - self.outputType = 0 # type: int - - @classmethod - def InitFromBuf(cls, buf, pos): - argMaxOptions = ArgMaxOptions() - argMaxOptions.Init(buf, pos) - return cls.InitFromObj(argMaxOptions) - - @classmethod - def InitFromObj(cls, argMaxOptions): - x = ArgMaxOptionsT() - x._UnPack(argMaxOptions) - return x - - # ArgMaxOptionsT - def _UnPack(self, argMaxOptions): - if argMaxOptions is None: - return - self.outputType = argMaxOptions.OutputType() - - # ArgMaxOptionsT - def Pack(self, builder): - ArgMaxOptionsStart(builder) - ArgMaxOptionsAddOutputType(builder, self.outputType) - argMaxOptions = ArgMaxOptionsEnd(builder) - return argMaxOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class ArgMinOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ArgMinOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsArgMinOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def ArgMinOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # ArgMinOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # ArgMinOptions - def OutputType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 - -def ArgMinOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return ArgMinOptionsStart(builder) -def ArgMinOptionsAddOutputType(builder, outputType): builder.PrependInt8Slot(0, outputType, 0) -def AddOutputType(builder, outputType): - return ArgMinOptionsAddOutputType(builder, outputType) -def ArgMinOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ArgMinOptionsEnd(builder) - -class ArgMinOptionsT(object): - - # ArgMinOptionsT - def __init__(self): - self.outputType = 0 # type: int - - @classmethod - def InitFromBuf(cls, buf, pos): - argMinOptions = ArgMinOptions() - argMinOptions.Init(buf, pos) - return cls.InitFromObj(argMinOptions) - - @classmethod - def InitFromObj(cls, argMinOptions): - x = ArgMinOptionsT() - x._UnPack(argMinOptions) - return x - - # ArgMinOptionsT - def _UnPack(self, argMinOptions): - if argMinOptions is None: - return - self.outputType = argMinOptions.OutputType() - - # ArgMinOptionsT - def Pack(self, builder): - ArgMinOptionsStart(builder) - ArgMinOptionsAddOutputType(builder, self.outputType) - argMinOptions = ArgMinOptionsEnd(builder) - return argMinOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class AssignVariableOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = AssignVariableOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsAssignVariableOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def AssignVariableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # AssignVariableOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def AssignVariableOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return AssignVariableOptionsStart(builder) -def AssignVariableOptionsEnd(builder): return builder.EndObject() -def End(builder): - return AssignVariableOptionsEnd(builder) - -class AssignVariableOptionsT(object): - - # AssignVariableOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - assignVariableOptions = AssignVariableOptions() - assignVariableOptions.Init(buf, pos) - return cls.InitFromObj(assignVariableOptions) - - @classmethod - def InitFromObj(cls, assignVariableOptions): - x = AssignVariableOptionsT() - x._UnPack(assignVariableOptions) - return x - - # AssignVariableOptionsT - def _UnPack(self, assignVariableOptions): - if assignVariableOptions is None: - return - - # AssignVariableOptionsT - def Pack(self, builder): - AssignVariableOptionsStart(builder) - assignVariableOptions = AssignVariableOptionsEnd(builder) - return assignVariableOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class BatchMatMulOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = BatchMatMulOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBatchMatMulOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BatchMatMulOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # BatchMatMulOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # BatchMatMulOptions - def AdjX(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - - # BatchMatMulOptions - def AdjY(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - - # BatchMatMulOptions - def AsymmetricQuantizeInputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - -def BatchMatMulOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return BatchMatMulOptionsStart(builder) -def BatchMatMulOptionsAddAdjX(builder, adjX): builder.PrependBoolSlot(0, adjX, 0) -def AddAdjX(builder, adjX): - return BatchMatMulOptionsAddAdjX(builder, adjX) -def BatchMatMulOptionsAddAdjY(builder, adjY): builder.PrependBoolSlot(1, adjY, 0) -def AddAdjY(builder, adjY): - return BatchMatMulOptionsAddAdjY(builder, adjY) -def BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def BatchMatMulOptionsEnd(builder): return builder.EndObject() -def End(builder): - return BatchMatMulOptionsEnd(builder) - -class BatchMatMulOptionsT(object): - - # BatchMatMulOptionsT - def __init__(self): - self.adjX = False # type: bool - self.adjY = False # type: bool - self.asymmetricQuantizeInputs = False # type: bool - - @classmethod - def InitFromBuf(cls, buf, pos): - batchMatMulOptions = BatchMatMulOptions() - batchMatMulOptions.Init(buf, pos) - return cls.InitFromObj(batchMatMulOptions) - - @classmethod - def InitFromObj(cls, batchMatMulOptions): - x = BatchMatMulOptionsT() - x._UnPack(batchMatMulOptions) - return x - - # BatchMatMulOptionsT - def _UnPack(self, batchMatMulOptions): - if batchMatMulOptions is None: - return - self.adjX = batchMatMulOptions.AdjX() - self.adjY = batchMatMulOptions.AdjY() - self.asymmetricQuantizeInputs = batchMatMulOptions.AsymmetricQuantizeInputs() - - # BatchMatMulOptionsT - def Pack(self, builder): - BatchMatMulOptionsStart(builder) - BatchMatMulOptionsAddAdjX(builder, self.adjX) - BatchMatMulOptionsAddAdjY(builder, self.adjY) - BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) - batchMatMulOptions = BatchMatMulOptionsEnd(builder) - return batchMatMulOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class BatchToSpaceNDOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = BatchToSpaceNDOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBatchToSpaceNDOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BatchToSpaceNDOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # BatchToSpaceNDOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def BatchToSpaceNDOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return BatchToSpaceNDOptionsStart(builder) -def BatchToSpaceNDOptionsEnd(builder): return builder.EndObject() -def End(builder): - return BatchToSpaceNDOptionsEnd(builder) - -class BatchToSpaceNDOptionsT(object): - - # BatchToSpaceNDOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - batchToSpaceNdoptions = BatchToSpaceNDOptions() - batchToSpaceNdoptions.Init(buf, pos) - return cls.InitFromObj(batchToSpaceNdoptions) - - @classmethod - def InitFromObj(cls, batchToSpaceNdoptions): - x = BatchToSpaceNDOptionsT() - x._UnPack(batchToSpaceNdoptions) - return x - - # BatchToSpaceNDOptionsT - def _UnPack(self, batchToSpaceNdoptions): - if batchToSpaceNdoptions is None: - return - - # BatchToSpaceNDOptionsT - def Pack(self, builder): - BatchToSpaceNDOptionsStart(builder) - batchToSpaceNdoptions = BatchToSpaceNDOptionsEnd(builder) - return batchToSpaceNdoptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class BidirectionalSequenceLSTMOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = BidirectionalSequenceLSTMOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBidirectionalSequenceLSTMOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BidirectionalSequenceLSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # BidirectionalSequenceLSTMOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # BidirectionalSequenceLSTMOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 - - # BidirectionalSequenceLSTMOptions - def CellClip(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 - - # BidirectionalSequenceLSTMOptions - def ProjClip(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 - - # BidirectionalSequenceLSTMOptions - def MergeOutputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - - # BidirectionalSequenceLSTMOptions - def TimeMajor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return True - - # BidirectionalSequenceLSTMOptions - def AsymmetricQuantizeInputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - -def BidirectionalSequenceLSTMOptionsStart(builder): builder.StartObject(6) -def Start(builder): - return BidirectionalSequenceLSTMOptionsStart(builder) -def BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def BidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) -def AddCellClip(builder, cellClip): - return BidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip) -def BidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) -def AddProjClip(builder, projClip): - return BidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip) -def BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, mergeOutputs): builder.PrependBoolSlot(3, mergeOutputs, 0) -def AddMergeOutputs(builder, mergeOutputs): - return BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, mergeOutputs) -def BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(4, timeMajor, 1) -def AddTimeMajor(builder, timeMajor): - return BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor) -def BidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(5, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return BidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def BidirectionalSequenceLSTMOptionsEnd(builder): return builder.EndObject() -def End(builder): - return BidirectionalSequenceLSTMOptionsEnd(builder) - -class BidirectionalSequenceLSTMOptionsT(object): - - # BidirectionalSequenceLSTMOptionsT - def __init__(self): - self.fusedActivationFunction = 0 # type: int - self.cellClip = 0.0 # type: float - self.projClip = 0.0 # type: float - self.mergeOutputs = False # type: bool - self.timeMajor = True # type: bool - self.asymmetricQuantizeInputs = False # type: bool - - @classmethod - def InitFromBuf(cls, buf, pos): - bidirectionalSequenceLstmoptions = BidirectionalSequenceLSTMOptions() - bidirectionalSequenceLstmoptions.Init(buf, pos) - return cls.InitFromObj(bidirectionalSequenceLstmoptions) - - @classmethod - def InitFromObj(cls, bidirectionalSequenceLstmoptions): - x = BidirectionalSequenceLSTMOptionsT() - x._UnPack(bidirectionalSequenceLstmoptions) - return x - - # BidirectionalSequenceLSTMOptionsT - def _UnPack(self, bidirectionalSequenceLstmoptions): - if bidirectionalSequenceLstmoptions is None: - return - self.fusedActivationFunction = bidirectionalSequenceLstmoptions.FusedActivationFunction() - self.cellClip = bidirectionalSequenceLstmoptions.CellClip() - self.projClip = bidirectionalSequenceLstmoptions.ProjClip() - self.mergeOutputs = bidirectionalSequenceLstmoptions.MergeOutputs() - self.timeMajor = bidirectionalSequenceLstmoptions.TimeMajor() - self.asymmetricQuantizeInputs = bidirectionalSequenceLstmoptions.AsymmetricQuantizeInputs() - - # BidirectionalSequenceLSTMOptionsT - def Pack(self, builder): - BidirectionalSequenceLSTMOptionsStart(builder) - BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - BidirectionalSequenceLSTMOptionsAddCellClip(builder, self.cellClip) - BidirectionalSequenceLSTMOptionsAddProjClip(builder, self.projClip) - BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, self.mergeOutputs) - BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, self.timeMajor) - BidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) - bidirectionalSequenceLstmoptions = BidirectionalSequenceLSTMOptionsEnd(builder) - return bidirectionalSequenceLstmoptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class BidirectionalSequenceRNNOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = BidirectionalSequenceRNNOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBidirectionalSequenceRNNOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BidirectionalSequenceRNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # BidirectionalSequenceRNNOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # BidirectionalSequenceRNNOptions - def TimeMajor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - - # BidirectionalSequenceRNNOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 - - # BidirectionalSequenceRNNOptions - def MergeOutputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - - # BidirectionalSequenceRNNOptions - def AsymmetricQuantizeInputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - -def BidirectionalSequenceRNNOptionsStart(builder): builder.StartObject(4) -def Start(builder): - return BidirectionalSequenceRNNOptionsStart(builder) -def BidirectionalSequenceRNNOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(0, timeMajor, 0) -def AddTimeMajor(builder, timeMajor): - return BidirectionalSequenceRNNOptionsAddTimeMajor(builder, timeMajor) -def BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, mergeOutputs): builder.PrependBoolSlot(2, mergeOutputs, 0) -def AddMergeOutputs(builder, mergeOutputs): - return BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, mergeOutputs) -def BidirectionalSequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return BidirectionalSequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def BidirectionalSequenceRNNOptionsEnd(builder): return builder.EndObject() -def End(builder): - return BidirectionalSequenceRNNOptionsEnd(builder) - -class BidirectionalSequenceRNNOptionsT(object): - - # BidirectionalSequenceRNNOptionsT - def __init__(self): - self.timeMajor = False # type: bool - self.fusedActivationFunction = 0 # type: int - self.mergeOutputs = False # type: bool - self.asymmetricQuantizeInputs = False # type: bool - - @classmethod - def InitFromBuf(cls, buf, pos): - bidirectionalSequenceRnnoptions = BidirectionalSequenceRNNOptions() - bidirectionalSequenceRnnoptions.Init(buf, pos) - return cls.InitFromObj(bidirectionalSequenceRnnoptions) - - @classmethod - def InitFromObj(cls, bidirectionalSequenceRnnoptions): - x = BidirectionalSequenceRNNOptionsT() - x._UnPack(bidirectionalSequenceRnnoptions) - return x - - # BidirectionalSequenceRNNOptionsT - def _UnPack(self, bidirectionalSequenceRnnoptions): - if bidirectionalSequenceRnnoptions is None: - return - self.timeMajor = bidirectionalSequenceRnnoptions.TimeMajor() - self.fusedActivationFunction = bidirectionalSequenceRnnoptions.FusedActivationFunction() - self.mergeOutputs = bidirectionalSequenceRnnoptions.MergeOutputs() - self.asymmetricQuantizeInputs = bidirectionalSequenceRnnoptions.AsymmetricQuantizeInputs() - - # BidirectionalSequenceRNNOptionsT - def Pack(self, builder): - BidirectionalSequenceRNNOptionsStart(builder) - BidirectionalSequenceRNNOptionsAddTimeMajor(builder, self.timeMajor) - BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, self.mergeOutputs) - BidirectionalSequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) - bidirectionalSequenceRnnoptions = BidirectionalSequenceRNNOptionsEnd(builder) - return bidirectionalSequenceRnnoptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class BitcastOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = BitcastOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBitcastOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BitcastOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # BitcastOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def BitcastOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return BitcastOptionsStart(builder) -def BitcastOptionsEnd(builder): return builder.EndObject() -def End(builder): - return BitcastOptionsEnd(builder) - -class BitcastOptionsT(object): - - # BitcastOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - bitcastOptions = BitcastOptions() - bitcastOptions.Init(buf, pos) - return cls.InitFromObj(bitcastOptions) - - @classmethod - def InitFromObj(cls, bitcastOptions): - x = BitcastOptionsT() - x._UnPack(bitcastOptions) - return x - - # BitcastOptionsT - def _UnPack(self, bitcastOptions): - if bitcastOptions is None: - return - - # BitcastOptionsT - def Pack(self, builder): - BitcastOptionsStart(builder) - bitcastOptions = BitcastOptionsEnd(builder) - return bitcastOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class BitwiseXorOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = BitwiseXorOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBitwiseXorOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BitwiseXorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # BitwiseXorOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def BitwiseXorOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return BitwiseXorOptionsStart(builder) -def BitwiseXorOptionsEnd(builder): return builder.EndObject() -def End(builder): - return BitwiseXorOptionsEnd(builder) - -class BitwiseXorOptionsT(object): - - # BitwiseXorOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - bitwiseXorOptions = BitwiseXorOptions() - bitwiseXorOptions.Init(buf, pos) - return cls.InitFromObj(bitwiseXorOptions) - - @classmethod - def InitFromObj(cls, bitwiseXorOptions): - x = BitwiseXorOptionsT() - x._UnPack(bitwiseXorOptions) - return x - - # BitwiseXorOptionsT - def _UnPack(self, bitwiseXorOptions): - if bitwiseXorOptions is None: - return - - # BitwiseXorOptionsT - def Pack(self, builder): - BitwiseXorOptionsStart(builder) - bitwiseXorOptions = BitwiseXorOptionsEnd(builder) - return bitwiseXorOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class BroadcastToOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = BroadcastToOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBroadcastToOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BroadcastToOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # BroadcastToOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def BroadcastToOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return BroadcastToOptionsStart(builder) -def BroadcastToOptionsEnd(builder): return builder.EndObject() -def End(builder): - return BroadcastToOptionsEnd(builder) - -class BroadcastToOptionsT(object): - - # BroadcastToOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - broadcastToOptions = BroadcastToOptions() - broadcastToOptions.Init(buf, pos) - return cls.InitFromObj(broadcastToOptions) - - @classmethod - def InitFromObj(cls, broadcastToOptions): - x = BroadcastToOptionsT() - x._UnPack(broadcastToOptions) - return x - - # BroadcastToOptionsT - def _UnPack(self, broadcastToOptions): - if broadcastToOptions is None: - return - - # BroadcastToOptionsT - def Pack(self, builder): - BroadcastToOptionsStart(builder) - broadcastToOptions = BroadcastToOptionsEnd(builder) - return broadcastToOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class BucketizeOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = BucketizeOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBucketizeOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BucketizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # BucketizeOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # BucketizeOptions - def Boundaries(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - - # BucketizeOptions - def BoundariesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) - return 0 - - # BucketizeOptions - def BoundariesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # BucketizeOptions - def BoundariesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - -def BucketizeOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return BucketizeOptionsStart(builder) -def BucketizeOptionsAddBoundaries(builder, boundaries): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(boundaries), 0) -def AddBoundaries(builder, boundaries): - return BucketizeOptionsAddBoundaries(builder, boundaries) -def BucketizeOptionsStartBoundariesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartBoundariesVector(builder, numElems): - return BucketizeOptionsStartBoundariesVector(builder, numElems) -def BucketizeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return BucketizeOptionsEnd(builder) -try: - from typing import List -except: - pass - -class BucketizeOptionsT(object): - - # BucketizeOptionsT - def __init__(self): - self.boundaries = None # type: List[float] - - @classmethod - def InitFromBuf(cls, buf, pos): - bucketizeOptions = BucketizeOptions() - bucketizeOptions.Init(buf, pos) - return cls.InitFromObj(bucketizeOptions) - - @classmethod - def InitFromObj(cls, bucketizeOptions): - x = BucketizeOptionsT() - x._UnPack(bucketizeOptions) - return x - - # BucketizeOptionsT - def _UnPack(self, bucketizeOptions): - if bucketizeOptions is None: - return - if not bucketizeOptions.BoundariesIsNone(): - if np is None: - self.boundaries = [] - for i in range(bucketizeOptions.BoundariesLength()): - self.boundaries.append(bucketizeOptions.Boundaries(i)) - else: - self.boundaries = bucketizeOptions.BoundariesAsNumpy() - - # BucketizeOptionsT - def Pack(self, builder): - if self.boundaries is not None: - if np is not None and type(self.boundaries) is np.ndarray: - boundaries = builder.CreateNumpyVector(self.boundaries) - else: - BucketizeOptionsStartBoundariesVector(builder, len(self.boundaries)) - for i in reversed(range(len(self.boundaries))): - builder.PrependFloat32(self.boundaries[i]) - boundaries = builder.EndVector() - BucketizeOptionsStart(builder) - if self.boundaries is not None: - BucketizeOptionsAddBoundaries(builder, boundaries) - bucketizeOptions = BucketizeOptionsEnd(builder) - return bucketizeOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class Buffer(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Buffer() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsBuffer(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def BufferBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # Buffer - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # Buffer - def Data(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) - return 0 - - # Buffer - def DataAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) - return 0 - - # Buffer - def DataLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # Buffer - def DataIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - - # Buffer - def Offset(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) - return 0 - - # Buffer - def Size(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) - return 0 - -def BufferStart(builder): builder.StartObject(3) -def Start(builder): - return BufferStart(builder) -def BufferAddData(builder, data): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) -def AddData(builder, data): - return BufferAddData(builder, data) -def BufferStartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def StartDataVector(builder, numElems): - return BufferStartDataVector(builder, numElems) -def BufferAddOffset(builder, offset): builder.PrependUint64Slot(1, offset, 0) -def AddOffset(builder, offset): - return BufferAddOffset(builder, offset) -def BufferAddSize(builder, size): builder.PrependUint64Slot(2, size, 0) -def AddSize(builder, size): - return BufferAddSize(builder, size) -def BufferEnd(builder): return builder.EndObject() -def End(builder): - return BufferEnd(builder) -try: - from typing import List -except: - pass - -class BufferT(object): - - # BufferT - def __init__(self): - self.data = None # type: List[int] - self.offset = 0 # type: int - self.size = 0 # type: int - - @classmethod - def InitFromBuf(cls, buf, pos): - buffer = Buffer() - buffer.Init(buf, pos) - return cls.InitFromObj(buffer) - - @classmethod - def InitFromObj(cls, buffer): - x = BufferT() - x._UnPack(buffer) - return x - - # BufferT - def _UnPack(self, buffer): - if buffer is None: - return - if not buffer.DataIsNone(): - if np is None: - self.data = [] - for i in range(buffer.DataLength()): - self.data.append(buffer.Data(i)) - else: - self.data = buffer.DataAsNumpy() - self.offset = buffer.Offset() - self.size = buffer.Size() - - # BufferT - def Pack(self, builder): - if self.data is not None: - if np is not None and type(self.data) is np.ndarray: - data = builder.CreateNumpyVector(self.data) - else: - BufferStartDataVector(builder, len(self.data)) - for i in reversed(range(len(self.data))): - builder.PrependUint8(self.data[i]) - data = builder.EndVector() - BufferStart(builder) - if self.data is not None: - BufferAddData(builder, data) - BufferAddOffset(builder, self.offset) - BufferAddSize(builder, self.size) - buffer = BufferEnd(builder) - return buffer -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class BuiltinOperator(object): - ADD = 0 - AVERAGE_POOL_2D = 1 - CONCATENATION = 2 - CONV_2D = 3 - DEPTHWISE_CONV_2D = 4 - DEPTH_TO_SPACE = 5 - DEQUANTIZE = 6 - EMBEDDING_LOOKUP = 7 - FLOOR = 8 - FULLY_CONNECTED = 9 - HASHTABLE_LOOKUP = 10 - L2_NORMALIZATION = 11 - L2_POOL_2D = 12 - LOCAL_RESPONSE_NORMALIZATION = 13 - LOGISTIC = 14 - LSH_PROJECTION = 15 - LSTM = 16 - MAX_POOL_2D = 17 - MUL = 18 - RELU = 19 - RELU_N1_TO_1 = 20 - RELU6 = 21 - RESHAPE = 22 - RESIZE_BILINEAR = 23 - RNN = 24 - SOFTMAX = 25 - SPACE_TO_DEPTH = 26 - SVDF = 27 - TANH = 28 - CONCAT_EMBEDDINGS = 29 - SKIP_GRAM = 30 - CALL = 31 - CUSTOM = 32 - EMBEDDING_LOOKUP_SPARSE = 33 - PAD = 34 - UNIDIRECTIONAL_SEQUENCE_RNN = 35 - GATHER = 36 - BATCH_TO_SPACE_ND = 37 - SPACE_TO_BATCH_ND = 38 - TRANSPOSE = 39 - MEAN = 40 - SUB = 41 - DIV = 42 - SQUEEZE = 43 - UNIDIRECTIONAL_SEQUENCE_LSTM = 44 - STRIDED_SLICE = 45 - BIDIRECTIONAL_SEQUENCE_RNN = 46 - EXP = 47 - TOPK_V2 = 48 - SPLIT = 49 - LOG_SOFTMAX = 50 - DELEGATE = 51 - BIDIRECTIONAL_SEQUENCE_LSTM = 52 - CAST = 53 - PRELU = 54 - MAXIMUM = 55 - ARG_MAX = 56 - MINIMUM = 57 - LESS = 58 - NEG = 59 - PADV2 = 60 - GREATER = 61 - GREATER_EQUAL = 62 - LESS_EQUAL = 63 - SELECT = 64 - SLICE = 65 - SIN = 66 - TRANSPOSE_CONV = 67 - SPARSE_TO_DENSE = 68 - TILE = 69 - EXPAND_DIMS = 70 - EQUAL = 71 - NOT_EQUAL = 72 - LOG = 73 - SUM = 74 - SQRT = 75 - RSQRT = 76 - SHAPE = 77 - POW = 78 - ARG_MIN = 79 - FAKE_QUANT = 80 - REDUCE_PROD = 81 - REDUCE_MAX = 82 - PACK = 83 - LOGICAL_OR = 84 - ONE_HOT = 85 - LOGICAL_AND = 86 - LOGICAL_NOT = 87 - UNPACK = 88 - REDUCE_MIN = 89 - FLOOR_DIV = 90 - REDUCE_ANY = 91 - SQUARE = 92 - ZEROS_LIKE = 93 - FILL = 94 - FLOOR_MOD = 95 - RANGE = 96 - RESIZE_NEAREST_NEIGHBOR = 97 - LEAKY_RELU = 98 - SQUARED_DIFFERENCE = 99 - MIRROR_PAD = 100 - ABS = 101 - SPLIT_V = 102 - UNIQUE = 103 - CEIL = 104 - REVERSE_V2 = 105 - ADD_N = 106 - GATHER_ND = 107 - COS = 108 - WHERE = 109 - RANK = 110 - ELU = 111 - REVERSE_SEQUENCE = 112 - MATRIX_DIAG = 113 - QUANTIZE = 114 - MATRIX_SET_DIAG = 115 - ROUND = 116 - HARD_SWISH = 117 - IF = 118 - WHILE = 119 - NON_MAX_SUPPRESSION_V4 = 120 - NON_MAX_SUPPRESSION_V5 = 121 - SCATTER_ND = 122 - SELECT_V2 = 123 - DENSIFY = 124 - SEGMENT_SUM = 125 - BATCH_MATMUL = 126 - PLACEHOLDER_FOR_GREATER_OP_CODES = 127 - CUMSUM = 128 - CALL_ONCE = 129 - BROADCAST_TO = 130 - RFFT2D = 131 - CONV_3D = 132 - IMAG = 133 - REAL = 134 - COMPLEX_ABS = 135 - HASHTABLE = 136 - HASHTABLE_FIND = 137 - HASHTABLE_IMPORT = 138 - HASHTABLE_SIZE = 139 - REDUCE_ALL = 140 - CONV_3D_TRANSPOSE = 141 - VAR_HANDLE = 142 - READ_VARIABLE = 143 - ASSIGN_VARIABLE = 144 - BROADCAST_ARGS = 145 - RANDOM_STANDARD_NORMAL = 146 - BUCKETIZE = 147 - RANDOM_UNIFORM = 148 - MULTINOMIAL = 149 - GELU = 150 - DYNAMIC_UPDATE_SLICE = 151 - RELU_0_TO_1 = 152 - UNSORTED_SEGMENT_PROD = 153 - UNSORTED_SEGMENT_MAX = 154 - UNSORTED_SEGMENT_SUM = 155 - ATAN2 = 156 - UNSORTED_SEGMENT_MIN = 157 - SIGN = 158 - BITCAST = 159 - BITWISE_XOR = 160 - RIGHT_SHIFT = 161 - STABLEHLO_LOGISTIC = 162 - STABLEHLO_ADD = 163 - STABLEHLO_DIVIDE = 164 - STABLEHLO_MULTIPLY = 165 - STABLEHLO_MAXIMUM = 166 - STABLEHLO_RESHAPE = 167 - STABLEHLO_CLAMP = 168 - STABLEHLO_CONCATENATE = 169 - STABLEHLO_BROADCAST_IN_DIM = 170 - STABLEHLO_CONVOLUTION = 171 - STABLEHLO_SLICE = 172 - STABLEHLO_CUSTOM_CALL = 173 - STABLEHLO_REDUCE = 174 - STABLEHLO_ABS = 175 - STABLEHLO_AND = 176 - STABLEHLO_COSINE = 177 - STABLEHLO_EXPONENTIAL = 178 - STABLEHLO_FLOOR = 179 - STABLEHLO_LOG = 180 - STABLEHLO_MINIMUM = 181 - STABLEHLO_NEGATE = 182 - STABLEHLO_OR = 183 - STABLEHLO_POWER = 184 - STABLEHLO_REMAINDER = 185 - STABLEHLO_RSQRT = 186 - STABLEHLO_SELECT = 187 - STABLEHLO_SUBTRACT = 188 - STABLEHLO_TANH = 189 - STABLEHLO_SCATTER = 190 - STABLEHLO_COMPARE = 191 - STABLEHLO_CONVERT = 192 - STABLEHLO_DYNAMIC_SLICE = 193 - STABLEHLO_DYNAMIC_UPDATE_SLICE = 194 - STABLEHLO_PAD = 195 - STABLEHLO_IOTA = 196 - STABLEHLO_DOT_GENERAL = 197 - STABLEHLO_REDUCE_WINDOW = 198 - STABLEHLO_SORT = 199 - STABLEHLO_WHILE = 200 - STABLEHLO_GATHER = 201 - STABLEHLO_TRANSPOSE = 202 - DILATE = 203 - STABLEHLO_RNG_BIT_GENERATOR = 204 - REDUCE_WINDOW = 205 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class BuiltinOptions(object): - NONE = 0 - Conv2DOptions = 1 - DepthwiseConv2DOptions = 2 - ConcatEmbeddingsOptions = 3 - LSHProjectionOptions = 4 - Pool2DOptions = 5 - SVDFOptions = 6 - RNNOptions = 7 - FullyConnectedOptions = 8 - SoftmaxOptions = 9 - ConcatenationOptions = 10 - AddOptions = 11 - L2NormOptions = 12 - LocalResponseNormalizationOptions = 13 - LSTMOptions = 14 - ResizeBilinearOptions = 15 - CallOptions = 16 - ReshapeOptions = 17 - SkipGramOptions = 18 - SpaceToDepthOptions = 19 - EmbeddingLookupSparseOptions = 20 - MulOptions = 21 - PadOptions = 22 - GatherOptions = 23 - BatchToSpaceNDOptions = 24 - SpaceToBatchNDOptions = 25 - TransposeOptions = 26 - ReducerOptions = 27 - SubOptions = 28 - DivOptions = 29 - SqueezeOptions = 30 - SequenceRNNOptions = 31 - StridedSliceOptions = 32 - ExpOptions = 33 - TopKV2Options = 34 - SplitOptions = 35 - LogSoftmaxOptions = 36 - CastOptions = 37 - DequantizeOptions = 38 - MaximumMinimumOptions = 39 - ArgMaxOptions = 40 - LessOptions = 41 - NegOptions = 42 - PadV2Options = 43 - GreaterOptions = 44 - GreaterEqualOptions = 45 - LessEqualOptions = 46 - SelectOptions = 47 - SliceOptions = 48 - TransposeConvOptions = 49 - SparseToDenseOptions = 50 - TileOptions = 51 - ExpandDimsOptions = 52 - EqualOptions = 53 - NotEqualOptions = 54 - ShapeOptions = 55 - PowOptions = 56 - ArgMinOptions = 57 - FakeQuantOptions = 58 - PackOptions = 59 - LogicalOrOptions = 60 - OneHotOptions = 61 - LogicalAndOptions = 62 - LogicalNotOptions = 63 - UnpackOptions = 64 - FloorDivOptions = 65 - SquareOptions = 66 - ZerosLikeOptions = 67 - FillOptions = 68 - BidirectionalSequenceLSTMOptions = 69 - BidirectionalSequenceRNNOptions = 70 - UnidirectionalSequenceLSTMOptions = 71 - FloorModOptions = 72 - RangeOptions = 73 - ResizeNearestNeighborOptions = 74 - LeakyReluOptions = 75 - SquaredDifferenceOptions = 76 - MirrorPadOptions = 77 - AbsOptions = 78 - SplitVOptions = 79 - UniqueOptions = 80 - ReverseV2Options = 81 - AddNOptions = 82 - GatherNdOptions = 83 - CosOptions = 84 - WhereOptions = 85 - RankOptions = 86 - ReverseSequenceOptions = 87 - MatrixDiagOptions = 88 - QuantizeOptions = 89 - MatrixSetDiagOptions = 90 - HardSwishOptions = 91 - IfOptions = 92 - WhileOptions = 93 - DepthToSpaceOptions = 94 - NonMaxSuppressionV4Options = 95 - NonMaxSuppressionV5Options = 96 - ScatterNdOptions = 97 - SelectV2Options = 98 - DensifyOptions = 99 - SegmentSumOptions = 100 - BatchMatMulOptions = 101 - CumsumOptions = 102 - CallOnceOptions = 103 - BroadcastToOptions = 104 - Rfft2dOptions = 105 - Conv3DOptions = 106 - HashtableOptions = 107 - HashtableFindOptions = 108 - HashtableImportOptions = 109 - HashtableSizeOptions = 110 - VarHandleOptions = 111 - ReadVariableOptions = 112 - AssignVariableOptions = 113 - RandomOptions = 114 - BucketizeOptions = 115 - GeluOptions = 116 - DynamicUpdateSliceOptions = 117 - UnsortedSegmentProdOptions = 118 - UnsortedSegmentMaxOptions = 119 - UnsortedSegmentMinOptions = 120 - UnsortedSegmentSumOptions = 121 - ATan2Options = 122 - SignOptions = 123 - BitcastOptions = 124 - BitwiseXorOptions = 125 - RightShiftOptions = 126 +class BuiltinOptions(object): + NONE = 0 + Conv2DOptions = 1 + DepthwiseConv2DOptions = 2 + ConcatEmbeddingsOptions = 3 + LSHProjectionOptions = 4 + Pool2DOptions = 5 + SVDFOptions = 6 + RNNOptions = 7 + FullyConnectedOptions = 8 + SoftmaxOptions = 9 + ConcatenationOptions = 10 + AddOptions = 11 + L2NormOptions = 12 + LocalResponseNormalizationOptions = 13 + LSTMOptions = 14 + ResizeBilinearOptions = 15 + CallOptions = 16 + ReshapeOptions = 17 + SkipGramOptions = 18 + SpaceToDepthOptions = 19 + EmbeddingLookupSparseOptions = 20 + MulOptions = 21 + PadOptions = 22 + GatherOptions = 23 + BatchToSpaceNDOptions = 24 + SpaceToBatchNDOptions = 25 + TransposeOptions = 26 + ReducerOptions = 27 + SubOptions = 28 + DivOptions = 29 + SqueezeOptions = 30 + SequenceRNNOptions = 31 + StridedSliceOptions = 32 + ExpOptions = 33 + TopKV2Options = 34 + SplitOptions = 35 + LogSoftmaxOptions = 36 + CastOptions = 37 + DequantizeOptions = 38 + MaximumMinimumOptions = 39 + ArgMaxOptions = 40 + LessOptions = 41 + NegOptions = 42 + PadV2Options = 43 + GreaterOptions = 44 + GreaterEqualOptions = 45 + LessEqualOptions = 46 + SelectOptions = 47 + SliceOptions = 48 + TransposeConvOptions = 49 + SparseToDenseOptions = 50 + TileOptions = 51 + ExpandDimsOptions = 52 + EqualOptions = 53 + NotEqualOptions = 54 + ShapeOptions = 55 + PowOptions = 56 + ArgMinOptions = 57 + FakeQuantOptions = 58 + PackOptions = 59 + LogicalOrOptions = 60 + OneHotOptions = 61 + LogicalAndOptions = 62 + LogicalNotOptions = 63 + UnpackOptions = 64 + FloorDivOptions = 65 + SquareOptions = 66 + ZerosLikeOptions = 67 + FillOptions = 68 + BidirectionalSequenceLSTMOptions = 69 + BidirectionalSequenceRNNOptions = 70 + UnidirectionalSequenceLSTMOptions = 71 + FloorModOptions = 72 + RangeOptions = 73 + ResizeNearestNeighborOptions = 74 + LeakyReluOptions = 75 + SquaredDifferenceOptions = 76 + MirrorPadOptions = 77 + AbsOptions = 78 + SplitVOptions = 79 + UniqueOptions = 80 + ReverseV2Options = 81 + AddNOptions = 82 + GatherNdOptions = 83 + CosOptions = 84 + WhereOptions = 85 + RankOptions = 86 + ReverseSequenceOptions = 87 + MatrixDiagOptions = 88 + QuantizeOptions = 89 + MatrixSetDiagOptions = 90 + HardSwishOptions = 91 + IfOptions = 92 + WhileOptions = 93 + DepthToSpaceOptions = 94 + NonMaxSuppressionV4Options = 95 + NonMaxSuppressionV5Options = 96 + ScatterNdOptions = 97 + SelectV2Options = 98 + DensifyOptions = 99 + SegmentSumOptions = 100 + BatchMatMulOptions = 101 + CumsumOptions = 102 + CallOnceOptions = 103 + BroadcastToOptions = 104 + Rfft2dOptions = 105 + Conv3DOptions = 106 + HashtableOptions = 107 + HashtableFindOptions = 108 + HashtableImportOptions = 109 + HashtableSizeOptions = 110 + VarHandleOptions = 111 + ReadVariableOptions = 112 + AssignVariableOptions = 113 + RandomOptions = 114 + BucketizeOptions = 115 + GeluOptions = 116 + DynamicUpdateSliceOptions = 117 + UnsortedSegmentProdOptions = 118 + UnsortedSegmentMaxOptions = 119 + UnsortedSegmentMinOptions = 120 + UnsortedSegmentSumOptions = 121 + ATan2Options = 122 + SignOptions = 123 + BitcastOptions = 124 + BitwiseXorOptions = 125 + RightShiftOptions = 126 def BuiltinOptionsCreator(unionType, table): from flatbuffers.table import Table @@ -1985,2503 +660,6629 @@ def BuiltinOptionsCreator(unionType, table): if unionType == BuiltinOptions().RightShiftOptions: return RightShiftOptionsT.InitFromBuf(table.Bytes, table.Pos) return None -# automatically generated by the FlatBuffers compiler, do not modify -# namespace: tflite -class BuiltinOptions2(object): - NONE = 0 - StablehloConcatenateOptions = 1 - StablehloBroadcastInDimOptions = 2 - StablehloSliceOptions = 3 - StablehloConvolutionOptions = 4 - StablehloCustomCallOptions = 5 - StablehloReduceOptions = 6 - StablehloScatterOptions = 7 - StablehloCompareOptions = 8 - StablehloDynamicSliceOptions = 9 - StablehloPadOptions = 10 - StablehloIotaOptions = 11 - StablehloDotGeneralOptions = 12 - StablehloReduceWindowOptions = 13 - StablehloSortOptions = 14 - StablehloWhileOptions = 15 - StablehloGatherOptions = 16 - StablehloTransposeOptions = 17 - DilateOptions = 18 - StablehloRngBitGeneratorOptions = 19 - ReduceWindowOptions = 20 +class BuiltinOptions2(object): + NONE = 0 + StablehloConcatenateOptions = 1 + StablehloBroadcastInDimOptions = 2 + StablehloSliceOptions = 3 + StablehloConvolutionOptions = 4 + StablehloCustomCallOptions = 5 + StablehloReduceOptions = 6 + StablehloScatterOptions = 7 + StablehloCompareOptions = 8 + StablehloDynamicSliceOptions = 9 + StablehloPadOptions = 10 + StablehloIotaOptions = 11 + StablehloDotGeneralOptions = 12 + StablehloReduceWindowOptions = 13 + StablehloSortOptions = 14 + StablehloWhileOptions = 15 + StablehloGatherOptions = 16 + StablehloTransposeOptions = 17 + DilateOptions = 18 + StablehloRngBitGeneratorOptions = 19 + ReduceWindowOptions = 20 + +def BuiltinOptions2Creator(unionType, table): + from flatbuffers.table import Table + if not isinstance(table, Table): + return None + if unionType == BuiltinOptions2().StablehloConcatenateOptions: + return StablehloConcatenateOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloBroadcastInDimOptions: + return StablehloBroadcastInDimOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloSliceOptions: + return StablehloSliceOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloConvolutionOptions: + return StablehloConvolutionOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloCustomCallOptions: + return StablehloCustomCallOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloReduceOptions: + return StablehloReduceOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloScatterOptions: + return StablehloScatterOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloCompareOptions: + return StablehloCompareOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloDynamicSliceOptions: + return StablehloDynamicSliceOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloPadOptions: + return StablehloPadOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloIotaOptions: + return StablehloIotaOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloDotGeneralOptions: + return StablehloDotGeneralOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloReduceWindowOptions: + return StablehloReduceWindowOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloSortOptions: + return StablehloSortOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloWhileOptions: + return StablehloWhileOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloGatherOptions: + return StablehloGatherOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloTransposeOptions: + return StablehloTransposeOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().DilateOptions: + return DilateOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().StablehloRngBitGeneratorOptions: + return StablehloRngBitGeneratorOptionsT.InitFromBuf(table.Bytes, table.Pos) + if unionType == BuiltinOptions2().ReduceWindowOptions: + return ReduceWindowOptionsT.InitFromBuf(table.Bytes, table.Pos) + return None + + +class StablehloPrecisionConfig(object): + DEFAULT = 0 + HIGH = 1 + HIGHEST = 2 + + +class StablehloComparisonDirection(object): + STABLEHLO_COMPARISON_DIRECTION_EQ = 0 + STABLEHLO_COMPARISON_DIRECTION_NE = 1 + STABLEHLO_COMPARISON_DIRECTION_GE = 2 + STABLEHLO_COMPARISON_DIRECTION_GT = 3 + STABLEHLO_COMPARISON_DIRECTION_LE = 4 + STABLEHLO_COMPARISON_DIRECTION_LT = 5 + + +class StablehloComparisonType(object): + STABLEHLO_COMPARISON_TYPE_NOTYPE = 0 + STABLEHLO_COMPARISON_TYPE_FLOAT = 1 + STABLEHLO_COMPARISON_TYPE_FLOAT_TOTAL_ORDER = 2 + STABLEHLO_COMPARISON_TYPE_SIGNED = 3 + STABLEHLO_COMPARISON_TYPE_UNSIGNED = 4 + + +class RngAlgorithm(object): + DEFAULT = 0 + PHILOX = 1 + THREEFRY = 2 + + +class Padding(object): + SAME = 0 + VALID = 1 + + +class ActivationFunctionType(object): + NONE = 0 + RELU = 1 + RELU_N1_TO_1 = 2 + RELU6 = 3 + TANH = 4 + SIGN_BIT = 5 + + +class LSHProjectionType(object): + UNKNOWN = 0 + SPARSE = 1 + DENSE = 2 + + +class FullyConnectedOptionsWeightsFormat(object): + DEFAULT = 0 + SHUFFLED4x16INT8 = 1 + + +class LSTMKernelType(object): + FULL = 0 + BASIC = 1 + + +class CombinerType(object): + SUM = 0 + MEAN = 1 + SQRTN = 2 + + +class MirrorPadMode(object): + REFLECT = 0 + SYMMETRIC = 1 + + +class ReduceWindowFunction(object): + UNSUPPORTED = 0 + ADD = 1 + MUL = 2 + MINIMUM = 3 + MAXIMUM = 4 + ALL = 5 + ANY = 6 + + +class CustomOptionsFormat(object): + FLEXBUFFERS = 0 + + +class CustomQuantization(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CustomQuantization() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsCustomQuantization(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def CustomQuantizationBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # CustomQuantization + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CustomQuantization + def Custom(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # CustomQuantization + def CustomAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # CustomQuantization + def CustomLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # CustomQuantization + def CustomIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def CustomQuantizationStart(builder): + builder.StartObject(1) + +def CustomQuantizationAddCustom(builder, custom): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(custom), 0) + +def CustomQuantizationStartCustomVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def CustomQuantizationEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class CustomQuantizationT(object): + + # CustomQuantizationT + def __init__(self): + self.custom = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + customQuantization = CustomQuantization() + customQuantization.Init(buf, pos) + return cls.InitFromObj(customQuantization) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, customQuantization): + x = CustomQuantizationT() + x._UnPack(customQuantization) + return x + + # CustomQuantizationT + def _UnPack(self, customQuantization): + if customQuantization is None: + return + if not customQuantization.CustomIsNone(): + if np is None: + self.custom = [] + for i in range(customQuantization.CustomLength()): + self.custom.append(customQuantization.Custom(i)) + else: + self.custom = customQuantization.CustomAsNumpy() + + # CustomQuantizationT + def Pack(self, builder): + if self.custom is not None: + if np is not None and type(self.custom) is np.ndarray: + custom = builder.CreateNumpyVector(self.custom) + else: + CustomQuantizationStartCustomVector(builder, len(self.custom)) + for i in reversed(range(len(self.custom))): + builder.PrependUint8(self.custom[i]) + custom = builder.EndVector() + CustomQuantizationStart(builder) + if self.custom is not None: + CustomQuantizationAddCustom(builder, custom) + customQuantization = CustomQuantizationEnd(builder) + return customQuantization + + +class QuantizationParameters(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = QuantizationParameters() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsQuantizationParameters(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def QuantizationParametersBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # QuantizationParameters + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # QuantizationParameters + def Min(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # QuantizationParameters + def MinAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) + return 0 + + # QuantizationParameters + def MinLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # QuantizationParameters + def MinIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # QuantizationParameters + def Max(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # QuantizationParameters + def MaxAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) + return 0 + + # QuantizationParameters + def MaxLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # QuantizationParameters + def MaxIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # QuantizationParameters + def Scale(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # QuantizationParameters + def ScaleAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) + return 0 + + # QuantizationParameters + def ScaleLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # QuantizationParameters + def ScaleIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # QuantizationParameters + def ZeroPoint(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # QuantizationParameters + def ZeroPointAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # QuantizationParameters + def ZeroPointLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # QuantizationParameters + def ZeroPointIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + + # QuantizationParameters + def DetailsType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # QuantizationParameters + def Details(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + + # QuantizationParameters + def QuantizedDimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def QuantizationParametersStart(builder): + builder.StartObject(7) + +def QuantizationParametersAddMin(builder, min): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(min), 0) + +def QuantizationParametersStartMinVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def QuantizationParametersAddMax(builder, max): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(max), 0) + +def QuantizationParametersStartMaxVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def QuantizationParametersAddScale(builder, scale): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(scale), 0) + +def QuantizationParametersStartScaleVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def QuantizationParametersAddZeroPoint(builder, zeroPoint): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(zeroPoint), 0) + +def QuantizationParametersStartZeroPointVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def QuantizationParametersAddDetailsType(builder, detailsType): + builder.PrependUint8Slot(4, detailsType, 0) + +def QuantizationParametersAddDetails(builder, details): + builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(details), 0) + +def QuantizationParametersAddQuantizedDimension(builder, quantizedDimension): + builder.PrependInt32Slot(6, quantizedDimension, 0) + +def QuantizationParametersEnd(builder): + return builder.EndObject() + + +try: + from typing import List, Union +except: + pass + +class QuantizationParametersT(object): + + # QuantizationParametersT + def __init__(self): + self.min = None # type: List[float] + self.max = None # type: List[float] + self.scale = None # type: List[float] + self.zeroPoint = None # type: List[int] + self.detailsType = 0 # type: int + self.details = None # type: Union[None, CustomQuantizationT] + self.quantizedDimension = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + quantizationParameters = QuantizationParameters() + quantizationParameters.Init(buf, pos) + return cls.InitFromObj(quantizationParameters) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, quantizationParameters): + x = QuantizationParametersT() + x._UnPack(quantizationParameters) + return x + + # QuantizationParametersT + def _UnPack(self, quantizationParameters): + if quantizationParameters is None: + return + if not quantizationParameters.MinIsNone(): + if np is None: + self.min = [] + for i in range(quantizationParameters.MinLength()): + self.min.append(quantizationParameters.Min(i)) + else: + self.min = quantizationParameters.MinAsNumpy() + if not quantizationParameters.MaxIsNone(): + if np is None: + self.max = [] + for i in range(quantizationParameters.MaxLength()): + self.max.append(quantizationParameters.Max(i)) + else: + self.max = quantizationParameters.MaxAsNumpy() + if not quantizationParameters.ScaleIsNone(): + if np is None: + self.scale = [] + for i in range(quantizationParameters.ScaleLength()): + self.scale.append(quantizationParameters.Scale(i)) + else: + self.scale = quantizationParameters.ScaleAsNumpy() + if not quantizationParameters.ZeroPointIsNone(): + if np is None: + self.zeroPoint = [] + for i in range(quantizationParameters.ZeroPointLength()): + self.zeroPoint.append(quantizationParameters.ZeroPoint(i)) + else: + self.zeroPoint = quantizationParameters.ZeroPointAsNumpy() + self.detailsType = quantizationParameters.DetailsType() + self.details = QuantizationDetailsCreator(self.detailsType, quantizationParameters.Details()) + self.quantizedDimension = quantizationParameters.QuantizedDimension() + + # QuantizationParametersT + def Pack(self, builder): + if self.min is not None: + if np is not None and type(self.min) is np.ndarray: + min = builder.CreateNumpyVector(self.min) + else: + QuantizationParametersStartMinVector(builder, len(self.min)) + for i in reversed(range(len(self.min))): + builder.PrependFloat32(self.min[i]) + min = builder.EndVector() + if self.max is not None: + if np is not None and type(self.max) is np.ndarray: + max = builder.CreateNumpyVector(self.max) + else: + QuantizationParametersStartMaxVector(builder, len(self.max)) + for i in reversed(range(len(self.max))): + builder.PrependFloat32(self.max[i]) + max = builder.EndVector() + if self.scale is not None: + if np is not None and type(self.scale) is np.ndarray: + scale = builder.CreateNumpyVector(self.scale) + else: + QuantizationParametersStartScaleVector(builder, len(self.scale)) + for i in reversed(range(len(self.scale))): + builder.PrependFloat32(self.scale[i]) + scale = builder.EndVector() + if self.zeroPoint is not None: + if np is not None and type(self.zeroPoint) is np.ndarray: + zeroPoint = builder.CreateNumpyVector(self.zeroPoint) + else: + QuantizationParametersStartZeroPointVector(builder, len(self.zeroPoint)) + for i in reversed(range(len(self.zeroPoint))): + builder.PrependInt64(self.zeroPoint[i]) + zeroPoint = builder.EndVector() + if self.details is not None: + details = self.details.Pack(builder) + QuantizationParametersStart(builder) + if self.min is not None: + QuantizationParametersAddMin(builder, min) + if self.max is not None: + QuantizationParametersAddMax(builder, max) + if self.scale is not None: + QuantizationParametersAddScale(builder, scale) + if self.zeroPoint is not None: + QuantizationParametersAddZeroPoint(builder, zeroPoint) + QuantizationParametersAddDetailsType(builder, self.detailsType) + if self.details is not None: + QuantizationParametersAddDetails(builder, details) + QuantizationParametersAddQuantizedDimension(builder, self.quantizedDimension) + quantizationParameters = QuantizationParametersEnd(builder) + return quantizationParameters + + +class Int32Vector(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Int32Vector() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsInt32Vector(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def Int32VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Int32Vector + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Int32Vector + def Values(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Int32Vector + def ValuesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Int32Vector + def ValuesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Int32Vector + def ValuesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Int32VectorStart(builder): + builder.StartObject(1) + +def Int32VectorAddValues(builder, values): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) + +def Int32VectorStartValuesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def Int32VectorEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class Int32VectorT(object): + + # Int32VectorT + def __init__(self): + self.values = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + int32Vector = Int32Vector() + int32Vector.Init(buf, pos) + return cls.InitFromObj(int32Vector) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, int32Vector): + x = Int32VectorT() + x._UnPack(int32Vector) + return x + + # Int32VectorT + def _UnPack(self, int32Vector): + if int32Vector is None: + return + if not int32Vector.ValuesIsNone(): + if np is None: + self.values = [] + for i in range(int32Vector.ValuesLength()): + self.values.append(int32Vector.Values(i)) + else: + self.values = int32Vector.ValuesAsNumpy() + + # Int32VectorT + def Pack(self, builder): + if self.values is not None: + if np is not None and type(self.values) is np.ndarray: + values = builder.CreateNumpyVector(self.values) + else: + Int32VectorStartValuesVector(builder, len(self.values)) + for i in reversed(range(len(self.values))): + builder.PrependInt32(self.values[i]) + values = builder.EndVector() + Int32VectorStart(builder) + if self.values is not None: + Int32VectorAddValues(builder, values) + int32Vector = Int32VectorEnd(builder) + return int32Vector + + +class Uint16Vector(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Uint16Vector() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsUint16Vector(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def Uint16VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Uint16Vector + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Uint16Vector + def Values(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) + return 0 + + # Uint16Vector + def ValuesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint16Flags, o) + return 0 + + # Uint16Vector + def ValuesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Uint16Vector + def ValuesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Uint16VectorStart(builder): + builder.StartObject(1) + +def Uint16VectorAddValues(builder, values): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) + +def Uint16VectorStartValuesVector(builder, numElems): + return builder.StartVector(2, numElems, 2) + +def Uint16VectorEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class Uint16VectorT(object): + + # Uint16VectorT + def __init__(self): + self.values = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + uint16Vector = Uint16Vector() + uint16Vector.Init(buf, pos) + return cls.InitFromObj(uint16Vector) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, uint16Vector): + x = Uint16VectorT() + x._UnPack(uint16Vector) + return x + + # Uint16VectorT + def _UnPack(self, uint16Vector): + if uint16Vector is None: + return + if not uint16Vector.ValuesIsNone(): + if np is None: + self.values = [] + for i in range(uint16Vector.ValuesLength()): + self.values.append(uint16Vector.Values(i)) + else: + self.values = uint16Vector.ValuesAsNumpy() + + # Uint16VectorT + def Pack(self, builder): + if self.values is not None: + if np is not None and type(self.values) is np.ndarray: + values = builder.CreateNumpyVector(self.values) + else: + Uint16VectorStartValuesVector(builder, len(self.values)) + for i in reversed(range(len(self.values))): + builder.PrependUint16(self.values[i]) + values = builder.EndVector() + Uint16VectorStart(builder) + if self.values is not None: + Uint16VectorAddValues(builder, values) + uint16Vector = Uint16VectorEnd(builder) + return uint16Vector + + +class Uint8Vector(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Uint8Vector() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsUint8Vector(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def Uint8VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Uint8Vector + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Uint8Vector + def Values(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Uint8Vector + def ValuesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Uint8Vector + def ValuesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Uint8Vector + def ValuesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Uint8VectorStart(builder): + builder.StartObject(1) + +def Uint8VectorAddValues(builder, values): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) + +def Uint8VectorStartValuesVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def Uint8VectorEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class Uint8VectorT(object): + + # Uint8VectorT + def __init__(self): + self.values = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + uint8Vector = Uint8Vector() + uint8Vector.Init(buf, pos) + return cls.InitFromObj(uint8Vector) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, uint8Vector): + x = Uint8VectorT() + x._UnPack(uint8Vector) + return x + + # Uint8VectorT + def _UnPack(self, uint8Vector): + if uint8Vector is None: + return + if not uint8Vector.ValuesIsNone(): + if np is None: + self.values = [] + for i in range(uint8Vector.ValuesLength()): + self.values.append(uint8Vector.Values(i)) + else: + self.values = uint8Vector.ValuesAsNumpy() + + # Uint8VectorT + def Pack(self, builder): + if self.values is not None: + if np is not None and type(self.values) is np.ndarray: + values = builder.CreateNumpyVector(self.values) + else: + Uint8VectorStartValuesVector(builder, len(self.values)) + for i in reversed(range(len(self.values))): + builder.PrependUint8(self.values[i]) + values = builder.EndVector() + Uint8VectorStart(builder) + if self.values is not None: + Uint8VectorAddValues(builder, values) + uint8Vector = Uint8VectorEnd(builder) + return uint8Vector + + +class DimensionMetadata(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = DimensionMetadata() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsDimensionMetadata(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def DimensionMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # DimensionMetadata + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # DimensionMetadata + def Format(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # DimensionMetadata + def DenseSize(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # DimensionMetadata + def ArraySegmentsType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # DimensionMetadata + def ArraySegments(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + + # DimensionMetadata + def ArrayIndicesType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # DimensionMetadata + def ArrayIndices(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + +def DimensionMetadataStart(builder): + builder.StartObject(6) + +def DimensionMetadataAddFormat(builder, format): + builder.PrependInt8Slot(0, format, 0) + +def DimensionMetadataAddDenseSize(builder, denseSize): + builder.PrependInt32Slot(1, denseSize, 0) + +def DimensionMetadataAddArraySegmentsType(builder, arraySegmentsType): + builder.PrependUint8Slot(2, arraySegmentsType, 0) + +def DimensionMetadataAddArraySegments(builder, arraySegments): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(arraySegments), 0) + +def DimensionMetadataAddArrayIndicesType(builder, arrayIndicesType): + builder.PrependUint8Slot(4, arrayIndicesType, 0) + +def DimensionMetadataAddArrayIndices(builder, arrayIndices): + builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(arrayIndices), 0) + +def DimensionMetadataEnd(builder): + return builder.EndObject() + + +try: + from typing import Union +except: + pass + +class DimensionMetadataT(object): + + # DimensionMetadataT + def __init__(self): + self.format = 0 # type: int + self.denseSize = 0 # type: int + self.arraySegmentsType = 0 # type: int + self.arraySegments = None # type: Union[None, Int32VectorT, Uint16VectorT, Uint8VectorT] + self.arrayIndicesType = 0 # type: int + self.arrayIndices = None # type: Union[None, Int32VectorT, Uint16VectorT, Uint8VectorT] + + @classmethod + def InitFromBuf(cls, buf, pos): + dimensionMetadata = DimensionMetadata() + dimensionMetadata.Init(buf, pos) + return cls.InitFromObj(dimensionMetadata) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, dimensionMetadata): + x = DimensionMetadataT() + x._UnPack(dimensionMetadata) + return x + + # DimensionMetadataT + def _UnPack(self, dimensionMetadata): + if dimensionMetadata is None: + return + self.format = dimensionMetadata.Format() + self.denseSize = dimensionMetadata.DenseSize() + self.arraySegmentsType = dimensionMetadata.ArraySegmentsType() + self.arraySegments = SparseIndexVectorCreator(self.arraySegmentsType, dimensionMetadata.ArraySegments()) + self.arrayIndicesType = dimensionMetadata.ArrayIndicesType() + self.arrayIndices = SparseIndexVectorCreator(self.arrayIndicesType, dimensionMetadata.ArrayIndices()) + + # DimensionMetadataT + def Pack(self, builder): + if self.arraySegments is not None: + arraySegments = self.arraySegments.Pack(builder) + if self.arrayIndices is not None: + arrayIndices = self.arrayIndices.Pack(builder) + DimensionMetadataStart(builder) + DimensionMetadataAddFormat(builder, self.format) + DimensionMetadataAddDenseSize(builder, self.denseSize) + DimensionMetadataAddArraySegmentsType(builder, self.arraySegmentsType) + if self.arraySegments is not None: + DimensionMetadataAddArraySegments(builder, arraySegments) + DimensionMetadataAddArrayIndicesType(builder, self.arrayIndicesType) + if self.arrayIndices is not None: + DimensionMetadataAddArrayIndices(builder, arrayIndices) + dimensionMetadata = DimensionMetadataEnd(builder) + return dimensionMetadata + + +class SparsityParameters(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SparsityParameters() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsSparsityParameters(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def SparsityParametersBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SparsityParameters + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SparsityParameters + def TraversalOrder(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # SparsityParameters + def TraversalOrderAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # SparsityParameters + def TraversalOrderLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SparsityParameters + def TraversalOrderIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # SparsityParameters + def BlockMap(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # SparsityParameters + def BlockMapAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # SparsityParameters + def BlockMapLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SparsityParameters + def BlockMapIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # SparsityParameters + def DimMetadata(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = DimensionMetadata() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # SparsityParameters + def DimMetadataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SparsityParameters + def DimMetadataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + +def SparsityParametersStart(builder): + builder.StartObject(3) + +def SparsityParametersAddTraversalOrder(builder, traversalOrder): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(traversalOrder), 0) + +def SparsityParametersStartTraversalOrderVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def SparsityParametersAddBlockMap(builder, blockMap): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blockMap), 0) + +def SparsityParametersStartBlockMapVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def SparsityParametersAddDimMetadata(builder, dimMetadata): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dimMetadata), 0) + +def SparsityParametersStartDimMetadataVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def SparsityParametersEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class SparsityParametersT(object): + + # SparsityParametersT + def __init__(self): + self.traversalOrder = None # type: List[int] + self.blockMap = None # type: List[int] + self.dimMetadata = None # type: List[DimensionMetadataT] + + @classmethod + def InitFromBuf(cls, buf, pos): + sparsityParameters = SparsityParameters() + sparsityParameters.Init(buf, pos) + return cls.InitFromObj(sparsityParameters) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, sparsityParameters): + x = SparsityParametersT() + x._UnPack(sparsityParameters) + return x + + # SparsityParametersT + def _UnPack(self, sparsityParameters): + if sparsityParameters is None: + return + if not sparsityParameters.TraversalOrderIsNone(): + if np is None: + self.traversalOrder = [] + for i in range(sparsityParameters.TraversalOrderLength()): + self.traversalOrder.append(sparsityParameters.TraversalOrder(i)) + else: + self.traversalOrder = sparsityParameters.TraversalOrderAsNumpy() + if not sparsityParameters.BlockMapIsNone(): + if np is None: + self.blockMap = [] + for i in range(sparsityParameters.BlockMapLength()): + self.blockMap.append(sparsityParameters.BlockMap(i)) + else: + self.blockMap = sparsityParameters.BlockMapAsNumpy() + if not sparsityParameters.DimMetadataIsNone(): + self.dimMetadata = [] + for i in range(sparsityParameters.DimMetadataLength()): + if sparsityParameters.DimMetadata(i) is None: + self.dimMetadata.append(None) + else: + dimensionMetadata_ = DimensionMetadataT.InitFromObj(sparsityParameters.DimMetadata(i)) + self.dimMetadata.append(dimensionMetadata_) + + # SparsityParametersT + def Pack(self, builder): + if self.traversalOrder is not None: + if np is not None and type(self.traversalOrder) is np.ndarray: + traversalOrder = builder.CreateNumpyVector(self.traversalOrder) + else: + SparsityParametersStartTraversalOrderVector(builder, len(self.traversalOrder)) + for i in reversed(range(len(self.traversalOrder))): + builder.PrependInt32(self.traversalOrder[i]) + traversalOrder = builder.EndVector() + if self.blockMap is not None: + if np is not None and type(self.blockMap) is np.ndarray: + blockMap = builder.CreateNumpyVector(self.blockMap) + else: + SparsityParametersStartBlockMapVector(builder, len(self.blockMap)) + for i in reversed(range(len(self.blockMap))): + builder.PrependInt32(self.blockMap[i]) + blockMap = builder.EndVector() + if self.dimMetadata is not None: + dimMetadatalist = [] + for i in range(len(self.dimMetadata)): + dimMetadatalist.append(self.dimMetadata[i].Pack(builder)) + SparsityParametersStartDimMetadataVector(builder, len(self.dimMetadata)) + for i in reversed(range(len(self.dimMetadata))): + builder.PrependUOffsetTRelative(dimMetadatalist[i]) + dimMetadata = builder.EndVector() + SparsityParametersStart(builder) + if self.traversalOrder is not None: + SparsityParametersAddTraversalOrder(builder, traversalOrder) + if self.blockMap is not None: + SparsityParametersAddBlockMap(builder, blockMap) + if self.dimMetadata is not None: + SparsityParametersAddDimMetadata(builder, dimMetadata) + sparsityParameters = SparsityParametersEnd(builder) + return sparsityParameters + + +class VariantSubType(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = VariantSubType() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsVariantSubType(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def VariantSubTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # VariantSubType + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # VariantSubType + def Shape(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # VariantSubType + def ShapeAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # VariantSubType + def ShapeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # VariantSubType + def ShapeIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # VariantSubType + def Type(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # VariantSubType + def HasRank(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def VariantSubTypeStart(builder): + builder.StartObject(3) + +def VariantSubTypeAddShape(builder, shape): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) + +def VariantSubTypeStartShapeVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def VariantSubTypeAddType(builder, type): + builder.PrependInt8Slot(1, type, 0) + +def VariantSubTypeAddHasRank(builder, hasRank): + builder.PrependBoolSlot(2, hasRank, 0) + +def VariantSubTypeEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class VariantSubTypeT(object): + + # VariantSubTypeT + def __init__(self): + self.shape = None # type: List[int] + self.type = 0 # type: int + self.hasRank = False # type: bool + + @classmethod + def InitFromBuf(cls, buf, pos): + variantSubType = VariantSubType() + variantSubType.Init(buf, pos) + return cls.InitFromObj(variantSubType) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, variantSubType): + x = VariantSubTypeT() + x._UnPack(variantSubType) + return x + + # VariantSubTypeT + def _UnPack(self, variantSubType): + if variantSubType is None: + return + if not variantSubType.ShapeIsNone(): + if np is None: + self.shape = [] + for i in range(variantSubType.ShapeLength()): + self.shape.append(variantSubType.Shape(i)) + else: + self.shape = variantSubType.ShapeAsNumpy() + self.type = variantSubType.Type() + self.hasRank = variantSubType.HasRank() + + # VariantSubTypeT + def Pack(self, builder): + if self.shape is not None: + if np is not None and type(self.shape) is np.ndarray: + shape = builder.CreateNumpyVector(self.shape) + else: + VariantSubTypeStartShapeVector(builder, len(self.shape)) + for i in reversed(range(len(self.shape))): + builder.PrependInt32(self.shape[i]) + shape = builder.EndVector() + VariantSubTypeStart(builder) + if self.shape is not None: + VariantSubTypeAddShape(builder, shape) + VariantSubTypeAddType(builder, self.type) + VariantSubTypeAddHasRank(builder, self.hasRank) + variantSubType = VariantSubTypeEnd(builder) + return variantSubType + + +class Tensor(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Tensor() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsTensor(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TensorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Tensor + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Tensor + def Shape(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Tensor + def ShapeAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Tensor + def ShapeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Tensor + def ShapeIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # Tensor + def Type(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # Tensor + def Buffer(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # Tensor + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # Tensor + def Quantization(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + obj = QuantizationParameters() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Tensor + def IsVariable(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # Tensor + def Sparsity(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + obj = SparsityParameters() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Tensor + def ShapeSignature(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Tensor + def ShapeSignatureAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Tensor + def ShapeSignatureLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Tensor + def ShapeSignatureIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + return o == 0 + + # Tensor + def HasRank(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # Tensor + def VariantTensors(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = VariantSubType() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Tensor + def VariantTensorsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Tensor + def VariantTensorsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + return o == 0 + +def TensorStart(builder): + builder.StartObject(10) + +def TensorAddShape(builder, shape): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) + +def TensorStartShapeVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def TensorAddType(builder, type): + builder.PrependInt8Slot(1, type, 0) + +def TensorAddBuffer(builder, buffer): + builder.PrependUint32Slot(2, buffer, 0) + +def TensorAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def TensorAddQuantization(builder, quantization): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(quantization), 0) + +def TensorAddIsVariable(builder, isVariable): + builder.PrependBoolSlot(5, isVariable, 0) + +def TensorAddSparsity(builder, sparsity): + builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(sparsity), 0) + +def TensorAddShapeSignature(builder, shapeSignature): + builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(shapeSignature), 0) + +def TensorStartShapeSignatureVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def TensorAddHasRank(builder, hasRank): + builder.PrependBoolSlot(8, hasRank, 0) + +def TensorAddVariantTensors(builder, variantTensors): + builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(variantTensors), 0) + +def TensorStartVariantTensorsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def TensorEnd(builder): + return builder.EndObject() + + +try: + from typing import List, Optional +except: + pass + +class TensorT(object): + + # TensorT + def __init__(self): + self.shape = None # type: List[int] + self.type = 0 # type: int + self.buffer = 0 # type: int + self.name = None # type: str + self.quantization = None # type: Optional[QuantizationParametersT] + self.isVariable = False # type: bool + self.sparsity = None # type: Optional[SparsityParametersT] + self.shapeSignature = None # type: List[int] + self.hasRank = False # type: bool + self.variantTensors = None # type: List[VariantSubTypeT] + + @classmethod + def InitFromBuf(cls, buf, pos): + tensor = Tensor() + tensor.Init(buf, pos) + return cls.InitFromObj(tensor) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, tensor): + x = TensorT() + x._UnPack(tensor) + return x + + # TensorT + def _UnPack(self, tensor): + if tensor is None: + return + if not tensor.ShapeIsNone(): + if np is None: + self.shape = [] + for i in range(tensor.ShapeLength()): + self.shape.append(tensor.Shape(i)) + else: + self.shape = tensor.ShapeAsNumpy() + self.type = tensor.Type() + self.buffer = tensor.Buffer() + self.name = tensor.Name() + if tensor.Quantization() is not None: + self.quantization = QuantizationParametersT.InitFromObj(tensor.Quantization()) + self.isVariable = tensor.IsVariable() + if tensor.Sparsity() is not None: + self.sparsity = SparsityParametersT.InitFromObj(tensor.Sparsity()) + if not tensor.ShapeSignatureIsNone(): + if np is None: + self.shapeSignature = [] + for i in range(tensor.ShapeSignatureLength()): + self.shapeSignature.append(tensor.ShapeSignature(i)) + else: + self.shapeSignature = tensor.ShapeSignatureAsNumpy() + self.hasRank = tensor.HasRank() + if not tensor.VariantTensorsIsNone(): + self.variantTensors = [] + for i in range(tensor.VariantTensorsLength()): + if tensor.VariantTensors(i) is None: + self.variantTensors.append(None) + else: + variantSubType_ = VariantSubTypeT.InitFromObj(tensor.VariantTensors(i)) + self.variantTensors.append(variantSubType_) + + # TensorT + def Pack(self, builder): + if self.shape is not None: + if np is not None and type(self.shape) is np.ndarray: + shape = builder.CreateNumpyVector(self.shape) + else: + TensorStartShapeVector(builder, len(self.shape)) + for i in reversed(range(len(self.shape))): + builder.PrependInt32(self.shape[i]) + shape = builder.EndVector() + if self.name is not None: + name = builder.CreateString(self.name) + if self.quantization is not None: + quantization = self.quantization.Pack(builder) + if self.sparsity is not None: + sparsity = self.sparsity.Pack(builder) + if self.shapeSignature is not None: + if np is not None and type(self.shapeSignature) is np.ndarray: + shapeSignature = builder.CreateNumpyVector(self.shapeSignature) + else: + TensorStartShapeSignatureVector(builder, len(self.shapeSignature)) + for i in reversed(range(len(self.shapeSignature))): + builder.PrependInt32(self.shapeSignature[i]) + shapeSignature = builder.EndVector() + if self.variantTensors is not None: + variantTensorslist = [] + for i in range(len(self.variantTensors)): + variantTensorslist.append(self.variantTensors[i].Pack(builder)) + TensorStartVariantTensorsVector(builder, len(self.variantTensors)) + for i in reversed(range(len(self.variantTensors))): + builder.PrependUOffsetTRelative(variantTensorslist[i]) + variantTensors = builder.EndVector() + TensorStart(builder) + if self.shape is not None: + TensorAddShape(builder, shape) + TensorAddType(builder, self.type) + TensorAddBuffer(builder, self.buffer) + if self.name is not None: + TensorAddName(builder, name) + if self.quantization is not None: + TensorAddQuantization(builder, quantization) + TensorAddIsVariable(builder, self.isVariable) + if self.sparsity is not None: + TensorAddSparsity(builder, sparsity) + if self.shapeSignature is not None: + TensorAddShapeSignature(builder, shapeSignature) + TensorAddHasRank(builder, self.hasRank) + if self.variantTensors is not None: + TensorAddVariantTensors(builder, variantTensors) + tensor = TensorEnd(builder) + return tensor + + +class StablehloGatherOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloGatherOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloGatherOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloGatherOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloGatherOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloGatherOptions + def OffsetDims(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloGatherOptions + def OffsetDimsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloGatherOptions + def OffsetDimsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloGatherOptions + def OffsetDimsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # StablehloGatherOptions + def CollapsedSliceDims(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloGatherOptions + def CollapsedSliceDimsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloGatherOptions + def CollapsedSliceDimsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloGatherOptions + def CollapsedSliceDimsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # StablehloGatherOptions + def StartIndexMap(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloGatherOptions + def StartIndexMapAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloGatherOptions + def StartIndexMapLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloGatherOptions + def StartIndexMapIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # StablehloGatherOptions + def IndexVectorDim(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + + # StablehloGatherOptions + def SliceSizes(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloGatherOptions + def SliceSizesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloGatherOptions + def SliceSizesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloGatherOptions + def SliceSizesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 + + # StablehloGatherOptions + def IndicesAreSorted(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def StablehloGatherOptionsStart(builder): + builder.StartObject(6) + +def StablehloGatherOptionsAddOffsetDims(builder, offsetDims): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(offsetDims), 0) + +def StablehloGatherOptionsStartOffsetDimsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloGatherOptionsAddCollapsedSliceDims(builder, collapsedSliceDims): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(collapsedSliceDims), 0) + +def StablehloGatherOptionsStartCollapsedSliceDimsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloGatherOptionsAddStartIndexMap(builder, startIndexMap): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(startIndexMap), 0) + +def StablehloGatherOptionsStartStartIndexMapVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloGatherOptionsAddIndexVectorDim(builder, indexVectorDim): + builder.PrependInt64Slot(3, indexVectorDim, 0) + +def StablehloGatherOptionsAddSliceSizes(builder, sliceSizes): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(sliceSizes), 0) + +def StablehloGatherOptionsStartSliceSizesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloGatherOptionsAddIndicesAreSorted(builder, indicesAreSorted): + builder.PrependBoolSlot(5, indicesAreSorted, 0) + +def StablehloGatherOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloGatherOptionsT(object): + + # StablehloGatherOptionsT + def __init__(self): + self.offsetDims = None # type: List[int] + self.collapsedSliceDims = None # type: List[int] + self.startIndexMap = None # type: List[int] + self.indexVectorDim = 0 # type: int + self.sliceSizes = None # type: List[int] + self.indicesAreSorted = False # type: bool + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloGatherOptions = StablehloGatherOptions() + stablehloGatherOptions.Init(buf, pos) + return cls.InitFromObj(stablehloGatherOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloGatherOptions): + x = StablehloGatherOptionsT() + x._UnPack(stablehloGatherOptions) + return x + + # StablehloGatherOptionsT + def _UnPack(self, stablehloGatherOptions): + if stablehloGatherOptions is None: + return + if not stablehloGatherOptions.OffsetDimsIsNone(): + if np is None: + self.offsetDims = [] + for i in range(stablehloGatherOptions.OffsetDimsLength()): + self.offsetDims.append(stablehloGatherOptions.OffsetDims(i)) + else: + self.offsetDims = stablehloGatherOptions.OffsetDimsAsNumpy() + if not stablehloGatherOptions.CollapsedSliceDimsIsNone(): + if np is None: + self.collapsedSliceDims = [] + for i in range(stablehloGatherOptions.CollapsedSliceDimsLength()): + self.collapsedSliceDims.append(stablehloGatherOptions.CollapsedSliceDims(i)) + else: + self.collapsedSliceDims = stablehloGatherOptions.CollapsedSliceDimsAsNumpy() + if not stablehloGatherOptions.StartIndexMapIsNone(): + if np is None: + self.startIndexMap = [] + for i in range(stablehloGatherOptions.StartIndexMapLength()): + self.startIndexMap.append(stablehloGatherOptions.StartIndexMap(i)) + else: + self.startIndexMap = stablehloGatherOptions.StartIndexMapAsNumpy() + self.indexVectorDim = stablehloGatherOptions.IndexVectorDim() + if not stablehloGatherOptions.SliceSizesIsNone(): + if np is None: + self.sliceSizes = [] + for i in range(stablehloGatherOptions.SliceSizesLength()): + self.sliceSizes.append(stablehloGatherOptions.SliceSizes(i)) + else: + self.sliceSizes = stablehloGatherOptions.SliceSizesAsNumpy() + self.indicesAreSorted = stablehloGatherOptions.IndicesAreSorted() + + # StablehloGatherOptionsT + def Pack(self, builder): + if self.offsetDims is not None: + if np is not None and type(self.offsetDims) is np.ndarray: + offsetDims = builder.CreateNumpyVector(self.offsetDims) + else: + StablehloGatherOptionsStartOffsetDimsVector(builder, len(self.offsetDims)) + for i in reversed(range(len(self.offsetDims))): + builder.PrependInt64(self.offsetDims[i]) + offsetDims = builder.EndVector() + if self.collapsedSliceDims is not None: + if np is not None and type(self.collapsedSliceDims) is np.ndarray: + collapsedSliceDims = builder.CreateNumpyVector(self.collapsedSliceDims) + else: + StablehloGatherOptionsStartCollapsedSliceDimsVector(builder, len(self.collapsedSliceDims)) + for i in reversed(range(len(self.collapsedSliceDims))): + builder.PrependInt64(self.collapsedSliceDims[i]) + collapsedSliceDims = builder.EndVector() + if self.startIndexMap is not None: + if np is not None and type(self.startIndexMap) is np.ndarray: + startIndexMap = builder.CreateNumpyVector(self.startIndexMap) + else: + StablehloGatherOptionsStartStartIndexMapVector(builder, len(self.startIndexMap)) + for i in reversed(range(len(self.startIndexMap))): + builder.PrependInt64(self.startIndexMap[i]) + startIndexMap = builder.EndVector() + if self.sliceSizes is not None: + if np is not None and type(self.sliceSizes) is np.ndarray: + sliceSizes = builder.CreateNumpyVector(self.sliceSizes) + else: + StablehloGatherOptionsStartSliceSizesVector(builder, len(self.sliceSizes)) + for i in reversed(range(len(self.sliceSizes))): + builder.PrependInt64(self.sliceSizes[i]) + sliceSizes = builder.EndVector() + StablehloGatherOptionsStart(builder) + if self.offsetDims is not None: + StablehloGatherOptionsAddOffsetDims(builder, offsetDims) + if self.collapsedSliceDims is not None: + StablehloGatherOptionsAddCollapsedSliceDims(builder, collapsedSliceDims) + if self.startIndexMap is not None: + StablehloGatherOptionsAddStartIndexMap(builder, startIndexMap) + StablehloGatherOptionsAddIndexVectorDim(builder, self.indexVectorDim) + if self.sliceSizes is not None: + StablehloGatherOptionsAddSliceSizes(builder, sliceSizes) + StablehloGatherOptionsAddIndicesAreSorted(builder, self.indicesAreSorted) + stablehloGatherOptions = StablehloGatherOptionsEnd(builder) + return stablehloGatherOptions + + +class StablehloTransposeOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloTransposeOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloTransposeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloTransposeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloTransposeOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloTransposeOptions + def Permutation(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloTransposeOptions + def PermutationAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloTransposeOptions + def PermutationLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloTransposeOptions + def PermutationIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def StablehloTransposeOptionsStart(builder): + builder.StartObject(1) + +def StablehloTransposeOptionsAddPermutation(builder, permutation): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(permutation), 0) + +def StablehloTransposeOptionsStartPermutationVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloTransposeOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloTransposeOptionsT(object): + + # StablehloTransposeOptionsT + def __init__(self): + self.permutation = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloTransposeOptions = StablehloTransposeOptions() + stablehloTransposeOptions.Init(buf, pos) + return cls.InitFromObj(stablehloTransposeOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloTransposeOptions): + x = StablehloTransposeOptionsT() + x._UnPack(stablehloTransposeOptions) + return x + + # StablehloTransposeOptionsT + def _UnPack(self, stablehloTransposeOptions): + if stablehloTransposeOptions is None: + return + if not stablehloTransposeOptions.PermutationIsNone(): + if np is None: + self.permutation = [] + for i in range(stablehloTransposeOptions.PermutationLength()): + self.permutation.append(stablehloTransposeOptions.Permutation(i)) + else: + self.permutation = stablehloTransposeOptions.PermutationAsNumpy() + + # StablehloTransposeOptionsT + def Pack(self, builder): + if self.permutation is not None: + if np is not None and type(self.permutation) is np.ndarray: + permutation = builder.CreateNumpyVector(self.permutation) + else: + StablehloTransposeOptionsStartPermutationVector(builder, len(self.permutation)) + for i in reversed(range(len(self.permutation))): + builder.PrependInt64(self.permutation[i]) + permutation = builder.EndVector() + StablehloTransposeOptionsStart(builder) + if self.permutation is not None: + StablehloTransposeOptionsAddPermutation(builder, permutation) + stablehloTransposeOptions = StablehloTransposeOptionsEnd(builder) + return stablehloTransposeOptions + + +class StablehloDotGeneralOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloDotGeneralOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloDotGeneralOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloDotGeneralOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloDotGeneralOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloDotGeneralOptions + def LhsBatchingDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloDotGeneralOptions + def LhsBatchingDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloDotGeneralOptions + def LhsBatchingDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloDotGeneralOptions + def LhsBatchingDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # StablehloDotGeneralOptions + def RhsBatchingDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloDotGeneralOptions + def RhsBatchingDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloDotGeneralOptions + def RhsBatchingDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloDotGeneralOptions + def RhsBatchingDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # StablehloDotGeneralOptions + def LhsContractingDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloDotGeneralOptions + def LhsContractingDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloDotGeneralOptions + def LhsContractingDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloDotGeneralOptions + def LhsContractingDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # StablehloDotGeneralOptions + def RhsContractingDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloDotGeneralOptions + def RhsContractingDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloDotGeneralOptions + def RhsContractingDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloDotGeneralOptions + def RhsContractingDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + + # StablehloDotGeneralOptions + def PrecisionConfig(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # StablehloDotGeneralOptions + def PrecisionConfigAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o) + return 0 + + # StablehloDotGeneralOptions + def PrecisionConfigLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloDotGeneralOptions + def PrecisionConfigIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 + +def StablehloDotGeneralOptionsStart(builder): + builder.StartObject(5) + +def StablehloDotGeneralOptionsAddLhsBatchingDimensions(builder, lhsBatchingDimensions): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(lhsBatchingDimensions), 0) + +def StablehloDotGeneralOptionsStartLhsBatchingDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloDotGeneralOptionsAddRhsBatchingDimensions(builder, rhsBatchingDimensions): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(rhsBatchingDimensions), 0) + +def StablehloDotGeneralOptionsStartRhsBatchingDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloDotGeneralOptionsAddLhsContractingDimensions(builder, lhsContractingDimensions): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(lhsContractingDimensions), 0) + +def StablehloDotGeneralOptionsStartLhsContractingDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloDotGeneralOptionsAddRhsContractingDimensions(builder, rhsContractingDimensions): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(rhsContractingDimensions), 0) + +def StablehloDotGeneralOptionsStartRhsContractingDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloDotGeneralOptionsAddPrecisionConfig(builder, precisionConfig): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(precisionConfig), 0) + +def StablehloDotGeneralOptionsStartPrecisionConfigVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StablehloDotGeneralOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloDotGeneralOptionsT(object): + + # StablehloDotGeneralOptionsT + def __init__(self): + self.lhsBatchingDimensions = None # type: List[int] + self.rhsBatchingDimensions = None # type: List[int] + self.lhsContractingDimensions = None # type: List[int] + self.rhsContractingDimensions = None # type: List[int] + self.precisionConfig = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloDotGeneralOptions = StablehloDotGeneralOptions() + stablehloDotGeneralOptions.Init(buf, pos) + return cls.InitFromObj(stablehloDotGeneralOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloDotGeneralOptions): + x = StablehloDotGeneralOptionsT() + x._UnPack(stablehloDotGeneralOptions) + return x + + # StablehloDotGeneralOptionsT + def _UnPack(self, stablehloDotGeneralOptions): + if stablehloDotGeneralOptions is None: + return + if not stablehloDotGeneralOptions.LhsBatchingDimensionsIsNone(): + if np is None: + self.lhsBatchingDimensions = [] + for i in range(stablehloDotGeneralOptions.LhsBatchingDimensionsLength()): + self.lhsBatchingDimensions.append(stablehloDotGeneralOptions.LhsBatchingDimensions(i)) + else: + self.lhsBatchingDimensions = stablehloDotGeneralOptions.LhsBatchingDimensionsAsNumpy() + if not stablehloDotGeneralOptions.RhsBatchingDimensionsIsNone(): + if np is None: + self.rhsBatchingDimensions = [] + for i in range(stablehloDotGeneralOptions.RhsBatchingDimensionsLength()): + self.rhsBatchingDimensions.append(stablehloDotGeneralOptions.RhsBatchingDimensions(i)) + else: + self.rhsBatchingDimensions = stablehloDotGeneralOptions.RhsBatchingDimensionsAsNumpy() + if not stablehloDotGeneralOptions.LhsContractingDimensionsIsNone(): + if np is None: + self.lhsContractingDimensions = [] + for i in range(stablehloDotGeneralOptions.LhsContractingDimensionsLength()): + self.lhsContractingDimensions.append(stablehloDotGeneralOptions.LhsContractingDimensions(i)) + else: + self.lhsContractingDimensions = stablehloDotGeneralOptions.LhsContractingDimensionsAsNumpy() + if not stablehloDotGeneralOptions.RhsContractingDimensionsIsNone(): + if np is None: + self.rhsContractingDimensions = [] + for i in range(stablehloDotGeneralOptions.RhsContractingDimensionsLength()): + self.rhsContractingDimensions.append(stablehloDotGeneralOptions.RhsContractingDimensions(i)) + else: + self.rhsContractingDimensions = stablehloDotGeneralOptions.RhsContractingDimensionsAsNumpy() + if not stablehloDotGeneralOptions.PrecisionConfigIsNone(): + if np is None: + self.precisionConfig = [] + for i in range(stablehloDotGeneralOptions.PrecisionConfigLength()): + self.precisionConfig.append(stablehloDotGeneralOptions.PrecisionConfig(i)) + else: + self.precisionConfig = stablehloDotGeneralOptions.PrecisionConfigAsNumpy() + + # StablehloDotGeneralOptionsT + def Pack(self, builder): + if self.lhsBatchingDimensions is not None: + if np is not None and type(self.lhsBatchingDimensions) is np.ndarray: + lhsBatchingDimensions = builder.CreateNumpyVector(self.lhsBatchingDimensions) + else: + StablehloDotGeneralOptionsStartLhsBatchingDimensionsVector(builder, len(self.lhsBatchingDimensions)) + for i in reversed(range(len(self.lhsBatchingDimensions))): + builder.PrependInt64(self.lhsBatchingDimensions[i]) + lhsBatchingDimensions = builder.EndVector() + if self.rhsBatchingDimensions is not None: + if np is not None and type(self.rhsBatchingDimensions) is np.ndarray: + rhsBatchingDimensions = builder.CreateNumpyVector(self.rhsBatchingDimensions) + else: + StablehloDotGeneralOptionsStartRhsBatchingDimensionsVector(builder, len(self.rhsBatchingDimensions)) + for i in reversed(range(len(self.rhsBatchingDimensions))): + builder.PrependInt64(self.rhsBatchingDimensions[i]) + rhsBatchingDimensions = builder.EndVector() + if self.lhsContractingDimensions is not None: + if np is not None and type(self.lhsContractingDimensions) is np.ndarray: + lhsContractingDimensions = builder.CreateNumpyVector(self.lhsContractingDimensions) + else: + StablehloDotGeneralOptionsStartLhsContractingDimensionsVector(builder, len(self.lhsContractingDimensions)) + for i in reversed(range(len(self.lhsContractingDimensions))): + builder.PrependInt64(self.lhsContractingDimensions[i]) + lhsContractingDimensions = builder.EndVector() + if self.rhsContractingDimensions is not None: + if np is not None and type(self.rhsContractingDimensions) is np.ndarray: + rhsContractingDimensions = builder.CreateNumpyVector(self.rhsContractingDimensions) + else: + StablehloDotGeneralOptionsStartRhsContractingDimensionsVector(builder, len(self.rhsContractingDimensions)) + for i in reversed(range(len(self.rhsContractingDimensions))): + builder.PrependInt64(self.rhsContractingDimensions[i]) + rhsContractingDimensions = builder.EndVector() + if self.precisionConfig is not None: + if np is not None and type(self.precisionConfig) is np.ndarray: + precisionConfig = builder.CreateNumpyVector(self.precisionConfig) + else: + StablehloDotGeneralOptionsStartPrecisionConfigVector(builder, len(self.precisionConfig)) + for i in reversed(range(len(self.precisionConfig))): + builder.PrependUint32(self.precisionConfig[i]) + precisionConfig = builder.EndVector() + StablehloDotGeneralOptionsStart(builder) + if self.lhsBatchingDimensions is not None: + StablehloDotGeneralOptionsAddLhsBatchingDimensions(builder, lhsBatchingDimensions) + if self.rhsBatchingDimensions is not None: + StablehloDotGeneralOptionsAddRhsBatchingDimensions(builder, rhsBatchingDimensions) + if self.lhsContractingDimensions is not None: + StablehloDotGeneralOptionsAddLhsContractingDimensions(builder, lhsContractingDimensions) + if self.rhsContractingDimensions is not None: + StablehloDotGeneralOptionsAddRhsContractingDimensions(builder, rhsContractingDimensions) + if self.precisionConfig is not None: + StablehloDotGeneralOptionsAddPrecisionConfig(builder, precisionConfig) + stablehloDotGeneralOptions = StablehloDotGeneralOptionsEnd(builder) + return stablehloDotGeneralOptions + + +class StablehloReduceWindowOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloReduceWindowOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloReduceWindowOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloReduceWindowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloReduceWindowOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloReduceWindowOptions + def WindowDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloReduceWindowOptions + def WindowDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloReduceWindowOptions + def WindowDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloReduceWindowOptions + def WindowDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # StablehloReduceWindowOptions + def WindowStrides(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloReduceWindowOptions + def WindowStridesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloReduceWindowOptions + def WindowStridesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloReduceWindowOptions + def WindowStridesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # StablehloReduceWindowOptions + def BaseDilations(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloReduceWindowOptions + def BaseDilationsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloReduceWindowOptions + def BaseDilationsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloReduceWindowOptions + def BaseDilationsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # StablehloReduceWindowOptions + def WindowDilations(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloReduceWindowOptions + def WindowDilationsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloReduceWindowOptions + def WindowDilationsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloReduceWindowOptions + def WindowDilationsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + + # StablehloReduceWindowOptions + def Padding(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloReduceWindowOptions + def PaddingAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloReduceWindowOptions + def PaddingLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloReduceWindowOptions + def PaddingIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 + + # StablehloReduceWindowOptions + def BodySubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def StablehloReduceWindowOptionsStart(builder): + builder.StartObject(6) + +def StablehloReduceWindowOptionsAddWindowDimensions(builder, windowDimensions): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(windowDimensions), 0) + +def StablehloReduceWindowOptionsStartWindowDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloReduceWindowOptionsAddWindowStrides(builder, windowStrides): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(windowStrides), 0) + +def StablehloReduceWindowOptionsStartWindowStridesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloReduceWindowOptionsAddBaseDilations(builder, baseDilations): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(baseDilations), 0) + +def StablehloReduceWindowOptionsStartBaseDilationsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloReduceWindowOptionsAddWindowDilations(builder, windowDilations): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(windowDilations), 0) + +def StablehloReduceWindowOptionsStartWindowDilationsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloReduceWindowOptionsAddPadding(builder, padding): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) + +def StablehloReduceWindowOptionsStartPaddingVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloReduceWindowOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): + builder.PrependInt32Slot(5, bodySubgraphIndex, 0) + +def StablehloReduceWindowOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloReduceWindowOptionsT(object): + + # StablehloReduceWindowOptionsT + def __init__(self): + self.windowDimensions = None # type: List[int] + self.windowStrides = None # type: List[int] + self.baseDilations = None # type: List[int] + self.windowDilations = None # type: List[int] + self.padding = None # type: List[int] + self.bodySubgraphIndex = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloReduceWindowOptions = StablehloReduceWindowOptions() + stablehloReduceWindowOptions.Init(buf, pos) + return cls.InitFromObj(stablehloReduceWindowOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloReduceWindowOptions): + x = StablehloReduceWindowOptionsT() + x._UnPack(stablehloReduceWindowOptions) + return x + + # StablehloReduceWindowOptionsT + def _UnPack(self, stablehloReduceWindowOptions): + if stablehloReduceWindowOptions is None: + return + if not stablehloReduceWindowOptions.WindowDimensionsIsNone(): + if np is None: + self.windowDimensions = [] + for i in range(stablehloReduceWindowOptions.WindowDimensionsLength()): + self.windowDimensions.append(stablehloReduceWindowOptions.WindowDimensions(i)) + else: + self.windowDimensions = stablehloReduceWindowOptions.WindowDimensionsAsNumpy() + if not stablehloReduceWindowOptions.WindowStridesIsNone(): + if np is None: + self.windowStrides = [] + for i in range(stablehloReduceWindowOptions.WindowStridesLength()): + self.windowStrides.append(stablehloReduceWindowOptions.WindowStrides(i)) + else: + self.windowStrides = stablehloReduceWindowOptions.WindowStridesAsNumpy() + if not stablehloReduceWindowOptions.BaseDilationsIsNone(): + if np is None: + self.baseDilations = [] + for i in range(stablehloReduceWindowOptions.BaseDilationsLength()): + self.baseDilations.append(stablehloReduceWindowOptions.BaseDilations(i)) + else: + self.baseDilations = stablehloReduceWindowOptions.BaseDilationsAsNumpy() + if not stablehloReduceWindowOptions.WindowDilationsIsNone(): + if np is None: + self.windowDilations = [] + for i in range(stablehloReduceWindowOptions.WindowDilationsLength()): + self.windowDilations.append(stablehloReduceWindowOptions.WindowDilations(i)) + else: + self.windowDilations = stablehloReduceWindowOptions.WindowDilationsAsNumpy() + if not stablehloReduceWindowOptions.PaddingIsNone(): + if np is None: + self.padding = [] + for i in range(stablehloReduceWindowOptions.PaddingLength()): + self.padding.append(stablehloReduceWindowOptions.Padding(i)) + else: + self.padding = stablehloReduceWindowOptions.PaddingAsNumpy() + self.bodySubgraphIndex = stablehloReduceWindowOptions.BodySubgraphIndex() + + # StablehloReduceWindowOptionsT + def Pack(self, builder): + if self.windowDimensions is not None: + if np is not None and type(self.windowDimensions) is np.ndarray: + windowDimensions = builder.CreateNumpyVector(self.windowDimensions) + else: + StablehloReduceWindowOptionsStartWindowDimensionsVector(builder, len(self.windowDimensions)) + for i in reversed(range(len(self.windowDimensions))): + builder.PrependInt64(self.windowDimensions[i]) + windowDimensions = builder.EndVector() + if self.windowStrides is not None: + if np is not None and type(self.windowStrides) is np.ndarray: + windowStrides = builder.CreateNumpyVector(self.windowStrides) + else: + StablehloReduceWindowOptionsStartWindowStridesVector(builder, len(self.windowStrides)) + for i in reversed(range(len(self.windowStrides))): + builder.PrependInt64(self.windowStrides[i]) + windowStrides = builder.EndVector() + if self.baseDilations is not None: + if np is not None and type(self.baseDilations) is np.ndarray: + baseDilations = builder.CreateNumpyVector(self.baseDilations) + else: + StablehloReduceWindowOptionsStartBaseDilationsVector(builder, len(self.baseDilations)) + for i in reversed(range(len(self.baseDilations))): + builder.PrependInt64(self.baseDilations[i]) + baseDilations = builder.EndVector() + if self.windowDilations is not None: + if np is not None and type(self.windowDilations) is np.ndarray: + windowDilations = builder.CreateNumpyVector(self.windowDilations) + else: + StablehloReduceWindowOptionsStartWindowDilationsVector(builder, len(self.windowDilations)) + for i in reversed(range(len(self.windowDilations))): + builder.PrependInt64(self.windowDilations[i]) + windowDilations = builder.EndVector() + if self.padding is not None: + if np is not None and type(self.padding) is np.ndarray: + padding = builder.CreateNumpyVector(self.padding) + else: + StablehloReduceWindowOptionsStartPaddingVector(builder, len(self.padding)) + for i in reversed(range(len(self.padding))): + builder.PrependInt64(self.padding[i]) + padding = builder.EndVector() + StablehloReduceWindowOptionsStart(builder) + if self.windowDimensions is not None: + StablehloReduceWindowOptionsAddWindowDimensions(builder, windowDimensions) + if self.windowStrides is not None: + StablehloReduceWindowOptionsAddWindowStrides(builder, windowStrides) + if self.baseDilations is not None: + StablehloReduceWindowOptionsAddBaseDilations(builder, baseDilations) + if self.windowDilations is not None: + StablehloReduceWindowOptionsAddWindowDilations(builder, windowDilations) + if self.padding is not None: + StablehloReduceWindowOptionsAddPadding(builder, padding) + StablehloReduceWindowOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex) + stablehloReduceWindowOptions = StablehloReduceWindowOptionsEnd(builder) + return stablehloReduceWindowOptions + + +class StablehloWhileOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloWhileOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloWhileOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloWhileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloWhileOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloWhileOptions + def CondSubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # StablehloWhileOptions + def BodySubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def StablehloWhileOptionsStart(builder): + builder.StartObject(2) + +def StablehloWhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex): + builder.PrependInt32Slot(0, condSubgraphIndex, 0) + +def StablehloWhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): + builder.PrependInt32Slot(1, bodySubgraphIndex, 0) + +def StablehloWhileOptionsEnd(builder): + return builder.EndObject() + + + +class StablehloWhileOptionsT(object): + + # StablehloWhileOptionsT + def __init__(self): + self.condSubgraphIndex = 0 # type: int + self.bodySubgraphIndex = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloWhileOptions = StablehloWhileOptions() + stablehloWhileOptions.Init(buf, pos) + return cls.InitFromObj(stablehloWhileOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloWhileOptions): + x = StablehloWhileOptionsT() + x._UnPack(stablehloWhileOptions) + return x + + # StablehloWhileOptionsT + def _UnPack(self, stablehloWhileOptions): + if stablehloWhileOptions is None: + return + self.condSubgraphIndex = stablehloWhileOptions.CondSubgraphIndex() + self.bodySubgraphIndex = stablehloWhileOptions.BodySubgraphIndex() + + # StablehloWhileOptionsT + def Pack(self, builder): + StablehloWhileOptionsStart(builder) + StablehloWhileOptionsAddCondSubgraphIndex(builder, self.condSubgraphIndex) + StablehloWhileOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex) + stablehloWhileOptions = StablehloWhileOptionsEnd(builder) + return stablehloWhileOptions + + +class StablehloSortOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloSortOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloSortOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloSortOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloSortOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloSortOptions + def Dimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + + # StablehloSortOptions + def IsStable(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # StablehloSortOptions + def ComparatorSubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def StablehloSortOptionsStart(builder): + builder.StartObject(3) + +def StablehloSortOptionsAddDimension(builder, dimension): + builder.PrependInt64Slot(0, dimension, 0) + +def StablehloSortOptionsAddIsStable(builder, isStable): + builder.PrependBoolSlot(1, isStable, 0) + +def StablehloSortOptionsAddComparatorSubgraphIndex(builder, comparatorSubgraphIndex): + builder.PrependInt32Slot(2, comparatorSubgraphIndex, 0) + +def StablehloSortOptionsEnd(builder): + return builder.EndObject() + + + +class StablehloSortOptionsT(object): + + # StablehloSortOptionsT + def __init__(self): + self.dimension = 0 # type: int + self.isStable = False # type: bool + self.comparatorSubgraphIndex = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloSortOptions = StablehloSortOptions() + stablehloSortOptions.Init(buf, pos) + return cls.InitFromObj(stablehloSortOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloSortOptions): + x = StablehloSortOptionsT() + x._UnPack(stablehloSortOptions) + return x + + # StablehloSortOptionsT + def _UnPack(self, stablehloSortOptions): + if stablehloSortOptions is None: + return + self.dimension = stablehloSortOptions.Dimension() + self.isStable = stablehloSortOptions.IsStable() + self.comparatorSubgraphIndex = stablehloSortOptions.ComparatorSubgraphIndex() + + # StablehloSortOptionsT + def Pack(self, builder): + StablehloSortOptionsStart(builder) + StablehloSortOptionsAddDimension(builder, self.dimension) + StablehloSortOptionsAddIsStable(builder, self.isStable) + StablehloSortOptionsAddComparatorSubgraphIndex(builder, self.comparatorSubgraphIndex) + stablehloSortOptions = StablehloSortOptionsEnd(builder) + return stablehloSortOptions + + +class StablehloConcatenateOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloConcatenateOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloConcatenateOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloConcatenateOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloConcatenateOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloConcatenateOptions + def Dimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + +def StablehloConcatenateOptionsStart(builder): + builder.StartObject(1) + +def StablehloConcatenateOptionsAddDimension(builder, dimension): + builder.PrependInt64Slot(0, dimension, 0) + +def StablehloConcatenateOptionsEnd(builder): + return builder.EndObject() + + + +class StablehloConcatenateOptionsT(object): + + # StablehloConcatenateOptionsT + def __init__(self): + self.dimension = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloConcatenateOptions = StablehloConcatenateOptions() + stablehloConcatenateOptions.Init(buf, pos) + return cls.InitFromObj(stablehloConcatenateOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloConcatenateOptions): + x = StablehloConcatenateOptionsT() + x._UnPack(stablehloConcatenateOptions) + return x + + # StablehloConcatenateOptionsT + def _UnPack(self, stablehloConcatenateOptions): + if stablehloConcatenateOptions is None: + return + self.dimension = stablehloConcatenateOptions.Dimension() + + # StablehloConcatenateOptionsT + def Pack(self, builder): + StablehloConcatenateOptionsStart(builder) + StablehloConcatenateOptionsAddDimension(builder, self.dimension) + stablehloConcatenateOptions = StablehloConcatenateOptionsEnd(builder) + return stablehloConcatenateOptions + + +class StablehloBroadcastInDimOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloBroadcastInDimOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloBroadcastInDimOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloBroadcastInDimOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloBroadcastInDimOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloBroadcastInDimOptions + def BroadcastDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloBroadcastInDimOptions + def BroadcastDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloBroadcastInDimOptions + def BroadcastDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloBroadcastInDimOptions + def BroadcastDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def StablehloBroadcastInDimOptionsStart(builder): + builder.StartObject(1) + +def StablehloBroadcastInDimOptionsAddBroadcastDimensions(builder, broadcastDimensions): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(broadcastDimensions), 0) + +def StablehloBroadcastInDimOptionsStartBroadcastDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloBroadcastInDimOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloBroadcastInDimOptionsT(object): + + # StablehloBroadcastInDimOptionsT + def __init__(self): + self.broadcastDimensions = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloBroadcastInDimOptions = StablehloBroadcastInDimOptions() + stablehloBroadcastInDimOptions.Init(buf, pos) + return cls.InitFromObj(stablehloBroadcastInDimOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloBroadcastInDimOptions): + x = StablehloBroadcastInDimOptionsT() + x._UnPack(stablehloBroadcastInDimOptions) + return x + + # StablehloBroadcastInDimOptionsT + def _UnPack(self, stablehloBroadcastInDimOptions): + if stablehloBroadcastInDimOptions is None: + return + if not stablehloBroadcastInDimOptions.BroadcastDimensionsIsNone(): + if np is None: + self.broadcastDimensions = [] + for i in range(stablehloBroadcastInDimOptions.BroadcastDimensionsLength()): + self.broadcastDimensions.append(stablehloBroadcastInDimOptions.BroadcastDimensions(i)) + else: + self.broadcastDimensions = stablehloBroadcastInDimOptions.BroadcastDimensionsAsNumpy() + + # StablehloBroadcastInDimOptionsT + def Pack(self, builder): + if self.broadcastDimensions is not None: + if np is not None and type(self.broadcastDimensions) is np.ndarray: + broadcastDimensions = builder.CreateNumpyVector(self.broadcastDimensions) + else: + StablehloBroadcastInDimOptionsStartBroadcastDimensionsVector(builder, len(self.broadcastDimensions)) + for i in reversed(range(len(self.broadcastDimensions))): + builder.PrependInt64(self.broadcastDimensions[i]) + broadcastDimensions = builder.EndVector() + StablehloBroadcastInDimOptionsStart(builder) + if self.broadcastDimensions is not None: + StablehloBroadcastInDimOptionsAddBroadcastDimensions(builder, broadcastDimensions) + stablehloBroadcastInDimOptions = StablehloBroadcastInDimOptionsEnd(builder) + return stablehloBroadcastInDimOptions + + +class StablehloCompareOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloCompareOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloCompareOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloCompareOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloCompareOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloCompareOptions + def ComparisonDirection(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # StablehloCompareOptions + def CompareType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def StablehloCompareOptionsStart(builder): + builder.StartObject(2) + +def StablehloCompareOptionsAddComparisonDirection(builder, comparisonDirection): + builder.PrependUint32Slot(0, comparisonDirection, 0) + +def StablehloCompareOptionsAddCompareType(builder, compareType): + builder.PrependUint32Slot(1, compareType, 0) + +def StablehloCompareOptionsEnd(builder): + return builder.EndObject() + + + +class StablehloCompareOptionsT(object): + + # StablehloCompareOptionsT + def __init__(self): + self.comparisonDirection = 0 # type: int + self.compareType = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloCompareOptions = StablehloCompareOptions() + stablehloCompareOptions.Init(buf, pos) + return cls.InitFromObj(stablehloCompareOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloCompareOptions): + x = StablehloCompareOptionsT() + x._UnPack(stablehloCompareOptions) + return x + + # StablehloCompareOptionsT + def _UnPack(self, stablehloCompareOptions): + if stablehloCompareOptions is None: + return + self.comparisonDirection = stablehloCompareOptions.ComparisonDirection() + self.compareType = stablehloCompareOptions.CompareType() + + # StablehloCompareOptionsT + def Pack(self, builder): + StablehloCompareOptionsStart(builder) + StablehloCompareOptionsAddComparisonDirection(builder, self.comparisonDirection) + StablehloCompareOptionsAddCompareType(builder, self.compareType) + stablehloCompareOptions = StablehloCompareOptionsEnd(builder) + return stablehloCompareOptions + + +class StablehloDynamicSliceOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloDynamicSliceOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloDynamicSliceOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloDynamicSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloDynamicSliceOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloDynamicSliceOptions + def SliceSizes(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloDynamicSliceOptions + def SliceSizesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloDynamicSliceOptions + def SliceSizesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloDynamicSliceOptions + def SliceSizesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def StablehloDynamicSliceOptionsStart(builder): + builder.StartObject(1) + +def StablehloDynamicSliceOptionsAddSliceSizes(builder, sliceSizes): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(sliceSizes), 0) + +def StablehloDynamicSliceOptionsStartSliceSizesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloDynamicSliceOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloDynamicSliceOptionsT(object): + + # StablehloDynamicSliceOptionsT + def __init__(self): + self.sliceSizes = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloDynamicSliceOptions = StablehloDynamicSliceOptions() + stablehloDynamicSliceOptions.Init(buf, pos) + return cls.InitFromObj(stablehloDynamicSliceOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloDynamicSliceOptions): + x = StablehloDynamicSliceOptionsT() + x._UnPack(stablehloDynamicSliceOptions) + return x + + # StablehloDynamicSliceOptionsT + def _UnPack(self, stablehloDynamicSliceOptions): + if stablehloDynamicSliceOptions is None: + return + if not stablehloDynamicSliceOptions.SliceSizesIsNone(): + if np is None: + self.sliceSizes = [] + for i in range(stablehloDynamicSliceOptions.SliceSizesLength()): + self.sliceSizes.append(stablehloDynamicSliceOptions.SliceSizes(i)) + else: + self.sliceSizes = stablehloDynamicSliceOptions.SliceSizesAsNumpy() + + # StablehloDynamicSliceOptionsT + def Pack(self, builder): + if self.sliceSizes is not None: + if np is not None and type(self.sliceSizes) is np.ndarray: + sliceSizes = builder.CreateNumpyVector(self.sliceSizes) + else: + StablehloDynamicSliceOptionsStartSliceSizesVector(builder, len(self.sliceSizes)) + for i in reversed(range(len(self.sliceSizes))): + builder.PrependInt64(self.sliceSizes[i]) + sliceSizes = builder.EndVector() + StablehloDynamicSliceOptionsStart(builder) + if self.sliceSizes is not None: + StablehloDynamicSliceOptionsAddSliceSizes(builder, sliceSizes) + stablehloDynamicSliceOptions = StablehloDynamicSliceOptionsEnd(builder) + return stablehloDynamicSliceOptions + + +class StablehloPadOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloPadOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloPadOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloPadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloPadOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloPadOptions + def EdgePaddingLow(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloPadOptions + def EdgePaddingLowAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloPadOptions + def EdgePaddingLowLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloPadOptions + def EdgePaddingLowIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # StablehloPadOptions + def EdgePaddingHigh(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloPadOptions + def EdgePaddingHighAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloPadOptions + def EdgePaddingHighLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloPadOptions + def EdgePaddingHighIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # StablehloPadOptions + def InteriorPadding(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloPadOptions + def InteriorPaddingAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloPadOptions + def InteriorPaddingLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloPadOptions + def InteriorPaddingIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + +def StablehloPadOptionsStart(builder): + builder.StartObject(3) + +def StablehloPadOptionsAddEdgePaddingLow(builder, edgePaddingLow): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(edgePaddingLow), 0) + +def StablehloPadOptionsStartEdgePaddingLowVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloPadOptionsAddEdgePaddingHigh(builder, edgePaddingHigh): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(edgePaddingHigh), 0) + +def StablehloPadOptionsStartEdgePaddingHighVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloPadOptionsAddInteriorPadding(builder, interiorPadding): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(interiorPadding), 0) + +def StablehloPadOptionsStartInteriorPaddingVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloPadOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloPadOptionsT(object): + + # StablehloPadOptionsT + def __init__(self): + self.edgePaddingLow = None # type: List[int] + self.edgePaddingHigh = None # type: List[int] + self.interiorPadding = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloPadOptions = StablehloPadOptions() + stablehloPadOptions.Init(buf, pos) + return cls.InitFromObj(stablehloPadOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloPadOptions): + x = StablehloPadOptionsT() + x._UnPack(stablehloPadOptions) + return x + + # StablehloPadOptionsT + def _UnPack(self, stablehloPadOptions): + if stablehloPadOptions is None: + return + if not stablehloPadOptions.EdgePaddingLowIsNone(): + if np is None: + self.edgePaddingLow = [] + for i in range(stablehloPadOptions.EdgePaddingLowLength()): + self.edgePaddingLow.append(stablehloPadOptions.EdgePaddingLow(i)) + else: + self.edgePaddingLow = stablehloPadOptions.EdgePaddingLowAsNumpy() + if not stablehloPadOptions.EdgePaddingHighIsNone(): + if np is None: + self.edgePaddingHigh = [] + for i in range(stablehloPadOptions.EdgePaddingHighLength()): + self.edgePaddingHigh.append(stablehloPadOptions.EdgePaddingHigh(i)) + else: + self.edgePaddingHigh = stablehloPadOptions.EdgePaddingHighAsNumpy() + if not stablehloPadOptions.InteriorPaddingIsNone(): + if np is None: + self.interiorPadding = [] + for i in range(stablehloPadOptions.InteriorPaddingLength()): + self.interiorPadding.append(stablehloPadOptions.InteriorPadding(i)) + else: + self.interiorPadding = stablehloPadOptions.InteriorPaddingAsNumpy() + + # StablehloPadOptionsT + def Pack(self, builder): + if self.edgePaddingLow is not None: + if np is not None and type(self.edgePaddingLow) is np.ndarray: + edgePaddingLow = builder.CreateNumpyVector(self.edgePaddingLow) + else: + StablehloPadOptionsStartEdgePaddingLowVector(builder, len(self.edgePaddingLow)) + for i in reversed(range(len(self.edgePaddingLow))): + builder.PrependInt64(self.edgePaddingLow[i]) + edgePaddingLow = builder.EndVector() + if self.edgePaddingHigh is not None: + if np is not None and type(self.edgePaddingHigh) is np.ndarray: + edgePaddingHigh = builder.CreateNumpyVector(self.edgePaddingHigh) + else: + StablehloPadOptionsStartEdgePaddingHighVector(builder, len(self.edgePaddingHigh)) + for i in reversed(range(len(self.edgePaddingHigh))): + builder.PrependInt64(self.edgePaddingHigh[i]) + edgePaddingHigh = builder.EndVector() + if self.interiorPadding is not None: + if np is not None and type(self.interiorPadding) is np.ndarray: + interiorPadding = builder.CreateNumpyVector(self.interiorPadding) + else: + StablehloPadOptionsStartInteriorPaddingVector(builder, len(self.interiorPadding)) + for i in reversed(range(len(self.interiorPadding))): + builder.PrependInt64(self.interiorPadding[i]) + interiorPadding = builder.EndVector() + StablehloPadOptionsStart(builder) + if self.edgePaddingLow is not None: + StablehloPadOptionsAddEdgePaddingLow(builder, edgePaddingLow) + if self.edgePaddingHigh is not None: + StablehloPadOptionsAddEdgePaddingHigh(builder, edgePaddingHigh) + if self.interiorPadding is not None: + StablehloPadOptionsAddInteriorPadding(builder, interiorPadding) + stablehloPadOptions = StablehloPadOptionsEnd(builder) + return stablehloPadOptions + + +class StablehloIotaOptions(object): + __slots__ = ['_tab'] -def BuiltinOptions2Creator(unionType, table): - from flatbuffers.table import Table - if not isinstance(table, Table): - return None - if unionType == BuiltinOptions2().StablehloConcatenateOptions: - return StablehloConcatenateOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloBroadcastInDimOptions: - return StablehloBroadcastInDimOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloSliceOptions: - return StablehloSliceOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloConvolutionOptions: - return StablehloConvolutionOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloCustomCallOptions: - return StablehloCustomCallOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloReduceOptions: - return StablehloReduceOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloScatterOptions: - return StablehloScatterOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloCompareOptions: - return StablehloCompareOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloDynamicSliceOptions: - return StablehloDynamicSliceOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloPadOptions: - return StablehloPadOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloIotaOptions: - return StablehloIotaOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloDotGeneralOptions: - return StablehloDotGeneralOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloReduceWindowOptions: - return StablehloReduceWindowOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloSortOptions: - return StablehloSortOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloWhileOptions: - return StablehloWhileOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloGatherOptions: - return StablehloGatherOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloTransposeOptions: - return StablehloTransposeOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().DilateOptions: - return DilateOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().StablehloRngBitGeneratorOptions: - return StablehloRngBitGeneratorOptionsT.InitFromBuf(table.Bytes, table.Pos) - if unionType == BuiltinOptions2().ReduceWindowOptions: - return ReduceWindowOptionsT.InitFromBuf(table.Bytes, table.Pos) - return None -# automatically generated by the FlatBuffers compiler, do not modify + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloIotaOptions() + x.Init(buf, n + offset) + return x -# namespace: tflite + @classmethod + def GetRootAsStablehloIotaOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloIotaOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) -from flatbuffers.compat import import_numpy -np = import_numpy() + # StablehloIotaOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) -class CallOnceOptions(object): + # StablehloIotaOptions + def IotaDimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + +def StablehloIotaOptionsStart(builder): + builder.StartObject(1) + +def StablehloIotaOptionsAddIotaDimension(builder, iotaDimension): + builder.PrependInt64Slot(0, iotaDimension, 0) + +def StablehloIotaOptionsEnd(builder): + return builder.EndObject() + + + +class StablehloIotaOptionsT(object): + + # StablehloIotaOptionsT + def __init__(self): + self.iotaDimension = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + stablehloIotaOptions = StablehloIotaOptions() + stablehloIotaOptions.Init(buf, pos) + return cls.InitFromObj(stablehloIotaOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloIotaOptions): + x = StablehloIotaOptionsT() + x._UnPack(stablehloIotaOptions) + return x + + # StablehloIotaOptionsT + def _UnPack(self, stablehloIotaOptions): + if stablehloIotaOptions is None: + return + self.iotaDimension = stablehloIotaOptions.IotaDimension() + + # StablehloIotaOptionsT + def Pack(self, builder): + StablehloIotaOptionsStart(builder) + StablehloIotaOptionsAddIotaDimension(builder, self.iotaDimension) + stablehloIotaOptions = StablehloIotaOptionsEnd(builder) + return stablehloIotaOptions + + +class StablehloCustomCallOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = CallOnceOptions() + x = StablehloCustomCallOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsCallOnceOptions(cls, buf, offset=0): + def GetRootAsStablehloCustomCallOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def CallOnceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def StablehloCustomCallOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # CallOnceOptions + # StablehloCustomCallOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # CallOnceOptions - def InitSubgraphIndex(self): + # StablehloCustomCallOptions + def CallTargetName(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # StablehloCustomCallOptions + def HasSideEffect(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # StablehloCustomCallOptions + def BackendConfig(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # StablehloCustomCallOptions + def ApiVersion(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def CallOnceOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return CallOnceOptionsStart(builder) -def CallOnceOptionsAddInitSubgraphIndex(builder, initSubgraphIndex): builder.PrependInt32Slot(0, initSubgraphIndex, 0) -def AddInitSubgraphIndex(builder, initSubgraphIndex): - return CallOnceOptionsAddInitSubgraphIndex(builder, initSubgraphIndex) -def CallOnceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return CallOnceOptionsEnd(builder) + # StablehloCustomCallOptions + def CalledComputations(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 -class CallOnceOptionsT(object): + # StablehloCustomCallOptions + def CalledComputationsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 - # CallOnceOptionsT - def __init__(self): - self.initSubgraphIndex = 0 # type: int + # StablehloCustomCallOptions + def CalledComputationsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 - @classmethod - def InitFromBuf(cls, buf, pos): - callOnceOptions = CallOnceOptions() - callOnceOptions.Init(buf, pos) - return cls.InitFromObj(callOnceOptions) + # StablehloCustomCallOptions + def CalledComputationsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 + + # StablehloCustomCallOptions + def CustomAttributes(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # StablehloCustomCallOptions + def CustomAttributesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # StablehloCustomCallOptions + def CustomAttributesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloCustomCallOptions + def CustomAttributesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + return o == 0 - @classmethod - def InitFromObj(cls, callOnceOptions): - x = CallOnceOptionsT() - x._UnPack(callOnceOptions) - return x +def StablehloCustomCallOptionsStart(builder): + builder.StartObject(6) - # CallOnceOptionsT - def _UnPack(self, callOnceOptions): - if callOnceOptions is None: - return - self.initSubgraphIndex = callOnceOptions.InitSubgraphIndex() +def StablehloCustomCallOptionsAddCallTargetName(builder, callTargetName): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(callTargetName), 0) - # CallOnceOptionsT - def Pack(self, builder): - CallOnceOptionsStart(builder) - CallOnceOptionsAddInitSubgraphIndex(builder, self.initSubgraphIndex) - callOnceOptions = CallOnceOptionsEnd(builder) - return callOnceOptions -# automatically generated by the FlatBuffers compiler, do not modify +def StablehloCustomCallOptionsAddHasSideEffect(builder, hasSideEffect): + builder.PrependBoolSlot(1, hasSideEffect, 0) -# namespace: tflite +def StablehloCustomCallOptionsAddBackendConfig(builder, backendConfig): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(backendConfig), 0) -from flatbuffers.compat import import_numpy -np = import_numpy() +def StablehloCustomCallOptionsAddApiVersion(builder, apiVersion): + builder.PrependInt32Slot(3, apiVersion, 0) -class CallOptions(object): - __slots__ = ['_tab'] +def StablehloCustomCallOptionsAddCalledComputations(builder, calledComputations): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(calledComputations), 0) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = CallOptions() - x.Init(buf, n + offset) - return x +def StablehloCustomCallOptionsStartCalledComputationsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - @classmethod - def GetRootAsCallOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def CallOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def StablehloCustomCallOptionsAddCustomAttributes(builder, customAttributes): + builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customAttributes), 0) - # CallOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def StablehloCustomCallOptionsStartCustomAttributesVector(builder, numElems): + return builder.StartVector(1, numElems, 1) - # CallOptions - def Subgraph(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) - return 0 +def StablehloCustomCallOptionsEnd(builder): + return builder.EndObject() -def CallOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return CallOptionsStart(builder) -def CallOptionsAddSubgraph(builder, subgraph): builder.PrependUint32Slot(0, subgraph, 0) -def AddSubgraph(builder, subgraph): - return CallOptionsAddSubgraph(builder, subgraph) -def CallOptionsEnd(builder): return builder.EndObject() -def End(builder): - return CallOptionsEnd(builder) -class CallOptionsT(object): +try: + from typing import List +except: + pass - # CallOptionsT +class StablehloCustomCallOptionsT(object): + + # StablehloCustomCallOptionsT def __init__(self): - self.subgraph = 0 # type: int + self.callTargetName = None # type: str + self.hasSideEffect = False # type: bool + self.backendConfig = None # type: str + self.apiVersion = 0 # type: int + self.calledComputations = None # type: List[int] + self.customAttributes = None # type: List[int] @classmethod def InitFromBuf(cls, buf, pos): - callOptions = CallOptions() - callOptions.Init(buf, pos) - return cls.InitFromObj(callOptions) + stablehloCustomCallOptions = StablehloCustomCallOptions() + stablehloCustomCallOptions.Init(buf, pos) + return cls.InitFromObj(stablehloCustomCallOptions) @classmethod - def InitFromObj(cls, callOptions): - x = CallOptionsT() - x._UnPack(callOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloCustomCallOptions): + x = StablehloCustomCallOptionsT() + x._UnPack(stablehloCustomCallOptions) return x - # CallOptionsT - def _UnPack(self, callOptions): - if callOptions is None: + # StablehloCustomCallOptionsT + def _UnPack(self, stablehloCustomCallOptions): + if stablehloCustomCallOptions is None: return - self.subgraph = callOptions.Subgraph() + self.callTargetName = stablehloCustomCallOptions.CallTargetName() + self.hasSideEffect = stablehloCustomCallOptions.HasSideEffect() + self.backendConfig = stablehloCustomCallOptions.BackendConfig() + self.apiVersion = stablehloCustomCallOptions.ApiVersion() + if not stablehloCustomCallOptions.CalledComputationsIsNone(): + if np is None: + self.calledComputations = [] + for i in range(stablehloCustomCallOptions.CalledComputationsLength()): + self.calledComputations.append(stablehloCustomCallOptions.CalledComputations(i)) + else: + self.calledComputations = stablehloCustomCallOptions.CalledComputationsAsNumpy() + if not stablehloCustomCallOptions.CustomAttributesIsNone(): + if np is None: + self.customAttributes = [] + for i in range(stablehloCustomCallOptions.CustomAttributesLength()): + self.customAttributes.append(stablehloCustomCallOptions.CustomAttributes(i)) + else: + self.customAttributes = stablehloCustomCallOptions.CustomAttributesAsNumpy() - # CallOptionsT + # StablehloCustomCallOptionsT def Pack(self, builder): - CallOptionsStart(builder) - CallOptionsAddSubgraph(builder, self.subgraph) - callOptions = CallOptionsEnd(builder) - return callOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.callTargetName is not None: + callTargetName = builder.CreateString(self.callTargetName) + if self.backendConfig is not None: + backendConfig = builder.CreateString(self.backendConfig) + if self.calledComputations is not None: + if np is not None and type(self.calledComputations) is np.ndarray: + calledComputations = builder.CreateNumpyVector(self.calledComputations) + else: + StablehloCustomCallOptionsStartCalledComputationsVector(builder, len(self.calledComputations)) + for i in reversed(range(len(self.calledComputations))): + builder.PrependInt32(self.calledComputations[i]) + calledComputations = builder.EndVector() + if self.customAttributes is not None: + if np is not None and type(self.customAttributes) is np.ndarray: + customAttributes = builder.CreateNumpyVector(self.customAttributes) + else: + StablehloCustomCallOptionsStartCustomAttributesVector(builder, len(self.customAttributes)) + for i in reversed(range(len(self.customAttributes))): + builder.PrependUint8(self.customAttributes[i]) + customAttributes = builder.EndVector() + StablehloCustomCallOptionsStart(builder) + if self.callTargetName is not None: + StablehloCustomCallOptionsAddCallTargetName(builder, callTargetName) + StablehloCustomCallOptionsAddHasSideEffect(builder, self.hasSideEffect) + if self.backendConfig is not None: + StablehloCustomCallOptionsAddBackendConfig(builder, backendConfig) + StablehloCustomCallOptionsAddApiVersion(builder, self.apiVersion) + if self.calledComputations is not None: + StablehloCustomCallOptionsAddCalledComputations(builder, calledComputations) + if self.customAttributes is not None: + StablehloCustomCallOptionsAddCustomAttributes(builder, customAttributes) + stablehloCustomCallOptions = StablehloCustomCallOptionsEnd(builder) + return stablehloCustomCallOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class CastOptions(object): +class StablehloReduceOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = CastOptions() + x = StablehloReduceOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsCastOptions(cls, buf, offset=0): + def GetRootAsStablehloReduceOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def CastOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def StablehloReduceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # CastOptions + # StablehloReduceOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # CastOptions - def InDataType(self): + # StablehloReduceOptions + def Dimensions(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) return 0 - # CastOptions - def OutDataType(self): + # StablehloReduceOptions + def DimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloReduceOptions + def DimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloReduceOptions + def DimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # StablehloReduceOptions + def BodySubgraphIndex(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def CastOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return CastOptionsStart(builder) -def CastOptionsAddInDataType(builder, inDataType): builder.PrependInt8Slot(0, inDataType, 0) -def AddInDataType(builder, inDataType): - return CastOptionsAddInDataType(builder, inDataType) -def CastOptionsAddOutDataType(builder, outDataType): builder.PrependInt8Slot(1, outDataType, 0) -def AddOutDataType(builder, outDataType): - return CastOptionsAddOutDataType(builder, outDataType) -def CastOptionsEnd(builder): return builder.EndObject() -def End(builder): - return CastOptionsEnd(builder) +def StablehloReduceOptionsStart(builder): + builder.StartObject(2) -class CastOptionsT(object): +def StablehloReduceOptionsAddDimensions(builder, dimensions): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(dimensions), 0) - # CastOptionsT +def StablehloReduceOptionsStartDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloReduceOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): + builder.PrependInt32Slot(1, bodySubgraphIndex, 0) + +def StablehloReduceOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloReduceOptionsT(object): + + # StablehloReduceOptionsT def __init__(self): - self.inDataType = 0 # type: int - self.outDataType = 0 # type: int + self.dimensions = None # type: List[int] + self.bodySubgraphIndex = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - castOptions = CastOptions() - castOptions.Init(buf, pos) - return cls.InitFromObj(castOptions) + stablehloReduceOptions = StablehloReduceOptions() + stablehloReduceOptions.Init(buf, pos) + return cls.InitFromObj(stablehloReduceOptions) @classmethod - def InitFromObj(cls, castOptions): - x = CastOptionsT() - x._UnPack(castOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloReduceOptions): + x = StablehloReduceOptionsT() + x._UnPack(stablehloReduceOptions) return x - # CastOptionsT - def _UnPack(self, castOptions): - if castOptions is None: + # StablehloReduceOptionsT + def _UnPack(self, stablehloReduceOptions): + if stablehloReduceOptions is None: return - self.inDataType = castOptions.InDataType() - self.outDataType = castOptions.OutDataType() + if not stablehloReduceOptions.DimensionsIsNone(): + if np is None: + self.dimensions = [] + for i in range(stablehloReduceOptions.DimensionsLength()): + self.dimensions.append(stablehloReduceOptions.Dimensions(i)) + else: + self.dimensions = stablehloReduceOptions.DimensionsAsNumpy() + self.bodySubgraphIndex = stablehloReduceOptions.BodySubgraphIndex() - # CastOptionsT + # StablehloReduceOptionsT def Pack(self, builder): - CastOptionsStart(builder) - CastOptionsAddInDataType(builder, self.inDataType) - CastOptionsAddOutDataType(builder, self.outDataType) - castOptions = CastOptionsEnd(builder) - return castOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class CombinerType(object): - SUM = 0 - MEAN = 1 - SQRTN = 2 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.dimensions is not None: + if np is not None and type(self.dimensions) is np.ndarray: + dimensions = builder.CreateNumpyVector(self.dimensions) + else: + StablehloReduceOptionsStartDimensionsVector(builder, len(self.dimensions)) + for i in reversed(range(len(self.dimensions))): + builder.PrependInt64(self.dimensions[i]) + dimensions = builder.EndVector() + StablehloReduceOptionsStart(builder) + if self.dimensions is not None: + StablehloReduceOptionsAddDimensions(builder, dimensions) + StablehloReduceOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex) + stablehloReduceOptions = StablehloReduceOptionsEnd(builder) + return stablehloReduceOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ConcatEmbeddingsOptions(object): +class StablehloSliceOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ConcatEmbeddingsOptions() + x = StablehloSliceOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsConcatEmbeddingsOptions(cls, buf, offset=0): + def GetRootAsStablehloSliceOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ConcatEmbeddingsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def StablehloSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ConcatEmbeddingsOptions + # StablehloSliceOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # ConcatEmbeddingsOptions - def NumChannels(self): + # StablehloSliceOptions + def StartIndices(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) return 0 - # ConcatEmbeddingsOptions - def NumColumnsPerChannel(self, j): + # StablehloSliceOptions + def StartIndicesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloSliceOptions + def StartIndicesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloSliceOptions + def StartIndicesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # StablehloSliceOptions + def LimitIndices(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) return 0 - # ConcatEmbeddingsOptions - def NumColumnsPerChannelAsNumpy(self): + # StablehloSliceOptions + def LimitIndicesAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) return 0 - # ConcatEmbeddingsOptions - def NumColumnsPerChannelLength(self): + # StablehloSliceOptions + def LimitIndicesLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.VectorLen(o) return 0 - # ConcatEmbeddingsOptions - def NumColumnsPerChannelIsNone(self): + # StablehloSliceOptions + def LimitIndicesIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) return o == 0 - # ConcatEmbeddingsOptions - def EmbeddingDimPerChannel(self, j): + # StablehloSliceOptions + def Strides(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) return 0 - # ConcatEmbeddingsOptions - def EmbeddingDimPerChannelAsNumpy(self): + # StablehloSliceOptions + def StridesAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) return 0 - # ConcatEmbeddingsOptions - def EmbeddingDimPerChannelLength(self): + # StablehloSliceOptions + def StridesLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return self._tab.VectorLen(o) return 0 - # ConcatEmbeddingsOptions - def EmbeddingDimPerChannelIsNone(self): + # StablehloSliceOptions + def StridesIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) return o == 0 -def ConcatEmbeddingsOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return ConcatEmbeddingsOptionsStart(builder) -def ConcatEmbeddingsOptionsAddNumChannels(builder, numChannels): builder.PrependInt32Slot(0, numChannels, 0) -def AddNumChannels(builder, numChannels): - return ConcatEmbeddingsOptionsAddNumChannels(builder, numChannels) -def ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(numColumnsPerChannel), 0) -def AddNumColumnsPerChannel(builder, numColumnsPerChannel): - return ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel) -def ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartNumColumnsPerChannelVector(builder, numElems): - return ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, numElems) -def ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(embeddingDimPerChannel), 0) -def AddEmbeddingDimPerChannel(builder, embeddingDimPerChannel): - return ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel) -def ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartEmbeddingDimPerChannelVector(builder, numElems): - return ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, numElems) -def ConcatEmbeddingsOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ConcatEmbeddingsOptionsEnd(builder) +def StablehloSliceOptionsStart(builder): + builder.StartObject(3) + +def StablehloSliceOptionsAddStartIndices(builder, startIndices): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(startIndices), 0) + +def StablehloSliceOptionsStartStartIndicesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloSliceOptionsAddLimitIndices(builder, limitIndices): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(limitIndices), 0) + +def StablehloSliceOptionsStartLimitIndicesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloSliceOptionsAddStrides(builder, strides): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(strides), 0) + +def StablehloSliceOptionsStartStridesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloSliceOptionsEnd(builder): + return builder.EndObject() + + try: from typing import List except: pass -class ConcatEmbeddingsOptionsT(object): +class StablehloSliceOptionsT(object): - # ConcatEmbeddingsOptionsT + # StablehloSliceOptionsT def __init__(self): - self.numChannels = 0 # type: int - self.numColumnsPerChannel = None # type: List[int] - self.embeddingDimPerChannel = None # type: List[int] + self.startIndices = None # type: List[int] + self.limitIndices = None # type: List[int] + self.strides = None # type: List[int] @classmethod def InitFromBuf(cls, buf, pos): - concatEmbeddingsOptions = ConcatEmbeddingsOptions() - concatEmbeddingsOptions.Init(buf, pos) - return cls.InitFromObj(concatEmbeddingsOptions) + stablehloSliceOptions = StablehloSliceOptions() + stablehloSliceOptions.Init(buf, pos) + return cls.InitFromObj(stablehloSliceOptions) @classmethod - def InitFromObj(cls, concatEmbeddingsOptions): - x = ConcatEmbeddingsOptionsT() - x._UnPack(concatEmbeddingsOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloSliceOptions): + x = StablehloSliceOptionsT() + x._UnPack(stablehloSliceOptions) return x - # ConcatEmbeddingsOptionsT - def _UnPack(self, concatEmbeddingsOptions): - if concatEmbeddingsOptions is None: + # StablehloSliceOptionsT + def _UnPack(self, stablehloSliceOptions): + if stablehloSliceOptions is None: return - self.numChannels = concatEmbeddingsOptions.NumChannels() - if not concatEmbeddingsOptions.NumColumnsPerChannelIsNone(): + if not stablehloSliceOptions.StartIndicesIsNone(): if np is None: - self.numColumnsPerChannel = [] - for i in range(concatEmbeddingsOptions.NumColumnsPerChannelLength()): - self.numColumnsPerChannel.append(concatEmbeddingsOptions.NumColumnsPerChannel(i)) + self.startIndices = [] + for i in range(stablehloSliceOptions.StartIndicesLength()): + self.startIndices.append(stablehloSliceOptions.StartIndices(i)) else: - self.numColumnsPerChannel = concatEmbeddingsOptions.NumColumnsPerChannelAsNumpy() - if not concatEmbeddingsOptions.EmbeddingDimPerChannelIsNone(): + self.startIndices = stablehloSliceOptions.StartIndicesAsNumpy() + if not stablehloSliceOptions.LimitIndicesIsNone(): if np is None: - self.embeddingDimPerChannel = [] - for i in range(concatEmbeddingsOptions.EmbeddingDimPerChannelLength()): - self.embeddingDimPerChannel.append(concatEmbeddingsOptions.EmbeddingDimPerChannel(i)) + self.limitIndices = [] + for i in range(stablehloSliceOptions.LimitIndicesLength()): + self.limitIndices.append(stablehloSliceOptions.LimitIndices(i)) else: - self.embeddingDimPerChannel = concatEmbeddingsOptions.EmbeddingDimPerChannelAsNumpy() + self.limitIndices = stablehloSliceOptions.LimitIndicesAsNumpy() + if not stablehloSliceOptions.StridesIsNone(): + if np is None: + self.strides = [] + for i in range(stablehloSliceOptions.StridesLength()): + self.strides.append(stablehloSliceOptions.Strides(i)) + else: + self.strides = stablehloSliceOptions.StridesAsNumpy() - # ConcatEmbeddingsOptionsT + # StablehloSliceOptionsT def Pack(self, builder): - if self.numColumnsPerChannel is not None: - if np is not None and type(self.numColumnsPerChannel) is np.ndarray: - numColumnsPerChannel = builder.CreateNumpyVector(self.numColumnsPerChannel) + if self.startIndices is not None: + if np is not None and type(self.startIndices) is np.ndarray: + startIndices = builder.CreateNumpyVector(self.startIndices) else: - ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, len(self.numColumnsPerChannel)) - for i in reversed(range(len(self.numColumnsPerChannel))): - builder.PrependInt32(self.numColumnsPerChannel[i]) - numColumnsPerChannel = builder.EndVector() - if self.embeddingDimPerChannel is not None: - if np is not None and type(self.embeddingDimPerChannel) is np.ndarray: - embeddingDimPerChannel = builder.CreateNumpyVector(self.embeddingDimPerChannel) + StablehloSliceOptionsStartStartIndicesVector(builder, len(self.startIndices)) + for i in reversed(range(len(self.startIndices))): + builder.PrependInt64(self.startIndices[i]) + startIndices = builder.EndVector() + if self.limitIndices is not None: + if np is not None and type(self.limitIndices) is np.ndarray: + limitIndices = builder.CreateNumpyVector(self.limitIndices) else: - ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, len(self.embeddingDimPerChannel)) - for i in reversed(range(len(self.embeddingDimPerChannel))): - builder.PrependInt32(self.embeddingDimPerChannel[i]) - embeddingDimPerChannel = builder.EndVector() - ConcatEmbeddingsOptionsStart(builder) - ConcatEmbeddingsOptionsAddNumChannels(builder, self.numChannels) - if self.numColumnsPerChannel is not None: - ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel) - if self.embeddingDimPerChannel is not None: - ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel) - concatEmbeddingsOptions = ConcatEmbeddingsOptionsEnd(builder) - return concatEmbeddingsOptions -# automatically generated by the FlatBuffers compiler, do not modify + StablehloSliceOptionsStartLimitIndicesVector(builder, len(self.limitIndices)) + for i in reversed(range(len(self.limitIndices))): + builder.PrependInt64(self.limitIndices[i]) + limitIndices = builder.EndVector() + if self.strides is not None: + if np is not None and type(self.strides) is np.ndarray: + strides = builder.CreateNumpyVector(self.strides) + else: + StablehloSliceOptionsStartStridesVector(builder, len(self.strides)) + for i in reversed(range(len(self.strides))): + builder.PrependInt64(self.strides[i]) + strides = builder.EndVector() + StablehloSliceOptionsStart(builder) + if self.startIndices is not None: + StablehloSliceOptionsAddStartIndices(builder, startIndices) + if self.limitIndices is not None: + StablehloSliceOptionsAddLimitIndices(builder, limitIndices) + if self.strides is not None: + StablehloSliceOptionsAddStrides(builder, strides) + stablehloSliceOptions = StablehloSliceOptionsEnd(builder) + return stablehloSliceOptions + + +class StablehloConvolutionOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = StablehloConvolutionOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsStablehloConvolutionOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def StablehloConvolutionOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # StablehloConvolutionOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # StablehloConvolutionOptions + def WindowStrides(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloConvolutionOptions + def WindowStridesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloConvolutionOptions + def WindowStridesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 -# namespace: tflite + # StablehloConvolutionOptions + def WindowStridesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 -from flatbuffers.compat import import_numpy -np = import_numpy() + # StablehloConvolutionOptions + def Padding(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 -class ConcatenationOptions(object): - __slots__ = ['_tab'] + # StablehloConvolutionOptions + def PaddingAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ConcatenationOptions() - x.Init(buf, n + offset) - return x + # StablehloConvolutionOptions + def PaddingLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 - @classmethod - def GetRootAsConcatenationOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def ConcatenationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + # StablehloConvolutionOptions + def PaddingIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 - # ConcatenationOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) + # StablehloConvolutionOptions + def LhsDilation(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 - # ConcatenationOptions - def Axis(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # StablehloConvolutionOptions + def LhsDilationAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) return 0 - # ConcatenationOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + # StablehloConvolutionOptions + def LhsDilationLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.VectorLen(o) return 0 -def ConcatenationOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return ConcatenationOptionsStart(builder) -def ConcatenationOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) -def AddAxis(builder, axis): - return ConcatenationOptionsAddAxis(builder, axis) -def ConcatenationOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return ConcatenationOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def ConcatenationOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ConcatenationOptionsEnd(builder) + # StablehloConvolutionOptions + def LhsDilationIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 -class ConcatenationOptionsT(object): + # StablehloConvolutionOptions + def RhsDilation(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 - # ConcatenationOptionsT - def __init__(self): - self.axis = 0 # type: int - self.fusedActivationFunction = 0 # type: int + # StablehloConvolutionOptions + def RhsDilationAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 - @classmethod - def InitFromBuf(cls, buf, pos): - concatenationOptions = ConcatenationOptions() - concatenationOptions.Init(buf, pos) - return cls.InitFromObj(concatenationOptions) + # StablehloConvolutionOptions + def RhsDilationLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 - @classmethod - def InitFromObj(cls, concatenationOptions): - x = ConcatenationOptionsT() - x._UnPack(concatenationOptions) - return x + # StablehloConvolutionOptions + def RhsDilationIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 - # ConcatenationOptionsT - def _UnPack(self, concatenationOptions): - if concatenationOptions is None: - return - self.axis = concatenationOptions.Axis() - self.fusedActivationFunction = concatenationOptions.FusedActivationFunction() + # StablehloConvolutionOptions + def WindowReversal(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 - # ConcatenationOptionsT - def Pack(self, builder): - ConcatenationOptionsStart(builder) - ConcatenationOptionsAddAxis(builder, self.axis) - ConcatenationOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - concatenationOptions = ConcatenationOptionsEnd(builder) - return concatenationOptions -# automatically generated by the FlatBuffers compiler, do not modify + # StablehloConvolutionOptions + def WindowReversalAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o) + return 0 -# namespace: tflite + # StablehloConvolutionOptions + def WindowReversalLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 -from flatbuffers.compat import import_numpy -np = import_numpy() + # StablehloConvolutionOptions + def WindowReversalIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 -class Conv2DOptions(object): - __slots__ = ['_tab'] + # StablehloConvolutionOptions + def InputBatchDimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Conv2DOptions() - x.Init(buf, n + offset) - return x + # StablehloConvolutionOptions + def InputFeatureDimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 - @classmethod - def GetRootAsConv2DOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def Conv2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + # StablehloConvolutionOptions + def InputSpatialDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 - # Conv2DOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) + # StablehloConvolutionOptions + def InputSpatialDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 - # Conv2DOptions - def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # StablehloConvolutionOptions + def InputSpatialDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.VectorLen(o) return 0 - # Conv2DOptions - def StrideW(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + # StablehloConvolutionOptions + def InputSpatialDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + return o == 0 + + # StablehloConvolutionOptions + def KernelInputFeatureDimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) return 0 - # Conv2DOptions - def StrideH(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + # StablehloConvolutionOptions + def KernelOutputFeatureDimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + + # StablehloConvolutionOptions + def KernelSpatialDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # StablehloConvolutionOptions + def KernelSpatialDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 + + # StablehloConvolutionOptions + def KernelSpatialDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # StablehloConvolutionOptions + def KernelSpatialDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + return o == 0 + + # StablehloConvolutionOptions + def OutputBatchDimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) return 0 - # Conv2DOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + # StablehloConvolutionOptions + def OutputFeatureDimension(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) return 0 - # Conv2DOptions - def DilationWFactor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + # StablehloConvolutionOptions + def OutputSpatialDimensions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 1 + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 - # Conv2DOptions - def DilationHFactor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + # StablehloConvolutionOptions + def OutputSpatialDimensionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 1 + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 - # Conv2DOptions - def QuantizedBiasType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + # StablehloConvolutionOptions + def OutputSpatialDimensionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.VectorLen(o) return 0 -def Conv2DOptionsStart(builder): builder.StartObject(7) -def Start(builder): - return Conv2DOptionsStart(builder) -def Conv2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) -def AddPadding(builder, padding): - return Conv2DOptionsAddPadding(builder, padding) -def Conv2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0) -def AddStrideW(builder, strideW): - return Conv2DOptionsAddStrideW(builder, strideW) -def Conv2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0) -def AddStrideH(builder, strideH): - return Conv2DOptionsAddStrideH(builder, strideH) -def Conv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(3, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return Conv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def Conv2DOptionsAddDilationWFactor(builder, dilationWFactor): builder.PrependInt32Slot(4, dilationWFactor, 1) -def AddDilationWFactor(builder, dilationWFactor): - return Conv2DOptionsAddDilationWFactor(builder, dilationWFactor) -def Conv2DOptionsAddDilationHFactor(builder, dilationHFactor): builder.PrependInt32Slot(5, dilationHFactor, 1) -def AddDilationHFactor(builder, dilationHFactor): - return Conv2DOptionsAddDilationHFactor(builder, dilationHFactor) -def Conv2DOptionsAddQuantizedBiasType(builder, quantizedBiasType): builder.PrependInt8Slot(6, quantizedBiasType, 0) -def AddQuantizedBiasType(builder, quantizedBiasType): - return Conv2DOptionsAddQuantizedBiasType(builder, quantizedBiasType) -def Conv2DOptionsEnd(builder): return builder.EndObject() -def End(builder): - return Conv2DOptionsEnd(builder) - -class Conv2DOptionsT(object): - - # Conv2DOptionsT - def __init__(self): - self.padding = 0 # type: int - self.strideW = 0 # type: int - self.strideH = 0 # type: int - self.fusedActivationFunction = 0 # type: int - self.dilationWFactor = 1 # type: int - self.dilationHFactor = 1 # type: int - self.quantizedBiasType = 0 # type: int - - @classmethod - def InitFromBuf(cls, buf, pos): - conv2doptions = Conv2DOptions() - conv2doptions.Init(buf, pos) - return cls.InitFromObj(conv2doptions) - - @classmethod - def InitFromObj(cls, conv2doptions): - x = Conv2DOptionsT() - x._UnPack(conv2doptions) - return x - - # Conv2DOptionsT - def _UnPack(self, conv2doptions): - if conv2doptions is None: - return - self.padding = conv2doptions.Padding() - self.strideW = conv2doptions.StrideW() - self.strideH = conv2doptions.StrideH() - self.fusedActivationFunction = conv2doptions.FusedActivationFunction() - self.dilationWFactor = conv2doptions.DilationWFactor() - self.dilationHFactor = conv2doptions.DilationHFactor() - self.quantizedBiasType = conv2doptions.QuantizedBiasType() - - # Conv2DOptionsT - def Pack(self, builder): - Conv2DOptionsStart(builder) - Conv2DOptionsAddPadding(builder, self.padding) - Conv2DOptionsAddStrideW(builder, self.strideW) - Conv2DOptionsAddStrideH(builder, self.strideH) - Conv2DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - Conv2DOptionsAddDilationWFactor(builder, self.dilationWFactor) - Conv2DOptionsAddDilationHFactor(builder, self.dilationHFactor) - Conv2DOptionsAddQuantizedBiasType(builder, self.quantizedBiasType) - conv2doptions = Conv2DOptionsEnd(builder) - return conv2doptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class Conv3DOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Conv3DOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsConv3DOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def Conv3DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # Conv3DOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) + # StablehloConvolutionOptions + def OutputSpatialDimensionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) + return o == 0 - # Conv3DOptions - def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # StablehloConvolutionOptions + def FeatureGroupCount(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) return 0 - # Conv3DOptions - def StrideD(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + # StablehloConvolutionOptions + def BatchGroupCount(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) return 0 - # Conv3DOptions - def StrideW(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + # StablehloConvolutionOptions + def PrecisionConfig(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) return 0 - # Conv3DOptions - def StrideH(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + # StablehloConvolutionOptions + def PrecisionConfigAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o) return 0 - # Conv3DOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + # StablehloConvolutionOptions + def PrecisionConfigLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.VectorLen(o) return 0 - # Conv3DOptions - def DilationDFactor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 1 - - # Conv3DOptions - def DilationWFactor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 1 + # StablehloConvolutionOptions + def PrecisionConfigIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) + return o == 0 - # Conv3DOptions - def DilationHFactor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 1 +def StablehloConvolutionOptionsStart(builder): + builder.StartObject(17) -def Conv3DOptionsStart(builder): builder.StartObject(8) -def Start(builder): - return Conv3DOptionsStart(builder) -def Conv3DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) -def AddPadding(builder, padding): - return Conv3DOptionsAddPadding(builder, padding) -def Conv3DOptionsAddStrideD(builder, strideD): builder.PrependInt32Slot(1, strideD, 0) -def AddStrideD(builder, strideD): - return Conv3DOptionsAddStrideD(builder, strideD) -def Conv3DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(2, strideW, 0) -def AddStrideW(builder, strideW): - return Conv3DOptionsAddStrideW(builder, strideW) -def Conv3DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(3, strideH, 0) -def AddStrideH(builder, strideH): - return Conv3DOptionsAddStrideH(builder, strideH) -def Conv3DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(4, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return Conv3DOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def Conv3DOptionsAddDilationDFactor(builder, dilationDFactor): builder.PrependInt32Slot(5, dilationDFactor, 1) -def AddDilationDFactor(builder, dilationDFactor): - return Conv3DOptionsAddDilationDFactor(builder, dilationDFactor) -def Conv3DOptionsAddDilationWFactor(builder, dilationWFactor): builder.PrependInt32Slot(6, dilationWFactor, 1) -def AddDilationWFactor(builder, dilationWFactor): - return Conv3DOptionsAddDilationWFactor(builder, dilationWFactor) -def Conv3DOptionsAddDilationHFactor(builder, dilationHFactor): builder.PrependInt32Slot(7, dilationHFactor, 1) -def AddDilationHFactor(builder, dilationHFactor): - return Conv3DOptionsAddDilationHFactor(builder, dilationHFactor) -def Conv3DOptionsEnd(builder): return builder.EndObject() -def End(builder): - return Conv3DOptionsEnd(builder) +def StablehloConvolutionOptionsAddWindowStrides(builder, windowStrides): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(windowStrides), 0) -class Conv3DOptionsT(object): +def StablehloConvolutionOptionsStartWindowStridesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) - # Conv3DOptionsT - def __init__(self): - self.padding = 0 # type: int - self.strideD = 0 # type: int - self.strideW = 0 # type: int - self.strideH = 0 # type: int - self.fusedActivationFunction = 0 # type: int - self.dilationDFactor = 1 # type: int - self.dilationWFactor = 1 # type: int - self.dilationHFactor = 1 # type: int +def StablehloConvolutionOptionsAddPadding(builder, padding): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) - @classmethod - def InitFromBuf(cls, buf, pos): - conv3doptions = Conv3DOptions() - conv3doptions.Init(buf, pos) - return cls.InitFromObj(conv3doptions) +def StablehloConvolutionOptionsStartPaddingVector(builder, numElems): + return builder.StartVector(8, numElems, 8) - @classmethod - def InitFromObj(cls, conv3doptions): - x = Conv3DOptionsT() - x._UnPack(conv3doptions) - return x +def StablehloConvolutionOptionsAddLhsDilation(builder, lhsDilation): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(lhsDilation), 0) - # Conv3DOptionsT - def _UnPack(self, conv3doptions): - if conv3doptions is None: - return - self.padding = conv3doptions.Padding() - self.strideD = conv3doptions.StrideD() - self.strideW = conv3doptions.StrideW() - self.strideH = conv3doptions.StrideH() - self.fusedActivationFunction = conv3doptions.FusedActivationFunction() - self.dilationDFactor = conv3doptions.DilationDFactor() - self.dilationWFactor = conv3doptions.DilationWFactor() - self.dilationHFactor = conv3doptions.DilationHFactor() +def StablehloConvolutionOptionsStartLhsDilationVector(builder, numElems): + return builder.StartVector(8, numElems, 8) - # Conv3DOptionsT - def Pack(self, builder): - Conv3DOptionsStart(builder) - Conv3DOptionsAddPadding(builder, self.padding) - Conv3DOptionsAddStrideD(builder, self.strideD) - Conv3DOptionsAddStrideW(builder, self.strideW) - Conv3DOptionsAddStrideH(builder, self.strideH) - Conv3DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - Conv3DOptionsAddDilationDFactor(builder, self.dilationDFactor) - Conv3DOptionsAddDilationWFactor(builder, self.dilationWFactor) - Conv3DOptionsAddDilationHFactor(builder, self.dilationHFactor) - conv3doptions = Conv3DOptionsEnd(builder) - return conv3doptions -# automatically generated by the FlatBuffers compiler, do not modify +def StablehloConvolutionOptionsAddRhsDilation(builder, rhsDilation): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(rhsDilation), 0) -# namespace: tflite +def StablehloConvolutionOptionsStartRhsDilationVector(builder, numElems): + return builder.StartVector(8, numElems, 8) -from flatbuffers.compat import import_numpy -np = import_numpy() +def StablehloConvolutionOptionsAddWindowReversal(builder, windowReversal): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(windowReversal), 0) -class CosOptions(object): - __slots__ = ['_tab'] +def StablehloConvolutionOptionsStartWindowReversalVector(builder, numElems): + return builder.StartVector(1, numElems, 1) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = CosOptions() - x.Init(buf, n + offset) - return x +def StablehloConvolutionOptionsAddInputBatchDimension(builder, inputBatchDimension): + builder.PrependInt64Slot(5, inputBatchDimension, 0) - @classmethod - def GetRootAsCosOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def CosOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def StablehloConvolutionOptionsAddInputFeatureDimension(builder, inputFeatureDimension): + builder.PrependInt64Slot(6, inputFeatureDimension, 0) - # CosOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def StablehloConvolutionOptionsAddInputSpatialDimensions(builder, inputSpatialDimensions): + builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(inputSpatialDimensions), 0) -def CosOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return CosOptionsStart(builder) -def CosOptionsEnd(builder): return builder.EndObject() -def End(builder): - return CosOptionsEnd(builder) +def StablehloConvolutionOptionsStartInputSpatialDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) -class CosOptionsT(object): +def StablehloConvolutionOptionsAddKernelInputFeatureDimension(builder, kernelInputFeatureDimension): + builder.PrependInt64Slot(8, kernelInputFeatureDimension, 0) - # CosOptionsT - def __init__(self): - pass +def StablehloConvolutionOptionsAddKernelOutputFeatureDimension(builder, kernelOutputFeatureDimension): + builder.PrependInt64Slot(9, kernelOutputFeatureDimension, 0) - @classmethod - def InitFromBuf(cls, buf, pos): - cosOptions = CosOptions() - cosOptions.Init(buf, pos) - return cls.InitFromObj(cosOptions) +def StablehloConvolutionOptionsAddKernelSpatialDimensions(builder, kernelSpatialDimensions): + builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(kernelSpatialDimensions), 0) - @classmethod - def InitFromObj(cls, cosOptions): - x = CosOptionsT() - x._UnPack(cosOptions) - return x +def StablehloConvolutionOptionsStartKernelSpatialDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) - # CosOptionsT - def _UnPack(self, cosOptions): - if cosOptions is None: - return +def StablehloConvolutionOptionsAddOutputBatchDimension(builder, outputBatchDimension): + builder.PrependInt64Slot(11, outputBatchDimension, 0) - # CosOptionsT - def Pack(self, builder): - CosOptionsStart(builder) - cosOptions = CosOptionsEnd(builder) - return cosOptions -# automatically generated by the FlatBuffers compiler, do not modify +def StablehloConvolutionOptionsAddOutputFeatureDimension(builder, outputFeatureDimension): + builder.PrependInt64Slot(12, outputFeatureDimension, 0) -# namespace: tflite +def StablehloConvolutionOptionsAddOutputSpatialDimensions(builder, outputSpatialDimensions): + builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(outputSpatialDimensions), 0) -from flatbuffers.compat import import_numpy -np = import_numpy() +def StablehloConvolutionOptionsStartOutputSpatialDimensionsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) -class CumsumOptions(object): - __slots__ = ['_tab'] +def StablehloConvolutionOptionsAddFeatureGroupCount(builder, featureGroupCount): + builder.PrependInt64Slot(14, featureGroupCount, 0) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = CumsumOptions() - x.Init(buf, n + offset) - return x +def StablehloConvolutionOptionsAddBatchGroupCount(builder, batchGroupCount): + builder.PrependInt64Slot(15, batchGroupCount, 0) - @classmethod - def GetRootAsCumsumOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def CumsumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig): + builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(precisionConfig), 0) - # CumsumOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def StablehloConvolutionOptionsStartPrecisionConfigVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - # CumsumOptions - def Exclusive(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def StablehloConvolutionOptionsEnd(builder): + return builder.EndObject() - # CumsumOptions - def Reverse(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False -def CumsumOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return CumsumOptionsStart(builder) -def CumsumOptionsAddExclusive(builder, exclusive): builder.PrependBoolSlot(0, exclusive, 0) -def AddExclusive(builder, exclusive): - return CumsumOptionsAddExclusive(builder, exclusive) -def CumsumOptionsAddReverse(builder, reverse): builder.PrependBoolSlot(1, reverse, 0) -def AddReverse(builder, reverse): - return CumsumOptionsAddReverse(builder, reverse) -def CumsumOptionsEnd(builder): return builder.EndObject() -def End(builder): - return CumsumOptionsEnd(builder) +try: + from typing import List +except: + pass -class CumsumOptionsT(object): +class StablehloConvolutionOptionsT(object): - # CumsumOptionsT + # StablehloConvolutionOptionsT def __init__(self): - self.exclusive = False # type: bool - self.reverse = False # type: bool + self.windowStrides = None # type: List[int] + self.padding = None # type: List[int] + self.lhsDilation = None # type: List[int] + self.rhsDilation = None # type: List[int] + self.windowReversal = None # type: List[bool] + self.inputBatchDimension = 0 # type: int + self.inputFeatureDimension = 0 # type: int + self.inputSpatialDimensions = None # type: List[int] + self.kernelInputFeatureDimension = 0 # type: int + self.kernelOutputFeatureDimension = 0 # type: int + self.kernelSpatialDimensions = None # type: List[int] + self.outputBatchDimension = 0 # type: int + self.outputFeatureDimension = 0 # type: int + self.outputSpatialDimensions = None # type: List[int] + self.featureGroupCount = 0 # type: int + self.batchGroupCount = 0 # type: int + self.precisionConfig = None # type: List[int] @classmethod def InitFromBuf(cls, buf, pos): - cumsumOptions = CumsumOptions() - cumsumOptions.Init(buf, pos) - return cls.InitFromObj(cumsumOptions) + stablehloConvolutionOptions = StablehloConvolutionOptions() + stablehloConvolutionOptions.Init(buf, pos) + return cls.InitFromObj(stablehloConvolutionOptions) @classmethod - def InitFromObj(cls, cumsumOptions): - x = CumsumOptionsT() - x._UnPack(cumsumOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloConvolutionOptions): + x = StablehloConvolutionOptionsT() + x._UnPack(stablehloConvolutionOptions) return x - # CumsumOptionsT - def _UnPack(self, cumsumOptions): - if cumsumOptions is None: + # StablehloConvolutionOptionsT + def _UnPack(self, stablehloConvolutionOptions): + if stablehloConvolutionOptions is None: return - self.exclusive = cumsumOptions.Exclusive() - self.reverse = cumsumOptions.Reverse() + if not stablehloConvolutionOptions.WindowStridesIsNone(): + if np is None: + self.windowStrides = [] + for i in range(stablehloConvolutionOptions.WindowStridesLength()): + self.windowStrides.append(stablehloConvolutionOptions.WindowStrides(i)) + else: + self.windowStrides = stablehloConvolutionOptions.WindowStridesAsNumpy() + if not stablehloConvolutionOptions.PaddingIsNone(): + if np is None: + self.padding = [] + for i in range(stablehloConvolutionOptions.PaddingLength()): + self.padding.append(stablehloConvolutionOptions.Padding(i)) + else: + self.padding = stablehloConvolutionOptions.PaddingAsNumpy() + if not stablehloConvolutionOptions.LhsDilationIsNone(): + if np is None: + self.lhsDilation = [] + for i in range(stablehloConvolutionOptions.LhsDilationLength()): + self.lhsDilation.append(stablehloConvolutionOptions.LhsDilation(i)) + else: + self.lhsDilation = stablehloConvolutionOptions.LhsDilationAsNumpy() + if not stablehloConvolutionOptions.RhsDilationIsNone(): + if np is None: + self.rhsDilation = [] + for i in range(stablehloConvolutionOptions.RhsDilationLength()): + self.rhsDilation.append(stablehloConvolutionOptions.RhsDilation(i)) + else: + self.rhsDilation = stablehloConvolutionOptions.RhsDilationAsNumpy() + if not stablehloConvolutionOptions.WindowReversalIsNone(): + if np is None: + self.windowReversal = [] + for i in range(stablehloConvolutionOptions.WindowReversalLength()): + self.windowReversal.append(stablehloConvolutionOptions.WindowReversal(i)) + else: + self.windowReversal = stablehloConvolutionOptions.WindowReversalAsNumpy() + self.inputBatchDimension = stablehloConvolutionOptions.InputBatchDimension() + self.inputFeatureDimension = stablehloConvolutionOptions.InputFeatureDimension() + if not stablehloConvolutionOptions.InputSpatialDimensionsIsNone(): + if np is None: + self.inputSpatialDimensions = [] + for i in range(stablehloConvolutionOptions.InputSpatialDimensionsLength()): + self.inputSpatialDimensions.append(stablehloConvolutionOptions.InputSpatialDimensions(i)) + else: + self.inputSpatialDimensions = stablehloConvolutionOptions.InputSpatialDimensionsAsNumpy() + self.kernelInputFeatureDimension = stablehloConvolutionOptions.KernelInputFeatureDimension() + self.kernelOutputFeatureDimension = stablehloConvolutionOptions.KernelOutputFeatureDimension() + if not stablehloConvolutionOptions.KernelSpatialDimensionsIsNone(): + if np is None: + self.kernelSpatialDimensions = [] + for i in range(stablehloConvolutionOptions.KernelSpatialDimensionsLength()): + self.kernelSpatialDimensions.append(stablehloConvolutionOptions.KernelSpatialDimensions(i)) + else: + self.kernelSpatialDimensions = stablehloConvolutionOptions.KernelSpatialDimensionsAsNumpy() + self.outputBatchDimension = stablehloConvolutionOptions.OutputBatchDimension() + self.outputFeatureDimension = stablehloConvolutionOptions.OutputFeatureDimension() + if not stablehloConvolutionOptions.OutputSpatialDimensionsIsNone(): + if np is None: + self.outputSpatialDimensions = [] + for i in range(stablehloConvolutionOptions.OutputSpatialDimensionsLength()): + self.outputSpatialDimensions.append(stablehloConvolutionOptions.OutputSpatialDimensions(i)) + else: + self.outputSpatialDimensions = stablehloConvolutionOptions.OutputSpatialDimensionsAsNumpy() + self.featureGroupCount = stablehloConvolutionOptions.FeatureGroupCount() + self.batchGroupCount = stablehloConvolutionOptions.BatchGroupCount() + if not stablehloConvolutionOptions.PrecisionConfigIsNone(): + if np is None: + self.precisionConfig = [] + for i in range(stablehloConvolutionOptions.PrecisionConfigLength()): + self.precisionConfig.append(stablehloConvolutionOptions.PrecisionConfig(i)) + else: + self.precisionConfig = stablehloConvolutionOptions.PrecisionConfigAsNumpy() - # CumsumOptionsT + # StablehloConvolutionOptionsT def Pack(self, builder): - CumsumOptionsStart(builder) - CumsumOptionsAddExclusive(builder, self.exclusive) - CumsumOptionsAddReverse(builder, self.reverse) - cumsumOptions = CumsumOptionsEnd(builder) - return cumsumOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class CustomOptionsFormat(object): - FLEXBUFFERS = 0 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.windowStrides is not None: + if np is not None and type(self.windowStrides) is np.ndarray: + windowStrides = builder.CreateNumpyVector(self.windowStrides) + else: + StablehloConvolutionOptionsStartWindowStridesVector(builder, len(self.windowStrides)) + for i in reversed(range(len(self.windowStrides))): + builder.PrependInt64(self.windowStrides[i]) + windowStrides = builder.EndVector() + if self.padding is not None: + if np is not None and type(self.padding) is np.ndarray: + padding = builder.CreateNumpyVector(self.padding) + else: + StablehloConvolutionOptionsStartPaddingVector(builder, len(self.padding)) + for i in reversed(range(len(self.padding))): + builder.PrependInt64(self.padding[i]) + padding = builder.EndVector() + if self.lhsDilation is not None: + if np is not None and type(self.lhsDilation) is np.ndarray: + lhsDilation = builder.CreateNumpyVector(self.lhsDilation) + else: + StablehloConvolutionOptionsStartLhsDilationVector(builder, len(self.lhsDilation)) + for i in reversed(range(len(self.lhsDilation))): + builder.PrependInt64(self.lhsDilation[i]) + lhsDilation = builder.EndVector() + if self.rhsDilation is not None: + if np is not None and type(self.rhsDilation) is np.ndarray: + rhsDilation = builder.CreateNumpyVector(self.rhsDilation) + else: + StablehloConvolutionOptionsStartRhsDilationVector(builder, len(self.rhsDilation)) + for i in reversed(range(len(self.rhsDilation))): + builder.PrependInt64(self.rhsDilation[i]) + rhsDilation = builder.EndVector() + if self.windowReversal is not None: + if np is not None and type(self.windowReversal) is np.ndarray: + windowReversal = builder.CreateNumpyVector(self.windowReversal) + else: + StablehloConvolutionOptionsStartWindowReversalVector(builder, len(self.windowReversal)) + for i in reversed(range(len(self.windowReversal))): + builder.PrependBool(self.windowReversal[i]) + windowReversal = builder.EndVector() + if self.inputSpatialDimensions is not None: + if np is not None and type(self.inputSpatialDimensions) is np.ndarray: + inputSpatialDimensions = builder.CreateNumpyVector(self.inputSpatialDimensions) + else: + StablehloConvolutionOptionsStartInputSpatialDimensionsVector(builder, len(self.inputSpatialDimensions)) + for i in reversed(range(len(self.inputSpatialDimensions))): + builder.PrependInt64(self.inputSpatialDimensions[i]) + inputSpatialDimensions = builder.EndVector() + if self.kernelSpatialDimensions is not None: + if np is not None and type(self.kernelSpatialDimensions) is np.ndarray: + kernelSpatialDimensions = builder.CreateNumpyVector(self.kernelSpatialDimensions) + else: + StablehloConvolutionOptionsStartKernelSpatialDimensionsVector(builder, len(self.kernelSpatialDimensions)) + for i in reversed(range(len(self.kernelSpatialDimensions))): + builder.PrependInt64(self.kernelSpatialDimensions[i]) + kernelSpatialDimensions = builder.EndVector() + if self.outputSpatialDimensions is not None: + if np is not None and type(self.outputSpatialDimensions) is np.ndarray: + outputSpatialDimensions = builder.CreateNumpyVector(self.outputSpatialDimensions) + else: + StablehloConvolutionOptionsStartOutputSpatialDimensionsVector(builder, len(self.outputSpatialDimensions)) + for i in reversed(range(len(self.outputSpatialDimensions))): + builder.PrependInt64(self.outputSpatialDimensions[i]) + outputSpatialDimensions = builder.EndVector() + if self.precisionConfig is not None: + if np is not None and type(self.precisionConfig) is np.ndarray: + precisionConfig = builder.CreateNumpyVector(self.precisionConfig) + else: + StablehloConvolutionOptionsStartPrecisionConfigVector(builder, len(self.precisionConfig)) + for i in reversed(range(len(self.precisionConfig))): + builder.PrependUint32(self.precisionConfig[i]) + precisionConfig = builder.EndVector() + StablehloConvolutionOptionsStart(builder) + if self.windowStrides is not None: + StablehloConvolutionOptionsAddWindowStrides(builder, windowStrides) + if self.padding is not None: + StablehloConvolutionOptionsAddPadding(builder, padding) + if self.lhsDilation is not None: + StablehloConvolutionOptionsAddLhsDilation(builder, lhsDilation) + if self.rhsDilation is not None: + StablehloConvolutionOptionsAddRhsDilation(builder, rhsDilation) + if self.windowReversal is not None: + StablehloConvolutionOptionsAddWindowReversal(builder, windowReversal) + StablehloConvolutionOptionsAddInputBatchDimension(builder, self.inputBatchDimension) + StablehloConvolutionOptionsAddInputFeatureDimension(builder, self.inputFeatureDimension) + if self.inputSpatialDimensions is not None: + StablehloConvolutionOptionsAddInputSpatialDimensions(builder, inputSpatialDimensions) + StablehloConvolutionOptionsAddKernelInputFeatureDimension(builder, self.kernelInputFeatureDimension) + StablehloConvolutionOptionsAddKernelOutputFeatureDimension(builder, self.kernelOutputFeatureDimension) + if self.kernelSpatialDimensions is not None: + StablehloConvolutionOptionsAddKernelSpatialDimensions(builder, kernelSpatialDimensions) + StablehloConvolutionOptionsAddOutputBatchDimension(builder, self.outputBatchDimension) + StablehloConvolutionOptionsAddOutputFeatureDimension(builder, self.outputFeatureDimension) + if self.outputSpatialDimensions is not None: + StablehloConvolutionOptionsAddOutputSpatialDimensions(builder, outputSpatialDimensions) + StablehloConvolutionOptionsAddFeatureGroupCount(builder, self.featureGroupCount) + StablehloConvolutionOptionsAddBatchGroupCount(builder, self.batchGroupCount) + if self.precisionConfig is not None: + StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig) + stablehloConvolutionOptions = StablehloConvolutionOptionsEnd(builder) + return stablehloConvolutionOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class CustomQuantization(object): +class StablehloScatterOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = CustomQuantization() + x = StablehloScatterOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsCustomQuantization(cls, buf, offset=0): + def GetRootAsStablehloScatterOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def CustomQuantizationBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def StablehloScatterOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # CustomQuantization + # StablehloScatterOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # CustomQuantization - def Custom(self, j): + # StablehloScatterOptions + def IndicesAreSorted(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # StablehloScatterOptions + def UpdateWindowDims(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) return 0 - # CustomQuantization - def CustomAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # StablehloScatterOptions + def UpdateWindowDimsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) return 0 - # CustomQuantization - def CustomLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # StablehloScatterOptions + def UpdateWindowDimsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.VectorLen(o) return 0 - # CustomQuantization - def CustomIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # StablehloScatterOptions + def UpdateWindowDimsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) return o == 0 -def CustomQuantizationStart(builder): builder.StartObject(1) -def Start(builder): - return CustomQuantizationStart(builder) -def CustomQuantizationAddCustom(builder, custom): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(custom), 0) -def AddCustom(builder, custom): - return CustomQuantizationAddCustom(builder, custom) -def CustomQuantizationStartCustomVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def StartCustomVector(builder, numElems): - return CustomQuantizationStartCustomVector(builder, numElems) -def CustomQuantizationEnd(builder): return builder.EndObject() -def End(builder): - return CustomQuantizationEnd(builder) -try: - from typing import List -except: - pass + # StablehloScatterOptions + def InsertedWindowDims(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 -class CustomQuantizationT(object): + # StablehloScatterOptions + def InsertedWindowDimsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 - # CustomQuantizationT - def __init__(self): - self.custom = None # type: List[int] + # StablehloScatterOptions + def InsertedWindowDimsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 - @classmethod - def InitFromBuf(cls, buf, pos): - customQuantization = CustomQuantization() - customQuantization.Init(buf, pos) - return cls.InitFromObj(customQuantization) + # StablehloScatterOptions + def InsertedWindowDimsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 - @classmethod - def InitFromObj(cls, customQuantization): - x = CustomQuantizationT() - x._UnPack(customQuantization) - return x + # StablehloScatterOptions + def ScatterDimsToOperandDims(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 - # CustomQuantizationT - def _UnPack(self, customQuantization): - if customQuantization is None: - return - if not customQuantization.CustomIsNone(): - if np is None: - self.custom = [] - for i in range(customQuantization.CustomLength()): - self.custom.append(customQuantization.Custom(i)) - else: - self.custom = customQuantization.CustomAsNumpy() + # StablehloScatterOptions + def ScatterDimsToOperandDimsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return 0 - # CustomQuantizationT - def Pack(self, builder): - if self.custom is not None: - if np is not None and type(self.custom) is np.ndarray: - custom = builder.CreateNumpyVector(self.custom) - else: - CustomQuantizationStartCustomVector(builder, len(self.custom)) - for i in reversed(range(len(self.custom))): - builder.PrependUint8(self.custom[i]) - custom = builder.EndVector() - CustomQuantizationStart(builder) - if self.custom is not None: - CustomQuantizationAddCustom(builder, custom) - customQuantization = CustomQuantizationEnd(builder) - return customQuantization -# automatically generated by the FlatBuffers compiler, do not modify + # StablehloScatterOptions + def ScatterDimsToOperandDimsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 -# namespace: tflite + # StablehloScatterOptions + def ScatterDimsToOperandDimsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 -from flatbuffers.compat import import_numpy -np = import_numpy() + # StablehloScatterOptions + def IndexVectorDim(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 -class DensifyOptions(object): - __slots__ = ['_tab'] + # StablehloScatterOptions + def UniqueIndices(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = DensifyOptions() - x.Init(buf, n + offset) - return x + # StablehloScatterOptions + def UpdateComputationSubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 - @classmethod - def GetRootAsDensifyOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def DensifyOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def StablehloScatterOptionsStart(builder): + builder.StartObject(7) - # DensifyOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def StablehloScatterOptionsAddIndicesAreSorted(builder, indicesAreSorted): + builder.PrependBoolSlot(0, indicesAreSorted, 0) -def DensifyOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return DensifyOptionsStart(builder) -def DensifyOptionsEnd(builder): return builder.EndObject() -def End(builder): - return DensifyOptionsEnd(builder) +def StablehloScatterOptionsAddUpdateWindowDims(builder, updateWindowDims): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(updateWindowDims), 0) -class DensifyOptionsT(object): +def StablehloScatterOptionsStartUpdateWindowDimsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) - # DensifyOptionsT +def StablehloScatterOptionsAddInsertedWindowDims(builder, insertedWindowDims): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(insertedWindowDims), 0) + +def StablehloScatterOptionsStartInsertedWindowDimsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloScatterOptionsAddScatterDimsToOperandDims(builder, scatterDimsToOperandDims): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(scatterDimsToOperandDims), 0) + +def StablehloScatterOptionsStartScatterDimsToOperandDimsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def StablehloScatterOptionsAddIndexVectorDim(builder, indexVectorDim): + builder.PrependInt64Slot(4, indexVectorDim, 0) + +def StablehloScatterOptionsAddUniqueIndices(builder, uniqueIndices): + builder.PrependBoolSlot(5, uniqueIndices, 0) + +def StablehloScatterOptionsAddUpdateComputationSubgraphIndex(builder, updateComputationSubgraphIndex): + builder.PrependInt32Slot(6, updateComputationSubgraphIndex, 0) + +def StablehloScatterOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class StablehloScatterOptionsT(object): + + # StablehloScatterOptionsT def __init__(self): - pass + self.indicesAreSorted = False # type: bool + self.updateWindowDims = None # type: List[int] + self.insertedWindowDims = None # type: List[int] + self.scatterDimsToOperandDims = None # type: List[int] + self.indexVectorDim = 0 # type: int + self.uniqueIndices = False # type: bool + self.updateComputationSubgraphIndex = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - densifyOptions = DensifyOptions() - densifyOptions.Init(buf, pos) - return cls.InitFromObj(densifyOptions) + stablehloScatterOptions = StablehloScatterOptions() + stablehloScatterOptions.Init(buf, pos) + return cls.InitFromObj(stablehloScatterOptions) @classmethod - def InitFromObj(cls, densifyOptions): - x = DensifyOptionsT() - x._UnPack(densifyOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloScatterOptions): + x = StablehloScatterOptionsT() + x._UnPack(stablehloScatterOptions) return x - # DensifyOptionsT - def _UnPack(self, densifyOptions): - if densifyOptions is None: + # StablehloScatterOptionsT + def _UnPack(self, stablehloScatterOptions): + if stablehloScatterOptions is None: return + self.indicesAreSorted = stablehloScatterOptions.IndicesAreSorted() + if not stablehloScatterOptions.UpdateWindowDimsIsNone(): + if np is None: + self.updateWindowDims = [] + for i in range(stablehloScatterOptions.UpdateWindowDimsLength()): + self.updateWindowDims.append(stablehloScatterOptions.UpdateWindowDims(i)) + else: + self.updateWindowDims = stablehloScatterOptions.UpdateWindowDimsAsNumpy() + if not stablehloScatterOptions.InsertedWindowDimsIsNone(): + if np is None: + self.insertedWindowDims = [] + for i in range(stablehloScatterOptions.InsertedWindowDimsLength()): + self.insertedWindowDims.append(stablehloScatterOptions.InsertedWindowDims(i)) + else: + self.insertedWindowDims = stablehloScatterOptions.InsertedWindowDimsAsNumpy() + if not stablehloScatterOptions.ScatterDimsToOperandDimsIsNone(): + if np is None: + self.scatterDimsToOperandDims = [] + for i in range(stablehloScatterOptions.ScatterDimsToOperandDimsLength()): + self.scatterDimsToOperandDims.append(stablehloScatterOptions.ScatterDimsToOperandDims(i)) + else: + self.scatterDimsToOperandDims = stablehloScatterOptions.ScatterDimsToOperandDimsAsNumpy() + self.indexVectorDim = stablehloScatterOptions.IndexVectorDim() + self.uniqueIndices = stablehloScatterOptions.UniqueIndices() + self.updateComputationSubgraphIndex = stablehloScatterOptions.UpdateComputationSubgraphIndex() - # DensifyOptionsT - def Pack(self, builder): - DensifyOptionsStart(builder) - densifyOptions = DensifyOptionsEnd(builder) - return densifyOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + # StablehloScatterOptionsT + def Pack(self, builder): + if self.updateWindowDims is not None: + if np is not None and type(self.updateWindowDims) is np.ndarray: + updateWindowDims = builder.CreateNumpyVector(self.updateWindowDims) + else: + StablehloScatterOptionsStartUpdateWindowDimsVector(builder, len(self.updateWindowDims)) + for i in reversed(range(len(self.updateWindowDims))): + builder.PrependInt64(self.updateWindowDims[i]) + updateWindowDims = builder.EndVector() + if self.insertedWindowDims is not None: + if np is not None and type(self.insertedWindowDims) is np.ndarray: + insertedWindowDims = builder.CreateNumpyVector(self.insertedWindowDims) + else: + StablehloScatterOptionsStartInsertedWindowDimsVector(builder, len(self.insertedWindowDims)) + for i in reversed(range(len(self.insertedWindowDims))): + builder.PrependInt64(self.insertedWindowDims[i]) + insertedWindowDims = builder.EndVector() + if self.scatterDimsToOperandDims is not None: + if np is not None and type(self.scatterDimsToOperandDims) is np.ndarray: + scatterDimsToOperandDims = builder.CreateNumpyVector(self.scatterDimsToOperandDims) + else: + StablehloScatterOptionsStartScatterDimsToOperandDimsVector(builder, len(self.scatterDimsToOperandDims)) + for i in reversed(range(len(self.scatterDimsToOperandDims))): + builder.PrependInt64(self.scatterDimsToOperandDims[i]) + scatterDimsToOperandDims = builder.EndVector() + StablehloScatterOptionsStart(builder) + StablehloScatterOptionsAddIndicesAreSorted(builder, self.indicesAreSorted) + if self.updateWindowDims is not None: + StablehloScatterOptionsAddUpdateWindowDims(builder, updateWindowDims) + if self.insertedWindowDims is not None: + StablehloScatterOptionsAddInsertedWindowDims(builder, insertedWindowDims) + if self.scatterDimsToOperandDims is not None: + StablehloScatterOptionsAddScatterDimsToOperandDims(builder, scatterDimsToOperandDims) + StablehloScatterOptionsAddIndexVectorDim(builder, self.indexVectorDim) + StablehloScatterOptionsAddUniqueIndices(builder, self.uniqueIndices) + StablehloScatterOptionsAddUpdateComputationSubgraphIndex(builder, self.updateComputationSubgraphIndex) + stablehloScatterOptions = StablehloScatterOptionsEnd(builder) + return stablehloScatterOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class DepthToSpaceOptions(object): +class StablehloRngBitGeneratorOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = DepthToSpaceOptions() + x = StablehloRngBitGeneratorOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsDepthToSpaceOptions(cls, buf, offset=0): + def GetRootAsStablehloRngBitGeneratorOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def DepthToSpaceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def StablehloRngBitGeneratorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # DepthToSpaceOptions + # StablehloRngBitGeneratorOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # DepthToSpaceOptions - def BlockSize(self): + # StablehloRngBitGeneratorOptions + def Algorithm(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 -def DepthToSpaceOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return DepthToSpaceOptionsStart(builder) -def DepthToSpaceOptionsAddBlockSize(builder, blockSize): builder.PrependInt32Slot(0, blockSize, 0) -def AddBlockSize(builder, blockSize): - return DepthToSpaceOptionsAddBlockSize(builder, blockSize) -def DepthToSpaceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return DepthToSpaceOptionsEnd(builder) +def StablehloRngBitGeneratorOptionsStart(builder): + builder.StartObject(1) -class DepthToSpaceOptionsT(object): +def StablehloRngBitGeneratorOptionsAddAlgorithm(builder, algorithm): + builder.PrependInt8Slot(0, algorithm, 0) - # DepthToSpaceOptionsT +def StablehloRngBitGeneratorOptionsEnd(builder): + return builder.EndObject() + + + +class StablehloRngBitGeneratorOptionsT(object): + + # StablehloRngBitGeneratorOptionsT def __init__(self): - self.blockSize = 0 # type: int + self.algorithm = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - depthToSpaceOptions = DepthToSpaceOptions() - depthToSpaceOptions.Init(buf, pos) - return cls.InitFromObj(depthToSpaceOptions) + stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptions() + stablehloRngBitGeneratorOptions.Init(buf, pos) + return cls.InitFromObj(stablehloRngBitGeneratorOptions) @classmethod - def InitFromObj(cls, depthToSpaceOptions): - x = DepthToSpaceOptionsT() - x._UnPack(depthToSpaceOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stablehloRngBitGeneratorOptions): + x = StablehloRngBitGeneratorOptionsT() + x._UnPack(stablehloRngBitGeneratorOptions) return x - # DepthToSpaceOptionsT - def _UnPack(self, depthToSpaceOptions): - if depthToSpaceOptions is None: + # StablehloRngBitGeneratorOptionsT + def _UnPack(self, stablehloRngBitGeneratorOptions): + if stablehloRngBitGeneratorOptions is None: return - self.blockSize = depthToSpaceOptions.BlockSize() + self.algorithm = stablehloRngBitGeneratorOptions.Algorithm() - # DepthToSpaceOptionsT + # StablehloRngBitGeneratorOptionsT def Pack(self, builder): - DepthToSpaceOptionsStart(builder) - DepthToSpaceOptionsAddBlockSize(builder, self.blockSize) - depthToSpaceOptions = DepthToSpaceOptionsEnd(builder) - return depthToSpaceOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + StablehloRngBitGeneratorOptionsStart(builder) + StablehloRngBitGeneratorOptionsAddAlgorithm(builder, self.algorithm) + stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptionsEnd(builder) + return stablehloRngBitGeneratorOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class DepthwiseConv2DOptions(object): +class Conv2DOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = DepthwiseConv2DOptions() + x = Conv2DOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsDepthwiseConv2DOptions(cls, buf, offset=0): + def GetRootAsConv2DOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def DepthwiseConv2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def Conv2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # DepthwiseConv2DOptions + # Conv2DOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # DepthwiseConv2DOptions + # Conv2DOptions def Padding(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # DepthwiseConv2DOptions + # Conv2DOptions def StrideW(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # DepthwiseConv2DOptions + # Conv2DOptions def StrideH(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # DepthwiseConv2DOptions - def DepthMultiplier(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 - - # DepthwiseConv2DOptions + # Conv2DOptions def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # DepthwiseConv2DOptions + # Conv2DOptions def DilationWFactor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 1 - # DepthwiseConv2DOptions + # Conv2DOptions def DilationHFactor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 1 -def DepthwiseConv2DOptionsStart(builder): builder.StartObject(7) -def Start(builder): - return DepthwiseConv2DOptionsStart(builder) -def DepthwiseConv2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) -def AddPadding(builder, padding): - return DepthwiseConv2DOptionsAddPadding(builder, padding) -def DepthwiseConv2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0) -def AddStrideW(builder, strideW): - return DepthwiseConv2DOptionsAddStrideW(builder, strideW) -def DepthwiseConv2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0) -def AddStrideH(builder, strideH): - return DepthwiseConv2DOptionsAddStrideH(builder, strideH) -def DepthwiseConv2DOptionsAddDepthMultiplier(builder, depthMultiplier): builder.PrependInt32Slot(3, depthMultiplier, 0) -def AddDepthMultiplier(builder, depthMultiplier): - return DepthwiseConv2DOptionsAddDepthMultiplier(builder, depthMultiplier) -def DepthwiseConv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(4, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return DepthwiseConv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def DepthwiseConv2DOptionsAddDilationWFactor(builder, dilationWFactor): builder.PrependInt32Slot(5, dilationWFactor, 1) -def AddDilationWFactor(builder, dilationWFactor): - return DepthwiseConv2DOptionsAddDilationWFactor(builder, dilationWFactor) -def DepthwiseConv2DOptionsAddDilationHFactor(builder, dilationHFactor): builder.PrependInt32Slot(6, dilationHFactor, 1) -def AddDilationHFactor(builder, dilationHFactor): - return DepthwiseConv2DOptionsAddDilationHFactor(builder, dilationHFactor) -def DepthwiseConv2DOptionsEnd(builder): return builder.EndObject() -def End(builder): - return DepthwiseConv2DOptionsEnd(builder) - -class DepthwiseConv2DOptionsT(object): - - # DepthwiseConv2DOptionsT - def __init__(self): - self.padding = 0 # type: int - self.strideW = 0 # type: int - self.strideH = 0 # type: int - self.depthMultiplier = 0 # type: int - self.fusedActivationFunction = 0 # type: int - self.dilationWFactor = 1 # type: int - self.dilationHFactor = 1 # type: int - - @classmethod - def InitFromBuf(cls, buf, pos): - depthwiseConv2doptions = DepthwiseConv2DOptions() - depthwiseConv2doptions.Init(buf, pos) - return cls.InitFromObj(depthwiseConv2doptions) - - @classmethod - def InitFromObj(cls, depthwiseConv2doptions): - x = DepthwiseConv2DOptionsT() - x._UnPack(depthwiseConv2doptions) - return x - - # DepthwiseConv2DOptionsT - def _UnPack(self, depthwiseConv2doptions): - if depthwiseConv2doptions is None: - return - self.padding = depthwiseConv2doptions.Padding() - self.strideW = depthwiseConv2doptions.StrideW() - self.strideH = depthwiseConv2doptions.StrideH() - self.depthMultiplier = depthwiseConv2doptions.DepthMultiplier() - self.fusedActivationFunction = depthwiseConv2doptions.FusedActivationFunction() - self.dilationWFactor = depthwiseConv2doptions.DilationWFactor() - self.dilationHFactor = depthwiseConv2doptions.DilationHFactor() - - # DepthwiseConv2DOptionsT - def Pack(self, builder): - DepthwiseConv2DOptionsStart(builder) - DepthwiseConv2DOptionsAddPadding(builder, self.padding) - DepthwiseConv2DOptionsAddStrideW(builder, self.strideW) - DepthwiseConv2DOptionsAddStrideH(builder, self.strideH) - DepthwiseConv2DOptionsAddDepthMultiplier(builder, self.depthMultiplier) - DepthwiseConv2DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - DepthwiseConv2DOptionsAddDilationWFactor(builder, self.dilationWFactor) - DepthwiseConv2DOptionsAddDilationHFactor(builder, self.dilationHFactor) - depthwiseConv2doptions = DepthwiseConv2DOptionsEnd(builder) - return depthwiseConv2doptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class DequantizeOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = DequantizeOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsDequantizeOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def DequantizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # DequantizeOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def DequantizeOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return DequantizeOptionsStart(builder) -def DequantizeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return DequantizeOptionsEnd(builder) - -class DequantizeOptionsT(object): - - # DequantizeOptionsT - def __init__(self): - pass + # Conv2DOptions + def QuantizedBiasType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 - @classmethod - def InitFromBuf(cls, buf, pos): - dequantizeOptions = DequantizeOptions() - dequantizeOptions.Init(buf, pos) - return cls.InitFromObj(dequantizeOptions) +def Conv2DOptionsStart(builder): + builder.StartObject(7) - @classmethod - def InitFromObj(cls, dequantizeOptions): - x = DequantizeOptionsT() - x._UnPack(dequantizeOptions) - return x +def Conv2DOptionsAddPadding(builder, padding): + builder.PrependInt8Slot(0, padding, 0) - # DequantizeOptionsT - def _UnPack(self, dequantizeOptions): - if dequantizeOptions is None: - return +def Conv2DOptionsAddStrideW(builder, strideW): + builder.PrependInt32Slot(1, strideW, 0) - # DequantizeOptionsT - def Pack(self, builder): - DequantizeOptionsStart(builder) - dequantizeOptions = DequantizeOptionsEnd(builder) - return dequantizeOptions -# automatically generated by the FlatBuffers compiler, do not modify +def Conv2DOptionsAddStrideH(builder, strideH): + builder.PrependInt32Slot(2, strideH, 0) -# namespace: tflite +def Conv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(3, fusedActivationFunction, 0) -from flatbuffers.compat import import_numpy -np = import_numpy() +def Conv2DOptionsAddDilationWFactor(builder, dilationWFactor): + builder.PrependInt32Slot(4, dilationWFactor, 1) -class DilateOptions(object): - __slots__ = ['_tab'] +def Conv2DOptionsAddDilationHFactor(builder, dilationHFactor): + builder.PrependInt32Slot(5, dilationHFactor, 1) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = DilateOptions() - x.Init(buf, n + offset) - return x +def Conv2DOptionsAddQuantizedBiasType(builder, quantizedBiasType): + builder.PrependInt8Slot(6, quantizedBiasType, 0) - @classmethod - def GetRootAsDilateOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def DilateOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def Conv2DOptionsEnd(builder): + return builder.EndObject() - # DilateOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) -def DilateOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return DilateOptionsStart(builder) -def DilateOptionsEnd(builder): return builder.EndObject() -def End(builder): - return DilateOptionsEnd(builder) -class DilateOptionsT(object): +class Conv2DOptionsT(object): - # DilateOptionsT + # Conv2DOptionsT def __init__(self): - pass + self.padding = 0 # type: int + self.strideW = 0 # type: int + self.strideH = 0 # type: int + self.fusedActivationFunction = 0 # type: int + self.dilationWFactor = 1 # type: int + self.dilationHFactor = 1 # type: int + self.quantizedBiasType = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - dilateOptions = DilateOptions() - dilateOptions.Init(buf, pos) - return cls.InitFromObj(dilateOptions) + conv2Doptions = Conv2DOptions() + conv2Doptions.Init(buf, pos) + return cls.InitFromObj(conv2Doptions) @classmethod - def InitFromObj(cls, dilateOptions): - x = DilateOptionsT() - x._UnPack(dilateOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, conv2Doptions): + x = Conv2DOptionsT() + x._UnPack(conv2Doptions) return x - # DilateOptionsT - def _UnPack(self, dilateOptions): - if dilateOptions is None: + # Conv2DOptionsT + def _UnPack(self, conv2Doptions): + if conv2Doptions is None: return + self.padding = conv2Doptions.Padding() + self.strideW = conv2Doptions.StrideW() + self.strideH = conv2Doptions.StrideH() + self.fusedActivationFunction = conv2Doptions.FusedActivationFunction() + self.dilationWFactor = conv2Doptions.DilationWFactor() + self.dilationHFactor = conv2Doptions.DilationHFactor() + self.quantizedBiasType = conv2Doptions.QuantizedBiasType() - # DilateOptionsT + # Conv2DOptionsT def Pack(self, builder): - DilateOptionsStart(builder) - dilateOptions = DilateOptionsEnd(builder) - return dilateOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + Conv2DOptionsStart(builder) + Conv2DOptionsAddPadding(builder, self.padding) + Conv2DOptionsAddStrideW(builder, self.strideW) + Conv2DOptionsAddStrideH(builder, self.strideH) + Conv2DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + Conv2DOptionsAddDilationWFactor(builder, self.dilationWFactor) + Conv2DOptionsAddDilationHFactor(builder, self.dilationHFactor) + Conv2DOptionsAddQuantizedBiasType(builder, self.quantizedBiasType) + conv2Doptions = Conv2DOptionsEnd(builder) + return conv2Doptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class DimensionMetadata(object): +class Conv3DOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = DimensionMetadata() + x = Conv3DOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsDimensionMetadata(cls, buf, offset=0): + def GetRootAsConv3DOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def DimensionMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def Conv3DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # DimensionMetadata + # Conv3DOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # DimensionMetadata - def Format(self): + # Conv3DOptions + def Padding(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # DimensionMetadata - def DenseSize(self): + # Conv3DOptions + def StrideD(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # DimensionMetadata - def ArraySegmentsType(self): + # Conv3DOptions + def StrideW(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # DimensionMetadata - def ArraySegments(self): + # Conv3DOptions + def StrideH(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: - from flatbuffers.table import Table - obj = Table(bytearray(), 0) - self._tab.Union(obj, o) - return obj - return None + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 - # DimensionMetadata - def ArrayIndicesType(self): + # Conv3DOptions + def FusedActivationFunction(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # DimensionMetadata - def ArrayIndices(self): + # Conv3DOptions + def DilationDFactor(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) if o != 0: - from flatbuffers.table import Table - obj = Table(bytearray(), 0) - self._tab.Union(obj, o) - return obj - return None + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 1 -def DimensionMetadataStart(builder): builder.StartObject(6) -def Start(builder): - return DimensionMetadataStart(builder) -def DimensionMetadataAddFormat(builder, format): builder.PrependInt8Slot(0, format, 0) -def AddFormat(builder, format): - return DimensionMetadataAddFormat(builder, format) -def DimensionMetadataAddDenseSize(builder, denseSize): builder.PrependInt32Slot(1, denseSize, 0) -def AddDenseSize(builder, denseSize): - return DimensionMetadataAddDenseSize(builder, denseSize) -def DimensionMetadataAddArraySegmentsType(builder, arraySegmentsType): builder.PrependUint8Slot(2, arraySegmentsType, 0) -def AddArraySegmentsType(builder, arraySegmentsType): - return DimensionMetadataAddArraySegmentsType(builder, arraySegmentsType) -def DimensionMetadataAddArraySegments(builder, arraySegments): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(arraySegments), 0) -def AddArraySegments(builder, arraySegments): - return DimensionMetadataAddArraySegments(builder, arraySegments) -def DimensionMetadataAddArrayIndicesType(builder, arrayIndicesType): builder.PrependUint8Slot(4, arrayIndicesType, 0) -def AddArrayIndicesType(builder, arrayIndicesType): - return DimensionMetadataAddArrayIndicesType(builder, arrayIndicesType) -def DimensionMetadataAddArrayIndices(builder, arrayIndices): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(arrayIndices), 0) -def AddArrayIndices(builder, arrayIndices): - return DimensionMetadataAddArrayIndices(builder, arrayIndices) -def DimensionMetadataEnd(builder): return builder.EndObject() -def End(builder): - return DimensionMetadataEnd(builder) -try: - from typing import Union -except: - pass + # Conv3DOptions + def DilationWFactor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 1 -class DimensionMetadataT(object): + # Conv3DOptions + def DilationHFactor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 1 - # DimensionMetadataT +def Conv3DOptionsStart(builder): + builder.StartObject(8) + +def Conv3DOptionsAddPadding(builder, padding): + builder.PrependInt8Slot(0, padding, 0) + +def Conv3DOptionsAddStrideD(builder, strideD): + builder.PrependInt32Slot(1, strideD, 0) + +def Conv3DOptionsAddStrideW(builder, strideW): + builder.PrependInt32Slot(2, strideW, 0) + +def Conv3DOptionsAddStrideH(builder, strideH): + builder.PrependInt32Slot(3, strideH, 0) + +def Conv3DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(4, fusedActivationFunction, 0) + +def Conv3DOptionsAddDilationDFactor(builder, dilationDFactor): + builder.PrependInt32Slot(5, dilationDFactor, 1) + +def Conv3DOptionsAddDilationWFactor(builder, dilationWFactor): + builder.PrependInt32Slot(6, dilationWFactor, 1) + +def Conv3DOptionsAddDilationHFactor(builder, dilationHFactor): + builder.PrependInt32Slot(7, dilationHFactor, 1) + +def Conv3DOptionsEnd(builder): + return builder.EndObject() + + + +class Conv3DOptionsT(object): + + # Conv3DOptionsT def __init__(self): - self.format = 0 # type: int - self.denseSize = 0 # type: int - self.arraySegmentsType = 0 # type: int - self.arraySegments = None # type: Union[None, Int32VectorT, Uint16VectorT, Uint8VectorT] - self.arrayIndicesType = 0 # type: int - self.arrayIndices = None # type: Union[None, Int32VectorT, Uint16VectorT, Uint8VectorT] + self.padding = 0 # type: int + self.strideD = 0 # type: int + self.strideW = 0 # type: int + self.strideH = 0 # type: int + self.fusedActivationFunction = 0 # type: int + self.dilationDFactor = 1 # type: int + self.dilationWFactor = 1 # type: int + self.dilationHFactor = 1 # type: int @classmethod def InitFromBuf(cls, buf, pos): - dimensionMetadata = DimensionMetadata() - dimensionMetadata.Init(buf, pos) - return cls.InitFromObj(dimensionMetadata) + conv3Doptions = Conv3DOptions() + conv3Doptions.Init(buf, pos) + return cls.InitFromObj(conv3Doptions) @classmethod - def InitFromObj(cls, dimensionMetadata): - x = DimensionMetadataT() - x._UnPack(dimensionMetadata) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, conv3Doptions): + x = Conv3DOptionsT() + x._UnPack(conv3Doptions) return x - # DimensionMetadataT - def _UnPack(self, dimensionMetadata): - if dimensionMetadata is None: + # Conv3DOptionsT + def _UnPack(self, conv3Doptions): + if conv3Doptions is None: return - self.format = dimensionMetadata.Format() - self.denseSize = dimensionMetadata.DenseSize() - self.arraySegmentsType = dimensionMetadata.ArraySegmentsType() - self.arraySegments = SparseIndexVectorCreator(self.arraySegmentsType, dimensionMetadata.ArraySegments()) - self.arrayIndicesType = dimensionMetadata.ArrayIndicesType() - self.arrayIndices = SparseIndexVectorCreator(self.arrayIndicesType, dimensionMetadata.ArrayIndices()) + self.padding = conv3Doptions.Padding() + self.strideD = conv3Doptions.StrideD() + self.strideW = conv3Doptions.StrideW() + self.strideH = conv3Doptions.StrideH() + self.fusedActivationFunction = conv3Doptions.FusedActivationFunction() + self.dilationDFactor = conv3Doptions.DilationDFactor() + self.dilationWFactor = conv3Doptions.DilationWFactor() + self.dilationHFactor = conv3Doptions.DilationHFactor() - # DimensionMetadataT + # Conv3DOptionsT def Pack(self, builder): - if self.arraySegments is not None: - arraySegments = self.arraySegments.Pack(builder) - if self.arrayIndices is not None: - arrayIndices = self.arrayIndices.Pack(builder) - DimensionMetadataStart(builder) - DimensionMetadataAddFormat(builder, self.format) - DimensionMetadataAddDenseSize(builder, self.denseSize) - DimensionMetadataAddArraySegmentsType(builder, self.arraySegmentsType) - if self.arraySegments is not None: - DimensionMetadataAddArraySegments(builder, arraySegments) - DimensionMetadataAddArrayIndicesType(builder, self.arrayIndicesType) - if self.arrayIndices is not None: - DimensionMetadataAddArrayIndices(builder, arrayIndices) - dimensionMetadata = DimensionMetadataEnd(builder) - return dimensionMetadata -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class DimensionType(object): - DENSE = 0 - SPARSE_CSR = 1 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + Conv3DOptionsStart(builder) + Conv3DOptionsAddPadding(builder, self.padding) + Conv3DOptionsAddStrideD(builder, self.strideD) + Conv3DOptionsAddStrideW(builder, self.strideW) + Conv3DOptionsAddStrideH(builder, self.strideH) + Conv3DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + Conv3DOptionsAddDilationDFactor(builder, self.dilationDFactor) + Conv3DOptionsAddDilationWFactor(builder, self.dilationWFactor) + Conv3DOptionsAddDilationHFactor(builder, self.dilationHFactor) + conv3Doptions = Conv3DOptionsEnd(builder) + return conv3Doptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class DivOptions(object): +class Pool2DOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = DivOptions() + x = Pool2DOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsDivOptions(cls, buf, offset=0): + def GetRootAsPool2DOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def DivOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def Pool2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # DivOptions + # Pool2DOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # DivOptions - def FusedActivationFunction(self): + # Pool2DOptions + def Padding(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 -def DivOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return DivOptionsStart(builder) -def DivOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return DivOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def DivOptionsEnd(builder): return builder.EndObject() -def End(builder): - return DivOptionsEnd(builder) + # Pool2DOptions + def StrideW(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # Pool2DOptions + def StrideH(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # Pool2DOptions + def FilterWidth(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # Pool2DOptions + def FilterHeight(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # Pool2DOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def Pool2DOptionsStart(builder): + builder.StartObject(6) + +def Pool2DOptionsAddPadding(builder, padding): + builder.PrependInt8Slot(0, padding, 0) + +def Pool2DOptionsAddStrideW(builder, strideW): + builder.PrependInt32Slot(1, strideW, 0) + +def Pool2DOptionsAddStrideH(builder, strideH): + builder.PrependInt32Slot(2, strideH, 0) + +def Pool2DOptionsAddFilterWidth(builder, filterWidth): + builder.PrependInt32Slot(3, filterWidth, 0) + +def Pool2DOptionsAddFilterHeight(builder, filterHeight): + builder.PrependInt32Slot(4, filterHeight, 0) + +def Pool2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(5, fusedActivationFunction, 0) + +def Pool2DOptionsEnd(builder): + return builder.EndObject() + -class DivOptionsT(object): - # DivOptionsT +class Pool2DOptionsT(object): + + # Pool2DOptionsT def __init__(self): + self.padding = 0 # type: int + self.strideW = 0 # type: int + self.strideH = 0 # type: int + self.filterWidth = 0 # type: int + self.filterHeight = 0 # type: int self.fusedActivationFunction = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - divOptions = DivOptions() - divOptions.Init(buf, pos) - return cls.InitFromObj(divOptions) + pool2Doptions = Pool2DOptions() + pool2Doptions.Init(buf, pos) + return cls.InitFromObj(pool2Doptions) @classmethod - def InitFromObj(cls, divOptions): - x = DivOptionsT() - x._UnPack(divOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, pool2Doptions): + x = Pool2DOptionsT() + x._UnPack(pool2Doptions) return x - # DivOptionsT - def _UnPack(self, divOptions): - if divOptions is None: + # Pool2DOptionsT + def _UnPack(self, pool2Doptions): + if pool2Doptions is None: return - self.fusedActivationFunction = divOptions.FusedActivationFunction() + self.padding = pool2Doptions.Padding() + self.strideW = pool2Doptions.StrideW() + self.strideH = pool2Doptions.StrideH() + self.filterWidth = pool2Doptions.FilterWidth() + self.filterHeight = pool2Doptions.FilterHeight() + self.fusedActivationFunction = pool2Doptions.FusedActivationFunction() - # DivOptionsT + # Pool2DOptionsT def Pack(self, builder): - DivOptionsStart(builder) - DivOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - divOptions = DivOptionsEnd(builder) - return divOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + Pool2DOptionsStart(builder) + Pool2DOptionsAddPadding(builder, self.padding) + Pool2DOptionsAddStrideW(builder, self.strideW) + Pool2DOptionsAddStrideH(builder, self.strideH) + Pool2DOptionsAddFilterWidth(builder, self.filterWidth) + Pool2DOptionsAddFilterHeight(builder, self.filterHeight) + Pool2DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + pool2Doptions = Pool2DOptionsEnd(builder) + return pool2Doptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class DynamicUpdateSliceOptions(object): +class DepthwiseConv2DOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = DynamicUpdateSliceOptions() + x = DepthwiseConv2DOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsDynamicUpdateSliceOptions(cls, buf, offset=0): + def GetRootAsDepthwiseConv2DOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def DynamicUpdateSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def DepthwiseConv2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # DynamicUpdateSliceOptions + # DepthwiseConv2DOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def DynamicUpdateSliceOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return DynamicUpdateSliceOptionsStart(builder) -def DynamicUpdateSliceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return DynamicUpdateSliceOptionsEnd(builder) + # DepthwiseConv2DOptions + def Padding(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 -class DynamicUpdateSliceOptionsT(object): + # DepthwiseConv2DOptions + def StrideW(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 - # DynamicUpdateSliceOptionsT - def __init__(self): - pass + # DepthwiseConv2DOptions + def StrideH(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 - @classmethod - def InitFromBuf(cls, buf, pos): - dynamicUpdateSliceOptions = DynamicUpdateSliceOptions() - dynamicUpdateSliceOptions.Init(buf, pos) - return cls.InitFromObj(dynamicUpdateSliceOptions) + # DepthwiseConv2DOptions + def DepthMultiplier(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 - @classmethod - def InitFromObj(cls, dynamicUpdateSliceOptions): - x = DynamicUpdateSliceOptionsT() - x._UnPack(dynamicUpdateSliceOptions) - return x + # DepthwiseConv2DOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 - # DynamicUpdateSliceOptionsT - def _UnPack(self, dynamicUpdateSliceOptions): - if dynamicUpdateSliceOptions is None: - return + # DepthwiseConv2DOptions + def DilationWFactor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 1 - # DynamicUpdateSliceOptionsT - def Pack(self, builder): - DynamicUpdateSliceOptionsStart(builder) - dynamicUpdateSliceOptions = DynamicUpdateSliceOptionsEnd(builder) - return dynamicUpdateSliceOptions -# automatically generated by the FlatBuffers compiler, do not modify + # DepthwiseConv2DOptions + def DilationHFactor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 1 -# namespace: tflite +def DepthwiseConv2DOptionsStart(builder): + builder.StartObject(7) -from flatbuffers.compat import import_numpy -np = import_numpy() +def DepthwiseConv2DOptionsAddPadding(builder, padding): + builder.PrependInt8Slot(0, padding, 0) -class EmbeddingLookupSparseOptions(object): - __slots__ = ['_tab'] +def DepthwiseConv2DOptionsAddStrideW(builder, strideW): + builder.PrependInt32Slot(1, strideW, 0) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = EmbeddingLookupSparseOptions() - x.Init(buf, n + offset) - return x +def DepthwiseConv2DOptionsAddStrideH(builder, strideH): + builder.PrependInt32Slot(2, strideH, 0) - @classmethod - def GetRootAsEmbeddingLookupSparseOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def EmbeddingLookupSparseOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def DepthwiseConv2DOptionsAddDepthMultiplier(builder, depthMultiplier): + builder.PrependInt32Slot(3, depthMultiplier, 0) - # EmbeddingLookupSparseOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def DepthwiseConv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(4, fusedActivationFunction, 0) - # EmbeddingLookupSparseOptions - def Combiner(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def DepthwiseConv2DOptionsAddDilationWFactor(builder, dilationWFactor): + builder.PrependInt32Slot(5, dilationWFactor, 1) -def EmbeddingLookupSparseOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return EmbeddingLookupSparseOptionsStart(builder) -def EmbeddingLookupSparseOptionsAddCombiner(builder, combiner): builder.PrependInt8Slot(0, combiner, 0) -def AddCombiner(builder, combiner): - return EmbeddingLookupSparseOptionsAddCombiner(builder, combiner) -def EmbeddingLookupSparseOptionsEnd(builder): return builder.EndObject() -def End(builder): - return EmbeddingLookupSparseOptionsEnd(builder) +def DepthwiseConv2DOptionsAddDilationHFactor(builder, dilationHFactor): + builder.PrependInt32Slot(6, dilationHFactor, 1) -class EmbeddingLookupSparseOptionsT(object): +def DepthwiseConv2DOptionsEnd(builder): + return builder.EndObject() - # EmbeddingLookupSparseOptionsT + + +class DepthwiseConv2DOptionsT(object): + + # DepthwiseConv2DOptionsT def __init__(self): - self.combiner = 0 # type: int + self.padding = 0 # type: int + self.strideW = 0 # type: int + self.strideH = 0 # type: int + self.depthMultiplier = 0 # type: int + self.fusedActivationFunction = 0 # type: int + self.dilationWFactor = 1 # type: int + self.dilationHFactor = 1 # type: int @classmethod def InitFromBuf(cls, buf, pos): - embeddingLookupSparseOptions = EmbeddingLookupSparseOptions() - embeddingLookupSparseOptions.Init(buf, pos) - return cls.InitFromObj(embeddingLookupSparseOptions) + depthwiseConv2Doptions = DepthwiseConv2DOptions() + depthwiseConv2Doptions.Init(buf, pos) + return cls.InitFromObj(depthwiseConv2Doptions) @classmethod - def InitFromObj(cls, embeddingLookupSparseOptions): - x = EmbeddingLookupSparseOptionsT() - x._UnPack(embeddingLookupSparseOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, depthwiseConv2Doptions): + x = DepthwiseConv2DOptionsT() + x._UnPack(depthwiseConv2Doptions) return x - # EmbeddingLookupSparseOptionsT - def _UnPack(self, embeddingLookupSparseOptions): - if embeddingLookupSparseOptions is None: + # DepthwiseConv2DOptionsT + def _UnPack(self, depthwiseConv2Doptions): + if depthwiseConv2Doptions is None: return - self.combiner = embeddingLookupSparseOptions.Combiner() + self.padding = depthwiseConv2Doptions.Padding() + self.strideW = depthwiseConv2Doptions.StrideW() + self.strideH = depthwiseConv2Doptions.StrideH() + self.depthMultiplier = depthwiseConv2Doptions.DepthMultiplier() + self.fusedActivationFunction = depthwiseConv2Doptions.FusedActivationFunction() + self.dilationWFactor = depthwiseConv2Doptions.DilationWFactor() + self.dilationHFactor = depthwiseConv2Doptions.DilationHFactor() - # EmbeddingLookupSparseOptionsT + # DepthwiseConv2DOptionsT def Pack(self, builder): - EmbeddingLookupSparseOptionsStart(builder) - EmbeddingLookupSparseOptionsAddCombiner(builder, self.combiner) - embeddingLookupSparseOptions = EmbeddingLookupSparseOptionsEnd(builder) - return embeddingLookupSparseOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + DepthwiseConv2DOptionsStart(builder) + DepthwiseConv2DOptionsAddPadding(builder, self.padding) + DepthwiseConv2DOptionsAddStrideW(builder, self.strideW) + DepthwiseConv2DOptionsAddStrideH(builder, self.strideH) + DepthwiseConv2DOptionsAddDepthMultiplier(builder, self.depthMultiplier) + DepthwiseConv2DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + DepthwiseConv2DOptionsAddDilationWFactor(builder, self.dilationWFactor) + DepthwiseConv2DOptionsAddDilationHFactor(builder, self.dilationHFactor) + depthwiseConv2Doptions = DepthwiseConv2DOptionsEnd(builder) + return depthwiseConv2Doptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class EqualOptions(object): +class ConcatEmbeddingsOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = EqualOptions() + x = ConcatEmbeddingsOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsEqualOptions(cls, buf, offset=0): + def GetRootAsConcatEmbeddingsOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def EqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ConcatEmbeddingsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # EqualOptions + # ConcatEmbeddingsOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def EqualOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return EqualOptionsStart(builder) -def EqualOptionsEnd(builder): return builder.EndObject() -def End(builder): - return EqualOptionsEnd(builder) + # ConcatEmbeddingsOptions + def NumChannels(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 -class EqualOptionsT(object): + # ConcatEmbeddingsOptions + def NumColumnsPerChannel(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 - # EqualOptionsT - def __init__(self): - pass + # ConcatEmbeddingsOptions + def NumColumnsPerChannelAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 - @classmethod - def InitFromBuf(cls, buf, pos): - equalOptions = EqualOptions() - equalOptions.Init(buf, pos) - return cls.InitFromObj(equalOptions) + # ConcatEmbeddingsOptions + def NumColumnsPerChannelLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ConcatEmbeddingsOptions + def NumColumnsPerChannelIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # ConcatEmbeddingsOptions + def EmbeddingDimPerChannel(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # ConcatEmbeddingsOptions + def EmbeddingDimPerChannelAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 - @classmethod - def InitFromObj(cls, equalOptions): - x = EqualOptionsT() - x._UnPack(equalOptions) - return x + # ConcatEmbeddingsOptions + def EmbeddingDimPerChannelLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 - # EqualOptionsT - def _UnPack(self, equalOptions): - if equalOptions is None: - return + # ConcatEmbeddingsOptions + def EmbeddingDimPerChannelIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 - # EqualOptionsT - def Pack(self, builder): - EqualOptionsStart(builder) - equalOptions = EqualOptionsEnd(builder) - return equalOptions -# automatically generated by the FlatBuffers compiler, do not modify +def ConcatEmbeddingsOptionsStart(builder): + builder.StartObject(3) -# namespace: tflite +def ConcatEmbeddingsOptionsAddNumChannels(builder, numChannels): + builder.PrependInt32Slot(0, numChannels, 0) -from flatbuffers.compat import import_numpy -np = import_numpy() +def ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(numColumnsPerChannel), 0) -class ExpOptions(object): - __slots__ = ['_tab'] +def ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ExpOptions() - x.Init(buf, n + offset) - return x +def ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(embeddingDimPerChannel), 0) - @classmethod - def GetRootAsExpOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def ExpOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - # ExpOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def ConcatEmbeddingsOptionsEnd(builder): + return builder.EndObject() -def ExpOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return ExpOptionsStart(builder) -def ExpOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ExpOptionsEnd(builder) -class ExpOptionsT(object): +try: + from typing import List +except: + pass - # ExpOptionsT +class ConcatEmbeddingsOptionsT(object): + + # ConcatEmbeddingsOptionsT def __init__(self): - pass + self.numChannels = 0 # type: int + self.numColumnsPerChannel = None # type: List[int] + self.embeddingDimPerChannel = None # type: List[int] @classmethod def InitFromBuf(cls, buf, pos): - expOptions = ExpOptions() - expOptions.Init(buf, pos) - return cls.InitFromObj(expOptions) + concatEmbeddingsOptions = ConcatEmbeddingsOptions() + concatEmbeddingsOptions.Init(buf, pos) + return cls.InitFromObj(concatEmbeddingsOptions) @classmethod - def InitFromObj(cls, expOptions): - x = ExpOptionsT() - x._UnPack(expOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, concatEmbeddingsOptions): + x = ConcatEmbeddingsOptionsT() + x._UnPack(concatEmbeddingsOptions) return x - # ExpOptionsT - def _UnPack(self, expOptions): - if expOptions is None: + # ConcatEmbeddingsOptionsT + def _UnPack(self, concatEmbeddingsOptions): + if concatEmbeddingsOptions is None: return + self.numChannels = concatEmbeddingsOptions.NumChannels() + if not concatEmbeddingsOptions.NumColumnsPerChannelIsNone(): + if np is None: + self.numColumnsPerChannel = [] + for i in range(concatEmbeddingsOptions.NumColumnsPerChannelLength()): + self.numColumnsPerChannel.append(concatEmbeddingsOptions.NumColumnsPerChannel(i)) + else: + self.numColumnsPerChannel = concatEmbeddingsOptions.NumColumnsPerChannelAsNumpy() + if not concatEmbeddingsOptions.EmbeddingDimPerChannelIsNone(): + if np is None: + self.embeddingDimPerChannel = [] + for i in range(concatEmbeddingsOptions.EmbeddingDimPerChannelLength()): + self.embeddingDimPerChannel.append(concatEmbeddingsOptions.EmbeddingDimPerChannel(i)) + else: + self.embeddingDimPerChannel = concatEmbeddingsOptions.EmbeddingDimPerChannelAsNumpy() - # ExpOptionsT + # ConcatEmbeddingsOptionsT def Pack(self, builder): - ExpOptionsStart(builder) - expOptions = ExpOptionsEnd(builder) - return expOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.numColumnsPerChannel is not None: + if np is not None and type(self.numColumnsPerChannel) is np.ndarray: + numColumnsPerChannel = builder.CreateNumpyVector(self.numColumnsPerChannel) + else: + ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, len(self.numColumnsPerChannel)) + for i in reversed(range(len(self.numColumnsPerChannel))): + builder.PrependInt32(self.numColumnsPerChannel[i]) + numColumnsPerChannel = builder.EndVector() + if self.embeddingDimPerChannel is not None: + if np is not None and type(self.embeddingDimPerChannel) is np.ndarray: + embeddingDimPerChannel = builder.CreateNumpyVector(self.embeddingDimPerChannel) + else: + ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, len(self.embeddingDimPerChannel)) + for i in reversed(range(len(self.embeddingDimPerChannel))): + builder.PrependInt32(self.embeddingDimPerChannel[i]) + embeddingDimPerChannel = builder.EndVector() + ConcatEmbeddingsOptionsStart(builder) + ConcatEmbeddingsOptionsAddNumChannels(builder, self.numChannels) + if self.numColumnsPerChannel is not None: + ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel) + if self.embeddingDimPerChannel is not None: + ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel) + concatEmbeddingsOptions = ConcatEmbeddingsOptionsEnd(builder) + return concatEmbeddingsOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ExpandDimsOptions(object): +class LSHProjectionOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ExpandDimsOptions() + x = LSHProjectionOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsExpandDimsOptions(cls, buf, offset=0): + def GetRootAsLSHProjectionOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ExpandDimsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LSHProjectionOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ExpandDimsOptions + # LSHProjectionOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def ExpandDimsOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return ExpandDimsOptionsStart(builder) -def ExpandDimsOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ExpandDimsOptionsEnd(builder) + # LSHProjectionOptions + def Type(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def LSHProjectionOptionsStart(builder): + builder.StartObject(1) -class ExpandDimsOptionsT(object): +def LSHProjectionOptionsAddType(builder, type): + builder.PrependInt8Slot(0, type, 0) - # ExpandDimsOptionsT +def LSHProjectionOptionsEnd(builder): + return builder.EndObject() + + + +class LSHProjectionOptionsT(object): + + # LSHProjectionOptionsT def __init__(self): - pass + self.type = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - expandDimsOptions = ExpandDimsOptions() - expandDimsOptions.Init(buf, pos) - return cls.InitFromObj(expandDimsOptions) + lshprojectionOptions = LSHProjectionOptions() + lshprojectionOptions.Init(buf, pos) + return cls.InitFromObj(lshprojectionOptions) @classmethod - def InitFromObj(cls, expandDimsOptions): - x = ExpandDimsOptionsT() - x._UnPack(expandDimsOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, lshprojectionOptions): + x = LSHProjectionOptionsT() + x._UnPack(lshprojectionOptions) return x - # ExpandDimsOptionsT - def _UnPack(self, expandDimsOptions): - if expandDimsOptions is None: + # LSHProjectionOptionsT + def _UnPack(self, lshprojectionOptions): + if lshprojectionOptions is None: return + self.type = lshprojectionOptions.Type() - # ExpandDimsOptionsT + # LSHProjectionOptionsT def Pack(self, builder): - ExpandDimsOptionsStart(builder) - expandDimsOptions = ExpandDimsOptionsEnd(builder) - return expandDimsOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LSHProjectionOptionsStart(builder) + LSHProjectionOptionsAddType(builder, self.type) + lshprojectionOptions = LSHProjectionOptionsEnd(builder) + return lshprojectionOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class FakeQuantOptions(object): +class SVDFOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = FakeQuantOptions() + x = SVDFOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsFakeQuantOptions(cls, buf, offset=0): + def GetRootAsSVDFOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def FakeQuantOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SVDFOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # FakeQuantOptions + # SVDFOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # FakeQuantOptions - def Min(self): + # SVDFOptions + def Rank(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 - # FakeQuantOptions - def Max(self): + # SVDFOptions + def FusedActivationFunction(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 - - # FakeQuantOptions - def NumBits(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # FakeQuantOptions - def NarrowRange(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + # SVDFOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False -def FakeQuantOptionsStart(builder): builder.StartObject(4) -def Start(builder): - return FakeQuantOptionsStart(builder) -def FakeQuantOptionsAddMin(builder, min): builder.PrependFloat32Slot(0, min, 0.0) -def AddMin(builder, min): - return FakeQuantOptionsAddMin(builder, min) -def FakeQuantOptionsAddMax(builder, max): builder.PrependFloat32Slot(1, max, 0.0) -def AddMax(builder, max): - return FakeQuantOptionsAddMax(builder, max) -def FakeQuantOptionsAddNumBits(builder, numBits): builder.PrependInt32Slot(2, numBits, 0) -def AddNumBits(builder, numBits): - return FakeQuantOptionsAddNumBits(builder, numBits) -def FakeQuantOptionsAddNarrowRange(builder, narrowRange): builder.PrependBoolSlot(3, narrowRange, 0) -def AddNarrowRange(builder, narrowRange): - return FakeQuantOptionsAddNarrowRange(builder, narrowRange) -def FakeQuantOptionsEnd(builder): return builder.EndObject() -def End(builder): - return FakeQuantOptionsEnd(builder) +def SVDFOptionsStart(builder): + builder.StartObject(3) -class FakeQuantOptionsT(object): +def SVDFOptionsAddRank(builder, rank): + builder.PrependInt32Slot(0, rank, 0) - # FakeQuantOptionsT +def SVDFOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(1, fusedActivationFunction, 0) + +def SVDFOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) + +def SVDFOptionsEnd(builder): + return builder.EndObject() + + + +class SVDFOptionsT(object): + + # SVDFOptionsT def __init__(self): - self.min = 0.0 # type: float - self.max = 0.0 # type: float - self.numBits = 0 # type: int - self.narrowRange = False # type: bool + self.rank = 0 # type: int + self.fusedActivationFunction = 0 # type: int + self.asymmetricQuantizeInputs = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - fakeQuantOptions = FakeQuantOptions() - fakeQuantOptions.Init(buf, pos) - return cls.InitFromObj(fakeQuantOptions) + svdfoptions = SVDFOptions() + svdfoptions.Init(buf, pos) + return cls.InitFromObj(svdfoptions) @classmethod - def InitFromObj(cls, fakeQuantOptions): - x = FakeQuantOptionsT() - x._UnPack(fakeQuantOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, svdfoptions): + x = SVDFOptionsT() + x._UnPack(svdfoptions) return x - # FakeQuantOptionsT - def _UnPack(self, fakeQuantOptions): - if fakeQuantOptions is None: + # SVDFOptionsT + def _UnPack(self, svdfoptions): + if svdfoptions is None: return - self.min = fakeQuantOptions.Min() - self.max = fakeQuantOptions.Max() - self.numBits = fakeQuantOptions.NumBits() - self.narrowRange = fakeQuantOptions.NarrowRange() + self.rank = svdfoptions.Rank() + self.fusedActivationFunction = svdfoptions.FusedActivationFunction() + self.asymmetricQuantizeInputs = svdfoptions.AsymmetricQuantizeInputs() - # FakeQuantOptionsT + # SVDFOptionsT def Pack(self, builder): - FakeQuantOptionsStart(builder) - FakeQuantOptionsAddMin(builder, self.min) - FakeQuantOptionsAddMax(builder, self.max) - FakeQuantOptionsAddNumBits(builder, self.numBits) - FakeQuantOptionsAddNarrowRange(builder, self.narrowRange) - fakeQuantOptions = FakeQuantOptionsEnd(builder) - return fakeQuantOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SVDFOptionsStart(builder) + SVDFOptionsAddRank(builder, self.rank) + SVDFOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + SVDFOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) + svdfoptions = SVDFOptionsEnd(builder) + return svdfoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class FillOptions(object): +class RNNOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = FillOptions() + x = RNNOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsFillOptions(cls, buf, offset=0): + def GetRootAsRNNOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def FillOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def RNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # FillOptions + # RNNOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def FillOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return FillOptionsStart(builder) -def FillOptionsEnd(builder): return builder.EndObject() -def End(builder): - return FillOptionsEnd(builder) + # RNNOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # RNNOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def RNNOptionsStart(builder): + builder.StartObject(2) -class FillOptionsT(object): +def RNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) - # FillOptionsT +def RNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(1, asymmetricQuantizeInputs, 0) + +def RNNOptionsEnd(builder): + return builder.EndObject() + + + +class RNNOptionsT(object): + + # RNNOptionsT def __init__(self): - pass + self.fusedActivationFunction = 0 # type: int + self.asymmetricQuantizeInputs = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - fillOptions = FillOptions() - fillOptions.Init(buf, pos) - return cls.InitFromObj(fillOptions) + rnnoptions = RNNOptions() + rnnoptions.Init(buf, pos) + return cls.InitFromObj(rnnoptions) @classmethod - def InitFromObj(cls, fillOptions): - x = FillOptionsT() - x._UnPack(fillOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, rnnoptions): + x = RNNOptionsT() + x._UnPack(rnnoptions) return x - # FillOptionsT - def _UnPack(self, fillOptions): - if fillOptions is None: + # RNNOptionsT + def _UnPack(self, rnnoptions): + if rnnoptions is None: return + self.fusedActivationFunction = rnnoptions.FusedActivationFunction() + self.asymmetricQuantizeInputs = rnnoptions.AsymmetricQuantizeInputs() - # FillOptionsT + # RNNOptionsT def Pack(self, builder): - FillOptionsStart(builder) - fillOptions = FillOptionsEnd(builder) - return fillOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + RNNOptionsStart(builder) + RNNOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + RNNOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) + rnnoptions = RNNOptionsEnd(builder) + return rnnoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class FloorDivOptions(object): +class SequenceRNNOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = FloorDivOptions() + x = SequenceRNNOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsFloorDivOptions(cls, buf, offset=0): + def GetRootAsSequenceRNNOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def FloorDivOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SequenceRNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # FloorDivOptions + # SequenceRNNOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def FloorDivOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return FloorDivOptionsStart(builder) -def FloorDivOptionsEnd(builder): return builder.EndObject() -def End(builder): - return FloorDivOptionsEnd(builder) + # SequenceRNNOptions + def TimeMajor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False -class FloorDivOptionsT(object): + # SequenceRNNOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 - # FloorDivOptionsT + # SequenceRNNOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def SequenceRNNOptionsStart(builder): + builder.StartObject(3) + +def SequenceRNNOptionsAddTimeMajor(builder, timeMajor): + builder.PrependBoolSlot(0, timeMajor, 0) + +def SequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(1, fusedActivationFunction, 0) + +def SequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) + +def SequenceRNNOptionsEnd(builder): + return builder.EndObject() + + + +class SequenceRNNOptionsT(object): + + # SequenceRNNOptionsT def __init__(self): - pass + self.timeMajor = False # type: bool + self.fusedActivationFunction = 0 # type: int + self.asymmetricQuantizeInputs = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - floorDivOptions = FloorDivOptions() - floorDivOptions.Init(buf, pos) - return cls.InitFromObj(floorDivOptions) + sequenceRnnoptions = SequenceRNNOptions() + sequenceRnnoptions.Init(buf, pos) + return cls.InitFromObj(sequenceRnnoptions) @classmethod - def InitFromObj(cls, floorDivOptions): - x = FloorDivOptionsT() - x._UnPack(floorDivOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, sequenceRnnoptions): + x = SequenceRNNOptionsT() + x._UnPack(sequenceRnnoptions) return x - # FloorDivOptionsT - def _UnPack(self, floorDivOptions): - if floorDivOptions is None: + # SequenceRNNOptionsT + def _UnPack(self, sequenceRnnoptions): + if sequenceRnnoptions is None: return + self.timeMajor = sequenceRnnoptions.TimeMajor() + self.fusedActivationFunction = sequenceRnnoptions.FusedActivationFunction() + self.asymmetricQuantizeInputs = sequenceRnnoptions.AsymmetricQuantizeInputs() - # FloorDivOptionsT + # SequenceRNNOptionsT def Pack(self, builder): - FloorDivOptionsStart(builder) - floorDivOptions = FloorDivOptionsEnd(builder) - return floorDivOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SequenceRNNOptionsStart(builder) + SequenceRNNOptionsAddTimeMajor(builder, self.timeMajor) + SequenceRNNOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + SequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) + sequenceRnnoptions = SequenceRNNOptionsEnd(builder) + return sequenceRnnoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class FloorModOptions(object): +class BidirectionalSequenceRNNOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = FloorModOptions() + x = BidirectionalSequenceRNNOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsFloorModOptions(cls, buf, offset=0): + def GetRootAsBidirectionalSequenceRNNOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def FloorModOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def BidirectionalSequenceRNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # FloorModOptions + # BidirectionalSequenceRNNOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def FloorModOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return FloorModOptionsStart(builder) -def FloorModOptionsEnd(builder): return builder.EndObject() -def End(builder): - return FloorModOptionsEnd(builder) + # BidirectionalSequenceRNNOptions + def TimeMajor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # BidirectionalSequenceRNNOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 -class FloorModOptionsT(object): + # BidirectionalSequenceRNNOptions + def MergeOutputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # FloorModOptionsT + # BidirectionalSequenceRNNOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def BidirectionalSequenceRNNOptionsStart(builder): + builder.StartObject(4) + +def BidirectionalSequenceRNNOptionsAddTimeMajor(builder, timeMajor): + builder.PrependBoolSlot(0, timeMajor, 0) + +def BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(1, fusedActivationFunction, 0) + +def BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, mergeOutputs): + builder.PrependBoolSlot(2, mergeOutputs, 0) + +def BidirectionalSequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0) + +def BidirectionalSequenceRNNOptionsEnd(builder): + return builder.EndObject() + + + +class BidirectionalSequenceRNNOptionsT(object): + + # BidirectionalSequenceRNNOptionsT def __init__(self): - pass + self.timeMajor = False # type: bool + self.fusedActivationFunction = 0 # type: int + self.mergeOutputs = False # type: bool + self.asymmetricQuantizeInputs = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - floorModOptions = FloorModOptions() - floorModOptions.Init(buf, pos) - return cls.InitFromObj(floorModOptions) + bidirectionalSequenceRnnoptions = BidirectionalSequenceRNNOptions() + bidirectionalSequenceRnnoptions.Init(buf, pos) + return cls.InitFromObj(bidirectionalSequenceRnnoptions) @classmethod - def InitFromObj(cls, floorModOptions): - x = FloorModOptionsT() - x._UnPack(floorModOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, bidirectionalSequenceRnnoptions): + x = BidirectionalSequenceRNNOptionsT() + x._UnPack(bidirectionalSequenceRnnoptions) return x - # FloorModOptionsT - def _UnPack(self, floorModOptions): - if floorModOptions is None: + # BidirectionalSequenceRNNOptionsT + def _UnPack(self, bidirectionalSequenceRnnoptions): + if bidirectionalSequenceRnnoptions is None: return + self.timeMajor = bidirectionalSequenceRnnoptions.TimeMajor() + self.fusedActivationFunction = bidirectionalSequenceRnnoptions.FusedActivationFunction() + self.mergeOutputs = bidirectionalSequenceRnnoptions.MergeOutputs() + self.asymmetricQuantizeInputs = bidirectionalSequenceRnnoptions.AsymmetricQuantizeInputs() - # FloorModOptionsT + # BidirectionalSequenceRNNOptionsT def Pack(self, builder): - FloorModOptionsStart(builder) - floorModOptions = FloorModOptionsEnd(builder) - return floorModOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + BidirectionalSequenceRNNOptionsStart(builder) + BidirectionalSequenceRNNOptionsAddTimeMajor(builder, self.timeMajor) + BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, self.mergeOutputs) + BidirectionalSequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) + bidirectionalSequenceRnnoptions = BidirectionalSequenceRNNOptionsEnd(builder) + return bidirectionalSequenceRnnoptions -from flatbuffers.compat import import_numpy -np = import_numpy() class FullyConnectedOptions(object): __slots__ = ['_tab'] @@ -4540,27 +7341,28 @@ def QuantizedBiasType(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 -def FullyConnectedOptionsStart(builder): builder.StartObject(5) -def Start(builder): - return FullyConnectedOptionsStart(builder) -def FullyConnectedOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return FullyConnectedOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def FullyConnectedOptionsAddWeightsFormat(builder, weightsFormat): builder.PrependInt8Slot(1, weightsFormat, 0) -def AddWeightsFormat(builder, weightsFormat): - return FullyConnectedOptionsAddWeightsFormat(builder, weightsFormat) -def FullyConnectedOptionsAddKeepNumDims(builder, keepNumDims): builder.PrependBoolSlot(2, keepNumDims, 0) -def AddKeepNumDims(builder, keepNumDims): - return FullyConnectedOptionsAddKeepNumDims(builder, keepNumDims) -def FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def FullyConnectedOptionsAddQuantizedBiasType(builder, quantizedBiasType): builder.PrependInt8Slot(4, quantizedBiasType, 0) -def AddQuantizedBiasType(builder, quantizedBiasType): - return FullyConnectedOptionsAddQuantizedBiasType(builder, quantizedBiasType) -def FullyConnectedOptionsEnd(builder): return builder.EndObject() -def End(builder): - return FullyConnectedOptionsEnd(builder) +def FullyConnectedOptionsStart(builder): + builder.StartObject(5) + +def FullyConnectedOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) + +def FullyConnectedOptionsAddWeightsFormat(builder, weightsFormat): + builder.PrependInt8Slot(1, weightsFormat, 0) + +def FullyConnectedOptionsAddKeepNumDims(builder, keepNumDims): + builder.PrependBoolSlot(2, keepNumDims, 0) + +def FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0) + +def FullyConnectedOptionsAddQuantizedBiasType(builder, quantizedBiasType): + builder.PrependInt8Slot(4, quantizedBiasType, 0) + +def FullyConnectedOptionsEnd(builder): + return builder.EndObject() + + class FullyConnectedOptionsT(object): @@ -4578,6 +7380,11 @@ def InitFromBuf(cls, buf, pos): fullyConnectedOptions.Init(buf, pos) return cls.InitFromObj(fullyConnectedOptions) + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + @classmethod def InitFromObj(cls, fullyConnectedOptions): x = FullyConnectedOptionsT() @@ -4602,13432 +7409,10755 @@ def Pack(self, builder): FullyConnectedOptionsAddKeepNumDims(builder, self.keepNumDims) FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) FullyConnectedOptionsAddQuantizedBiasType(builder, self.quantizedBiasType) - fullyConnectedOptions = FullyConnectedOptionsEnd(builder) - return fullyConnectedOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class FullyConnectedOptionsWeightsFormat(object): - DEFAULT = 0 - SHUFFLED4x16INT8 = 1 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class GatherNdOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = GatherNdOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsGatherNdOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def GatherNdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # GatherNdOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - -def GatherNdOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return GatherNdOptionsStart(builder) -def GatherNdOptionsEnd(builder): return builder.EndObject() -def End(builder): - return GatherNdOptionsEnd(builder) - -class GatherNdOptionsT(object): - - # GatherNdOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - gatherNdOptions = GatherNdOptions() - gatherNdOptions.Init(buf, pos) - return cls.InitFromObj(gatherNdOptions) - - @classmethod - def InitFromObj(cls, gatherNdOptions): - x = GatherNdOptionsT() - x._UnPack(gatherNdOptions) - return x - - # GatherNdOptionsT - def _UnPack(self, gatherNdOptions): - if gatherNdOptions is None: - return - - # GatherNdOptionsT - def Pack(self, builder): - GatherNdOptionsStart(builder) - gatherNdOptions = GatherNdOptionsEnd(builder) - return gatherNdOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class GatherOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = GatherOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsGatherOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def GatherOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # GatherOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # GatherOptions - def Axis(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 - - # GatherOptions - def BatchDims(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 - -def GatherOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return GatherOptionsStart(builder) -def GatherOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) -def AddAxis(builder, axis): - return GatherOptionsAddAxis(builder, axis) -def GatherOptionsAddBatchDims(builder, batchDims): builder.PrependInt32Slot(1, batchDims, 0) -def AddBatchDims(builder, batchDims): - return GatherOptionsAddBatchDims(builder, batchDims) -def GatherOptionsEnd(builder): return builder.EndObject() -def End(builder): - return GatherOptionsEnd(builder) - -class GatherOptionsT(object): - - # GatherOptionsT - def __init__(self): - self.axis = 0 # type: int - self.batchDims = 0 # type: int - - @classmethod - def InitFromBuf(cls, buf, pos): - gatherOptions = GatherOptions() - gatherOptions.Init(buf, pos) - return cls.InitFromObj(gatherOptions) - - @classmethod - def InitFromObj(cls, gatherOptions): - x = GatherOptionsT() - x._UnPack(gatherOptions) - return x - - # GatherOptionsT - def _UnPack(self, gatherOptions): - if gatherOptions is None: - return - self.axis = gatherOptions.Axis() - self.batchDims = gatherOptions.BatchDims() - - # GatherOptionsT - def Pack(self, builder): - GatherOptionsStart(builder) - GatherOptionsAddAxis(builder, self.axis) - GatherOptionsAddBatchDims(builder, self.batchDims) - gatherOptions = GatherOptionsEnd(builder) - return gatherOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -from flatbuffers.compat import import_numpy -np = import_numpy() - -class GeluOptions(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = GeluOptions() - x.Init(buf, n + offset) - return x - - @classmethod - def GetRootAsGeluOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def GeluOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - - # GeluOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # GeluOptions - def Approximate(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - -def GeluOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return GeluOptionsStart(builder) -def GeluOptionsAddApproximate(builder, approximate): builder.PrependBoolSlot(0, approximate, 0) -def AddApproximate(builder, approximate): - return GeluOptionsAddApproximate(builder, approximate) -def GeluOptionsEnd(builder): return builder.EndObject() -def End(builder): - return GeluOptionsEnd(builder) - -class GeluOptionsT(object): - - # GeluOptionsT - def __init__(self): - self.approximate = False # type: bool - - @classmethod - def InitFromBuf(cls, buf, pos): - geluOptions = GeluOptions() - geluOptions.Init(buf, pos) - return cls.InitFromObj(geluOptions) - - @classmethod - def InitFromObj(cls, geluOptions): - x = GeluOptionsT() - x._UnPack(geluOptions) - return x - - # GeluOptionsT - def _UnPack(self, geluOptions): - if geluOptions is None: - return - self.approximate = geluOptions.Approximate() - - # GeluOptionsT - def Pack(self, builder): - GeluOptionsStart(builder) - GeluOptionsAddApproximate(builder, self.approximate) - geluOptions = GeluOptionsEnd(builder) - return geluOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + fullyConnectedOptions = FullyConnectedOptionsEnd(builder) + return fullyConnectedOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class GreaterEqualOptions(object): +class SoftmaxOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = GreaterEqualOptions() + x = SoftmaxOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsGreaterEqualOptions(cls, buf, offset=0): + def GetRootAsSoftmaxOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def GreaterEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SoftmaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # GreaterEqualOptions + # SoftmaxOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def GreaterEqualOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return GreaterEqualOptionsStart(builder) -def GreaterEqualOptionsEnd(builder): return builder.EndObject() -def End(builder): - return GreaterEqualOptionsEnd(builder) + # SoftmaxOptions + def Beta(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + +def SoftmaxOptionsStart(builder): + builder.StartObject(1) -class GreaterEqualOptionsT(object): +def SoftmaxOptionsAddBeta(builder, beta): + builder.PrependFloat32Slot(0, beta, 0.0) - # GreaterEqualOptionsT +def SoftmaxOptionsEnd(builder): + return builder.EndObject() + + + +class SoftmaxOptionsT(object): + + # SoftmaxOptionsT def __init__(self): - pass + self.beta = 0.0 # type: float @classmethod def InitFromBuf(cls, buf, pos): - greaterEqualOptions = GreaterEqualOptions() - greaterEqualOptions.Init(buf, pos) - return cls.InitFromObj(greaterEqualOptions) + softmaxOptions = SoftmaxOptions() + softmaxOptions.Init(buf, pos) + return cls.InitFromObj(softmaxOptions) @classmethod - def InitFromObj(cls, greaterEqualOptions): - x = GreaterEqualOptionsT() - x._UnPack(greaterEqualOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, softmaxOptions): + x = SoftmaxOptionsT() + x._UnPack(softmaxOptions) return x - # GreaterEqualOptionsT - def _UnPack(self, greaterEqualOptions): - if greaterEqualOptions is None: + # SoftmaxOptionsT + def _UnPack(self, softmaxOptions): + if softmaxOptions is None: return + self.beta = softmaxOptions.Beta() - # GreaterEqualOptionsT + # SoftmaxOptionsT def Pack(self, builder): - GreaterEqualOptionsStart(builder) - greaterEqualOptions = GreaterEqualOptionsEnd(builder) - return greaterEqualOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SoftmaxOptionsStart(builder) + SoftmaxOptionsAddBeta(builder, self.beta) + softmaxOptions = SoftmaxOptionsEnd(builder) + return softmaxOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class GreaterOptions(object): +class ConcatenationOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = GreaterOptions() + x = ConcatenationOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsGreaterOptions(cls, buf, offset=0): + def GetRootAsConcatenationOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def GreaterOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ConcatenationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # GreaterOptions + # ConcatenationOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def GreaterOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return GreaterOptionsStart(builder) -def GreaterOptionsEnd(builder): return builder.EndObject() -def End(builder): - return GreaterOptionsEnd(builder) + # ConcatenationOptions + def Axis(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ConcatenationOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def ConcatenationOptionsStart(builder): + builder.StartObject(2) -class GreaterOptionsT(object): +def ConcatenationOptionsAddAxis(builder, axis): + builder.PrependInt32Slot(0, axis, 0) - # GreaterOptionsT +def ConcatenationOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(1, fusedActivationFunction, 0) + +def ConcatenationOptionsEnd(builder): + return builder.EndObject() + + + +class ConcatenationOptionsT(object): + + # ConcatenationOptionsT def __init__(self): - pass + self.axis = 0 # type: int + self.fusedActivationFunction = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - greaterOptions = GreaterOptions() - greaterOptions.Init(buf, pos) - return cls.InitFromObj(greaterOptions) + concatenationOptions = ConcatenationOptions() + concatenationOptions.Init(buf, pos) + return cls.InitFromObj(concatenationOptions) @classmethod - def InitFromObj(cls, greaterOptions): - x = GreaterOptionsT() - x._UnPack(greaterOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, concatenationOptions): + x = ConcatenationOptionsT() + x._UnPack(concatenationOptions) return x - # GreaterOptionsT - def _UnPack(self, greaterOptions): - if greaterOptions is None: + # ConcatenationOptionsT + def _UnPack(self, concatenationOptions): + if concatenationOptions is None: return + self.axis = concatenationOptions.Axis() + self.fusedActivationFunction = concatenationOptions.FusedActivationFunction() - # GreaterOptionsT + # ConcatenationOptionsT def Pack(self, builder): - GreaterOptionsStart(builder) - greaterOptions = GreaterOptionsEnd(builder) - return greaterOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ConcatenationOptionsStart(builder) + ConcatenationOptionsAddAxis(builder, self.axis) + ConcatenationOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + concatenationOptions = ConcatenationOptionsEnd(builder) + return concatenationOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class HardSwishOptions(object): +class AddOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = HardSwishOptions() + x = AddOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsHardSwishOptions(cls, buf, offset=0): + def GetRootAsAddOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def HardSwishOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def AddOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # HardSwishOptions + # AddOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def HardSwishOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return HardSwishOptionsStart(builder) -def HardSwishOptionsEnd(builder): return builder.EndObject() -def End(builder): - return HardSwishOptionsEnd(builder) + # AddOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 -class HardSwishOptionsT(object): + # AddOptions + def PotScaleInt16(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return True - # HardSwishOptionsT +def AddOptionsStart(builder): + builder.StartObject(2) + +def AddOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) + +def AddOptionsAddPotScaleInt16(builder, potScaleInt16): + builder.PrependBoolSlot(1, potScaleInt16, 1) + +def AddOptionsEnd(builder): + return builder.EndObject() + + + +class AddOptionsT(object): + + # AddOptionsT def __init__(self): - pass + self.fusedActivationFunction = 0 # type: int + self.potScaleInt16 = True # type: bool @classmethod def InitFromBuf(cls, buf, pos): - hardSwishOptions = HardSwishOptions() - hardSwishOptions.Init(buf, pos) - return cls.InitFromObj(hardSwishOptions) + addOptions = AddOptions() + addOptions.Init(buf, pos) + return cls.InitFromObj(addOptions) @classmethod - def InitFromObj(cls, hardSwishOptions): - x = HardSwishOptionsT() - x._UnPack(hardSwishOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, addOptions): + x = AddOptionsT() + x._UnPack(addOptions) return x - # HardSwishOptionsT - def _UnPack(self, hardSwishOptions): - if hardSwishOptions is None: + # AddOptionsT + def _UnPack(self, addOptions): + if addOptions is None: return + self.fusedActivationFunction = addOptions.FusedActivationFunction() + self.potScaleInt16 = addOptions.PotScaleInt16() - # HardSwishOptionsT + # AddOptionsT def Pack(self, builder): - HardSwishOptionsStart(builder) - hardSwishOptions = HardSwishOptionsEnd(builder) - return hardSwishOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + AddOptionsStart(builder) + AddOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + AddOptionsAddPotScaleInt16(builder, self.potScaleInt16) + addOptions = AddOptionsEnd(builder) + return addOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class HashtableFindOptions(object): +class MulOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = HashtableFindOptions() + x = MulOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsHashtableFindOptions(cls, buf, offset=0): + def GetRootAsMulOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def HashtableFindOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def MulOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # HashtableFindOptions + # MulOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def HashtableFindOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return HashtableFindOptionsStart(builder) -def HashtableFindOptionsEnd(builder): return builder.EndObject() -def End(builder): - return HashtableFindOptionsEnd(builder) + # MulOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def MulOptionsStart(builder): + builder.StartObject(1) -class HashtableFindOptionsT(object): +def MulOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) - # HashtableFindOptionsT +def MulOptionsEnd(builder): + return builder.EndObject() + + + +class MulOptionsT(object): + + # MulOptionsT def __init__(self): - pass + self.fusedActivationFunction = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - hashtableFindOptions = HashtableFindOptions() - hashtableFindOptions.Init(buf, pos) - return cls.InitFromObj(hashtableFindOptions) + mulOptions = MulOptions() + mulOptions.Init(buf, pos) + return cls.InitFromObj(mulOptions) @classmethod - def InitFromObj(cls, hashtableFindOptions): - x = HashtableFindOptionsT() - x._UnPack(hashtableFindOptions) - return x + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # HashtableFindOptionsT - def _UnPack(self, hashtableFindOptions): - if hashtableFindOptions is None: + @classmethod + def InitFromObj(cls, mulOptions): + x = MulOptionsT() + x._UnPack(mulOptions) + return x + + # MulOptionsT + def _UnPack(self, mulOptions): + if mulOptions is None: return + self.fusedActivationFunction = mulOptions.FusedActivationFunction() - # HashtableFindOptionsT + # MulOptionsT def Pack(self, builder): - HashtableFindOptionsStart(builder) - hashtableFindOptions = HashtableFindOptionsEnd(builder) - return hashtableFindOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + MulOptionsStart(builder) + MulOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + mulOptions = MulOptionsEnd(builder) + return mulOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class HashtableImportOptions(object): +class L2NormOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = HashtableImportOptions() + x = L2NormOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsHashtableImportOptions(cls, buf, offset=0): + def GetRootAsL2NormOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def HashtableImportOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def L2NormOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # HashtableImportOptions + # L2NormOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def HashtableImportOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return HashtableImportOptionsStart(builder) -def HashtableImportOptionsEnd(builder): return builder.EndObject() -def End(builder): - return HashtableImportOptionsEnd(builder) + # L2NormOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def L2NormOptionsStart(builder): + builder.StartObject(1) -class HashtableImportOptionsT(object): +def L2NormOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) - # HashtableImportOptionsT +def L2NormOptionsEnd(builder): + return builder.EndObject() + + + +class L2NormOptionsT(object): + + # L2NormOptionsT def __init__(self): - pass + self.fusedActivationFunction = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - hashtableImportOptions = HashtableImportOptions() - hashtableImportOptions.Init(buf, pos) - return cls.InitFromObj(hashtableImportOptions) + l2NormOptions = L2NormOptions() + l2NormOptions.Init(buf, pos) + return cls.InitFromObj(l2NormOptions) @classmethod - def InitFromObj(cls, hashtableImportOptions): - x = HashtableImportOptionsT() - x._UnPack(hashtableImportOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, l2NormOptions): + x = L2NormOptionsT() + x._UnPack(l2NormOptions) return x - # HashtableImportOptionsT - def _UnPack(self, hashtableImportOptions): - if hashtableImportOptions is None: + # L2NormOptionsT + def _UnPack(self, l2NormOptions): + if l2NormOptions is None: return + self.fusedActivationFunction = l2NormOptions.FusedActivationFunction() - # HashtableImportOptionsT + # L2NormOptionsT def Pack(self, builder): - HashtableImportOptionsStart(builder) - hashtableImportOptions = HashtableImportOptionsEnd(builder) - return hashtableImportOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + L2NormOptionsStart(builder) + L2NormOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + l2NormOptions = L2NormOptionsEnd(builder) + return l2NormOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class HashtableOptions(object): +class LocalResponseNormalizationOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = HashtableOptions() + x = LocalResponseNormalizationOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsHashtableOptions(cls, buf, offset=0): + def GetRootAsLocalResponseNormalizationOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def HashtableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LocalResponseNormalizationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # HashtableOptions + # LocalResponseNormalizationOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # HashtableOptions - def TableId(self): + # LocalResponseNormalizationOptions + def Radius(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # HashtableOptions - def KeyDtype(self): + # LocalResponseNormalizationOptions + def Bias(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 - # HashtableOptions - def ValueDtype(self): + # LocalResponseNormalizationOptions + def Alpha(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + + # LocalResponseNormalizationOptions + def Beta(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 -def HashtableOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return HashtableOptionsStart(builder) -def HashtableOptionsAddTableId(builder, tableId): builder.PrependInt32Slot(0, tableId, 0) -def AddTableId(builder, tableId): - return HashtableOptionsAddTableId(builder, tableId) -def HashtableOptionsAddKeyDtype(builder, keyDtype): builder.PrependInt8Slot(1, keyDtype, 0) -def AddKeyDtype(builder, keyDtype): - return HashtableOptionsAddKeyDtype(builder, keyDtype) -def HashtableOptionsAddValueDtype(builder, valueDtype): builder.PrependInt8Slot(2, valueDtype, 0) -def AddValueDtype(builder, valueDtype): - return HashtableOptionsAddValueDtype(builder, valueDtype) -def HashtableOptionsEnd(builder): return builder.EndObject() -def End(builder): - return HashtableOptionsEnd(builder) +def LocalResponseNormalizationOptionsStart(builder): + builder.StartObject(4) -class HashtableOptionsT(object): +def LocalResponseNormalizationOptionsAddRadius(builder, radius): + builder.PrependInt32Slot(0, radius, 0) - # HashtableOptionsT +def LocalResponseNormalizationOptionsAddBias(builder, bias): + builder.PrependFloat32Slot(1, bias, 0.0) + +def LocalResponseNormalizationOptionsAddAlpha(builder, alpha): + builder.PrependFloat32Slot(2, alpha, 0.0) + +def LocalResponseNormalizationOptionsAddBeta(builder, beta): + builder.PrependFloat32Slot(3, beta, 0.0) + +def LocalResponseNormalizationOptionsEnd(builder): + return builder.EndObject() + + + +class LocalResponseNormalizationOptionsT(object): + + # LocalResponseNormalizationOptionsT def __init__(self): - self.tableId = 0 # type: int - self.keyDtype = 0 # type: int - self.valueDtype = 0 # type: int + self.radius = 0 # type: int + self.bias = 0.0 # type: float + self.alpha = 0.0 # type: float + self.beta = 0.0 # type: float @classmethod def InitFromBuf(cls, buf, pos): - hashtableOptions = HashtableOptions() - hashtableOptions.Init(buf, pos) - return cls.InitFromObj(hashtableOptions) + localResponseNormalizationOptions = LocalResponseNormalizationOptions() + localResponseNormalizationOptions.Init(buf, pos) + return cls.InitFromObj(localResponseNormalizationOptions) @classmethod - def InitFromObj(cls, hashtableOptions): - x = HashtableOptionsT() - x._UnPack(hashtableOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, localResponseNormalizationOptions): + x = LocalResponseNormalizationOptionsT() + x._UnPack(localResponseNormalizationOptions) return x - # HashtableOptionsT - def _UnPack(self, hashtableOptions): - if hashtableOptions is None: + # LocalResponseNormalizationOptionsT + def _UnPack(self, localResponseNormalizationOptions): + if localResponseNormalizationOptions is None: return - self.tableId = hashtableOptions.TableId() - self.keyDtype = hashtableOptions.KeyDtype() - self.valueDtype = hashtableOptions.ValueDtype() + self.radius = localResponseNormalizationOptions.Radius() + self.bias = localResponseNormalizationOptions.Bias() + self.alpha = localResponseNormalizationOptions.Alpha() + self.beta = localResponseNormalizationOptions.Beta() - # HashtableOptionsT + # LocalResponseNormalizationOptionsT def Pack(self, builder): - HashtableOptionsStart(builder) - HashtableOptionsAddTableId(builder, self.tableId) - HashtableOptionsAddKeyDtype(builder, self.keyDtype) - HashtableOptionsAddValueDtype(builder, self.valueDtype) - hashtableOptions = HashtableOptionsEnd(builder) - return hashtableOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LocalResponseNormalizationOptionsStart(builder) + LocalResponseNormalizationOptionsAddRadius(builder, self.radius) + LocalResponseNormalizationOptionsAddBias(builder, self.bias) + LocalResponseNormalizationOptionsAddAlpha(builder, self.alpha) + LocalResponseNormalizationOptionsAddBeta(builder, self.beta) + localResponseNormalizationOptions = LocalResponseNormalizationOptionsEnd(builder) + return localResponseNormalizationOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class HashtableSizeOptions(object): +class LSTMOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = HashtableSizeOptions() + x = LSTMOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsHashtableSizeOptions(cls, buf, offset=0): + def GetRootAsLSTMOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def HashtableSizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # HashtableSizeOptions + # LSTMOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def HashtableSizeOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return HashtableSizeOptionsStart(builder) -def HashtableSizeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return HashtableSizeOptionsEnd(builder) + # LSTMOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 -class HashtableSizeOptionsT(object): + # LSTMOptions + def CellClip(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 - # HashtableSizeOptionsT + # LSTMOptions + def ProjClip(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + + # LSTMOptions + def KernelType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # LSTMOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def LSTMOptionsStart(builder): + builder.StartObject(5) + +def LSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) + +def LSTMOptionsAddCellClip(builder, cellClip): + builder.PrependFloat32Slot(1, cellClip, 0.0) + +def LSTMOptionsAddProjClip(builder, projClip): + builder.PrependFloat32Slot(2, projClip, 0.0) + +def LSTMOptionsAddKernelType(builder, kernelType): + builder.PrependInt8Slot(3, kernelType, 0) + +def LSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(4, asymmetricQuantizeInputs, 0) + +def LSTMOptionsEnd(builder): + return builder.EndObject() + + + +class LSTMOptionsT(object): + + # LSTMOptionsT def __init__(self): - pass + self.fusedActivationFunction = 0 # type: int + self.cellClip = 0.0 # type: float + self.projClip = 0.0 # type: float + self.kernelType = 0 # type: int + self.asymmetricQuantizeInputs = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - hashtableSizeOptions = HashtableSizeOptions() - hashtableSizeOptions.Init(buf, pos) - return cls.InitFromObj(hashtableSizeOptions) + lstmoptions = LSTMOptions() + lstmoptions.Init(buf, pos) + return cls.InitFromObj(lstmoptions) @classmethod - def InitFromObj(cls, hashtableSizeOptions): - x = HashtableSizeOptionsT() - x._UnPack(hashtableSizeOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, lstmoptions): + x = LSTMOptionsT() + x._UnPack(lstmoptions) return x - # HashtableSizeOptionsT - def _UnPack(self, hashtableSizeOptions): - if hashtableSizeOptions is None: + # LSTMOptionsT + def _UnPack(self, lstmoptions): + if lstmoptions is None: return + self.fusedActivationFunction = lstmoptions.FusedActivationFunction() + self.cellClip = lstmoptions.CellClip() + self.projClip = lstmoptions.ProjClip() + self.kernelType = lstmoptions.KernelType() + self.asymmetricQuantizeInputs = lstmoptions.AsymmetricQuantizeInputs() - # HashtableSizeOptionsT + # LSTMOptionsT def Pack(self, builder): - HashtableSizeOptionsStart(builder) - hashtableSizeOptions = HashtableSizeOptionsEnd(builder) - return hashtableSizeOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LSTMOptionsStart(builder) + LSTMOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + LSTMOptionsAddCellClip(builder, self.cellClip) + LSTMOptionsAddProjClip(builder, self.projClip) + LSTMOptionsAddKernelType(builder, self.kernelType) + LSTMOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) + lstmoptions = LSTMOptionsEnd(builder) + return lstmoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class IfOptions(object): +class UnidirectionalSequenceLSTMOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = IfOptions() + x = UnidirectionalSequenceLSTMOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsIfOptions(cls, buf, offset=0): + def GetRootAsUnidirectionalSequenceLSTMOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def IfOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def UnidirectionalSequenceLSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # IfOptions + # UnidirectionalSequenceLSTMOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # IfOptions - def ThenSubgraphIndex(self): + # UnidirectionalSequenceLSTMOptions + def FusedActivationFunction(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # IfOptions - def ElseSubgraphIndex(self): + # UnidirectionalSequenceLSTMOptions + def CellClip(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 -def IfOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return IfOptionsStart(builder) -def IfOptionsAddThenSubgraphIndex(builder, thenSubgraphIndex): builder.PrependInt32Slot(0, thenSubgraphIndex, 0) -def AddThenSubgraphIndex(builder, thenSubgraphIndex): - return IfOptionsAddThenSubgraphIndex(builder, thenSubgraphIndex) -def IfOptionsAddElseSubgraphIndex(builder, elseSubgraphIndex): builder.PrependInt32Slot(1, elseSubgraphIndex, 0) -def AddElseSubgraphIndex(builder, elseSubgraphIndex): - return IfOptionsAddElseSubgraphIndex(builder, elseSubgraphIndex) -def IfOptionsEnd(builder): return builder.EndObject() -def End(builder): - return IfOptionsEnd(builder) + # UnidirectionalSequenceLSTMOptions + def ProjClip(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 -class IfOptionsT(object): + # UnidirectionalSequenceLSTMOptions + def TimeMajor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # IfOptionsT + # UnidirectionalSequenceLSTMOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # UnidirectionalSequenceLSTMOptions + def DiagonalRecurrentTensors(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def UnidirectionalSequenceLSTMOptionsStart(builder): + builder.StartObject(6) + +def UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) + +def UnidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): + builder.PrependFloat32Slot(1, cellClip, 0.0) + +def UnidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): + builder.PrependFloat32Slot(2, projClip, 0.0) + +def UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): + builder.PrependBoolSlot(3, timeMajor, 0) + +def UnidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(4, asymmetricQuantizeInputs, 0) + +def UnidirectionalSequenceLSTMOptionsAddDiagonalRecurrentTensors(builder, diagonalRecurrentTensors): + builder.PrependBoolSlot(5, diagonalRecurrentTensors, 0) + +def UnidirectionalSequenceLSTMOptionsEnd(builder): + return builder.EndObject() + + + +class UnidirectionalSequenceLSTMOptionsT(object): + + # UnidirectionalSequenceLSTMOptionsT def __init__(self): - self.thenSubgraphIndex = 0 # type: int - self.elseSubgraphIndex = 0 # type: int + self.fusedActivationFunction = 0 # type: int + self.cellClip = 0.0 # type: float + self.projClip = 0.0 # type: float + self.timeMajor = False # type: bool + self.asymmetricQuantizeInputs = False # type: bool + self.diagonalRecurrentTensors = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - ifOptions = IfOptions() - ifOptions.Init(buf, pos) - return cls.InitFromObj(ifOptions) + unidirectionalSequenceLstmoptions = UnidirectionalSequenceLSTMOptions() + unidirectionalSequenceLstmoptions.Init(buf, pos) + return cls.InitFromObj(unidirectionalSequenceLstmoptions) @classmethod - def InitFromObj(cls, ifOptions): - x = IfOptionsT() - x._UnPack(ifOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, unidirectionalSequenceLstmoptions): + x = UnidirectionalSequenceLSTMOptionsT() + x._UnPack(unidirectionalSequenceLstmoptions) return x - # IfOptionsT - def _UnPack(self, ifOptions): - if ifOptions is None: + # UnidirectionalSequenceLSTMOptionsT + def _UnPack(self, unidirectionalSequenceLstmoptions): + if unidirectionalSequenceLstmoptions is None: return - self.thenSubgraphIndex = ifOptions.ThenSubgraphIndex() - self.elseSubgraphIndex = ifOptions.ElseSubgraphIndex() + self.fusedActivationFunction = unidirectionalSequenceLstmoptions.FusedActivationFunction() + self.cellClip = unidirectionalSequenceLstmoptions.CellClip() + self.projClip = unidirectionalSequenceLstmoptions.ProjClip() + self.timeMajor = unidirectionalSequenceLstmoptions.TimeMajor() + self.asymmetricQuantizeInputs = unidirectionalSequenceLstmoptions.AsymmetricQuantizeInputs() + self.diagonalRecurrentTensors = unidirectionalSequenceLstmoptions.DiagonalRecurrentTensors() - # IfOptionsT + # UnidirectionalSequenceLSTMOptionsT def Pack(self, builder): - IfOptionsStart(builder) - IfOptionsAddThenSubgraphIndex(builder, self.thenSubgraphIndex) - IfOptionsAddElseSubgraphIndex(builder, self.elseSubgraphIndex) - ifOptions = IfOptionsEnd(builder) - return ifOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + UnidirectionalSequenceLSTMOptionsStart(builder) + UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + UnidirectionalSequenceLSTMOptionsAddCellClip(builder, self.cellClip) + UnidirectionalSequenceLSTMOptionsAddProjClip(builder, self.projClip) + UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, self.timeMajor) + UnidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) + UnidirectionalSequenceLSTMOptionsAddDiagonalRecurrentTensors(builder, self.diagonalRecurrentTensors) + unidirectionalSequenceLstmoptions = UnidirectionalSequenceLSTMOptionsEnd(builder) + return unidirectionalSequenceLstmoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class Int32Vector(object): +class BidirectionalSequenceLSTMOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Int32Vector() + x = BidirectionalSequenceLSTMOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsInt32Vector(cls, buf, offset=0): + def GetRootAsBidirectionalSequenceLSTMOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def Int32VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def BidirectionalSequenceLSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Int32Vector + # BidirectionalSequenceLSTMOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # Int32Vector - def Values(self, j): + # BidirectionalSequenceLSTMOptions + def FusedActivationFunction(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # Int32Vector - def ValuesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # BidirectionalSequenceLSTMOptions + def CellClip(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 - # Int32Vector - def ValuesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # BidirectionalSequenceLSTMOptions + def ProjClip(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.VectorLen(o) - return 0 - - # Int32Vector - def ValuesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - -def Int32VectorStart(builder): builder.StartObject(1) -def Start(builder): - return Int32VectorStart(builder) -def Int32VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) -def AddValues(builder, values): - return Int32VectorAddValues(builder, values) -def Int32VectorStartValuesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartValuesVector(builder, numElems): - return Int32VectorStartValuesVector(builder, numElems) -def Int32VectorEnd(builder): return builder.EndObject() -def End(builder): - return Int32VectorEnd(builder) -try: - from typing import List -except: - pass - -class Int32VectorT(object): - - # Int32VectorT - def __init__(self): - self.values = None # type: List[int] - - @classmethod - def InitFromBuf(cls, buf, pos): - int32vector = Int32Vector() - int32vector.Init(buf, pos) - return cls.InitFromObj(int32vector) - - @classmethod - def InitFromObj(cls, int32vector): - x = Int32VectorT() - x._UnPack(int32vector) - return x - - # Int32VectorT - def _UnPack(self, int32vector): - if int32vector is None: - return - if not int32vector.ValuesIsNone(): - if np is None: - self.values = [] - for i in range(int32vector.ValuesLength()): - self.values.append(int32vector.Values(i)) - else: - self.values = int32vector.ValuesAsNumpy() - - # Int32VectorT - def Pack(self, builder): - if self.values is not None: - if np is not None and type(self.values) is np.ndarray: - values = builder.CreateNumpyVector(self.values) - else: - Int32VectorStartValuesVector(builder, len(self.values)) - for i in reversed(range(len(self.values))): - builder.PrependInt32(self.values[i]) - values = builder.EndVector() - Int32VectorStart(builder) - if self.values is not None: - Int32VectorAddValues(builder, values) - int32vector = Int32VectorEnd(builder) - return int32vector -# automatically generated by the FlatBuffers compiler, do not modify + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 -# namespace: tflite + # BidirectionalSequenceLSTMOptions + def MergeOutputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False -from flatbuffers.compat import import_numpy -np = import_numpy() + # BidirectionalSequenceLSTMOptions + def TimeMajor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return True -class L2NormOptions(object): - __slots__ = ['_tab'] + # BidirectionalSequenceLSTMOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = L2NormOptions() - x.Init(buf, n + offset) - return x +def BidirectionalSequenceLSTMOptionsStart(builder): + builder.StartObject(6) - @classmethod - def GetRootAsL2NormOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def L2NormOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) - # L2NormOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def BidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): + builder.PrependFloat32Slot(1, cellClip, 0.0) - # L2NormOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def BidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): + builder.PrependFloat32Slot(2, projClip, 0.0) -def L2NormOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return L2NormOptionsStart(builder) -def L2NormOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return L2NormOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def L2NormOptionsEnd(builder): return builder.EndObject() -def End(builder): - return L2NormOptionsEnd(builder) +def BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, mergeOutputs): + builder.PrependBoolSlot(3, mergeOutputs, 0) -class L2NormOptionsT(object): +def BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): + builder.PrependBoolSlot(4, timeMajor, 1) - # L2NormOptionsT +def BidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(5, asymmetricQuantizeInputs, 0) + +def BidirectionalSequenceLSTMOptionsEnd(builder): + return builder.EndObject() + + + +class BidirectionalSequenceLSTMOptionsT(object): + + # BidirectionalSequenceLSTMOptionsT def __init__(self): self.fusedActivationFunction = 0 # type: int + self.cellClip = 0.0 # type: float + self.projClip = 0.0 # type: float + self.mergeOutputs = False # type: bool + self.timeMajor = True # type: bool + self.asymmetricQuantizeInputs = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - l2normOptions = L2NormOptions() - l2normOptions.Init(buf, pos) - return cls.InitFromObj(l2normOptions) + bidirectionalSequenceLstmoptions = BidirectionalSequenceLSTMOptions() + bidirectionalSequenceLstmoptions.Init(buf, pos) + return cls.InitFromObj(bidirectionalSequenceLstmoptions) @classmethod - def InitFromObj(cls, l2normOptions): - x = L2NormOptionsT() - x._UnPack(l2normOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, bidirectionalSequenceLstmoptions): + x = BidirectionalSequenceLSTMOptionsT() + x._UnPack(bidirectionalSequenceLstmoptions) return x - # L2NormOptionsT - def _UnPack(self, l2normOptions): - if l2normOptions is None: + # BidirectionalSequenceLSTMOptionsT + def _UnPack(self, bidirectionalSequenceLstmoptions): + if bidirectionalSequenceLstmoptions is None: return - self.fusedActivationFunction = l2normOptions.FusedActivationFunction() + self.fusedActivationFunction = bidirectionalSequenceLstmoptions.FusedActivationFunction() + self.cellClip = bidirectionalSequenceLstmoptions.CellClip() + self.projClip = bidirectionalSequenceLstmoptions.ProjClip() + self.mergeOutputs = bidirectionalSequenceLstmoptions.MergeOutputs() + self.timeMajor = bidirectionalSequenceLstmoptions.TimeMajor() + self.asymmetricQuantizeInputs = bidirectionalSequenceLstmoptions.AsymmetricQuantizeInputs() - # L2NormOptionsT + # BidirectionalSequenceLSTMOptionsT def Pack(self, builder): - L2NormOptionsStart(builder) - L2NormOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - l2normOptions = L2NormOptionsEnd(builder) - return l2normOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + BidirectionalSequenceLSTMOptionsStart(builder) + BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + BidirectionalSequenceLSTMOptionsAddCellClip(builder, self.cellClip) + BidirectionalSequenceLSTMOptionsAddProjClip(builder, self.projClip) + BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, self.mergeOutputs) + BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, self.timeMajor) + BidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) + bidirectionalSequenceLstmoptions = BidirectionalSequenceLSTMOptionsEnd(builder) + return bidirectionalSequenceLstmoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LSHProjectionOptions(object): +class ResizeBilinearOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LSHProjectionOptions() + x = ResizeBilinearOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLSHProjectionOptions(cls, buf, offset=0): + def GetRootAsResizeBilinearOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LSHProjectionOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ResizeBilinearOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LSHProjectionOptions + # ResizeBilinearOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # LSHProjectionOptions - def Type(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # ResizeBilinearOptions + def AlignCorners(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # ResizeBilinearOptions + def HalfPixelCenters(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False -def LSHProjectionOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return LSHProjectionOptionsStart(builder) -def LSHProjectionOptionsAddType(builder, type): builder.PrependInt8Slot(0, type, 0) -def AddType(builder, type): - return LSHProjectionOptionsAddType(builder, type) -def LSHProjectionOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LSHProjectionOptionsEnd(builder) +def ResizeBilinearOptionsStart(builder): + builder.StartObject(4) -class LSHProjectionOptionsT(object): +def ResizeBilinearOptionsAddAlignCorners(builder, alignCorners): + builder.PrependBoolSlot(2, alignCorners, 0) - # LSHProjectionOptionsT +def ResizeBilinearOptionsAddHalfPixelCenters(builder, halfPixelCenters): + builder.PrependBoolSlot(3, halfPixelCenters, 0) + +def ResizeBilinearOptionsEnd(builder): + return builder.EndObject() + + + +class ResizeBilinearOptionsT(object): + + # ResizeBilinearOptionsT def __init__(self): - self.type = 0 # type: int + self.alignCorners = False # type: bool + self.halfPixelCenters = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - lshprojectionOptions = LSHProjectionOptions() - lshprojectionOptions.Init(buf, pos) - return cls.InitFromObj(lshprojectionOptions) + resizeBilinearOptions = ResizeBilinearOptions() + resizeBilinearOptions.Init(buf, pos) + return cls.InitFromObj(resizeBilinearOptions) @classmethod - def InitFromObj(cls, lshprojectionOptions): - x = LSHProjectionOptionsT() - x._UnPack(lshprojectionOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, resizeBilinearOptions): + x = ResizeBilinearOptionsT() + x._UnPack(resizeBilinearOptions) return x - # LSHProjectionOptionsT - def _UnPack(self, lshprojectionOptions): - if lshprojectionOptions is None: + # ResizeBilinearOptionsT + def _UnPack(self, resizeBilinearOptions): + if resizeBilinearOptions is None: return - self.type = lshprojectionOptions.Type() + self.alignCorners = resizeBilinearOptions.AlignCorners() + self.halfPixelCenters = resizeBilinearOptions.HalfPixelCenters() - # LSHProjectionOptionsT + # ResizeBilinearOptionsT def Pack(self, builder): - LSHProjectionOptionsStart(builder) - LSHProjectionOptionsAddType(builder, self.type) - lshprojectionOptions = LSHProjectionOptionsEnd(builder) - return lshprojectionOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class LSHProjectionType(object): - UNKNOWN = 0 - SPARSE = 1 - DENSE = 2 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class LSTMKernelType(object): - FULL = 0 - BASIC = 1 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ResizeBilinearOptionsStart(builder) + ResizeBilinearOptionsAddAlignCorners(builder, self.alignCorners) + ResizeBilinearOptionsAddHalfPixelCenters(builder, self.halfPixelCenters) + resizeBilinearOptions = ResizeBilinearOptionsEnd(builder) + return resizeBilinearOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LSTMOptions(object): +class ResizeNearestNeighborOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LSTMOptions() + x = ResizeNearestNeighborOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLSTMOptions(cls, buf, offset=0): + def GetRootAsResizeNearestNeighborOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ResizeNearestNeighborOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LSTMOptions + # ResizeNearestNeighborOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # LSTMOptions - def FusedActivationFunction(self): + # ResizeNearestNeighborOptions + def AlignCorners(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # LSTMOptions - def CellClip(self): + # ResizeNearestNeighborOptions + def HalfPixelCenters(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # LSTMOptions - def ProjClip(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 +def ResizeNearestNeighborOptionsStart(builder): + builder.StartObject(2) - # LSTMOptions - def KernelType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def ResizeNearestNeighborOptionsAddAlignCorners(builder, alignCorners): + builder.PrependBoolSlot(0, alignCorners, 0) - # LSTMOptions - def AsymmetricQuantizeInputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, halfPixelCenters): + builder.PrependBoolSlot(1, halfPixelCenters, 0) -def LSTMOptionsStart(builder): builder.StartObject(5) -def Start(builder): - return LSTMOptionsStart(builder) -def LSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return LSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def LSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) -def AddCellClip(builder, cellClip): - return LSTMOptionsAddCellClip(builder, cellClip) -def LSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) -def AddProjClip(builder, projClip): - return LSTMOptionsAddProjClip(builder, projClip) -def LSTMOptionsAddKernelType(builder, kernelType): builder.PrependInt8Slot(3, kernelType, 0) -def AddKernelType(builder, kernelType): - return LSTMOptionsAddKernelType(builder, kernelType) -def LSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(4, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return LSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def LSTMOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LSTMOptionsEnd(builder) +def ResizeNearestNeighborOptionsEnd(builder): + return builder.EndObject() -class LSTMOptionsT(object): - # LSTMOptionsT + +class ResizeNearestNeighborOptionsT(object): + + # ResizeNearestNeighborOptionsT def __init__(self): - self.fusedActivationFunction = 0 # type: int - self.cellClip = 0.0 # type: float - self.projClip = 0.0 # type: float - self.kernelType = 0 # type: int - self.asymmetricQuantizeInputs = False # type: bool + self.alignCorners = False # type: bool + self.halfPixelCenters = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - lstmoptions = LSTMOptions() - lstmoptions.Init(buf, pos) - return cls.InitFromObj(lstmoptions) + resizeNearestNeighborOptions = ResizeNearestNeighborOptions() + resizeNearestNeighborOptions.Init(buf, pos) + return cls.InitFromObj(resizeNearestNeighborOptions) @classmethod - def InitFromObj(cls, lstmoptions): - x = LSTMOptionsT() - x._UnPack(lstmoptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, resizeNearestNeighborOptions): + x = ResizeNearestNeighborOptionsT() + x._UnPack(resizeNearestNeighborOptions) return x - # LSTMOptionsT - def _UnPack(self, lstmoptions): - if lstmoptions is None: + # ResizeNearestNeighborOptionsT + def _UnPack(self, resizeNearestNeighborOptions): + if resizeNearestNeighborOptions is None: return - self.fusedActivationFunction = lstmoptions.FusedActivationFunction() - self.cellClip = lstmoptions.CellClip() - self.projClip = lstmoptions.ProjClip() - self.kernelType = lstmoptions.KernelType() - self.asymmetricQuantizeInputs = lstmoptions.AsymmetricQuantizeInputs() - - # LSTMOptionsT - def Pack(self, builder): - LSTMOptionsStart(builder) - LSTMOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - LSTMOptionsAddCellClip(builder, self.cellClip) - LSTMOptionsAddProjClip(builder, self.projClip) - LSTMOptionsAddKernelType(builder, self.kernelType) - LSTMOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) - lstmoptions = LSTMOptionsEnd(builder) - return lstmoptions -# automatically generated by the FlatBuffers compiler, do not modify + self.alignCorners = resizeNearestNeighborOptions.AlignCorners() + self.halfPixelCenters = resizeNearestNeighborOptions.HalfPixelCenters() -# namespace: tflite + # ResizeNearestNeighborOptionsT + def Pack(self, builder): + ResizeNearestNeighborOptionsStart(builder) + ResizeNearestNeighborOptionsAddAlignCorners(builder, self.alignCorners) + ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, self.halfPixelCenters) + resizeNearestNeighborOptions = ResizeNearestNeighborOptionsEnd(builder) + return resizeNearestNeighborOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LeakyReluOptions(object): +class CallOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LeakyReluOptions() + x = CallOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLeakyReluOptions(cls, buf, offset=0): + def GetRootAsCallOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LeakyReluOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def CallOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LeakyReluOptions + # CallOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # LeakyReluOptions - def Alpha(self): + # CallOptions + def Subgraph(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 -def LeakyReluOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return LeakyReluOptionsStart(builder) -def LeakyReluOptionsAddAlpha(builder, alpha): builder.PrependFloat32Slot(0, alpha, 0.0) -def AddAlpha(builder, alpha): - return LeakyReluOptionsAddAlpha(builder, alpha) -def LeakyReluOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LeakyReluOptionsEnd(builder) +def CallOptionsStart(builder): + builder.StartObject(1) -class LeakyReluOptionsT(object): +def CallOptionsAddSubgraph(builder, subgraph): + builder.PrependUint32Slot(0, subgraph, 0) - # LeakyReluOptionsT +def CallOptionsEnd(builder): + return builder.EndObject() + + + +class CallOptionsT(object): + + # CallOptionsT def __init__(self): - self.alpha = 0.0 # type: float + self.subgraph = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - leakyReluOptions = LeakyReluOptions() - leakyReluOptions.Init(buf, pos) - return cls.InitFromObj(leakyReluOptions) + callOptions = CallOptions() + callOptions.Init(buf, pos) + return cls.InitFromObj(callOptions) @classmethod - def InitFromObj(cls, leakyReluOptions): - x = LeakyReluOptionsT() - x._UnPack(leakyReluOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, callOptions): + x = CallOptionsT() + x._UnPack(callOptions) return x - # LeakyReluOptionsT - def _UnPack(self, leakyReluOptions): - if leakyReluOptions is None: + # CallOptionsT + def _UnPack(self, callOptions): + if callOptions is None: return - self.alpha = leakyReluOptions.Alpha() + self.subgraph = callOptions.Subgraph() - # LeakyReluOptionsT + # CallOptionsT def Pack(self, builder): - LeakyReluOptionsStart(builder) - LeakyReluOptionsAddAlpha(builder, self.alpha) - leakyReluOptions = LeakyReluOptionsEnd(builder) - return leakyReluOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + CallOptionsStart(builder) + CallOptionsAddSubgraph(builder, self.subgraph) + callOptions = CallOptionsEnd(builder) + return callOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LessEqualOptions(object): +class PadOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LessEqualOptions() + x = PadOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLessEqualOptions(cls, buf, offset=0): + def GetRootAsPadOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LessEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def PadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LessEqualOptions + # PadOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def LessEqualOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return LessEqualOptionsStart(builder) -def LessEqualOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LessEqualOptionsEnd(builder) +def PadOptionsStart(builder): + builder.StartObject(0) -class LessEqualOptionsT(object): +def PadOptionsEnd(builder): + return builder.EndObject() - # LessEqualOptionsT + + +class PadOptionsT(object): + + # PadOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - lessEqualOptions = LessEqualOptions() - lessEqualOptions.Init(buf, pos) - return cls.InitFromObj(lessEqualOptions) + padOptions = PadOptions() + padOptions.Init(buf, pos) + return cls.InitFromObj(padOptions) @classmethod - def InitFromObj(cls, lessEqualOptions): - x = LessEqualOptionsT() - x._UnPack(lessEqualOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, padOptions): + x = PadOptionsT() + x._UnPack(padOptions) return x - # LessEqualOptionsT - def _UnPack(self, lessEqualOptions): - if lessEqualOptions is None: + # PadOptionsT + def _UnPack(self, padOptions): + if padOptions is None: return - # LessEqualOptionsT + # PadOptionsT def Pack(self, builder): - LessEqualOptionsStart(builder) - lessEqualOptions = LessEqualOptionsEnd(builder) - return lessEqualOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + PadOptionsStart(builder) + padOptions = PadOptionsEnd(builder) + return padOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LessOptions(object): +class PadV2Options(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LessOptions() + x = PadV2Options() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLessOptions(cls, buf, offset=0): + def GetRootAsPadV2Options(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LessOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def PadV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LessOptions + # PadV2Options def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def LessOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return LessOptionsStart(builder) -def LessOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LessOptionsEnd(builder) +def PadV2OptionsStart(builder): + builder.StartObject(0) -class LessOptionsT(object): +def PadV2OptionsEnd(builder): + return builder.EndObject() - # LessOptionsT + + +class PadV2OptionsT(object): + + # PadV2OptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - lessOptions = LessOptions() - lessOptions.Init(buf, pos) - return cls.InitFromObj(lessOptions) + padV2Options = PadV2Options() + padV2Options.Init(buf, pos) + return cls.InitFromObj(padV2Options) @classmethod - def InitFromObj(cls, lessOptions): - x = LessOptionsT() - x._UnPack(lessOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, padV2Options): + x = PadV2OptionsT() + x._UnPack(padV2Options) return x - # LessOptionsT - def _UnPack(self, lessOptions): - if lessOptions is None: + # PadV2OptionsT + def _UnPack(self, padV2Options): + if padV2Options is None: return - # LessOptionsT + # PadV2OptionsT def Pack(self, builder): - LessOptionsStart(builder) - lessOptions = LessOptionsEnd(builder) - return lessOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + PadV2OptionsStart(builder) + padV2Options = PadV2OptionsEnd(builder) + return padV2Options -from flatbuffers.compat import import_numpy -np = import_numpy() -class LocalResponseNormalizationOptions(object): +class ReshapeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LocalResponseNormalizationOptions() + x = ReshapeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLocalResponseNormalizationOptions(cls, buf, offset=0): + def GetRootAsReshapeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LocalResponseNormalizationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ReshapeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LocalResponseNormalizationOptions + # ReshapeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # LocalResponseNormalizationOptions - def Radius(self): + # ReshapeOptions + def NewShape(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) return 0 - # LocalResponseNormalizationOptions - def Bias(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + # ReshapeOptions + def NewShapeAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 - # LocalResponseNormalizationOptions - def Alpha(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + # ReshapeOptions + def NewShapeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return self._tab.VectorLen(o) + return 0 - # LocalResponseNormalizationOptions - def Beta(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + # ReshapeOptions + def NewShapeIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 -def LocalResponseNormalizationOptionsStart(builder): builder.StartObject(4) -def Start(builder): - return LocalResponseNormalizationOptionsStart(builder) -def LocalResponseNormalizationOptionsAddRadius(builder, radius): builder.PrependInt32Slot(0, radius, 0) -def AddRadius(builder, radius): - return LocalResponseNormalizationOptionsAddRadius(builder, radius) -def LocalResponseNormalizationOptionsAddBias(builder, bias): builder.PrependFloat32Slot(1, bias, 0.0) -def AddBias(builder, bias): - return LocalResponseNormalizationOptionsAddBias(builder, bias) -def LocalResponseNormalizationOptionsAddAlpha(builder, alpha): builder.PrependFloat32Slot(2, alpha, 0.0) -def AddAlpha(builder, alpha): - return LocalResponseNormalizationOptionsAddAlpha(builder, alpha) -def LocalResponseNormalizationOptionsAddBeta(builder, beta): builder.PrependFloat32Slot(3, beta, 0.0) -def AddBeta(builder, beta): - return LocalResponseNormalizationOptionsAddBeta(builder, beta) -def LocalResponseNormalizationOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LocalResponseNormalizationOptionsEnd(builder) +def ReshapeOptionsStart(builder): + builder.StartObject(1) -class LocalResponseNormalizationOptionsT(object): +def ReshapeOptionsAddNewShape(builder, newShape): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(newShape), 0) - # LocalResponseNormalizationOptionsT +def ReshapeOptionsStartNewShapeVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def ReshapeOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class ReshapeOptionsT(object): + + # ReshapeOptionsT def __init__(self): - self.radius = 0 # type: int - self.bias = 0.0 # type: float - self.alpha = 0.0 # type: float - self.beta = 0.0 # type: float + self.newShape = None # type: List[int] @classmethod def InitFromBuf(cls, buf, pos): - localResponseNormalizationOptions = LocalResponseNormalizationOptions() - localResponseNormalizationOptions.Init(buf, pos) - return cls.InitFromObj(localResponseNormalizationOptions) + reshapeOptions = ReshapeOptions() + reshapeOptions.Init(buf, pos) + return cls.InitFromObj(reshapeOptions) @classmethod - def InitFromObj(cls, localResponseNormalizationOptions): - x = LocalResponseNormalizationOptionsT() - x._UnPack(localResponseNormalizationOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, reshapeOptions): + x = ReshapeOptionsT() + x._UnPack(reshapeOptions) return x - # LocalResponseNormalizationOptionsT - def _UnPack(self, localResponseNormalizationOptions): - if localResponseNormalizationOptions is None: + # ReshapeOptionsT + def _UnPack(self, reshapeOptions): + if reshapeOptions is None: return - self.radius = localResponseNormalizationOptions.Radius() - self.bias = localResponseNormalizationOptions.Bias() - self.alpha = localResponseNormalizationOptions.Alpha() - self.beta = localResponseNormalizationOptions.Beta() + if not reshapeOptions.NewShapeIsNone(): + if np is None: + self.newShape = [] + for i in range(reshapeOptions.NewShapeLength()): + self.newShape.append(reshapeOptions.NewShape(i)) + else: + self.newShape = reshapeOptions.NewShapeAsNumpy() - # LocalResponseNormalizationOptionsT + # ReshapeOptionsT def Pack(self, builder): - LocalResponseNormalizationOptionsStart(builder) - LocalResponseNormalizationOptionsAddRadius(builder, self.radius) - LocalResponseNormalizationOptionsAddBias(builder, self.bias) - LocalResponseNormalizationOptionsAddAlpha(builder, self.alpha) - LocalResponseNormalizationOptionsAddBeta(builder, self.beta) - localResponseNormalizationOptions = LocalResponseNormalizationOptionsEnd(builder) - return localResponseNormalizationOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.newShape is not None: + if np is not None and type(self.newShape) is np.ndarray: + newShape = builder.CreateNumpyVector(self.newShape) + else: + ReshapeOptionsStartNewShapeVector(builder, len(self.newShape)) + for i in reversed(range(len(self.newShape))): + builder.PrependInt32(self.newShape[i]) + newShape = builder.EndVector() + ReshapeOptionsStart(builder) + if self.newShape is not None: + ReshapeOptionsAddNewShape(builder, newShape) + reshapeOptions = ReshapeOptionsEnd(builder) + return reshapeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LogSoftmaxOptions(object): +class SpaceToBatchNDOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LogSoftmaxOptions() + x = SpaceToBatchNDOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLogSoftmaxOptions(cls, buf, offset=0): + def GetRootAsSpaceToBatchNDOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LogSoftmaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SpaceToBatchNDOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LogSoftmaxOptions + # SpaceToBatchNDOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def LogSoftmaxOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return LogSoftmaxOptionsStart(builder) -def LogSoftmaxOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LogSoftmaxOptionsEnd(builder) +def SpaceToBatchNDOptionsStart(builder): + builder.StartObject(0) -class LogSoftmaxOptionsT(object): +def SpaceToBatchNDOptionsEnd(builder): + return builder.EndObject() - # LogSoftmaxOptionsT + + +class SpaceToBatchNDOptionsT(object): + + # SpaceToBatchNDOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - logSoftmaxOptions = LogSoftmaxOptions() - logSoftmaxOptions.Init(buf, pos) - return cls.InitFromObj(logSoftmaxOptions) + spaceToBatchNdoptions = SpaceToBatchNDOptions() + spaceToBatchNdoptions.Init(buf, pos) + return cls.InitFromObj(spaceToBatchNdoptions) @classmethod - def InitFromObj(cls, logSoftmaxOptions): - x = LogSoftmaxOptionsT() - x._UnPack(logSoftmaxOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, spaceToBatchNdoptions): + x = SpaceToBatchNDOptionsT() + x._UnPack(spaceToBatchNdoptions) return x - # LogSoftmaxOptionsT - def _UnPack(self, logSoftmaxOptions): - if logSoftmaxOptions is None: + # SpaceToBatchNDOptionsT + def _UnPack(self, spaceToBatchNdoptions): + if spaceToBatchNdoptions is None: return - # LogSoftmaxOptionsT + # SpaceToBatchNDOptionsT def Pack(self, builder): - LogSoftmaxOptionsStart(builder) - logSoftmaxOptions = LogSoftmaxOptionsEnd(builder) - return logSoftmaxOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SpaceToBatchNDOptionsStart(builder) + spaceToBatchNdoptions = SpaceToBatchNDOptionsEnd(builder) + return spaceToBatchNdoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LogicalAndOptions(object): +class BatchToSpaceNDOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LogicalAndOptions() + x = BatchToSpaceNDOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLogicalAndOptions(cls, buf, offset=0): + def GetRootAsBatchToSpaceNDOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LogicalAndOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def BatchToSpaceNDOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LogicalAndOptions + # BatchToSpaceNDOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def LogicalAndOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return LogicalAndOptionsStart(builder) -def LogicalAndOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LogicalAndOptionsEnd(builder) +def BatchToSpaceNDOptionsStart(builder): + builder.StartObject(0) -class LogicalAndOptionsT(object): +def BatchToSpaceNDOptionsEnd(builder): + return builder.EndObject() - # LogicalAndOptionsT + + +class BatchToSpaceNDOptionsT(object): + + # BatchToSpaceNDOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - logicalAndOptions = LogicalAndOptions() - logicalAndOptions.Init(buf, pos) - return cls.InitFromObj(logicalAndOptions) + batchToSpaceNdoptions = BatchToSpaceNDOptions() + batchToSpaceNdoptions.Init(buf, pos) + return cls.InitFromObj(batchToSpaceNdoptions) @classmethod - def InitFromObj(cls, logicalAndOptions): - x = LogicalAndOptionsT() - x._UnPack(logicalAndOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, batchToSpaceNdoptions): + x = BatchToSpaceNDOptionsT() + x._UnPack(batchToSpaceNdoptions) return x - # LogicalAndOptionsT - def _UnPack(self, logicalAndOptions): - if logicalAndOptions is None: + # BatchToSpaceNDOptionsT + def _UnPack(self, batchToSpaceNdoptions): + if batchToSpaceNdoptions is None: return - # LogicalAndOptionsT + # BatchToSpaceNDOptionsT def Pack(self, builder): - LogicalAndOptionsStart(builder) - logicalAndOptions = LogicalAndOptionsEnd(builder) - return logicalAndOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + BatchToSpaceNDOptionsStart(builder) + batchToSpaceNdoptions = BatchToSpaceNDOptionsEnd(builder) + return batchToSpaceNdoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LogicalNotOptions(object): +class SkipGramOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LogicalNotOptions() + x = SkipGramOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLogicalNotOptions(cls, buf, offset=0): + def GetRootAsSkipGramOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LogicalNotOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SkipGramOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LogicalNotOptions + # SkipGramOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def LogicalNotOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return LogicalNotOptionsStart(builder) -def LogicalNotOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LogicalNotOptionsEnd(builder) + # SkipGramOptions + def NgramSize(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 -class LogicalNotOptionsT(object): + # SkipGramOptions + def MaxSkipSize(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 - # LogicalNotOptionsT + # SkipGramOptions + def IncludeAllNgrams(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def SkipGramOptionsStart(builder): + builder.StartObject(3) + +def SkipGramOptionsAddNgramSize(builder, ngramSize): + builder.PrependInt32Slot(0, ngramSize, 0) + +def SkipGramOptionsAddMaxSkipSize(builder, maxSkipSize): + builder.PrependInt32Slot(1, maxSkipSize, 0) + +def SkipGramOptionsAddIncludeAllNgrams(builder, includeAllNgrams): + builder.PrependBoolSlot(2, includeAllNgrams, 0) + +def SkipGramOptionsEnd(builder): + return builder.EndObject() + + + +class SkipGramOptionsT(object): + + # SkipGramOptionsT def __init__(self): - pass + self.ngramSize = 0 # type: int + self.maxSkipSize = 0 # type: int + self.includeAllNgrams = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - logicalNotOptions = LogicalNotOptions() - logicalNotOptions.Init(buf, pos) - return cls.InitFromObj(logicalNotOptions) + skipGramOptions = SkipGramOptions() + skipGramOptions.Init(buf, pos) + return cls.InitFromObj(skipGramOptions) @classmethod - def InitFromObj(cls, logicalNotOptions): - x = LogicalNotOptionsT() - x._UnPack(logicalNotOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, skipGramOptions): + x = SkipGramOptionsT() + x._UnPack(skipGramOptions) return x - # LogicalNotOptionsT - def _UnPack(self, logicalNotOptions): - if logicalNotOptions is None: + # SkipGramOptionsT + def _UnPack(self, skipGramOptions): + if skipGramOptions is None: return + self.ngramSize = skipGramOptions.NgramSize() + self.maxSkipSize = skipGramOptions.MaxSkipSize() + self.includeAllNgrams = skipGramOptions.IncludeAllNgrams() - # LogicalNotOptionsT + # SkipGramOptionsT def Pack(self, builder): - LogicalNotOptionsStart(builder) - logicalNotOptions = LogicalNotOptionsEnd(builder) - return logicalNotOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SkipGramOptionsStart(builder) + SkipGramOptionsAddNgramSize(builder, self.ngramSize) + SkipGramOptionsAddMaxSkipSize(builder, self.maxSkipSize) + SkipGramOptionsAddIncludeAllNgrams(builder, self.includeAllNgrams) + skipGramOptions = SkipGramOptionsEnd(builder) + return skipGramOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class LogicalOrOptions(object): +class SpaceToDepthOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = LogicalOrOptions() + x = SpaceToDepthOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsLogicalOrOptions(cls, buf, offset=0): + def GetRootAsSpaceToDepthOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def LogicalOrOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SpaceToDepthOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # LogicalOrOptions + # SpaceToDepthOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def LogicalOrOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return LogicalOrOptionsStart(builder) -def LogicalOrOptionsEnd(builder): return builder.EndObject() -def End(builder): - return LogicalOrOptionsEnd(builder) + # SpaceToDepthOptions + def BlockSize(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def SpaceToDepthOptionsStart(builder): + builder.StartObject(1) -class LogicalOrOptionsT(object): +def SpaceToDepthOptionsAddBlockSize(builder, blockSize): + builder.PrependInt32Slot(0, blockSize, 0) - # LogicalOrOptionsT +def SpaceToDepthOptionsEnd(builder): + return builder.EndObject() + + + +class SpaceToDepthOptionsT(object): + + # SpaceToDepthOptionsT def __init__(self): - pass + self.blockSize = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - logicalOrOptions = LogicalOrOptions() - logicalOrOptions.Init(buf, pos) - return cls.InitFromObj(logicalOrOptions) + spaceToDepthOptions = SpaceToDepthOptions() + spaceToDepthOptions.Init(buf, pos) + return cls.InitFromObj(spaceToDepthOptions) @classmethod - def InitFromObj(cls, logicalOrOptions): - x = LogicalOrOptionsT() - x._UnPack(logicalOrOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, spaceToDepthOptions): + x = SpaceToDepthOptionsT() + x._UnPack(spaceToDepthOptions) return x - # LogicalOrOptionsT - def _UnPack(self, logicalOrOptions): - if logicalOrOptions is None: + # SpaceToDepthOptionsT + def _UnPack(self, spaceToDepthOptions): + if spaceToDepthOptions is None: return + self.blockSize = spaceToDepthOptions.BlockSize() - # LogicalOrOptionsT + # SpaceToDepthOptionsT def Pack(self, builder): - LogicalOrOptionsStart(builder) - logicalOrOptions = LogicalOrOptionsEnd(builder) - return logicalOrOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SpaceToDepthOptionsStart(builder) + SpaceToDepthOptionsAddBlockSize(builder, self.blockSize) + spaceToDepthOptions = SpaceToDepthOptionsEnd(builder) + return spaceToDepthOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class MatrixDiagOptions(object): +class DepthToSpaceOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = MatrixDiagOptions() + x = DepthToSpaceOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsMatrixDiagOptions(cls, buf, offset=0): + def GetRootAsDepthToSpaceOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def MatrixDiagOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def DepthToSpaceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # MatrixDiagOptions + # DepthToSpaceOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def MatrixDiagOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return MatrixDiagOptionsStart(builder) -def MatrixDiagOptionsEnd(builder): return builder.EndObject() -def End(builder): - return MatrixDiagOptionsEnd(builder) + # DepthToSpaceOptions + def BlockSize(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 -class MatrixDiagOptionsT(object): +def DepthToSpaceOptionsStart(builder): + builder.StartObject(1) - # MatrixDiagOptionsT +def DepthToSpaceOptionsAddBlockSize(builder, blockSize): + builder.PrependInt32Slot(0, blockSize, 0) + +def DepthToSpaceOptionsEnd(builder): + return builder.EndObject() + + + +class DepthToSpaceOptionsT(object): + + # DepthToSpaceOptionsT def __init__(self): - pass + self.blockSize = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - matrixDiagOptions = MatrixDiagOptions() - matrixDiagOptions.Init(buf, pos) - return cls.InitFromObj(matrixDiagOptions) + depthToSpaceOptions = DepthToSpaceOptions() + depthToSpaceOptions.Init(buf, pos) + return cls.InitFromObj(depthToSpaceOptions) @classmethod - def InitFromObj(cls, matrixDiagOptions): - x = MatrixDiagOptionsT() - x._UnPack(matrixDiagOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, depthToSpaceOptions): + x = DepthToSpaceOptionsT() + x._UnPack(depthToSpaceOptions) return x - # MatrixDiagOptionsT - def _UnPack(self, matrixDiagOptions): - if matrixDiagOptions is None: + # DepthToSpaceOptionsT + def _UnPack(self, depthToSpaceOptions): + if depthToSpaceOptions is None: return + self.blockSize = depthToSpaceOptions.BlockSize() - # MatrixDiagOptionsT + # DepthToSpaceOptionsT def Pack(self, builder): - MatrixDiagOptionsStart(builder) - matrixDiagOptions = MatrixDiagOptionsEnd(builder) - return matrixDiagOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + DepthToSpaceOptionsStart(builder) + DepthToSpaceOptionsAddBlockSize(builder, self.blockSize) + depthToSpaceOptions = DepthToSpaceOptionsEnd(builder) + return depthToSpaceOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class MatrixSetDiagOptions(object): +class SubOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = MatrixSetDiagOptions() + x = SubOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsMatrixSetDiagOptions(cls, buf, offset=0): + def GetRootAsSubOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def MatrixSetDiagOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SubOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # MatrixSetDiagOptions + # SubOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def MatrixSetDiagOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return MatrixSetDiagOptionsStart(builder) -def MatrixSetDiagOptionsEnd(builder): return builder.EndObject() -def End(builder): - return MatrixSetDiagOptionsEnd(builder) + # SubOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # SubOptions + def PotScaleInt16(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return True + +def SubOptionsStart(builder): + builder.StartObject(2) -class MatrixSetDiagOptionsT(object): +def SubOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) - # MatrixSetDiagOptionsT +def SubOptionsAddPotScaleInt16(builder, potScaleInt16): + builder.PrependBoolSlot(1, potScaleInt16, 1) + +def SubOptionsEnd(builder): + return builder.EndObject() + + + +class SubOptionsT(object): + + # SubOptionsT def __init__(self): - pass + self.fusedActivationFunction = 0 # type: int + self.potScaleInt16 = True # type: bool @classmethod def InitFromBuf(cls, buf, pos): - matrixSetDiagOptions = MatrixSetDiagOptions() - matrixSetDiagOptions.Init(buf, pos) - return cls.InitFromObj(matrixSetDiagOptions) + subOptions = SubOptions() + subOptions.Init(buf, pos) + return cls.InitFromObj(subOptions) @classmethod - def InitFromObj(cls, matrixSetDiagOptions): - x = MatrixSetDiagOptionsT() - x._UnPack(matrixSetDiagOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, subOptions): + x = SubOptionsT() + x._UnPack(subOptions) return x - # MatrixSetDiagOptionsT - def _UnPack(self, matrixSetDiagOptions): - if matrixSetDiagOptions is None: + # SubOptionsT + def _UnPack(self, subOptions): + if subOptions is None: return + self.fusedActivationFunction = subOptions.FusedActivationFunction() + self.potScaleInt16 = subOptions.PotScaleInt16() - # MatrixSetDiagOptionsT + # SubOptionsT def Pack(self, builder): - MatrixSetDiagOptionsStart(builder) - matrixSetDiagOptions = MatrixSetDiagOptionsEnd(builder) - return matrixSetDiagOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SubOptionsStart(builder) + SubOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + SubOptionsAddPotScaleInt16(builder, self.potScaleInt16) + subOptions = SubOptionsEnd(builder) + return subOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class MaximumMinimumOptions(object): +class DivOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = MaximumMinimumOptions() + x = DivOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsMaximumMinimumOptions(cls, buf, offset=0): + def GetRootAsDivOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def MaximumMinimumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def DivOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # MaximumMinimumOptions + # DivOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def MaximumMinimumOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return MaximumMinimumOptionsStart(builder) -def MaximumMinimumOptionsEnd(builder): return builder.EndObject() -def End(builder): - return MaximumMinimumOptionsEnd(builder) + # DivOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 -class MaximumMinimumOptionsT(object): +def DivOptionsStart(builder): + builder.StartObject(1) - # MaximumMinimumOptionsT +def DivOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(0, fusedActivationFunction, 0) + +def DivOptionsEnd(builder): + return builder.EndObject() + + + +class DivOptionsT(object): + + # DivOptionsT def __init__(self): - pass + self.fusedActivationFunction = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - maximumMinimumOptions = MaximumMinimumOptions() - maximumMinimumOptions.Init(buf, pos) - return cls.InitFromObj(maximumMinimumOptions) + divOptions = DivOptions() + divOptions.Init(buf, pos) + return cls.InitFromObj(divOptions) @classmethod - def InitFromObj(cls, maximumMinimumOptions): - x = MaximumMinimumOptionsT() - x._UnPack(maximumMinimumOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, divOptions): + x = DivOptionsT() + x._UnPack(divOptions) return x - # MaximumMinimumOptionsT - def _UnPack(self, maximumMinimumOptions): - if maximumMinimumOptions is None: + # DivOptionsT + def _UnPack(self, divOptions): + if divOptions is None: return + self.fusedActivationFunction = divOptions.FusedActivationFunction() - # MaximumMinimumOptionsT + # DivOptionsT def Pack(self, builder): - MaximumMinimumOptionsStart(builder) - maximumMinimumOptions = MaximumMinimumOptionsEnd(builder) - return maximumMinimumOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + DivOptionsStart(builder) + DivOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + divOptions = DivOptionsEnd(builder) + return divOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class Metadata(object): +class TopKV2Options(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Metadata() + x = TopKV2Options() x.Init(buf, n + offset) return x @classmethod - def GetRootAsMetadata(cls, buf, offset=0): + def GetRootAsTopKV2Options(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def MetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def TopKV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Metadata + # TopKV2Options def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # Metadata - def Name(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None +def TopKV2OptionsStart(builder): + builder.StartObject(0) - # Metadata - def Buffer(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) - return 0 +def TopKV2OptionsEnd(builder): + return builder.EndObject() -def MetadataStart(builder): builder.StartObject(2) -def Start(builder): - return MetadataStart(builder) -def MetadataAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def AddName(builder, name): - return MetadataAddName(builder, name) -def MetadataAddBuffer(builder, buffer): builder.PrependUint32Slot(1, buffer, 0) -def AddBuffer(builder, buffer): - return MetadataAddBuffer(builder, buffer) -def MetadataEnd(builder): return builder.EndObject() -def End(builder): - return MetadataEnd(builder) -class MetadataT(object): - # MetadataT +class TopKV2OptionsT(object): + + # TopKV2OptionsT def __init__(self): - self.name = None # type: str - self.buffer = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - metadata = Metadata() - metadata.Init(buf, pos) - return cls.InitFromObj(metadata) + topKv2Options = TopKV2Options() + topKv2Options.Init(buf, pos) + return cls.InitFromObj(topKv2Options) @classmethod - def InitFromObj(cls, metadata): - x = MetadataT() - x._UnPack(metadata) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, topKv2Options): + x = TopKV2OptionsT() + x._UnPack(topKv2Options) return x - # MetadataT - def _UnPack(self, metadata): - if metadata is None: + # TopKV2OptionsT + def _UnPack(self, topKv2Options): + if topKv2Options is None: return - self.name = metadata.Name() - self.buffer = metadata.Buffer() - # MetadataT + # TopKV2OptionsT def Pack(self, builder): - if self.name is not None: - name = builder.CreateString(self.name) - MetadataStart(builder) - if self.name is not None: - MetadataAddName(builder, name) - MetadataAddBuffer(builder, self.buffer) - metadata = MetadataEnd(builder) - return metadata -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class MirrorPadMode(object): - REFLECT = 0 - SYMMETRIC = 1 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + TopKV2OptionsStart(builder) + topKv2Options = TopKV2OptionsEnd(builder) + return topKv2Options -from flatbuffers.compat import import_numpy -np = import_numpy() -class MirrorPadOptions(object): +class EmbeddingLookupSparseOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = MirrorPadOptions() + x = EmbeddingLookupSparseOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsMirrorPadOptions(cls, buf, offset=0): + def GetRootAsEmbeddingLookupSparseOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def MirrorPadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def EmbeddingLookupSparseOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # MirrorPadOptions + # EmbeddingLookupSparseOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # MirrorPadOptions - def Mode(self): + # EmbeddingLookupSparseOptions + def Combiner(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 -def MirrorPadOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return MirrorPadOptionsStart(builder) -def MirrorPadOptionsAddMode(builder, mode): builder.PrependInt8Slot(0, mode, 0) -def AddMode(builder, mode): - return MirrorPadOptionsAddMode(builder, mode) -def MirrorPadOptionsEnd(builder): return builder.EndObject() -def End(builder): - return MirrorPadOptionsEnd(builder) +def EmbeddingLookupSparseOptionsStart(builder): + builder.StartObject(1) -class MirrorPadOptionsT(object): +def EmbeddingLookupSparseOptionsAddCombiner(builder, combiner): + builder.PrependInt8Slot(0, combiner, 0) - # MirrorPadOptionsT +def EmbeddingLookupSparseOptionsEnd(builder): + return builder.EndObject() + + + +class EmbeddingLookupSparseOptionsT(object): + + # EmbeddingLookupSparseOptionsT def __init__(self): - self.mode = 0 # type: int + self.combiner = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - mirrorPadOptions = MirrorPadOptions() - mirrorPadOptions.Init(buf, pos) - return cls.InitFromObj(mirrorPadOptions) + embeddingLookupSparseOptions = EmbeddingLookupSparseOptions() + embeddingLookupSparseOptions.Init(buf, pos) + return cls.InitFromObj(embeddingLookupSparseOptions) @classmethod - def InitFromObj(cls, mirrorPadOptions): - x = MirrorPadOptionsT() - x._UnPack(mirrorPadOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, embeddingLookupSparseOptions): + x = EmbeddingLookupSparseOptionsT() + x._UnPack(embeddingLookupSparseOptions) return x - # MirrorPadOptionsT - def _UnPack(self, mirrorPadOptions): - if mirrorPadOptions is None: + # EmbeddingLookupSparseOptionsT + def _UnPack(self, embeddingLookupSparseOptions): + if embeddingLookupSparseOptions is None: return - self.mode = mirrorPadOptions.Mode() + self.combiner = embeddingLookupSparseOptions.Combiner() - # MirrorPadOptionsT + # EmbeddingLookupSparseOptionsT def Pack(self, builder): - MirrorPadOptionsStart(builder) - MirrorPadOptionsAddMode(builder, self.mode) - mirrorPadOptions = MirrorPadOptionsEnd(builder) - return mirrorPadOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + EmbeddingLookupSparseOptionsStart(builder) + EmbeddingLookupSparseOptionsAddCombiner(builder, self.combiner) + embeddingLookupSparseOptions = EmbeddingLookupSparseOptionsEnd(builder) + return embeddingLookupSparseOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class Model(object): +class GatherOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Model() + x = GatherOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsModel(cls, buf, offset=0): + def GetRootAsGatherOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def GatherOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Model + # GatherOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # Model - def Version(self): + # GatherOptions + def Axis(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # Model - def OperatorCodes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = OperatorCode() - obj.Init(self._tab.Bytes, x) - return obj - return None - - # Model - def OperatorCodesLength(self): + # GatherOptions + def BatchDims(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.VectorLen(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # Model - def OperatorCodesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 +def GatherOptionsStart(builder): + builder.StartObject(2) - # Model - def Subgraphs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = SubGraph() - obj.Init(self._tab.Bytes, x) - return obj - return None +def GatherOptionsAddAxis(builder, axis): + builder.PrependInt32Slot(0, axis, 0) - # Model - def SubgraphsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def GatherOptionsAddBatchDims(builder, batchDims): + builder.PrependInt32Slot(1, batchDims, 0) - # Model - def SubgraphsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 +def GatherOptionsEnd(builder): + return builder.EndObject() - # Model - def Description(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None - # Model - def Buffers(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = Buffer() - obj.Init(self._tab.Bytes, x) - return obj - return None - # Model - def BuffersLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class GatherOptionsT(object): - # Model - def BuffersIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - return o == 0 + # GatherOptionsT + def __init__(self): + self.axis = 0 # type: int + self.batchDims = 0 # type: int - # Model - def MetadataBuffer(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 + @classmethod + def InitFromBuf(cls, buf, pos): + gatherOptions = GatherOptions() + gatherOptions.Init(buf, pos) + return cls.InitFromObj(gatherOptions) - # Model - def MetadataBufferAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # Model - def MetadataBufferLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + @classmethod + def InitFromObj(cls, gatherOptions): + x = GatherOptionsT() + x._UnPack(gatherOptions) + return x - # Model - def MetadataBufferIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - return o == 0 + # GatherOptionsT + def _UnPack(self, gatherOptions): + if gatherOptions is None: + return + self.axis = gatherOptions.Axis() + self.batchDims = gatherOptions.BatchDims() - # Model - def Metadata(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = Metadata() - obj.Init(self._tab.Bytes, x) - return obj - return None + # GatherOptionsT + def Pack(self, builder): + GatherOptionsStart(builder) + GatherOptionsAddAxis(builder, self.axis) + GatherOptionsAddBatchDims(builder, self.batchDims) + gatherOptions = GatherOptionsEnd(builder) + return gatherOptions - # Model - def MetadataLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - # Model - def MetadataIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - return o == 0 +class TransposeOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TransposeOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsTransposeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TransposeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Model - def SignatureDefs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = SignatureDef() - obj.Init(self._tab.Bytes, x) - return obj - return None + # TransposeOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) - # Model - def SignatureDefsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def TransposeOptionsStart(builder): + builder.StartObject(0) - # Model - def SignatureDefsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - return o == 0 +def TransposeOptionsEnd(builder): + return builder.EndObject() -def ModelStart(builder): builder.StartObject(8) -def Start(builder): - return ModelStart(builder) -def ModelAddVersion(builder, version): builder.PrependUint32Slot(0, version, 0) -def AddVersion(builder, version): - return ModelAddVersion(builder, version) -def ModelAddOperatorCodes(builder, operatorCodes): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operatorCodes), 0) -def AddOperatorCodes(builder, operatorCodes): - return ModelAddOperatorCodes(builder, operatorCodes) -def ModelStartOperatorCodesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartOperatorCodesVector(builder, numElems): - return ModelStartOperatorCodesVector(builder, numElems) -def ModelAddSubgraphs(builder, subgraphs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subgraphs), 0) -def AddSubgraphs(builder, subgraphs): - return ModelAddSubgraphs(builder, subgraphs) -def ModelStartSubgraphsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartSubgraphsVector(builder, numElems): - return ModelStartSubgraphsVector(builder, numElems) -def ModelAddDescription(builder, description): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0) -def AddDescription(builder, description): - return ModelAddDescription(builder, description) -def ModelAddBuffers(builder, buffers): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(buffers), 0) -def AddBuffers(builder, buffers): - return ModelAddBuffers(builder, buffers) -def ModelStartBuffersVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartBuffersVector(builder, numElems): - return ModelStartBuffersVector(builder, numElems) -def ModelAddMetadataBuffer(builder, metadataBuffer): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(metadataBuffer), 0) -def AddMetadataBuffer(builder, metadataBuffer): - return ModelAddMetadataBuffer(builder, metadataBuffer) -def ModelStartMetadataBufferVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartMetadataBufferVector(builder, numElems): - return ModelStartMetadataBufferVector(builder, numElems) -def ModelAddMetadata(builder, metadata): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(metadata), 0) -def AddMetadata(builder, metadata): - return ModelAddMetadata(builder, metadata) -def ModelStartMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartMetadataVector(builder, numElems): - return ModelStartMetadataVector(builder, numElems) -def ModelAddSignatureDefs(builder, signatureDefs): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(signatureDefs), 0) -def AddSignatureDefs(builder, signatureDefs): - return ModelAddSignatureDefs(builder, signatureDefs) -def ModelStartSignatureDefsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartSignatureDefsVector(builder, numElems): - return ModelStartSignatureDefsVector(builder, numElems) -def ModelEnd(builder): return builder.EndObject() -def End(builder): - return ModelEnd(builder) -try: - from typing import List -except: - pass -class ModelT(object): - # ModelT +class TransposeOptionsT(object): + + # TransposeOptionsT def __init__(self): - self.version = 0 # type: int - self.operatorCodes = None # type: List[OperatorCodeT] - self.subgraphs = None # type: List[SubGraphT] - self.description = None # type: str - self.buffers = None # type: List[BufferT] - self.metadataBuffer = None # type: List[int] - self.metadata = None # type: List[MetadataT] - self.signatureDefs = None # type: List[SignatureDefT] + pass @classmethod def InitFromBuf(cls, buf, pos): - model = Model() - model.Init(buf, pos) - return cls.InitFromObj(model) + transposeOptions = TransposeOptions() + transposeOptions.Init(buf, pos) + return cls.InitFromObj(transposeOptions) @classmethod - def InitFromObj(cls, model): - x = ModelT() - x._UnPack(model) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, transposeOptions): + x = TransposeOptionsT() + x._UnPack(transposeOptions) return x - # ModelT - def _UnPack(self, model): - if model is None: + # TransposeOptionsT + def _UnPack(self, transposeOptions): + if transposeOptions is None: return - self.version = model.Version() - if not model.OperatorCodesIsNone(): - self.operatorCodes = [] - for i in range(model.OperatorCodesLength()): - if model.OperatorCodes(i) is None: - self.operatorCodes.append(None) - else: - operatorCode_ = OperatorCodeT.InitFromObj(model.OperatorCodes(i)) - self.operatorCodes.append(operatorCode_) - if not model.SubgraphsIsNone(): - self.subgraphs = [] - for i in range(model.SubgraphsLength()): - if model.Subgraphs(i) is None: - self.subgraphs.append(None) - else: - subGraph_ = SubGraphT.InitFromObj(model.Subgraphs(i)) - self.subgraphs.append(subGraph_) - self.description = model.Description() - if not model.BuffersIsNone(): - self.buffers = [] - for i in range(model.BuffersLength()): - if model.Buffers(i) is None: - self.buffers.append(None) - else: - buffer_ = BufferT.InitFromObj(model.Buffers(i)) - self.buffers.append(buffer_) - if not model.MetadataBufferIsNone(): - if np is None: - self.metadataBuffer = [] - for i in range(model.MetadataBufferLength()): - self.metadataBuffer.append(model.MetadataBuffer(i)) - else: - self.metadataBuffer = model.MetadataBufferAsNumpy() - if not model.MetadataIsNone(): - self.metadata = [] - for i in range(model.MetadataLength()): - if model.Metadata(i) is None: - self.metadata.append(None) - else: - metadata_ = MetadataT.InitFromObj(model.Metadata(i)) - self.metadata.append(metadata_) - if not model.SignatureDefsIsNone(): - self.signatureDefs = [] - for i in range(model.SignatureDefsLength()): - if model.SignatureDefs(i) is None: - self.signatureDefs.append(None) - else: - signatureDef_ = SignatureDefT.InitFromObj(model.SignatureDefs(i)) - self.signatureDefs.append(signatureDef_) - # ModelT + # TransposeOptionsT def Pack(self, builder): - if self.operatorCodes is not None: - operatorCodeslist = [] - for i in range(len(self.operatorCodes)): - operatorCodeslist.append(self.operatorCodes[i].Pack(builder)) - ModelStartOperatorCodesVector(builder, len(self.operatorCodes)) - for i in reversed(range(len(self.operatorCodes))): - builder.PrependUOffsetTRelative(operatorCodeslist[i]) - operatorCodes = builder.EndVector() - if self.subgraphs is not None: - subgraphslist = [] - for i in range(len(self.subgraphs)): - subgraphslist.append(self.subgraphs[i].Pack(builder)) - ModelStartSubgraphsVector(builder, len(self.subgraphs)) - for i in reversed(range(len(self.subgraphs))): - builder.PrependUOffsetTRelative(subgraphslist[i]) - subgraphs = builder.EndVector() - if self.description is not None: - description = builder.CreateString(self.description) - if self.buffers is not None: - bufferslist = [] - for i in range(len(self.buffers)): - bufferslist.append(self.buffers[i].Pack(builder)) - ModelStartBuffersVector(builder, len(self.buffers)) - for i in reversed(range(len(self.buffers))): - builder.PrependUOffsetTRelative(bufferslist[i]) - buffers = builder.EndVector() - if self.metadataBuffer is not None: - if np is not None and type(self.metadataBuffer) is np.ndarray: - metadataBuffer = builder.CreateNumpyVector(self.metadataBuffer) - else: - ModelStartMetadataBufferVector(builder, len(self.metadataBuffer)) - for i in reversed(range(len(self.metadataBuffer))): - builder.PrependInt32(self.metadataBuffer[i]) - metadataBuffer = builder.EndVector() - if self.metadata is not None: - metadatalist = [] - for i in range(len(self.metadata)): - metadatalist.append(self.metadata[i].Pack(builder)) - ModelStartMetadataVector(builder, len(self.metadata)) - for i in reversed(range(len(self.metadata))): - builder.PrependUOffsetTRelative(metadatalist[i]) - metadata = builder.EndVector() - if self.signatureDefs is not None: - signatureDefslist = [] - for i in range(len(self.signatureDefs)): - signatureDefslist.append(self.signatureDefs[i].Pack(builder)) - ModelStartSignatureDefsVector(builder, len(self.signatureDefs)) - for i in reversed(range(len(self.signatureDefs))): - builder.PrependUOffsetTRelative(signatureDefslist[i]) - signatureDefs = builder.EndVector() - ModelStart(builder) - ModelAddVersion(builder, self.version) - if self.operatorCodes is not None: - ModelAddOperatorCodes(builder, operatorCodes) - if self.subgraphs is not None: - ModelAddSubgraphs(builder, subgraphs) - if self.description is not None: - ModelAddDescription(builder, description) - if self.buffers is not None: - ModelAddBuffers(builder, buffers) - if self.metadataBuffer is not None: - ModelAddMetadataBuffer(builder, metadataBuffer) - if self.metadata is not None: - ModelAddMetadata(builder, metadata) - if self.signatureDefs is not None: - ModelAddSignatureDefs(builder, signatureDefs) - model = ModelEnd(builder) - return model -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + TransposeOptionsStart(builder) + transposeOptions = TransposeOptionsEnd(builder) + return transposeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class MulOptions(object): +class ExpOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = MulOptions() + x = ExpOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsMulOptions(cls, buf, offset=0): + def GetRootAsExpOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def MulOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ExpOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # MulOptions + # ExpOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # MulOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def ExpOptionsStart(builder): + builder.StartObject(0) -def MulOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return MulOptionsStart(builder) -def MulOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return MulOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def MulOptionsEnd(builder): return builder.EndObject() -def End(builder): - return MulOptionsEnd(builder) +def ExpOptionsEnd(builder): + return builder.EndObject() -class MulOptionsT(object): - # MulOptionsT + +class ExpOptionsT(object): + + # ExpOptionsT def __init__(self): - self.fusedActivationFunction = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - mulOptions = MulOptions() - mulOptions.Init(buf, pos) - return cls.InitFromObj(mulOptions) + expOptions = ExpOptions() + expOptions.Init(buf, pos) + return cls.InitFromObj(expOptions) @classmethod - def InitFromObj(cls, mulOptions): - x = MulOptionsT() - x._UnPack(mulOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, expOptions): + x = ExpOptionsT() + x._UnPack(expOptions) return x - # MulOptionsT - def _UnPack(self, mulOptions): - if mulOptions is None: + # ExpOptionsT + def _UnPack(self, expOptions): + if expOptions is None: return - self.fusedActivationFunction = mulOptions.FusedActivationFunction() - # MulOptionsT + # ExpOptionsT def Pack(self, builder): - MulOptionsStart(builder) - MulOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - mulOptions = MulOptionsEnd(builder) - return mulOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ExpOptionsStart(builder) + expOptions = ExpOptionsEnd(builder) + return expOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class NegOptions(object): +class CosOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = NegOptions() + x = CosOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsNegOptions(cls, buf, offset=0): + def GetRootAsCosOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def NegOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def CosOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # NegOptions + # CosOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def NegOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return NegOptionsStart(builder) -def NegOptionsEnd(builder): return builder.EndObject() -def End(builder): - return NegOptionsEnd(builder) +def CosOptionsStart(builder): + builder.StartObject(0) -class NegOptionsT(object): +def CosOptionsEnd(builder): + return builder.EndObject() - # NegOptionsT + + +class CosOptionsT(object): + + # CosOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - negOptions = NegOptions() - negOptions.Init(buf, pos) - return cls.InitFromObj(negOptions) + cosOptions = CosOptions() + cosOptions.Init(buf, pos) + return cls.InitFromObj(cosOptions) @classmethod - def InitFromObj(cls, negOptions): - x = NegOptionsT() - x._UnPack(negOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, cosOptions): + x = CosOptionsT() + x._UnPack(cosOptions) return x - # NegOptionsT - def _UnPack(self, negOptions): - if negOptions is None: + # CosOptionsT + def _UnPack(self, cosOptions): + if cosOptions is None: return - # NegOptionsT + # CosOptionsT def Pack(self, builder): - NegOptionsStart(builder) - negOptions = NegOptionsEnd(builder) - return negOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + CosOptionsStart(builder) + cosOptions = CosOptionsEnd(builder) + return cosOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class NonMaxSuppressionV4Options(object): +class ReducerOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = NonMaxSuppressionV4Options() + x = ReducerOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsNonMaxSuppressionV4Options(cls, buf, offset=0): + def GetRootAsReducerOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def NonMaxSuppressionV4OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ReducerOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # NonMaxSuppressionV4Options + # ReducerOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def NonMaxSuppressionV4OptionsStart(builder): builder.StartObject(0) -def Start(builder): - return NonMaxSuppressionV4OptionsStart(builder) -def NonMaxSuppressionV4OptionsEnd(builder): return builder.EndObject() -def End(builder): - return NonMaxSuppressionV4OptionsEnd(builder) + # ReducerOptions + def KeepDims(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False -class NonMaxSuppressionV4OptionsT(object): +def ReducerOptionsStart(builder): + builder.StartObject(1) - # NonMaxSuppressionV4OptionsT +def ReducerOptionsAddKeepDims(builder, keepDims): + builder.PrependBoolSlot(0, keepDims, 0) + +def ReducerOptionsEnd(builder): + return builder.EndObject() + + + +class ReducerOptionsT(object): + + # ReducerOptionsT def __init__(self): - pass + self.keepDims = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - nonMaxSuppressionV4options = NonMaxSuppressionV4Options() - nonMaxSuppressionV4options.Init(buf, pos) - return cls.InitFromObj(nonMaxSuppressionV4options) + reducerOptions = ReducerOptions() + reducerOptions.Init(buf, pos) + return cls.InitFromObj(reducerOptions) @classmethod - def InitFromObj(cls, nonMaxSuppressionV4options): - x = NonMaxSuppressionV4OptionsT() - x._UnPack(nonMaxSuppressionV4options) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, reducerOptions): + x = ReducerOptionsT() + x._UnPack(reducerOptions) return x - # NonMaxSuppressionV4OptionsT - def _UnPack(self, nonMaxSuppressionV4options): - if nonMaxSuppressionV4options is None: + # ReducerOptionsT + def _UnPack(self, reducerOptions): + if reducerOptions is None: return + self.keepDims = reducerOptions.KeepDims() - # NonMaxSuppressionV4OptionsT + # ReducerOptionsT def Pack(self, builder): - NonMaxSuppressionV4OptionsStart(builder) - nonMaxSuppressionV4options = NonMaxSuppressionV4OptionsEnd(builder) - return nonMaxSuppressionV4options -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ReducerOptionsStart(builder) + ReducerOptionsAddKeepDims(builder, self.keepDims) + reducerOptions = ReducerOptionsEnd(builder) + return reducerOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class NonMaxSuppressionV5Options(object): +class SqueezeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = NonMaxSuppressionV5Options() + x = SqueezeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsNonMaxSuppressionV5Options(cls, buf, offset=0): + def GetRootAsSqueezeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def NonMaxSuppressionV5OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SqueezeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # NonMaxSuppressionV5Options + # SqueezeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def NonMaxSuppressionV5OptionsStart(builder): builder.StartObject(0) -def Start(builder): - return NonMaxSuppressionV5OptionsStart(builder) -def NonMaxSuppressionV5OptionsEnd(builder): return builder.EndObject() -def End(builder): - return NonMaxSuppressionV5OptionsEnd(builder) + # SqueezeOptions + def SqueezeDims(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 -class NonMaxSuppressionV5OptionsT(object): + # SqueezeOptions + def SqueezeDimsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 - # NonMaxSuppressionV5OptionsT + # SqueezeOptions + def SqueezeDimsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SqueezeOptions + def SqueezeDimsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def SqueezeOptionsStart(builder): + builder.StartObject(1) + +def SqueezeOptionsAddSqueezeDims(builder, squeezeDims): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(squeezeDims), 0) + +def SqueezeOptionsStartSqueezeDimsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def SqueezeOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class SqueezeOptionsT(object): + + # SqueezeOptionsT def __init__(self): - pass + self.squeezeDims = None # type: List[int] @classmethod def InitFromBuf(cls, buf, pos): - nonMaxSuppressionV5options = NonMaxSuppressionV5Options() - nonMaxSuppressionV5options.Init(buf, pos) - return cls.InitFromObj(nonMaxSuppressionV5options) + squeezeOptions = SqueezeOptions() + squeezeOptions.Init(buf, pos) + return cls.InitFromObj(squeezeOptions) @classmethod - def InitFromObj(cls, nonMaxSuppressionV5options): - x = NonMaxSuppressionV5OptionsT() - x._UnPack(nonMaxSuppressionV5options) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, squeezeOptions): + x = SqueezeOptionsT() + x._UnPack(squeezeOptions) return x - # NonMaxSuppressionV5OptionsT - def _UnPack(self, nonMaxSuppressionV5options): - if nonMaxSuppressionV5options is None: + # SqueezeOptionsT + def _UnPack(self, squeezeOptions): + if squeezeOptions is None: return + if not squeezeOptions.SqueezeDimsIsNone(): + if np is None: + self.squeezeDims = [] + for i in range(squeezeOptions.SqueezeDimsLength()): + self.squeezeDims.append(squeezeOptions.SqueezeDims(i)) + else: + self.squeezeDims = squeezeOptions.SqueezeDimsAsNumpy() - # NonMaxSuppressionV5OptionsT + # SqueezeOptionsT def Pack(self, builder): - NonMaxSuppressionV5OptionsStart(builder) - nonMaxSuppressionV5options = NonMaxSuppressionV5OptionsEnd(builder) - return nonMaxSuppressionV5options -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.squeezeDims is not None: + if np is not None and type(self.squeezeDims) is np.ndarray: + squeezeDims = builder.CreateNumpyVector(self.squeezeDims) + else: + SqueezeOptionsStartSqueezeDimsVector(builder, len(self.squeezeDims)) + for i in reversed(range(len(self.squeezeDims))): + builder.PrependInt32(self.squeezeDims[i]) + squeezeDims = builder.EndVector() + SqueezeOptionsStart(builder) + if self.squeezeDims is not None: + SqueezeOptionsAddSqueezeDims(builder, squeezeDims) + squeezeOptions = SqueezeOptionsEnd(builder) + return squeezeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class NotEqualOptions(object): +class SplitOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = NotEqualOptions() + x = SplitOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsNotEqualOptions(cls, buf, offset=0): + def GetRootAsSplitOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def NotEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SplitOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # NotEqualOptions + # SplitOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def NotEqualOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return NotEqualOptionsStart(builder) -def NotEqualOptionsEnd(builder): return builder.EndObject() -def End(builder): - return NotEqualOptionsEnd(builder) + # SplitOptions + def NumSplits(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def SplitOptionsStart(builder): + builder.StartObject(1) -class NotEqualOptionsT(object): +def SplitOptionsAddNumSplits(builder, numSplits): + builder.PrependInt32Slot(0, numSplits, 0) - # NotEqualOptionsT +def SplitOptionsEnd(builder): + return builder.EndObject() + + + +class SplitOptionsT(object): + + # SplitOptionsT def __init__(self): - pass + self.numSplits = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - notEqualOptions = NotEqualOptions() - notEqualOptions.Init(buf, pos) - return cls.InitFromObj(notEqualOptions) + splitOptions = SplitOptions() + splitOptions.Init(buf, pos) + return cls.InitFromObj(splitOptions) @classmethod - def InitFromObj(cls, notEqualOptions): - x = NotEqualOptionsT() - x._UnPack(notEqualOptions) - return x + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # NotEqualOptionsT - def _UnPack(self, notEqualOptions): - if notEqualOptions is None: - return + @classmethod + def InitFromObj(cls, splitOptions): + x = SplitOptionsT() + x._UnPack(splitOptions) + return x - # NotEqualOptionsT - def Pack(self, builder): - NotEqualOptionsStart(builder) - notEqualOptions = NotEqualOptionsEnd(builder) - return notEqualOptions -# automatically generated by the FlatBuffers compiler, do not modify + # SplitOptionsT + def _UnPack(self, splitOptions): + if splitOptions is None: + return + self.numSplits = splitOptions.NumSplits() -# namespace: tflite + # SplitOptionsT + def Pack(self, builder): + SplitOptionsStart(builder) + SplitOptionsAddNumSplits(builder, self.numSplits) + splitOptions = SplitOptionsEnd(builder) + return splitOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class OneHotOptions(object): +class SplitVOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = OneHotOptions() + x = SplitVOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsOneHotOptions(cls, buf, offset=0): + def GetRootAsSplitVOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def OneHotOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SplitVOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # OneHotOptions + # SplitVOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # OneHotOptions - def Axis(self): + # SplitVOptions + def NumSplits(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def OneHotOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return OneHotOptionsStart(builder) -def OneHotOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) -def AddAxis(builder, axis): - return OneHotOptionsAddAxis(builder, axis) -def OneHotOptionsEnd(builder): return builder.EndObject() -def End(builder): - return OneHotOptionsEnd(builder) +def SplitVOptionsStart(builder): + builder.StartObject(1) -class OneHotOptionsT(object): +def SplitVOptionsAddNumSplits(builder, numSplits): + builder.PrependInt32Slot(0, numSplits, 0) - # OneHotOptionsT +def SplitVOptionsEnd(builder): + return builder.EndObject() + + + +class SplitVOptionsT(object): + + # SplitVOptionsT def __init__(self): - self.axis = 0 # type: int + self.numSplits = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - oneHotOptions = OneHotOptions() - oneHotOptions.Init(buf, pos) - return cls.InitFromObj(oneHotOptions) + splitVoptions = SplitVOptions() + splitVoptions.Init(buf, pos) + return cls.InitFromObj(splitVoptions) @classmethod - def InitFromObj(cls, oneHotOptions): - x = OneHotOptionsT() - x._UnPack(oneHotOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, splitVoptions): + x = SplitVOptionsT() + x._UnPack(splitVoptions) return x - # OneHotOptionsT - def _UnPack(self, oneHotOptions): - if oneHotOptions is None: + # SplitVOptionsT + def _UnPack(self, splitVoptions): + if splitVoptions is None: return - self.axis = oneHotOptions.Axis() + self.numSplits = splitVoptions.NumSplits() - # OneHotOptionsT + # SplitVOptionsT def Pack(self, builder): - OneHotOptionsStart(builder) - OneHotOptionsAddAxis(builder, self.axis) - oneHotOptions = OneHotOptionsEnd(builder) - return oneHotOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SplitVOptionsStart(builder) + SplitVOptionsAddNumSplits(builder, self.numSplits) + splitVoptions = SplitVOptionsEnd(builder) + return splitVoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class Operator(object): +class StridedSliceOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Operator() + x = StridedSliceOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsOperator(cls, buf, offset=0): + def GetRootAsStridedSliceOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def OperatorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def StridedSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Operator + # StridedSliceOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # Operator - def OpcodeIndex(self): + # StridedSliceOptions + def BeginMask(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) - return 0 - - # Operator - def Inputs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - - # Operator - def InputsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # Operator - def InputsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # Operator - def InputsIsNone(self): + # StridedSliceOptions + def EndMask(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 - - # Operator - def Outputs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - - # Operator - def OutputsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # Operator - def OutputsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.VectorLen(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # Operator - def OutputsIsNone(self): + # StridedSliceOptions + def EllipsisMask(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 - - # Operator - def BuiltinOptionsType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) - return 0 - - # Operator - def BuiltinOptions(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - from flatbuffers.table import Table - obj = Table(bytearray(), 0) - self._tab.Union(obj, o) - return obj - return None - - # Operator - def CustomOptions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) - return 0 - - # Operator - def CustomOptionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) - return 0 - - # Operator - def CustomOptionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # Operator - def CustomOptionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - return o == 0 - - # Operator - def CustomOptionsFormat(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 - - # Operator - def MutatingVariableInputs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) - return 0 - - # Operator - def MutatingVariableInputsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o) - return 0 - - # Operator - def MutatingVariableInputsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # Operator - def MutatingVariableInputsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - return o == 0 - - # Operator - def Intermediates(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - - # Operator - def IntermediatesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # Operator - def IntermediatesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # Operator - def IntermediatesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) - return o == 0 - - # Operator - def LargeCustomOptionsOffset(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # Operator - def LargeCustomOptionsSize(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + # StridedSliceOptions + def NewAxisMask(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # Operator - def BuiltinOptions2Type(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + # StridedSliceOptions + def ShrinkAxisMask(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # Operator - def BuiltinOptions2(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + # StridedSliceOptions + def Offset(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) if o != 0: - from flatbuffers.table import Table - obj = Table(bytearray(), 0) - self._tab.Union(obj, o) - return obj - return None + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False -def OperatorStart(builder): builder.StartObject(13) -def Start(builder): - return OperatorStart(builder) -def OperatorAddOpcodeIndex(builder, opcodeIndex): builder.PrependUint32Slot(0, opcodeIndex, 0) -def AddOpcodeIndex(builder, opcodeIndex): - return OperatorAddOpcodeIndex(builder, opcodeIndex) -def OperatorAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) -def AddInputs(builder, inputs): - return OperatorAddInputs(builder, inputs) -def OperatorStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartInputsVector(builder, numElems): - return OperatorStartInputsVector(builder, numElems) -def OperatorAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) -def AddOutputs(builder, outputs): - return OperatorAddOutputs(builder, outputs) -def OperatorStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartOutputsVector(builder, numElems): - return OperatorStartOutputsVector(builder, numElems) -def OperatorAddBuiltinOptionsType(builder, builtinOptionsType): builder.PrependUint8Slot(3, builtinOptionsType, 0) -def AddBuiltinOptionsType(builder, builtinOptionsType): - return OperatorAddBuiltinOptionsType(builder, builtinOptionsType) -def OperatorAddBuiltinOptions(builder, builtinOptions): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions), 0) -def AddBuiltinOptions(builder, builtinOptions): - return OperatorAddBuiltinOptions(builder, builtinOptions) -def OperatorAddCustomOptions(builder, customOptions): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customOptions), 0) -def AddCustomOptions(builder, customOptions): - return OperatorAddCustomOptions(builder, customOptions) -def OperatorStartCustomOptionsVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def StartCustomOptionsVector(builder, numElems): - return OperatorStartCustomOptionsVector(builder, numElems) -def OperatorAddCustomOptionsFormat(builder, customOptionsFormat): builder.PrependInt8Slot(6, customOptionsFormat, 0) -def AddCustomOptionsFormat(builder, customOptionsFormat): - return OperatorAddCustomOptionsFormat(builder, customOptionsFormat) -def OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(mutatingVariableInputs), 0) -def AddMutatingVariableInputs(builder, mutatingVariableInputs): - return OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs) -def OperatorStartMutatingVariableInputsVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def StartMutatingVariableInputsVector(builder, numElems): - return OperatorStartMutatingVariableInputsVector(builder, numElems) -def OperatorAddIntermediates(builder, intermediates): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(intermediates), 0) -def AddIntermediates(builder, intermediates): - return OperatorAddIntermediates(builder, intermediates) -def OperatorStartIntermediatesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartIntermediatesVector(builder, numElems): - return OperatorStartIntermediatesVector(builder, numElems) -def OperatorAddLargeCustomOptionsOffset(builder, largeCustomOptionsOffset): builder.PrependUint64Slot(9, largeCustomOptionsOffset, 0) -def AddLargeCustomOptionsOffset(builder, largeCustomOptionsOffset): - return OperatorAddLargeCustomOptionsOffset(builder, largeCustomOptionsOffset) -def OperatorAddLargeCustomOptionsSize(builder, largeCustomOptionsSize): builder.PrependUint64Slot(10, largeCustomOptionsSize, 0) -def AddLargeCustomOptionsSize(builder, largeCustomOptionsSize): - return OperatorAddLargeCustomOptionsSize(builder, largeCustomOptionsSize) -def OperatorAddBuiltinOptions2Type(builder, builtinOptions2Type): builder.PrependUint8Slot(11, builtinOptions2Type, 0) -def AddBuiltinOptions2Type(builder, builtinOptions2Type): - return OperatorAddBuiltinOptions2Type(builder, builtinOptions2Type) -def OperatorAddBuiltinOptions2(builder, builtinOptions2): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions2), 0) -def AddBuiltinOptions2(builder, builtinOptions2): - return OperatorAddBuiltinOptions2(builder, builtinOptions2) -def OperatorEnd(builder): return builder.EndObject() -def End(builder): - return OperatorEnd(builder) -try: - from typing import List, Union -except: - pass +def StridedSliceOptionsStart(builder): + builder.StartObject(6) -class OperatorT(object): +def StridedSliceOptionsAddBeginMask(builder, beginMask): + builder.PrependInt32Slot(0, beginMask, 0) - # OperatorT +def StridedSliceOptionsAddEndMask(builder, endMask): + builder.PrependInt32Slot(1, endMask, 0) + +def StridedSliceOptionsAddEllipsisMask(builder, ellipsisMask): + builder.PrependInt32Slot(2, ellipsisMask, 0) + +def StridedSliceOptionsAddNewAxisMask(builder, newAxisMask): + builder.PrependInt32Slot(3, newAxisMask, 0) + +def StridedSliceOptionsAddShrinkAxisMask(builder, shrinkAxisMask): + builder.PrependInt32Slot(4, shrinkAxisMask, 0) + +def StridedSliceOptionsAddOffset(builder, offset): + builder.PrependBoolSlot(5, offset, 0) + +def StridedSliceOptionsEnd(builder): + return builder.EndObject() + + + +class StridedSliceOptionsT(object): + + # StridedSliceOptionsT def __init__(self): - self.opcodeIndex = 0 # type: int - self.inputs = None # type: List[int] - self.outputs = None # type: List[int] - self.builtinOptionsType = 0 # type: int - self.builtinOptions = None # type: Union[None, Conv2DOptionsT, DepthwiseConv2DOptionsT, ConcatEmbeddingsOptionsT, LSHProjectionOptionsT, Pool2DOptionsT, SVDFOptionsT, RNNOptionsT, FullyConnectedOptionsT, SoftmaxOptionsT, ConcatenationOptionsT, AddOptionsT, L2NormOptionsT, LocalResponseNormalizationOptionsT, LSTMOptionsT, ResizeBilinearOptionsT, CallOptionsT, ReshapeOptionsT, SkipGramOptionsT, SpaceToDepthOptionsT, EmbeddingLookupSparseOptionsT, MulOptionsT, PadOptionsT, GatherOptionsT, BatchToSpaceNDOptionsT, SpaceToBatchNDOptionsT, TransposeOptionsT, ReducerOptionsT, SubOptionsT, DivOptionsT, SqueezeOptionsT, SequenceRNNOptionsT, StridedSliceOptionsT, ExpOptionsT, TopKV2OptionsT, SplitOptionsT, LogSoftmaxOptionsT, CastOptionsT, DequantizeOptionsT, MaximumMinimumOptionsT, ArgMaxOptionsT, LessOptionsT, NegOptionsT, PadV2OptionsT, GreaterOptionsT, GreaterEqualOptionsT, LessEqualOptionsT, SelectOptionsT, SliceOptionsT, TransposeConvOptionsT, SparseToDenseOptionsT, TileOptionsT, ExpandDimsOptionsT, EqualOptionsT, NotEqualOptionsT, ShapeOptionsT, PowOptionsT, ArgMinOptionsT, FakeQuantOptionsT, PackOptionsT, LogicalOrOptionsT, OneHotOptionsT, LogicalAndOptionsT, LogicalNotOptionsT, UnpackOptionsT, FloorDivOptionsT, SquareOptionsT, ZerosLikeOptionsT, FillOptionsT, BidirectionalSequenceLSTMOptionsT, BidirectionalSequenceRNNOptionsT, UnidirectionalSequenceLSTMOptionsT, FloorModOptionsT, RangeOptionsT, ResizeNearestNeighborOptionsT, LeakyReluOptionsT, SquaredDifferenceOptionsT, MirrorPadOptionsT, AbsOptionsT, SplitVOptionsT, UniqueOptionsT, ReverseV2OptionsT, AddNOptionsT, GatherNdOptionsT, CosOptionsT, WhereOptionsT, RankOptionsT, ReverseSequenceOptionsT, MatrixDiagOptionsT, QuantizeOptionsT, MatrixSetDiagOptionsT, HardSwishOptionsT, IfOptionsT, WhileOptionsT, DepthToSpaceOptionsT, NonMaxSuppressionV4OptionsT, NonMaxSuppressionV5OptionsT, ScatterNdOptionsT, SelectV2OptionsT, DensifyOptionsT, SegmentSumOptionsT, BatchMatMulOptionsT, CumsumOptionsT, CallOnceOptionsT, BroadcastToOptionsT, Rfft2dOptionsT, Conv3DOptionsT, HashtableOptionsT, HashtableFindOptionsT, HashtableImportOptionsT, HashtableSizeOptionsT, VarHandleOptionsT, ReadVariableOptionsT, AssignVariableOptionsT, RandomOptionsT, BucketizeOptionsT, GeluOptionsT, DynamicUpdateSliceOptionsT, UnsortedSegmentProdOptionsT, UnsortedSegmentMaxOptionsT, UnsortedSegmentMinOptionsT, UnsortedSegmentSumOptionsT, ATan2OptionsT, SignOptionsT, BitcastOptionsT, BitwiseXorOptionsT, RightShiftOptionsT] - self.customOptions = None # type: List[int] - self.customOptionsFormat = 0 # type: int - self.mutatingVariableInputs = None # type: List[bool] - self.intermediates = None # type: List[int] - self.largeCustomOptionsOffset = 0 # type: int - self.largeCustomOptionsSize = 0 # type: int - self.builtinOptions2Type = 0 # type: int - self.builtinOptions2 = None # type: Union[None, StablehloConcatenateOptionsT, StablehloBroadcastInDimOptionsT, StablehloSliceOptionsT, StablehloConvolutionOptionsT, StablehloCustomCallOptionsT, StablehloReduceOptionsT, StablehloScatterOptionsT, StablehloCompareOptionsT, StablehloDynamicSliceOptionsT, StablehloPadOptionsT, StablehloIotaOptionsT, StablehloDotGeneralOptionsT, StablehloReduceWindowOptionsT, StablehloSortOptionsT, StablehloWhileOptionsT, StablehloGatherOptionsT, StablehloTransposeOptionsT, DilateOptionsT, StablehloRngBitGeneratorOptionsT, ReduceWindowOptionsT] + self.beginMask = 0 # type: int + self.endMask = 0 # type: int + self.ellipsisMask = 0 # type: int + self.newAxisMask = 0 # type: int + self.shrinkAxisMask = 0 # type: int + self.offset = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - operator = Operator() - operator.Init(buf, pos) - return cls.InitFromObj(operator) + stridedSliceOptions = StridedSliceOptions() + stridedSliceOptions.Init(buf, pos) + return cls.InitFromObj(stridedSliceOptions) @classmethod - def InitFromObj(cls, operator): - x = OperatorT() - x._UnPack(operator) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, stridedSliceOptions): + x = StridedSliceOptionsT() + x._UnPack(stridedSliceOptions) return x - # OperatorT - def _UnPack(self, operator): - if operator is None: + # StridedSliceOptionsT + def _UnPack(self, stridedSliceOptions): + if stridedSliceOptions is None: return - self.opcodeIndex = operator.OpcodeIndex() - if not operator.InputsIsNone(): - if np is None: - self.inputs = [] - for i in range(operator.InputsLength()): - self.inputs.append(operator.Inputs(i)) - else: - self.inputs = operator.InputsAsNumpy() - if not operator.OutputsIsNone(): - if np is None: - self.outputs = [] - for i in range(operator.OutputsLength()): - self.outputs.append(operator.Outputs(i)) - else: - self.outputs = operator.OutputsAsNumpy() - self.builtinOptionsType = operator.BuiltinOptionsType() - self.builtinOptions = BuiltinOptionsCreator(self.builtinOptionsType, operator.BuiltinOptions()) - if not operator.CustomOptionsIsNone(): - if np is None: - self.customOptions = [] - for i in range(operator.CustomOptionsLength()): - self.customOptions.append(operator.CustomOptions(i)) - else: - self.customOptions = operator.CustomOptionsAsNumpy() - self.customOptionsFormat = operator.CustomOptionsFormat() - if not operator.MutatingVariableInputsIsNone(): - if np is None: - self.mutatingVariableInputs = [] - for i in range(operator.MutatingVariableInputsLength()): - self.mutatingVariableInputs.append(operator.MutatingVariableInputs(i)) - else: - self.mutatingVariableInputs = operator.MutatingVariableInputsAsNumpy() - if not operator.IntermediatesIsNone(): - if np is None: - self.intermediates = [] - for i in range(operator.IntermediatesLength()): - self.intermediates.append(operator.Intermediates(i)) - else: - self.intermediates = operator.IntermediatesAsNumpy() - self.largeCustomOptionsOffset = operator.LargeCustomOptionsOffset() - self.largeCustomOptionsSize = operator.LargeCustomOptionsSize() - self.builtinOptions2Type = operator.BuiltinOptions2Type() - self.builtinOptions2 = BuiltinOptions2Creator(self.builtinOptions2Type, operator.BuiltinOptions2()) + self.beginMask = stridedSliceOptions.BeginMask() + self.endMask = stridedSliceOptions.EndMask() + self.ellipsisMask = stridedSliceOptions.EllipsisMask() + self.newAxisMask = stridedSliceOptions.NewAxisMask() + self.shrinkAxisMask = stridedSliceOptions.ShrinkAxisMask() + self.offset = stridedSliceOptions.Offset() - # OperatorT + # StridedSliceOptionsT def Pack(self, builder): - if self.inputs is not None: - if np is not None and type(self.inputs) is np.ndarray: - inputs = builder.CreateNumpyVector(self.inputs) - else: - OperatorStartInputsVector(builder, len(self.inputs)) - for i in reversed(range(len(self.inputs))): - builder.PrependInt32(self.inputs[i]) - inputs = builder.EndVector() - if self.outputs is not None: - if np is not None and type(self.outputs) is np.ndarray: - outputs = builder.CreateNumpyVector(self.outputs) - else: - OperatorStartOutputsVector(builder, len(self.outputs)) - for i in reversed(range(len(self.outputs))): - builder.PrependInt32(self.outputs[i]) - outputs = builder.EndVector() - if self.builtinOptions is not None: - builtinOptions = self.builtinOptions.Pack(builder) - if self.customOptions is not None: - if np is not None and type(self.customOptions) is np.ndarray: - customOptions = builder.CreateNumpyVector(self.customOptions) - else: - OperatorStartCustomOptionsVector(builder, len(self.customOptions)) - for i in reversed(range(len(self.customOptions))): - builder.PrependUint8(self.customOptions[i]) - customOptions = builder.EndVector() - if self.mutatingVariableInputs is not None: - if np is not None and type(self.mutatingVariableInputs) is np.ndarray: - mutatingVariableInputs = builder.CreateNumpyVector(self.mutatingVariableInputs) - else: - OperatorStartMutatingVariableInputsVector(builder, len(self.mutatingVariableInputs)) - for i in reversed(range(len(self.mutatingVariableInputs))): - builder.PrependBool(self.mutatingVariableInputs[i]) - mutatingVariableInputs = builder.EndVector() - if self.intermediates is not None: - if np is not None and type(self.intermediates) is np.ndarray: - intermediates = builder.CreateNumpyVector(self.intermediates) - else: - OperatorStartIntermediatesVector(builder, len(self.intermediates)) - for i in reversed(range(len(self.intermediates))): - builder.PrependInt32(self.intermediates[i]) - intermediates = builder.EndVector() - if self.builtinOptions2 is not None: - builtinOptions2 = self.builtinOptions2.Pack(builder) - OperatorStart(builder) - OperatorAddOpcodeIndex(builder, self.opcodeIndex) - if self.inputs is not None: - OperatorAddInputs(builder, inputs) - if self.outputs is not None: - OperatorAddOutputs(builder, outputs) - OperatorAddBuiltinOptionsType(builder, self.builtinOptionsType) - if self.builtinOptions is not None: - OperatorAddBuiltinOptions(builder, builtinOptions) - if self.customOptions is not None: - OperatorAddCustomOptions(builder, customOptions) - OperatorAddCustomOptionsFormat(builder, self.customOptionsFormat) - if self.mutatingVariableInputs is not None: - OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs) - if self.intermediates is not None: - OperatorAddIntermediates(builder, intermediates) - OperatorAddLargeCustomOptionsOffset(builder, self.largeCustomOptionsOffset) - OperatorAddLargeCustomOptionsSize(builder, self.largeCustomOptionsSize) - OperatorAddBuiltinOptions2Type(builder, self.builtinOptions2Type) - if self.builtinOptions2 is not None: - OperatorAddBuiltinOptions2(builder, builtinOptions2) - operator = OperatorEnd(builder) - return operator -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + StridedSliceOptionsStart(builder) + StridedSliceOptionsAddBeginMask(builder, self.beginMask) + StridedSliceOptionsAddEndMask(builder, self.endMask) + StridedSliceOptionsAddEllipsisMask(builder, self.ellipsisMask) + StridedSliceOptionsAddNewAxisMask(builder, self.newAxisMask) + StridedSliceOptionsAddShrinkAxisMask(builder, self.shrinkAxisMask) + StridedSliceOptionsAddOffset(builder, self.offset) + stridedSliceOptions = StridedSliceOptionsEnd(builder) + return stridedSliceOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class OperatorCode(object): +class LogSoftmaxOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = OperatorCode() + x = LogSoftmaxOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsOperatorCode(cls, buf, offset=0): + def GetRootAsLogSoftmaxOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def OperatorCodeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LogSoftmaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # OperatorCode + # LogSoftmaxOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # OperatorCode - def DeprecatedBuiltinCode(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 - - # OperatorCode - def CustomCode(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None +def LogSoftmaxOptionsStart(builder): + builder.StartObject(0) - # OperatorCode - def Version(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 1 +def LogSoftmaxOptionsEnd(builder): + return builder.EndObject() - # OperatorCode - def BuiltinCode(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 -def OperatorCodeStart(builder): builder.StartObject(4) -def Start(builder): - return OperatorCodeStart(builder) -def OperatorCodeAddDeprecatedBuiltinCode(builder, deprecatedBuiltinCode): builder.PrependInt8Slot(0, deprecatedBuiltinCode, 0) -def AddDeprecatedBuiltinCode(builder, deprecatedBuiltinCode): - return OperatorCodeAddDeprecatedBuiltinCode(builder, deprecatedBuiltinCode) -def OperatorCodeAddCustomCode(builder, customCode): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(customCode), 0) -def AddCustomCode(builder, customCode): - return OperatorCodeAddCustomCode(builder, customCode) -def OperatorCodeAddVersion(builder, version): builder.PrependInt32Slot(2, version, 1) -def AddVersion(builder, version): - return OperatorCodeAddVersion(builder, version) -def OperatorCodeAddBuiltinCode(builder, builtinCode): builder.PrependInt32Slot(3, builtinCode, 0) -def AddBuiltinCode(builder, builtinCode): - return OperatorCodeAddBuiltinCode(builder, builtinCode) -def OperatorCodeEnd(builder): return builder.EndObject() -def End(builder): - return OperatorCodeEnd(builder) -class OperatorCodeT(object): +class LogSoftmaxOptionsT(object): - # OperatorCodeT + # LogSoftmaxOptionsT def __init__(self): - self.deprecatedBuiltinCode = 0 # type: int - self.customCode = None # type: str - self.version = 1 # type: int - self.builtinCode = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - operatorCode = OperatorCode() - operatorCode.Init(buf, pos) - return cls.InitFromObj(operatorCode) + logSoftmaxOptions = LogSoftmaxOptions() + logSoftmaxOptions.Init(buf, pos) + return cls.InitFromObj(logSoftmaxOptions) @classmethod - def InitFromObj(cls, operatorCode): - x = OperatorCodeT() - x._UnPack(operatorCode) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, logSoftmaxOptions): + x = LogSoftmaxOptionsT() + x._UnPack(logSoftmaxOptions) return x - # OperatorCodeT - def _UnPack(self, operatorCode): - if operatorCode is None: + # LogSoftmaxOptionsT + def _UnPack(self, logSoftmaxOptions): + if logSoftmaxOptions is None: return - self.deprecatedBuiltinCode = operatorCode.DeprecatedBuiltinCode() - self.customCode = operatorCode.CustomCode() - self.version = operatorCode.Version() - self.builtinCode = operatorCode.BuiltinCode() - # OperatorCodeT + # LogSoftmaxOptionsT def Pack(self, builder): - if self.customCode is not None: - customCode = builder.CreateString(self.customCode) - OperatorCodeStart(builder) - OperatorCodeAddDeprecatedBuiltinCode(builder, self.deprecatedBuiltinCode) - if self.customCode is not None: - OperatorCodeAddCustomCode(builder, customCode) - OperatorCodeAddVersion(builder, self.version) - OperatorCodeAddBuiltinCode(builder, self.builtinCode) - operatorCode = OperatorCodeEnd(builder) - return operatorCode -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LogSoftmaxOptionsStart(builder) + logSoftmaxOptions = LogSoftmaxOptionsEnd(builder) + return logSoftmaxOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class PackOptions(object): +class CastOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = PackOptions() + x = CastOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsPackOptions(cls, buf, offset=0): + def GetRootAsCastOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def PackOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def CastOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # PackOptions + # CastOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # PackOptions - def ValuesCount(self): + # CastOptions + def InDataType(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # PackOptions - def Axis(self): + # CastOptions + def OutDataType(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 -def PackOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return PackOptionsStart(builder) -def PackOptionsAddValuesCount(builder, valuesCount): builder.PrependInt32Slot(0, valuesCount, 0) -def AddValuesCount(builder, valuesCount): - return PackOptionsAddValuesCount(builder, valuesCount) -def PackOptionsAddAxis(builder, axis): builder.PrependInt32Slot(1, axis, 0) -def AddAxis(builder, axis): - return PackOptionsAddAxis(builder, axis) -def PackOptionsEnd(builder): return builder.EndObject() -def End(builder): - return PackOptionsEnd(builder) +def CastOptionsStart(builder): + builder.StartObject(2) -class PackOptionsT(object): +def CastOptionsAddInDataType(builder, inDataType): + builder.PrependInt8Slot(0, inDataType, 0) - # PackOptionsT +def CastOptionsAddOutDataType(builder, outDataType): + builder.PrependInt8Slot(1, outDataType, 0) + +def CastOptionsEnd(builder): + return builder.EndObject() + + + +class CastOptionsT(object): + + # CastOptionsT def __init__(self): - self.valuesCount = 0 # type: int - self.axis = 0 # type: int + self.inDataType = 0 # type: int + self.outDataType = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - packOptions = PackOptions() - packOptions.Init(buf, pos) - return cls.InitFromObj(packOptions) + castOptions = CastOptions() + castOptions.Init(buf, pos) + return cls.InitFromObj(castOptions) @classmethod - def InitFromObj(cls, packOptions): - x = PackOptionsT() - x._UnPack(packOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, castOptions): + x = CastOptionsT() + x._UnPack(castOptions) return x - # PackOptionsT - def _UnPack(self, packOptions): - if packOptions is None: + # CastOptionsT + def _UnPack(self, castOptions): + if castOptions is None: return - self.valuesCount = packOptions.ValuesCount() - self.axis = packOptions.Axis() + self.inDataType = castOptions.InDataType() + self.outDataType = castOptions.OutDataType() - # PackOptionsT + # CastOptionsT def Pack(self, builder): - PackOptionsStart(builder) - PackOptionsAddValuesCount(builder, self.valuesCount) - PackOptionsAddAxis(builder, self.axis) - packOptions = PackOptionsEnd(builder) - return packOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + CastOptionsStart(builder) + CastOptionsAddInDataType(builder, self.inDataType) + CastOptionsAddOutDataType(builder, self.outDataType) + castOptions = CastOptionsEnd(builder) + return castOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class PadOptions(object): +class DequantizeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = PadOptions() + x = DequantizeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsPadOptions(cls, buf, offset=0): + def GetRootAsDequantizeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def PadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def DequantizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # PadOptions + # DequantizeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def PadOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return PadOptionsStart(builder) -def PadOptionsEnd(builder): return builder.EndObject() -def End(builder): - return PadOptionsEnd(builder) +def DequantizeOptionsStart(builder): + builder.StartObject(0) -class PadOptionsT(object): +def DequantizeOptionsEnd(builder): + return builder.EndObject() - # PadOptionsT + + +class DequantizeOptionsT(object): + + # DequantizeOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - padOptions = PadOptions() - padOptions.Init(buf, pos) - return cls.InitFromObj(padOptions) + dequantizeOptions = DequantizeOptions() + dequantizeOptions.Init(buf, pos) + return cls.InitFromObj(dequantizeOptions) @classmethod - def InitFromObj(cls, padOptions): - x = PadOptionsT() - x._UnPack(padOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, dequantizeOptions): + x = DequantizeOptionsT() + x._UnPack(dequantizeOptions) return x - # PadOptionsT - def _UnPack(self, padOptions): - if padOptions is None: + # DequantizeOptionsT + def _UnPack(self, dequantizeOptions): + if dequantizeOptions is None: return - # PadOptionsT + # DequantizeOptionsT def Pack(self, builder): - PadOptionsStart(builder) - padOptions = PadOptionsEnd(builder) - return padOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + DequantizeOptionsStart(builder) + dequantizeOptions = DequantizeOptionsEnd(builder) + return dequantizeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class PadV2Options(object): +class MaximumMinimumOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = PadV2Options() + x = MaximumMinimumOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsPadV2Options(cls, buf, offset=0): + def GetRootAsMaximumMinimumOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def PadV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def MaximumMinimumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # PadV2Options + # MaximumMinimumOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def PadV2OptionsStart(builder): builder.StartObject(0) -def Start(builder): - return PadV2OptionsStart(builder) -def PadV2OptionsEnd(builder): return builder.EndObject() -def End(builder): - return PadV2OptionsEnd(builder) +def MaximumMinimumOptionsStart(builder): + builder.StartObject(0) -class PadV2OptionsT(object): +def MaximumMinimumOptionsEnd(builder): + return builder.EndObject() - # PadV2OptionsT + + +class MaximumMinimumOptionsT(object): + + # MaximumMinimumOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - padV2options = PadV2Options() - padV2options.Init(buf, pos) - return cls.InitFromObj(padV2options) + maximumMinimumOptions = MaximumMinimumOptions() + maximumMinimumOptions.Init(buf, pos) + return cls.InitFromObj(maximumMinimumOptions) @classmethod - def InitFromObj(cls, padV2options): - x = PadV2OptionsT() - x._UnPack(padV2options) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, maximumMinimumOptions): + x = MaximumMinimumOptionsT() + x._UnPack(maximumMinimumOptions) return x - # PadV2OptionsT - def _UnPack(self, padV2options): - if padV2options is None: + # MaximumMinimumOptionsT + def _UnPack(self, maximumMinimumOptions): + if maximumMinimumOptions is None: return - # PadV2OptionsT + # MaximumMinimumOptionsT def Pack(self, builder): - PadV2OptionsStart(builder) - padV2options = PadV2OptionsEnd(builder) - return padV2options -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class Padding(object): - SAME = 0 - VALID = 1 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + MaximumMinimumOptionsStart(builder) + maximumMinimumOptions = MaximumMinimumOptionsEnd(builder) + return maximumMinimumOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class Pool2DOptions(object): +class TileOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Pool2DOptions() + x = TileOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsPool2DOptions(cls, buf, offset=0): + def GetRootAsTileOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def Pool2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def TileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Pool2DOptions + # TileOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # Pool2DOptions - def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 - - # Pool2DOptions - def StrideW(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 - - # Pool2DOptions - def StrideH(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 - - # Pool2DOptions - def FilterWidth(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def TileOptionsStart(builder): + builder.StartObject(0) - # Pool2DOptions - def FilterHeight(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def TileOptionsEnd(builder): + return builder.EndObject() - # Pool2DOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 -def Pool2DOptionsStart(builder): builder.StartObject(6) -def Start(builder): - return Pool2DOptionsStart(builder) -def Pool2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) -def AddPadding(builder, padding): - return Pool2DOptionsAddPadding(builder, padding) -def Pool2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0) -def AddStrideW(builder, strideW): - return Pool2DOptionsAddStrideW(builder, strideW) -def Pool2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0) -def AddStrideH(builder, strideH): - return Pool2DOptionsAddStrideH(builder, strideH) -def Pool2DOptionsAddFilterWidth(builder, filterWidth): builder.PrependInt32Slot(3, filterWidth, 0) -def AddFilterWidth(builder, filterWidth): - return Pool2DOptionsAddFilterWidth(builder, filterWidth) -def Pool2DOptionsAddFilterHeight(builder, filterHeight): builder.PrependInt32Slot(4, filterHeight, 0) -def AddFilterHeight(builder, filterHeight): - return Pool2DOptionsAddFilterHeight(builder, filterHeight) -def Pool2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(5, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return Pool2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def Pool2DOptionsEnd(builder): return builder.EndObject() -def End(builder): - return Pool2DOptionsEnd(builder) -class Pool2DOptionsT(object): +class TileOptionsT(object): - # Pool2DOptionsT + # TileOptionsT def __init__(self): - self.padding = 0 # type: int - self.strideW = 0 # type: int - self.strideH = 0 # type: int - self.filterWidth = 0 # type: int - self.filterHeight = 0 # type: int - self.fusedActivationFunction = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - pool2doptions = Pool2DOptions() - pool2doptions.Init(buf, pos) - return cls.InitFromObj(pool2doptions) + tileOptions = TileOptions() + tileOptions.Init(buf, pos) + return cls.InitFromObj(tileOptions) @classmethod - def InitFromObj(cls, pool2doptions): - x = Pool2DOptionsT() - x._UnPack(pool2doptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, tileOptions): + x = TileOptionsT() + x._UnPack(tileOptions) return x - # Pool2DOptionsT - def _UnPack(self, pool2doptions): - if pool2doptions is None: + # TileOptionsT + def _UnPack(self, tileOptions): + if tileOptions is None: return - self.padding = pool2doptions.Padding() - self.strideW = pool2doptions.StrideW() - self.strideH = pool2doptions.StrideH() - self.filterWidth = pool2doptions.FilterWidth() - self.filterHeight = pool2doptions.FilterHeight() - self.fusedActivationFunction = pool2doptions.FusedActivationFunction() - # Pool2DOptionsT + # TileOptionsT def Pack(self, builder): - Pool2DOptionsStart(builder) - Pool2DOptionsAddPadding(builder, self.padding) - Pool2DOptionsAddStrideW(builder, self.strideW) - Pool2DOptionsAddStrideH(builder, self.strideH) - Pool2DOptionsAddFilterWidth(builder, self.filterWidth) - Pool2DOptionsAddFilterHeight(builder, self.filterHeight) - Pool2DOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - pool2doptions = Pool2DOptionsEnd(builder) - return pool2doptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + TileOptionsStart(builder) + tileOptions = TileOptionsEnd(builder) + return tileOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class PowOptions(object): +class ArgMaxOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = PowOptions() + x = ArgMaxOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsPowOptions(cls, buf, offset=0): + def GetRootAsArgMaxOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def PowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ArgMaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # PowOptions + # ArgMaxOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def PowOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return PowOptionsStart(builder) -def PowOptionsEnd(builder): return builder.EndObject() -def End(builder): - return PowOptionsEnd(builder) + # ArgMaxOptions + def OutputType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def ArgMaxOptionsStart(builder): + builder.StartObject(1) -class PowOptionsT(object): +def ArgMaxOptionsAddOutputType(builder, outputType): + builder.PrependInt8Slot(0, outputType, 0) - # PowOptionsT +def ArgMaxOptionsEnd(builder): + return builder.EndObject() + + + +class ArgMaxOptionsT(object): + + # ArgMaxOptionsT def __init__(self): - pass + self.outputType = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - powOptions = PowOptions() - powOptions.Init(buf, pos) - return cls.InitFromObj(powOptions) + argMaxOptions = ArgMaxOptions() + argMaxOptions.Init(buf, pos) + return cls.InitFromObj(argMaxOptions) @classmethod - def InitFromObj(cls, powOptions): - x = PowOptionsT() - x._UnPack(powOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, argMaxOptions): + x = ArgMaxOptionsT() + x._UnPack(argMaxOptions) return x - # PowOptionsT - def _UnPack(self, powOptions): - if powOptions is None: + # ArgMaxOptionsT + def _UnPack(self, argMaxOptions): + if argMaxOptions is None: return + self.outputType = argMaxOptions.OutputType() - # PowOptionsT + # ArgMaxOptionsT def Pack(self, builder): - PowOptionsStart(builder) - powOptions = PowOptionsEnd(builder) - return powOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class QuantizationDetails(object): - NONE = 0 - CustomQuantization = 1 - -def QuantizationDetailsCreator(unionType, table): - from flatbuffers.table import Table - if not isinstance(table, Table): - return None - if unionType == QuantizationDetails().CustomQuantization: - return CustomQuantizationT.InitFromBuf(table.Bytes, table.Pos) - return None -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ArgMaxOptionsStart(builder) + ArgMaxOptionsAddOutputType(builder, self.outputType) + argMaxOptions = ArgMaxOptionsEnd(builder) + return argMaxOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class QuantizationParameters(object): +class ArgMinOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = QuantizationParameters() + x = ArgMinOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsQuantizationParameters(cls, buf, offset=0): + def GetRootAsArgMinOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def QuantizationParametersBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ArgMinOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # QuantizationParameters + # ArgMinOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # QuantizationParameters - def Min(self, j): + # ArgMinOptions + def OutputType(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # QuantizationParameters - def MinAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) - return 0 +def ArgMinOptionsStart(builder): + builder.StartObject(1) - # QuantizationParameters - def MinLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def ArgMinOptionsAddOutputType(builder, outputType): + builder.PrependInt8Slot(0, outputType, 0) - # QuantizationParameters - def MinIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 +def ArgMinOptionsEnd(builder): + return builder.EndObject() - # QuantizationParameters - def Max(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - # QuantizationParameters - def MaxAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) - return 0 - # QuantizationParameters - def MaxLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class ArgMinOptionsT(object): - # QuantizationParameters - def MaxIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 + # ArgMinOptionsT + def __init__(self): + self.outputType = 0 # type: int - # QuantizationParameters - def Scale(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 + @classmethod + def InitFromBuf(cls, buf, pos): + argMinOptions = ArgMinOptions() + argMinOptions.Init(buf, pos) + return cls.InitFromObj(argMinOptions) - # QuantizationParameters - def ScaleAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) - return 0 + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # QuantizationParameters - def ScaleLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + @classmethod + def InitFromObj(cls, argMinOptions): + x = ArgMinOptionsT() + x._UnPack(argMinOptions) + return x - # QuantizationParameters - def ScaleIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 + # ArgMinOptionsT + def _UnPack(self, argMinOptions): + if argMinOptions is None: + return + self.outputType = argMinOptions.OutputType() - # QuantizationParameters - def ZeroPoint(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 + # ArgMinOptionsT + def Pack(self, builder): + ArgMinOptionsStart(builder) + ArgMinOptionsAddOutputType(builder, self.outputType) + argMinOptions = ArgMinOptionsEnd(builder) + return argMinOptions - # QuantizationParameters - def ZeroPointAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - # QuantizationParameters - def ZeroPointLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class GreaterOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = GreaterOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsGreaterOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def GreaterOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # QuantizationParameters - def ZeroPointIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - return o == 0 + # GreaterOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) - # QuantizationParameters - def DetailsType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) - return 0 +def GreaterOptionsStart(builder): + builder.StartObject(0) - # QuantizationParameters - def Details(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - from flatbuffers.table import Table - obj = Table(bytearray(), 0) - self._tab.Union(obj, o) - return obj - return None +def GreaterOptionsEnd(builder): + return builder.EndObject() - # QuantizationParameters - def QuantizedDimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 -def QuantizationParametersStart(builder): builder.StartObject(7) -def Start(builder): - return QuantizationParametersStart(builder) -def QuantizationParametersAddMin(builder, min): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(min), 0) -def AddMin(builder, min): - return QuantizationParametersAddMin(builder, min) -def QuantizationParametersStartMinVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartMinVector(builder, numElems): - return QuantizationParametersStartMinVector(builder, numElems) -def QuantizationParametersAddMax(builder, max): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(max), 0) -def AddMax(builder, max): - return QuantizationParametersAddMax(builder, max) -def QuantizationParametersStartMaxVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartMaxVector(builder, numElems): - return QuantizationParametersStartMaxVector(builder, numElems) -def QuantizationParametersAddScale(builder, scale): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(scale), 0) -def AddScale(builder, scale): - return QuantizationParametersAddScale(builder, scale) -def QuantizationParametersStartScaleVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartScaleVector(builder, numElems): - return QuantizationParametersStartScaleVector(builder, numElems) -def QuantizationParametersAddZeroPoint(builder, zeroPoint): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(zeroPoint), 0) -def AddZeroPoint(builder, zeroPoint): - return QuantizationParametersAddZeroPoint(builder, zeroPoint) -def QuantizationParametersStartZeroPointVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartZeroPointVector(builder, numElems): - return QuantizationParametersStartZeroPointVector(builder, numElems) -def QuantizationParametersAddDetailsType(builder, detailsType): builder.PrependUint8Slot(4, detailsType, 0) -def AddDetailsType(builder, detailsType): - return QuantizationParametersAddDetailsType(builder, detailsType) -def QuantizationParametersAddDetails(builder, details): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(details), 0) -def AddDetails(builder, details): - return QuantizationParametersAddDetails(builder, details) -def QuantizationParametersAddQuantizedDimension(builder, quantizedDimension): builder.PrependInt32Slot(6, quantizedDimension, 0) -def AddQuantizedDimension(builder, quantizedDimension): - return QuantizationParametersAddQuantizedDimension(builder, quantizedDimension) -def QuantizationParametersEnd(builder): return builder.EndObject() -def End(builder): - return QuantizationParametersEnd(builder) -try: - from typing import List, Union -except: - pass -class QuantizationParametersT(object): +class GreaterOptionsT(object): - # QuantizationParametersT + # GreaterOptionsT def __init__(self): - self.min = None # type: List[float] - self.max = None # type: List[float] - self.scale = None # type: List[float] - self.zeroPoint = None # type: List[int] - self.detailsType = 0 # type: int - self.details = None # type: Union[None, CustomQuantizationT] - self.quantizedDimension = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - quantizationParameters = QuantizationParameters() - quantizationParameters.Init(buf, pos) - return cls.InitFromObj(quantizationParameters) + greaterOptions = GreaterOptions() + greaterOptions.Init(buf, pos) + return cls.InitFromObj(greaterOptions) @classmethod - def InitFromObj(cls, quantizationParameters): - x = QuantizationParametersT() - x._UnPack(quantizationParameters) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, greaterOptions): + x = GreaterOptionsT() + x._UnPack(greaterOptions) return x - # QuantizationParametersT - def _UnPack(self, quantizationParameters): - if quantizationParameters is None: + # GreaterOptionsT + def _UnPack(self, greaterOptions): + if greaterOptions is None: return - if not quantizationParameters.MinIsNone(): - if np is None: - self.min = [] - for i in range(quantizationParameters.MinLength()): - self.min.append(quantizationParameters.Min(i)) - else: - self.min = quantizationParameters.MinAsNumpy() - if not quantizationParameters.MaxIsNone(): - if np is None: - self.max = [] - for i in range(quantizationParameters.MaxLength()): - self.max.append(quantizationParameters.Max(i)) - else: - self.max = quantizationParameters.MaxAsNumpy() - if not quantizationParameters.ScaleIsNone(): - if np is None: - self.scale = [] - for i in range(quantizationParameters.ScaleLength()): - self.scale.append(quantizationParameters.Scale(i)) - else: - self.scale = quantizationParameters.ScaleAsNumpy() - if not quantizationParameters.ZeroPointIsNone(): - if np is None: - self.zeroPoint = [] - for i in range(quantizationParameters.ZeroPointLength()): - self.zeroPoint.append(quantizationParameters.ZeroPoint(i)) - else: - self.zeroPoint = quantizationParameters.ZeroPointAsNumpy() - self.detailsType = quantizationParameters.DetailsType() - self.details = QuantizationDetailsCreator(self.detailsType, quantizationParameters.Details()) - self.quantizedDimension = quantizationParameters.QuantizedDimension() - # QuantizationParametersT + # GreaterOptionsT def Pack(self, builder): - if self.min is not None: - if np is not None and type(self.min) is np.ndarray: - min = builder.CreateNumpyVector(self.min) - else: - QuantizationParametersStartMinVector(builder, len(self.min)) - for i in reversed(range(len(self.min))): - builder.PrependFloat32(self.min[i]) - min = builder.EndVector() - if self.max is not None: - if np is not None and type(self.max) is np.ndarray: - max = builder.CreateNumpyVector(self.max) - else: - QuantizationParametersStartMaxVector(builder, len(self.max)) - for i in reversed(range(len(self.max))): - builder.PrependFloat32(self.max[i]) - max = builder.EndVector() - if self.scale is not None: - if np is not None and type(self.scale) is np.ndarray: - scale = builder.CreateNumpyVector(self.scale) - else: - QuantizationParametersStartScaleVector(builder, len(self.scale)) - for i in reversed(range(len(self.scale))): - builder.PrependFloat32(self.scale[i]) - scale = builder.EndVector() - if self.zeroPoint is not None: - if np is not None and type(self.zeroPoint) is np.ndarray: - zeroPoint = builder.CreateNumpyVector(self.zeroPoint) - else: - QuantizationParametersStartZeroPointVector(builder, len(self.zeroPoint)) - for i in reversed(range(len(self.zeroPoint))): - builder.PrependInt64(self.zeroPoint[i]) - zeroPoint = builder.EndVector() - if self.details is not None: - details = self.details.Pack(builder) - QuantizationParametersStart(builder) - if self.min is not None: - QuantizationParametersAddMin(builder, min) - if self.max is not None: - QuantizationParametersAddMax(builder, max) - if self.scale is not None: - QuantizationParametersAddScale(builder, scale) - if self.zeroPoint is not None: - QuantizationParametersAddZeroPoint(builder, zeroPoint) - QuantizationParametersAddDetailsType(builder, self.detailsType) - if self.details is not None: - QuantizationParametersAddDetails(builder, details) - QuantizationParametersAddQuantizedDimension(builder, self.quantizedDimension) - quantizationParameters = QuantizationParametersEnd(builder) - return quantizationParameters -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + GreaterOptionsStart(builder) + greaterOptions = GreaterOptionsEnd(builder) + return greaterOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class QuantizeOptions(object): +class GreaterEqualOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = QuantizeOptions() + x = GreaterEqualOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsQuantizeOptions(cls, buf, offset=0): + def GetRootAsGreaterEqualOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def QuantizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def GreaterEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # QuantizeOptions + # GreaterEqualOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def QuantizeOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return QuantizeOptionsStart(builder) -def QuantizeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return QuantizeOptionsEnd(builder) +def GreaterEqualOptionsStart(builder): + builder.StartObject(0) -class QuantizeOptionsT(object): +def GreaterEqualOptionsEnd(builder): + return builder.EndObject() - # QuantizeOptionsT + + +class GreaterEqualOptionsT(object): + + # GreaterEqualOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - quantizeOptions = QuantizeOptions() - quantizeOptions.Init(buf, pos) - return cls.InitFromObj(quantizeOptions) + greaterEqualOptions = GreaterEqualOptions() + greaterEqualOptions.Init(buf, pos) + return cls.InitFromObj(greaterEqualOptions) @classmethod - def InitFromObj(cls, quantizeOptions): - x = QuantizeOptionsT() - x._UnPack(quantizeOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, greaterEqualOptions): + x = GreaterEqualOptionsT() + x._UnPack(greaterEqualOptions) return x - # QuantizeOptionsT - def _UnPack(self, quantizeOptions): - if quantizeOptions is None: + # GreaterEqualOptionsT + def _UnPack(self, greaterEqualOptions): + if greaterEqualOptions is None: return - # QuantizeOptionsT + # GreaterEqualOptionsT def Pack(self, builder): - QuantizeOptionsStart(builder) - quantizeOptions = QuantizeOptionsEnd(builder) - return quantizeOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + GreaterEqualOptionsStart(builder) + greaterEqualOptions = GreaterEqualOptionsEnd(builder) + return greaterEqualOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class RNNOptions(object): +class LessOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = RNNOptions() + x = LessOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsRNNOptions(cls, buf, offset=0): + def GetRootAsLessOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def RNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LessOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # RNNOptions + # LessOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # RNNOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def LessOptionsStart(builder): + builder.StartObject(0) - # RNNOptions - def AsymmetricQuantizeInputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def LessOptionsEnd(builder): + return builder.EndObject() -def RNNOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return RNNOptionsStart(builder) -def RNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return RNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def RNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(1, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return RNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def RNNOptionsEnd(builder): return builder.EndObject() -def End(builder): - return RNNOptionsEnd(builder) -class RNNOptionsT(object): - # RNNOptionsT +class LessOptionsT(object): + + # LessOptionsT def __init__(self): - self.fusedActivationFunction = 0 # type: int - self.asymmetricQuantizeInputs = False # type: bool + pass @classmethod def InitFromBuf(cls, buf, pos): - rnnoptions = RNNOptions() - rnnoptions.Init(buf, pos) - return cls.InitFromObj(rnnoptions) + lessOptions = LessOptions() + lessOptions.Init(buf, pos) + return cls.InitFromObj(lessOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) @classmethod - def InitFromObj(cls, rnnoptions): - x = RNNOptionsT() - x._UnPack(rnnoptions) + def InitFromObj(cls, lessOptions): + x = LessOptionsT() + x._UnPack(lessOptions) return x - # RNNOptionsT - def _UnPack(self, rnnoptions): - if rnnoptions is None: + # LessOptionsT + def _UnPack(self, lessOptions): + if lessOptions is None: return - self.fusedActivationFunction = rnnoptions.FusedActivationFunction() - self.asymmetricQuantizeInputs = rnnoptions.AsymmetricQuantizeInputs() - # RNNOptionsT + # LessOptionsT def Pack(self, builder): - RNNOptionsStart(builder) - RNNOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - RNNOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) - rnnoptions = RNNOptionsEnd(builder) - return rnnoptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LessOptionsStart(builder) + lessOptions = LessOptionsEnd(builder) + return lessOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class RandomOptions(object): +class LessEqualOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = RandomOptions() + x = LessEqualOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsRandomOptions(cls, buf, offset=0): + def GetRootAsLessEqualOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def RandomOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LessEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # RandomOptions + # LessEqualOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # RandomOptions - def Seed(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 +def LessEqualOptionsStart(builder): + builder.StartObject(0) - # RandomOptions - def Seed2(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 +def LessEqualOptionsEnd(builder): + return builder.EndObject() -def RandomOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return RandomOptionsStart(builder) -def RandomOptionsAddSeed(builder, seed): builder.PrependInt64Slot(0, seed, 0) -def AddSeed(builder, seed): - return RandomOptionsAddSeed(builder, seed) -def RandomOptionsAddSeed2(builder, seed2): builder.PrependInt64Slot(1, seed2, 0) -def AddSeed2(builder, seed2): - return RandomOptionsAddSeed2(builder, seed2) -def RandomOptionsEnd(builder): return builder.EndObject() -def End(builder): - return RandomOptionsEnd(builder) -class RandomOptionsT(object): - # RandomOptionsT +class LessEqualOptionsT(object): + + # LessEqualOptionsT def __init__(self): - self.seed = 0 # type: int - self.seed2 = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - randomOptions = RandomOptions() - randomOptions.Init(buf, pos) - return cls.InitFromObj(randomOptions) + lessEqualOptions = LessEqualOptions() + lessEqualOptions.Init(buf, pos) + return cls.InitFromObj(lessEqualOptions) @classmethod - def InitFromObj(cls, randomOptions): - x = RandomOptionsT() - x._UnPack(randomOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, lessEqualOptions): + x = LessEqualOptionsT() + x._UnPack(lessEqualOptions) return x - # RandomOptionsT - def _UnPack(self, randomOptions): - if randomOptions is None: + # LessEqualOptionsT + def _UnPack(self, lessEqualOptions): + if lessEqualOptions is None: return - self.seed = randomOptions.Seed() - self.seed2 = randomOptions.Seed2() - # RandomOptionsT + # LessEqualOptionsT def Pack(self, builder): - RandomOptionsStart(builder) - RandomOptionsAddSeed(builder, self.seed) - RandomOptionsAddSeed2(builder, self.seed2) - randomOptions = RandomOptionsEnd(builder) - return randomOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LessEqualOptionsStart(builder) + lessEqualOptions = LessEqualOptionsEnd(builder) + return lessEqualOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class RangeOptions(object): +class NegOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = RangeOptions() + x = NegOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsRangeOptions(cls, buf, offset=0): + def GetRootAsNegOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def RangeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def NegOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # RangeOptions + # NegOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def RangeOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return RangeOptionsStart(builder) -def RangeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return RangeOptionsEnd(builder) +def NegOptionsStart(builder): + builder.StartObject(0) -class RangeOptionsT(object): +def NegOptionsEnd(builder): + return builder.EndObject() - # RangeOptionsT + + +class NegOptionsT(object): + + # NegOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - rangeOptions = RangeOptions() - rangeOptions.Init(buf, pos) - return cls.InitFromObj(rangeOptions) + negOptions = NegOptions() + negOptions.Init(buf, pos) + return cls.InitFromObj(negOptions) @classmethod - def InitFromObj(cls, rangeOptions): - x = RangeOptionsT() - x._UnPack(rangeOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, negOptions): + x = NegOptionsT() + x._UnPack(negOptions) return x - # RangeOptionsT - def _UnPack(self, rangeOptions): - if rangeOptions is None: + # NegOptionsT + def _UnPack(self, negOptions): + if negOptions is None: return - # RangeOptionsT + # NegOptionsT def Pack(self, builder): - RangeOptionsStart(builder) - rangeOptions = RangeOptionsEnd(builder) - return rangeOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + NegOptionsStart(builder) + negOptions = NegOptionsEnd(builder) + return negOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class RankOptions(object): +class SelectOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = RankOptions() + x = SelectOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsRankOptions(cls, buf, offset=0): + def GetRootAsSelectOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def RankOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SelectOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # RankOptions + # SelectOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def RankOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return RankOptionsStart(builder) -def RankOptionsEnd(builder): return builder.EndObject() -def End(builder): - return RankOptionsEnd(builder) +def SelectOptionsStart(builder): + builder.StartObject(0) -class RankOptionsT(object): +def SelectOptionsEnd(builder): + return builder.EndObject() - # RankOptionsT + + +class SelectOptionsT(object): + + # SelectOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - rankOptions = RankOptions() - rankOptions.Init(buf, pos) - return cls.InitFromObj(rankOptions) + selectOptions = SelectOptions() + selectOptions.Init(buf, pos) + return cls.InitFromObj(selectOptions) @classmethod - def InitFromObj(cls, rankOptions): - x = RankOptionsT() - x._UnPack(rankOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, selectOptions): + x = SelectOptionsT() + x._UnPack(selectOptions) return x - # RankOptionsT - def _UnPack(self, rankOptions): - if rankOptions is None: + # SelectOptionsT + def _UnPack(self, selectOptions): + if selectOptions is None: return - # RankOptionsT + # SelectOptionsT def Pack(self, builder): - RankOptionsStart(builder) - rankOptions = RankOptionsEnd(builder) - return rankOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SelectOptionsStart(builder) + selectOptions = SelectOptionsEnd(builder) + return selectOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ReadVariableOptions(object): +class SliceOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ReadVariableOptions() + x = SliceOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsReadVariableOptions(cls, buf, offset=0): + def GetRootAsSliceOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ReadVariableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ReadVariableOptions + # SliceOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def ReadVariableOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return ReadVariableOptionsStart(builder) -def ReadVariableOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ReadVariableOptionsEnd(builder) +def SliceOptionsStart(builder): + builder.StartObject(0) -class ReadVariableOptionsT(object): +def SliceOptionsEnd(builder): + return builder.EndObject() - # ReadVariableOptionsT + + +class SliceOptionsT(object): + + # SliceOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - readVariableOptions = ReadVariableOptions() - readVariableOptions.Init(buf, pos) - return cls.InitFromObj(readVariableOptions) + sliceOptions = SliceOptions() + sliceOptions.Init(buf, pos) + return cls.InitFromObj(sliceOptions) @classmethod - def InitFromObj(cls, readVariableOptions): - x = ReadVariableOptionsT() - x._UnPack(readVariableOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, sliceOptions): + x = SliceOptionsT() + x._UnPack(sliceOptions) return x - # ReadVariableOptionsT - def _UnPack(self, readVariableOptions): - if readVariableOptions is None: + # SliceOptionsT + def _UnPack(self, sliceOptions): + if sliceOptions is None: return - # ReadVariableOptionsT + # SliceOptionsT def Pack(self, builder): - ReadVariableOptionsStart(builder) - readVariableOptions = ReadVariableOptionsEnd(builder) - return readVariableOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class ReduceWindowFunction(object): - UNSUPPORTED = 0 - ADD = 1 - MUL = 2 - MINIMUM = 3 - MAXIMUM = 4 - ALL = 5 - ANY = 6 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SliceOptionsStart(builder) + sliceOptions = SliceOptionsEnd(builder) + return sliceOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ReduceWindowOptions(object): +class TransposeConvOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ReduceWindowOptions() + x = TransposeConvOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsReduceWindowOptions(cls, buf, offset=0): + def GetRootAsTransposeConvOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ReduceWindowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def TransposeConvOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ReduceWindowOptions + # TransposeConvOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # ReduceWindowOptions - def ReduceFunction(self): + # TransposeConvOptions + def Padding(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # TransposeConvOptions + def StrideW(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def ReduceWindowOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return ReduceWindowOptionsStart(builder) -def ReduceWindowOptionsAddReduceFunction(builder, reduceFunction): builder.PrependInt32Slot(0, reduceFunction, 0) -def AddReduceFunction(builder, reduceFunction): - return ReduceWindowOptionsAddReduceFunction(builder, reduceFunction) -def ReduceWindowOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ReduceWindowOptionsEnd(builder) + # TransposeConvOptions + def StrideH(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 -class ReduceWindowOptionsT(object): + # TransposeConvOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 - # ReduceWindowOptionsT + # TransposeConvOptions + def QuantizedBiasType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def TransposeConvOptionsStart(builder): + builder.StartObject(5) + +def TransposeConvOptionsAddPadding(builder, padding): + builder.PrependInt8Slot(0, padding, 0) + +def TransposeConvOptionsAddStrideW(builder, strideW): + builder.PrependInt32Slot(1, strideW, 0) + +def TransposeConvOptionsAddStrideH(builder, strideH): + builder.PrependInt32Slot(2, strideH, 0) + +def TransposeConvOptionsAddFusedActivationFunction(builder, fusedActivationFunction): + builder.PrependInt8Slot(3, fusedActivationFunction, 0) + +def TransposeConvOptionsAddQuantizedBiasType(builder, quantizedBiasType): + builder.PrependInt8Slot(4, quantizedBiasType, 0) + +def TransposeConvOptionsEnd(builder): + return builder.EndObject() + + + +class TransposeConvOptionsT(object): + + # TransposeConvOptionsT def __init__(self): - self.reduceFunction = 0 # type: int + self.padding = 0 # type: int + self.strideW = 0 # type: int + self.strideH = 0 # type: int + self.fusedActivationFunction = 0 # type: int + self.quantizedBiasType = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - reduceWindowOptions = ReduceWindowOptions() - reduceWindowOptions.Init(buf, pos) - return cls.InitFromObj(reduceWindowOptions) + transposeConvOptions = TransposeConvOptions() + transposeConvOptions.Init(buf, pos) + return cls.InitFromObj(transposeConvOptions) @classmethod - def InitFromObj(cls, reduceWindowOptions): - x = ReduceWindowOptionsT() - x._UnPack(reduceWindowOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, transposeConvOptions): + x = TransposeConvOptionsT() + x._UnPack(transposeConvOptions) return x - # ReduceWindowOptionsT - def _UnPack(self, reduceWindowOptions): - if reduceWindowOptions is None: + # TransposeConvOptionsT + def _UnPack(self, transposeConvOptions): + if transposeConvOptions is None: return - self.reduceFunction = reduceWindowOptions.ReduceFunction() + self.padding = transposeConvOptions.Padding() + self.strideW = transposeConvOptions.StrideW() + self.strideH = transposeConvOptions.StrideH() + self.fusedActivationFunction = transposeConvOptions.FusedActivationFunction() + self.quantizedBiasType = transposeConvOptions.QuantizedBiasType() - # ReduceWindowOptionsT + # TransposeConvOptionsT def Pack(self, builder): - ReduceWindowOptionsStart(builder) - ReduceWindowOptionsAddReduceFunction(builder, self.reduceFunction) - reduceWindowOptions = ReduceWindowOptionsEnd(builder) - return reduceWindowOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + TransposeConvOptionsStart(builder) + TransposeConvOptionsAddPadding(builder, self.padding) + TransposeConvOptionsAddStrideW(builder, self.strideW) + TransposeConvOptionsAddStrideH(builder, self.strideH) + TransposeConvOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) + TransposeConvOptionsAddQuantizedBiasType(builder, self.quantizedBiasType) + transposeConvOptions = TransposeConvOptionsEnd(builder) + return transposeConvOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ReducerOptions(object): +class ExpandDimsOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ReducerOptions() + x = ExpandDimsOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsReducerOptions(cls, buf, offset=0): + def GetRootAsExpandDimsOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ReducerOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ExpandDimsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ReducerOptions + # ExpandDimsOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # ReducerOptions - def KeepDims(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def ExpandDimsOptionsStart(builder): + builder.StartObject(0) -def ReducerOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return ReducerOptionsStart(builder) -def ReducerOptionsAddKeepDims(builder, keepDims): builder.PrependBoolSlot(0, keepDims, 0) -def AddKeepDims(builder, keepDims): - return ReducerOptionsAddKeepDims(builder, keepDims) -def ReducerOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ReducerOptionsEnd(builder) +def ExpandDimsOptionsEnd(builder): + return builder.EndObject() -class ReducerOptionsT(object): - # ReducerOptionsT + +class ExpandDimsOptionsT(object): + + # ExpandDimsOptionsT def __init__(self): - self.keepDims = False # type: bool + pass @classmethod def InitFromBuf(cls, buf, pos): - reducerOptions = ReducerOptions() - reducerOptions.Init(buf, pos) - return cls.InitFromObj(reducerOptions) + expandDimsOptions = ExpandDimsOptions() + expandDimsOptions.Init(buf, pos) + return cls.InitFromObj(expandDimsOptions) @classmethod - def InitFromObj(cls, reducerOptions): - x = ReducerOptionsT() - x._UnPack(reducerOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, expandDimsOptions): + x = ExpandDimsOptionsT() + x._UnPack(expandDimsOptions) return x - # ReducerOptionsT - def _UnPack(self, reducerOptions): - if reducerOptions is None: + # ExpandDimsOptionsT + def _UnPack(self, expandDimsOptions): + if expandDimsOptions is None: return - self.keepDims = reducerOptions.KeepDims() - # ReducerOptionsT + # ExpandDimsOptionsT def Pack(self, builder): - ReducerOptionsStart(builder) - ReducerOptionsAddKeepDims(builder, self.keepDims) - reducerOptions = ReducerOptionsEnd(builder) - return reducerOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ExpandDimsOptionsStart(builder) + expandDimsOptions = ExpandDimsOptionsEnd(builder) + return expandDimsOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ReshapeOptions(object): +class SparseToDenseOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ReshapeOptions() + x = SparseToDenseOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsReshapeOptions(cls, buf, offset=0): + def GetRootAsSparseToDenseOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ReshapeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SparseToDenseOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ReshapeOptions + # SparseToDenseOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # ReshapeOptions - def NewShape(self, j): + # SparseToDenseOptions + def ValidateIndices(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # ReshapeOptions - def NewShapeAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 +def SparseToDenseOptionsStart(builder): + builder.StartObject(1) - # ReshapeOptions - def NewShapeLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def SparseToDenseOptionsAddValidateIndices(builder, validateIndices): + builder.PrependBoolSlot(0, validateIndices, 0) - # ReshapeOptions - def NewShapeIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 +def SparseToDenseOptionsEnd(builder): + return builder.EndObject() -def ReshapeOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return ReshapeOptionsStart(builder) -def ReshapeOptionsAddNewShape(builder, newShape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(newShape), 0) -def AddNewShape(builder, newShape): - return ReshapeOptionsAddNewShape(builder, newShape) -def ReshapeOptionsStartNewShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartNewShapeVector(builder, numElems): - return ReshapeOptionsStartNewShapeVector(builder, numElems) -def ReshapeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ReshapeOptionsEnd(builder) -try: - from typing import List -except: - pass -class ReshapeOptionsT(object): - # ReshapeOptionsT +class SparseToDenseOptionsT(object): + + # SparseToDenseOptionsT def __init__(self): - self.newShape = None # type: List[int] + self.validateIndices = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - reshapeOptions = ReshapeOptions() - reshapeOptions.Init(buf, pos) - return cls.InitFromObj(reshapeOptions) + sparseToDenseOptions = SparseToDenseOptions() + sparseToDenseOptions.Init(buf, pos) + return cls.InitFromObj(sparseToDenseOptions) @classmethod - def InitFromObj(cls, reshapeOptions): - x = ReshapeOptionsT() - x._UnPack(reshapeOptions) - return x - - # ReshapeOptionsT - def _UnPack(self, reshapeOptions): - if reshapeOptions is None: - return - if not reshapeOptions.NewShapeIsNone(): - if np is None: - self.newShape = [] - for i in range(reshapeOptions.NewShapeLength()): - self.newShape.append(reshapeOptions.NewShape(i)) - else: - self.newShape = reshapeOptions.NewShapeAsNumpy() + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # ReshapeOptionsT - def Pack(self, builder): - if self.newShape is not None: - if np is not None and type(self.newShape) is np.ndarray: - newShape = builder.CreateNumpyVector(self.newShape) - else: - ReshapeOptionsStartNewShapeVector(builder, len(self.newShape)) - for i in reversed(range(len(self.newShape))): - builder.PrependInt32(self.newShape[i]) - newShape = builder.EndVector() - ReshapeOptionsStart(builder) - if self.newShape is not None: - ReshapeOptionsAddNewShape(builder, newShape) - reshapeOptions = ReshapeOptionsEnd(builder) - return reshapeOptions -# automatically generated by the FlatBuffers compiler, do not modify + @classmethod + def InitFromObj(cls, sparseToDenseOptions): + x = SparseToDenseOptionsT() + x._UnPack(sparseToDenseOptions) + return x -# namespace: tflite + # SparseToDenseOptionsT + def _UnPack(self, sparseToDenseOptions): + if sparseToDenseOptions is None: + return + self.validateIndices = sparseToDenseOptions.ValidateIndices() -from flatbuffers.compat import import_numpy -np = import_numpy() + # SparseToDenseOptionsT + def Pack(self, builder): + SparseToDenseOptionsStart(builder) + SparseToDenseOptionsAddValidateIndices(builder, self.validateIndices) + sparseToDenseOptions = SparseToDenseOptionsEnd(builder) + return sparseToDenseOptions -class ResizeBilinearOptions(object): + +class EqualOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ResizeBilinearOptions() + x = EqualOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsResizeBilinearOptions(cls, buf, offset=0): + def GetRootAsEqualOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ResizeBilinearOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def EqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ResizeBilinearOptions + # EqualOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # ResizeBilinearOptions - def AlignCorners(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def EqualOptionsStart(builder): + builder.StartObject(0) - # ResizeBilinearOptions - def HalfPixelCenters(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def EqualOptionsEnd(builder): + return builder.EndObject() -def ResizeBilinearOptionsStart(builder): builder.StartObject(4) -def Start(builder): - return ResizeBilinearOptionsStart(builder) -def ResizeBilinearOptionsAddAlignCorners(builder, alignCorners): builder.PrependBoolSlot(2, alignCorners, 0) -def AddAlignCorners(builder, alignCorners): - return ResizeBilinearOptionsAddAlignCorners(builder, alignCorners) -def ResizeBilinearOptionsAddHalfPixelCenters(builder, halfPixelCenters): builder.PrependBoolSlot(3, halfPixelCenters, 0) -def AddHalfPixelCenters(builder, halfPixelCenters): - return ResizeBilinearOptionsAddHalfPixelCenters(builder, halfPixelCenters) -def ResizeBilinearOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ResizeBilinearOptionsEnd(builder) -class ResizeBilinearOptionsT(object): - # ResizeBilinearOptionsT +class EqualOptionsT(object): + + # EqualOptionsT def __init__(self): - self.alignCorners = False # type: bool - self.halfPixelCenters = False # type: bool + pass @classmethod def InitFromBuf(cls, buf, pos): - resizeBilinearOptions = ResizeBilinearOptions() - resizeBilinearOptions.Init(buf, pos) - return cls.InitFromObj(resizeBilinearOptions) + equalOptions = EqualOptions() + equalOptions.Init(buf, pos) + return cls.InitFromObj(equalOptions) @classmethod - def InitFromObj(cls, resizeBilinearOptions): - x = ResizeBilinearOptionsT() - x._UnPack(resizeBilinearOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, equalOptions): + x = EqualOptionsT() + x._UnPack(equalOptions) return x - # ResizeBilinearOptionsT - def _UnPack(self, resizeBilinearOptions): - if resizeBilinearOptions is None: + # EqualOptionsT + def _UnPack(self, equalOptions): + if equalOptions is None: return - self.alignCorners = resizeBilinearOptions.AlignCorners() - self.halfPixelCenters = resizeBilinearOptions.HalfPixelCenters() - # ResizeBilinearOptionsT + # EqualOptionsT def Pack(self, builder): - ResizeBilinearOptionsStart(builder) - ResizeBilinearOptionsAddAlignCorners(builder, self.alignCorners) - ResizeBilinearOptionsAddHalfPixelCenters(builder, self.halfPixelCenters) - resizeBilinearOptions = ResizeBilinearOptionsEnd(builder) - return resizeBilinearOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + EqualOptionsStart(builder) + equalOptions = EqualOptionsEnd(builder) + return equalOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ResizeNearestNeighborOptions(object): +class NotEqualOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ResizeNearestNeighborOptions() + x = NotEqualOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsResizeNearestNeighborOptions(cls, buf, offset=0): + def GetRootAsNotEqualOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ResizeNearestNeighborOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def NotEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ResizeNearestNeighborOptions + # NotEqualOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # ResizeNearestNeighborOptions - def AlignCorners(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def NotEqualOptionsStart(builder): + builder.StartObject(0) - # ResizeNearestNeighborOptions - def HalfPixelCenters(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def NotEqualOptionsEnd(builder): + return builder.EndObject() -def ResizeNearestNeighborOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return ResizeNearestNeighborOptionsStart(builder) -def ResizeNearestNeighborOptionsAddAlignCorners(builder, alignCorners): builder.PrependBoolSlot(0, alignCorners, 0) -def AddAlignCorners(builder, alignCorners): - return ResizeNearestNeighborOptionsAddAlignCorners(builder, alignCorners) -def ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, halfPixelCenters): builder.PrependBoolSlot(1, halfPixelCenters, 0) -def AddHalfPixelCenters(builder, halfPixelCenters): - return ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, halfPixelCenters) -def ResizeNearestNeighborOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ResizeNearestNeighborOptionsEnd(builder) -class ResizeNearestNeighborOptionsT(object): - # ResizeNearestNeighborOptionsT +class NotEqualOptionsT(object): + + # NotEqualOptionsT def __init__(self): - self.alignCorners = False # type: bool - self.halfPixelCenters = False # type: bool + pass @classmethod def InitFromBuf(cls, buf, pos): - resizeNearestNeighborOptions = ResizeNearestNeighborOptions() - resizeNearestNeighborOptions.Init(buf, pos) - return cls.InitFromObj(resizeNearestNeighborOptions) + notEqualOptions = NotEqualOptions() + notEqualOptions.Init(buf, pos) + return cls.InitFromObj(notEqualOptions) @classmethod - def InitFromObj(cls, resizeNearestNeighborOptions): - x = ResizeNearestNeighborOptionsT() - x._UnPack(resizeNearestNeighborOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, notEqualOptions): + x = NotEqualOptionsT() + x._UnPack(notEqualOptions) return x - # ResizeNearestNeighborOptionsT - def _UnPack(self, resizeNearestNeighborOptions): - if resizeNearestNeighborOptions is None: + # NotEqualOptionsT + def _UnPack(self, notEqualOptions): + if notEqualOptions is None: return - self.alignCorners = resizeNearestNeighborOptions.AlignCorners() - self.halfPixelCenters = resizeNearestNeighborOptions.HalfPixelCenters() - # ResizeNearestNeighborOptionsT + # NotEqualOptionsT def Pack(self, builder): - ResizeNearestNeighborOptionsStart(builder) - ResizeNearestNeighborOptionsAddAlignCorners(builder, self.alignCorners) - ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, self.halfPixelCenters) - resizeNearestNeighborOptions = ResizeNearestNeighborOptionsEnd(builder) - return resizeNearestNeighborOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + NotEqualOptionsStart(builder) + notEqualOptions = NotEqualOptionsEnd(builder) + return notEqualOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ReverseSequenceOptions(object): +class ShapeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ReverseSequenceOptions() + x = ShapeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsReverseSequenceOptions(cls, buf, offset=0): + def GetRootAsShapeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ReverseSequenceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ShapeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ReverseSequenceOptions + # ShapeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # ReverseSequenceOptions - def SeqDim(self): + # ShapeOptions + def OutType(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # ReverseSequenceOptions - def BatchDim(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def ShapeOptionsStart(builder): + builder.StartObject(1) -def ReverseSequenceOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return ReverseSequenceOptionsStart(builder) -def ReverseSequenceOptionsAddSeqDim(builder, seqDim): builder.PrependInt32Slot(0, seqDim, 0) -def AddSeqDim(builder, seqDim): - return ReverseSequenceOptionsAddSeqDim(builder, seqDim) -def ReverseSequenceOptionsAddBatchDim(builder, batchDim): builder.PrependInt32Slot(1, batchDim, 0) -def AddBatchDim(builder, batchDim): - return ReverseSequenceOptionsAddBatchDim(builder, batchDim) -def ReverseSequenceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ReverseSequenceOptionsEnd(builder) +def ShapeOptionsAddOutType(builder, outType): + builder.PrependInt8Slot(0, outType, 0) -class ReverseSequenceOptionsT(object): +def ShapeOptionsEnd(builder): + return builder.EndObject() - # ReverseSequenceOptionsT + + +class ShapeOptionsT(object): + + # ShapeOptionsT def __init__(self): - self.seqDim = 0 # type: int - self.batchDim = 0 # type: int + self.outType = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - reverseSequenceOptions = ReverseSequenceOptions() - reverseSequenceOptions.Init(buf, pos) - return cls.InitFromObj(reverseSequenceOptions) + shapeOptions = ShapeOptions() + shapeOptions.Init(buf, pos) + return cls.InitFromObj(shapeOptions) @classmethod - def InitFromObj(cls, reverseSequenceOptions): - x = ReverseSequenceOptionsT() - x._UnPack(reverseSequenceOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, shapeOptions): + x = ShapeOptionsT() + x._UnPack(shapeOptions) return x - # ReverseSequenceOptionsT - def _UnPack(self, reverseSequenceOptions): - if reverseSequenceOptions is None: + # ShapeOptionsT + def _UnPack(self, shapeOptions): + if shapeOptions is None: return - self.seqDim = reverseSequenceOptions.SeqDim() - self.batchDim = reverseSequenceOptions.BatchDim() + self.outType = shapeOptions.OutType() - # ReverseSequenceOptionsT + # ShapeOptionsT def Pack(self, builder): - ReverseSequenceOptionsStart(builder) - ReverseSequenceOptionsAddSeqDim(builder, self.seqDim) - ReverseSequenceOptionsAddBatchDim(builder, self.batchDim) - reverseSequenceOptions = ReverseSequenceOptionsEnd(builder) - return reverseSequenceOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ShapeOptionsStart(builder) + ShapeOptionsAddOutType(builder, self.outType) + shapeOptions = ShapeOptionsEnd(builder) + return shapeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ReverseV2Options(object): +class RankOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ReverseV2Options() + x = RankOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsReverseV2Options(cls, buf, offset=0): + def GetRootAsRankOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ReverseV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def RankOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ReverseV2Options + # RankOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def ReverseV2OptionsStart(builder): builder.StartObject(0) -def Start(builder): - return ReverseV2OptionsStart(builder) -def ReverseV2OptionsEnd(builder): return builder.EndObject() -def End(builder): - return ReverseV2OptionsEnd(builder) +def RankOptionsStart(builder): + builder.StartObject(0) -class ReverseV2OptionsT(object): +def RankOptionsEnd(builder): + return builder.EndObject() - # ReverseV2OptionsT + + +class RankOptionsT(object): + + # RankOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - reverseV2options = ReverseV2Options() - reverseV2options.Init(buf, pos) - return cls.InitFromObj(reverseV2options) + rankOptions = RankOptions() + rankOptions.Init(buf, pos) + return cls.InitFromObj(rankOptions) @classmethod - def InitFromObj(cls, reverseV2options): - x = ReverseV2OptionsT() - x._UnPack(reverseV2options) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, rankOptions): + x = RankOptionsT() + x._UnPack(rankOptions) return x - # ReverseV2OptionsT - def _UnPack(self, reverseV2options): - if reverseV2options is None: + # RankOptionsT + def _UnPack(self, rankOptions): + if rankOptions is None: return - # ReverseV2OptionsT + # RankOptionsT def Pack(self, builder): - ReverseV2OptionsStart(builder) - reverseV2options = ReverseV2OptionsEnd(builder) - return reverseV2options -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + RankOptionsStart(builder) + rankOptions = RankOptionsEnd(builder) + return rankOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class Rfft2dOptions(object): +class PowOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Rfft2dOptions() + x = PowOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsRfft2dOptions(cls, buf, offset=0): + def GetRootAsPowOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def Rfft2dOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def PowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Rfft2dOptions + # PowOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def Rfft2dOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return Rfft2dOptionsStart(builder) -def Rfft2dOptionsEnd(builder): return builder.EndObject() -def End(builder): - return Rfft2dOptionsEnd(builder) +def PowOptionsStart(builder): + builder.StartObject(0) -class Rfft2dOptionsT(object): +def PowOptionsEnd(builder): + return builder.EndObject() - # Rfft2dOptionsT + + +class PowOptionsT(object): + + # PowOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - rfft2dOptions = Rfft2dOptions() - rfft2dOptions.Init(buf, pos) - return cls.InitFromObj(rfft2dOptions) + powOptions = PowOptions() + powOptions.Init(buf, pos) + return cls.InitFromObj(powOptions) @classmethod - def InitFromObj(cls, rfft2dOptions): - x = Rfft2dOptionsT() - x._UnPack(rfft2dOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, powOptions): + x = PowOptionsT() + x._UnPack(powOptions) return x - # Rfft2dOptionsT - def _UnPack(self, rfft2dOptions): - if rfft2dOptions is None: + # PowOptionsT + def _UnPack(self, powOptions): + if powOptions is None: return - # Rfft2dOptionsT + # PowOptionsT def Pack(self, builder): - Rfft2dOptionsStart(builder) - rfft2dOptions = Rfft2dOptionsEnd(builder) - return rfft2dOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + PowOptionsStart(builder) + powOptions = PowOptionsEnd(builder) + return powOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class RightShiftOptions(object): +class FakeQuantOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = RightShiftOptions() + x = FakeQuantOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsRightShiftOptions(cls, buf, offset=0): + def GetRootAsFakeQuantOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def RightShiftOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def FakeQuantOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # RightShiftOptions + # FakeQuantOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def RightShiftOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return RightShiftOptionsStart(builder) -def RightShiftOptionsEnd(builder): return builder.EndObject() -def End(builder): - return RightShiftOptionsEnd(builder) + # FakeQuantOptions + def Min(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 -class RightShiftOptionsT(object): + # FakeQuantOptions + def Max(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 - # RightShiftOptionsT + # FakeQuantOptions + def NumBits(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # FakeQuantOptions + def NarrowRange(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def FakeQuantOptionsStart(builder): + builder.StartObject(4) + +def FakeQuantOptionsAddMin(builder, min): + builder.PrependFloat32Slot(0, min, 0.0) + +def FakeQuantOptionsAddMax(builder, max): + builder.PrependFloat32Slot(1, max, 0.0) + +def FakeQuantOptionsAddNumBits(builder, numBits): + builder.PrependInt32Slot(2, numBits, 0) + +def FakeQuantOptionsAddNarrowRange(builder, narrowRange): + builder.PrependBoolSlot(3, narrowRange, 0) + +def FakeQuantOptionsEnd(builder): + return builder.EndObject() + + + +class FakeQuantOptionsT(object): + + # FakeQuantOptionsT def __init__(self): - pass + self.min = 0.0 # type: float + self.max = 0.0 # type: float + self.numBits = 0 # type: int + self.narrowRange = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - rightShiftOptions = RightShiftOptions() - rightShiftOptions.Init(buf, pos) - return cls.InitFromObj(rightShiftOptions) + fakeQuantOptions = FakeQuantOptions() + fakeQuantOptions.Init(buf, pos) + return cls.InitFromObj(fakeQuantOptions) @classmethod - def InitFromObj(cls, rightShiftOptions): - x = RightShiftOptionsT() - x._UnPack(rightShiftOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, fakeQuantOptions): + x = FakeQuantOptionsT() + x._UnPack(fakeQuantOptions) return x - # RightShiftOptionsT - def _UnPack(self, rightShiftOptions): - if rightShiftOptions is None: + # FakeQuantOptionsT + def _UnPack(self, fakeQuantOptions): + if fakeQuantOptions is None: return + self.min = fakeQuantOptions.Min() + self.max = fakeQuantOptions.Max() + self.numBits = fakeQuantOptions.NumBits() + self.narrowRange = fakeQuantOptions.NarrowRange() - # RightShiftOptionsT + # FakeQuantOptionsT def Pack(self, builder): - RightShiftOptionsStart(builder) - rightShiftOptions = RightShiftOptionsEnd(builder) - return rightShiftOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class RngAlgorithm(object): - DEFAULT = 0 - PHILOX = 1 - THREEFRY = 2 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + FakeQuantOptionsStart(builder) + FakeQuantOptionsAddMin(builder, self.min) + FakeQuantOptionsAddMax(builder, self.max) + FakeQuantOptionsAddNumBits(builder, self.numBits) + FakeQuantOptionsAddNarrowRange(builder, self.narrowRange) + fakeQuantOptions = FakeQuantOptionsEnd(builder) + return fakeQuantOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SVDFOptions(object): +class PackOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SVDFOptions() + x = PackOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSVDFOptions(cls, buf, offset=0): + def GetRootAsPackOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SVDFOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def PackOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SVDFOptions + # PackOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SVDFOptions - def Rank(self): + # PackOptions + def ValuesCount(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # SVDFOptions - def FusedActivationFunction(self): + # PackOptions + def Axis(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # SVDFOptions - def AsymmetricQuantizeInputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def PackOptionsStart(builder): + builder.StartObject(2) -def SVDFOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return SVDFOptionsStart(builder) -def SVDFOptionsAddRank(builder, rank): builder.PrependInt32Slot(0, rank, 0) -def AddRank(builder, rank): - return SVDFOptionsAddRank(builder, rank) -def SVDFOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return SVDFOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def SVDFOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return SVDFOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def SVDFOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SVDFOptionsEnd(builder) +def PackOptionsAddValuesCount(builder, valuesCount): + builder.PrependInt32Slot(0, valuesCount, 0) -class SVDFOptionsT(object): +def PackOptionsAddAxis(builder, axis): + builder.PrependInt32Slot(1, axis, 0) - # SVDFOptionsT +def PackOptionsEnd(builder): + return builder.EndObject() + + + +class PackOptionsT(object): + + # PackOptionsT def __init__(self): - self.rank = 0 # type: int - self.fusedActivationFunction = 0 # type: int - self.asymmetricQuantizeInputs = False # type: bool + self.valuesCount = 0 # type: int + self.axis = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - svdfoptions = SVDFOptions() - svdfoptions.Init(buf, pos) - return cls.InitFromObj(svdfoptions) + packOptions = PackOptions() + packOptions.Init(buf, pos) + return cls.InitFromObj(packOptions) @classmethod - def InitFromObj(cls, svdfoptions): - x = SVDFOptionsT() - x._UnPack(svdfoptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, packOptions): + x = PackOptionsT() + x._UnPack(packOptions) return x - # SVDFOptionsT - def _UnPack(self, svdfoptions): - if svdfoptions is None: + # PackOptionsT + def _UnPack(self, packOptions): + if packOptions is None: return - self.rank = svdfoptions.Rank() - self.fusedActivationFunction = svdfoptions.FusedActivationFunction() - self.asymmetricQuantizeInputs = svdfoptions.AsymmetricQuantizeInputs() + self.valuesCount = packOptions.ValuesCount() + self.axis = packOptions.Axis() - # SVDFOptionsT + # PackOptionsT def Pack(self, builder): - SVDFOptionsStart(builder) - SVDFOptionsAddRank(builder, self.rank) - SVDFOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - SVDFOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) - svdfoptions = SVDFOptionsEnd(builder) - return svdfoptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + PackOptionsStart(builder) + PackOptionsAddValuesCount(builder, self.valuesCount) + PackOptionsAddAxis(builder, self.axis) + packOptions = PackOptionsEnd(builder) + return packOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ScatterNdOptions(object): +class LogicalOrOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ScatterNdOptions() + x = LogicalOrOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsScatterNdOptions(cls, buf, offset=0): + def GetRootAsLogicalOrOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ScatterNdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LogicalOrOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ScatterNdOptions + # LogicalOrOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def ScatterNdOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return ScatterNdOptionsStart(builder) -def ScatterNdOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ScatterNdOptionsEnd(builder) +def LogicalOrOptionsStart(builder): + builder.StartObject(0) -class ScatterNdOptionsT(object): +def LogicalOrOptionsEnd(builder): + return builder.EndObject() - # ScatterNdOptionsT + + +class LogicalOrOptionsT(object): + + # LogicalOrOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - scatterNdOptions = ScatterNdOptions() - scatterNdOptions.Init(buf, pos) - return cls.InitFromObj(scatterNdOptions) + logicalOrOptions = LogicalOrOptions() + logicalOrOptions.Init(buf, pos) + return cls.InitFromObj(logicalOrOptions) @classmethod - def InitFromObj(cls, scatterNdOptions): - x = ScatterNdOptionsT() - x._UnPack(scatterNdOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, logicalOrOptions): + x = LogicalOrOptionsT() + x._UnPack(logicalOrOptions) return x - # ScatterNdOptionsT - def _UnPack(self, scatterNdOptions): - if scatterNdOptions is None: + # LogicalOrOptionsT + def _UnPack(self, logicalOrOptions): + if logicalOrOptions is None: return - # ScatterNdOptionsT + # LogicalOrOptionsT def Pack(self, builder): - ScatterNdOptionsStart(builder) - scatterNdOptions = ScatterNdOptionsEnd(builder) - return scatterNdOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LogicalOrOptionsStart(builder) + logicalOrOptions = LogicalOrOptionsEnd(builder) + return logicalOrOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SegmentSumOptions(object): +class OneHotOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SegmentSumOptions() + x = OneHotOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSegmentSumOptions(cls, buf, offset=0): + def GetRootAsOneHotOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SegmentSumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def OneHotOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SegmentSumOptions + # OneHotOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def SegmentSumOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return SegmentSumOptionsStart(builder) -def SegmentSumOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SegmentSumOptionsEnd(builder) + # OneHotOptions + def Axis(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def OneHotOptionsStart(builder): + builder.StartObject(1) -class SegmentSumOptionsT(object): +def OneHotOptionsAddAxis(builder, axis): + builder.PrependInt32Slot(0, axis, 0) - # SegmentSumOptionsT +def OneHotOptionsEnd(builder): + return builder.EndObject() + + + +class OneHotOptionsT(object): + + # OneHotOptionsT def __init__(self): - pass + self.axis = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - segmentSumOptions = SegmentSumOptions() - segmentSumOptions.Init(buf, pos) - return cls.InitFromObj(segmentSumOptions) + oneHotOptions = OneHotOptions() + oneHotOptions.Init(buf, pos) + return cls.InitFromObj(oneHotOptions) @classmethod - def InitFromObj(cls, segmentSumOptions): - x = SegmentSumOptionsT() - x._UnPack(segmentSumOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, oneHotOptions): + x = OneHotOptionsT() + x._UnPack(oneHotOptions) return x - # SegmentSumOptionsT - def _UnPack(self, segmentSumOptions): - if segmentSumOptions is None: + # OneHotOptionsT + def _UnPack(self, oneHotOptions): + if oneHotOptions is None: return + self.axis = oneHotOptions.Axis() - # SegmentSumOptionsT + # OneHotOptionsT def Pack(self, builder): - SegmentSumOptionsStart(builder) - segmentSumOptions = SegmentSumOptionsEnd(builder) - return segmentSumOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + OneHotOptionsStart(builder) + OneHotOptionsAddAxis(builder, self.axis) + oneHotOptions = OneHotOptionsEnd(builder) + return oneHotOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SelectOptions(object): +class AbsOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SelectOptions() + x = AbsOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSelectOptions(cls, buf, offset=0): + def GetRootAsAbsOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SelectOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def AbsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SelectOptions + # AbsOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def SelectOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return SelectOptionsStart(builder) -def SelectOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SelectOptionsEnd(builder) +def AbsOptionsStart(builder): + builder.StartObject(0) -class SelectOptionsT(object): +def AbsOptionsEnd(builder): + return builder.EndObject() - # SelectOptionsT + + +class AbsOptionsT(object): + + # AbsOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - selectOptions = SelectOptions() - selectOptions.Init(buf, pos) - return cls.InitFromObj(selectOptions) + absOptions = AbsOptions() + absOptions.Init(buf, pos) + return cls.InitFromObj(absOptions) @classmethod - def InitFromObj(cls, selectOptions): - x = SelectOptionsT() - x._UnPack(selectOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, absOptions): + x = AbsOptionsT() + x._UnPack(absOptions) return x - # SelectOptionsT - def _UnPack(self, selectOptions): - if selectOptions is None: + # AbsOptionsT + def _UnPack(self, absOptions): + if absOptions is None: return - # SelectOptionsT + # AbsOptionsT def Pack(self, builder): - SelectOptionsStart(builder) - selectOptions = SelectOptionsEnd(builder) - return selectOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + AbsOptionsStart(builder) + absOptions = AbsOptionsEnd(builder) + return absOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SelectV2Options(object): +class HardSwishOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SelectV2Options() + x = HardSwishOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSelectV2Options(cls, buf, offset=0): + def GetRootAsHardSwishOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SelectV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def HardSwishOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SelectV2Options + # HardSwishOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def SelectV2OptionsStart(builder): builder.StartObject(0) -def Start(builder): - return SelectV2OptionsStart(builder) -def SelectV2OptionsEnd(builder): return builder.EndObject() -def End(builder): - return SelectV2OptionsEnd(builder) +def HardSwishOptionsStart(builder): + builder.StartObject(0) -class SelectV2OptionsT(object): +def HardSwishOptionsEnd(builder): + return builder.EndObject() - # SelectV2OptionsT + + +class HardSwishOptionsT(object): + + # HardSwishOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - selectV2options = SelectV2Options() - selectV2options.Init(buf, pos) - return cls.InitFromObj(selectV2options) + hardSwishOptions = HardSwishOptions() + hardSwishOptions.Init(buf, pos) + return cls.InitFromObj(hardSwishOptions) @classmethod - def InitFromObj(cls, selectV2options): - x = SelectV2OptionsT() - x._UnPack(selectV2options) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, hardSwishOptions): + x = HardSwishOptionsT() + x._UnPack(hardSwishOptions) return x - # SelectV2OptionsT - def _UnPack(self, selectV2options): - if selectV2options is None: + # HardSwishOptionsT + def _UnPack(self, hardSwishOptions): + if hardSwishOptions is None: return - # SelectV2OptionsT + # HardSwishOptionsT def Pack(self, builder): - SelectV2OptionsStart(builder) - selectV2options = SelectV2OptionsEnd(builder) - return selectV2options -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + HardSwishOptionsStart(builder) + hardSwishOptions = HardSwishOptionsEnd(builder) + return hardSwishOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SequenceRNNOptions(object): +class LogicalAndOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SequenceRNNOptions() + x = LogicalAndOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSequenceRNNOptions(cls, buf, offset=0): + def GetRootAsLogicalAndOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SequenceRNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LogicalAndOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SequenceRNNOptions + # LogicalAndOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SequenceRNNOptions - def TimeMajor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def LogicalAndOptionsStart(builder): + builder.StartObject(0) - # SequenceRNNOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def LogicalAndOptionsEnd(builder): + return builder.EndObject() - # SequenceRNNOptions - def AsymmetricQuantizeInputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False -def SequenceRNNOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return SequenceRNNOptionsStart(builder) -def SequenceRNNOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(0, timeMajor, 0) -def AddTimeMajor(builder, timeMajor): - return SequenceRNNOptionsAddTimeMajor(builder, timeMajor) -def SequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return SequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def SequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return SequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def SequenceRNNOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SequenceRNNOptionsEnd(builder) -class SequenceRNNOptionsT(object): +class LogicalAndOptionsT(object): - # SequenceRNNOptionsT + # LogicalAndOptionsT def __init__(self): - self.timeMajor = False # type: bool - self.fusedActivationFunction = 0 # type: int - self.asymmetricQuantizeInputs = False # type: bool + pass @classmethod def InitFromBuf(cls, buf, pos): - sequenceRnnoptions = SequenceRNNOptions() - sequenceRnnoptions.Init(buf, pos) - return cls.InitFromObj(sequenceRnnoptions) + logicalAndOptions = LogicalAndOptions() + logicalAndOptions.Init(buf, pos) + return cls.InitFromObj(logicalAndOptions) @classmethod - def InitFromObj(cls, sequenceRnnoptions): - x = SequenceRNNOptionsT() - x._UnPack(sequenceRnnoptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, logicalAndOptions): + x = LogicalAndOptionsT() + x._UnPack(logicalAndOptions) return x - # SequenceRNNOptionsT - def _UnPack(self, sequenceRnnoptions): - if sequenceRnnoptions is None: + # LogicalAndOptionsT + def _UnPack(self, logicalAndOptions): + if logicalAndOptions is None: return - self.timeMajor = sequenceRnnoptions.TimeMajor() - self.fusedActivationFunction = sequenceRnnoptions.FusedActivationFunction() - self.asymmetricQuantizeInputs = sequenceRnnoptions.AsymmetricQuantizeInputs() - - # SequenceRNNOptionsT - def Pack(self, builder): - SequenceRNNOptionsStart(builder) - SequenceRNNOptionsAddTimeMajor(builder, self.timeMajor) - SequenceRNNOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - SequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) - sequenceRnnoptions = SequenceRNNOptionsEnd(builder) - return sequenceRnnoptions -# automatically generated by the FlatBuffers compiler, do not modify -# namespace: tflite + # LogicalAndOptionsT + def Pack(self, builder): + LogicalAndOptionsStart(builder) + logicalAndOptions = LogicalAndOptionsEnd(builder) + return logicalAndOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class ShapeOptions(object): +class LogicalNotOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ShapeOptions() + x = LogicalNotOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsShapeOptions(cls, buf, offset=0): + def GetRootAsLogicalNotOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def ShapeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LogicalNotOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # ShapeOptions + # LogicalNotOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # ShapeOptions - def OutType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def LogicalNotOptionsStart(builder): + builder.StartObject(0) -def ShapeOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return ShapeOptionsStart(builder) -def ShapeOptionsAddOutType(builder, outType): builder.PrependInt8Slot(0, outType, 0) -def AddOutType(builder, outType): - return ShapeOptionsAddOutType(builder, outType) -def ShapeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ShapeOptionsEnd(builder) +def LogicalNotOptionsEnd(builder): + return builder.EndObject() -class ShapeOptionsT(object): - # ShapeOptionsT + +class LogicalNotOptionsT(object): + + # LogicalNotOptionsT def __init__(self): - self.outType = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - shapeOptions = ShapeOptions() - shapeOptions.Init(buf, pos) - return cls.InitFromObj(shapeOptions) + logicalNotOptions = LogicalNotOptions() + logicalNotOptions.Init(buf, pos) + return cls.InitFromObj(logicalNotOptions) @classmethod - def InitFromObj(cls, shapeOptions): - x = ShapeOptionsT() - x._UnPack(shapeOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, logicalNotOptions): + x = LogicalNotOptionsT() + x._UnPack(logicalNotOptions) return x - # ShapeOptionsT - def _UnPack(self, shapeOptions): - if shapeOptions is None: + # LogicalNotOptionsT + def _UnPack(self, logicalNotOptions): + if logicalNotOptions is None: return - self.outType = shapeOptions.OutType() - # ShapeOptionsT + # LogicalNotOptionsT def Pack(self, builder): - ShapeOptionsStart(builder) - ShapeOptionsAddOutType(builder, self.outType) - shapeOptions = ShapeOptionsEnd(builder) - return shapeOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LogicalNotOptionsStart(builder) + logicalNotOptions = LogicalNotOptionsEnd(builder) + return logicalNotOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SignOptions(object): +class UnpackOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SignOptions() + x = UnpackOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSignOptions(cls, buf, offset=0): + def GetRootAsUnpackOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SignOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def UnpackOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SignOptions + # UnpackOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def SignOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return SignOptionsStart(builder) -def SignOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SignOptionsEnd(builder) + # UnpackOptions + def Num(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # UnpackOptions + def Axis(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def UnpackOptionsStart(builder): + builder.StartObject(2) -class SignOptionsT(object): +def UnpackOptionsAddNum(builder, num): + builder.PrependInt32Slot(0, num, 0) - # SignOptionsT +def UnpackOptionsAddAxis(builder, axis): + builder.PrependInt32Slot(1, axis, 0) + +def UnpackOptionsEnd(builder): + return builder.EndObject() + + + +class UnpackOptionsT(object): + + # UnpackOptionsT def __init__(self): - pass + self.num = 0 # type: int + self.axis = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - signOptions = SignOptions() - signOptions.Init(buf, pos) - return cls.InitFromObj(signOptions) + unpackOptions = UnpackOptions() + unpackOptions.Init(buf, pos) + return cls.InitFromObj(unpackOptions) @classmethod - def InitFromObj(cls, signOptions): - x = SignOptionsT() - x._UnPack(signOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, unpackOptions): + x = UnpackOptionsT() + x._UnPack(unpackOptions) return x - # SignOptionsT - def _UnPack(self, signOptions): - if signOptions is None: + # UnpackOptionsT + def _UnPack(self, unpackOptions): + if unpackOptions is None: return + self.num = unpackOptions.Num() + self.axis = unpackOptions.Axis() - # SignOptionsT + # UnpackOptionsT def Pack(self, builder): - SignOptionsStart(builder) - signOptions = SignOptionsEnd(builder) - return signOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + UnpackOptionsStart(builder) + UnpackOptionsAddNum(builder, self.num) + UnpackOptionsAddAxis(builder, self.axis) + unpackOptions = UnpackOptionsEnd(builder) + return unpackOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SignatureDef(object): +class FloorDivOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SignatureDef() + x = FloorDivOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSignatureDef(cls, buf, offset=0): + def GetRootAsFloorDivOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SignatureDefBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def FloorDivOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SignatureDef + # FloorDivOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SignatureDef - def Inputs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = TensorMap() - obj.Init(self._tab.Bytes, x) - return obj - return None - - # SignatureDef - def InputsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # SignatureDef - def InputsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - - # SignatureDef - def Outputs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = TensorMap() - obj.Init(self._tab.Bytes, x) - return obj - return None - - # SignatureDef - def OutputsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # SignatureDef - def OutputsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 +def FloorDivOptionsStart(builder): + builder.StartObject(0) - # SignatureDef - def SignatureKey(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None +def FloorDivOptionsEnd(builder): + return builder.EndObject() - # SignatureDef - def SubgraphIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) - return 0 -def SignatureDefStart(builder): builder.StartObject(5) -def Start(builder): - return SignatureDefStart(builder) -def SignatureDefAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) -def AddInputs(builder, inputs): - return SignatureDefAddInputs(builder, inputs) -def SignatureDefStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartInputsVector(builder, numElems): - return SignatureDefStartInputsVector(builder, numElems) -def SignatureDefAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) -def AddOutputs(builder, outputs): - return SignatureDefAddOutputs(builder, outputs) -def SignatureDefStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartOutputsVector(builder, numElems): - return SignatureDefStartOutputsVector(builder, numElems) -def SignatureDefAddSignatureKey(builder, signatureKey): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(signatureKey), 0) -def AddSignatureKey(builder, signatureKey): - return SignatureDefAddSignatureKey(builder, signatureKey) -def SignatureDefAddSubgraphIndex(builder, subgraphIndex): builder.PrependUint32Slot(4, subgraphIndex, 0) -def AddSubgraphIndex(builder, subgraphIndex): - return SignatureDefAddSubgraphIndex(builder, subgraphIndex) -def SignatureDefEnd(builder): return builder.EndObject() -def End(builder): - return SignatureDefEnd(builder) -try: - from typing import List -except: - pass -class SignatureDefT(object): +class FloorDivOptionsT(object): - # SignatureDefT + # FloorDivOptionsT def __init__(self): - self.inputs = None # type: List[TensorMapT] - self.outputs = None # type: List[TensorMapT] - self.signatureKey = None # type: str - self.subgraphIndex = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - signatureDef = SignatureDef() - signatureDef.Init(buf, pos) - return cls.InitFromObj(signatureDef) - - @classmethod - def InitFromObj(cls, signatureDef): - x = SignatureDefT() - x._UnPack(signatureDef) - return x + floorDivOptions = FloorDivOptions() + floorDivOptions.Init(buf, pos) + return cls.InitFromObj(floorDivOptions) - # SignatureDefT - def _UnPack(self, signatureDef): - if signatureDef is None: - return - if not signatureDef.InputsIsNone(): - self.inputs = [] - for i in range(signatureDef.InputsLength()): - if signatureDef.Inputs(i) is None: - self.inputs.append(None) - else: - tensorMap_ = TensorMapT.InitFromObj(signatureDef.Inputs(i)) - self.inputs.append(tensorMap_) - if not signatureDef.OutputsIsNone(): - self.outputs = [] - for i in range(signatureDef.OutputsLength()): - if signatureDef.Outputs(i) is None: - self.outputs.append(None) - else: - tensorMap_ = TensorMapT.InitFromObj(signatureDef.Outputs(i)) - self.outputs.append(tensorMap_) - self.signatureKey = signatureDef.SignatureKey() - self.subgraphIndex = signatureDef.SubgraphIndex() + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # SignatureDefT - def Pack(self, builder): - if self.inputs is not None: - inputslist = [] - for i in range(len(self.inputs)): - inputslist.append(self.inputs[i].Pack(builder)) - SignatureDefStartInputsVector(builder, len(self.inputs)) - for i in reversed(range(len(self.inputs))): - builder.PrependUOffsetTRelative(inputslist[i]) - inputs = builder.EndVector() - if self.outputs is not None: - outputslist = [] - for i in range(len(self.outputs)): - outputslist.append(self.outputs[i].Pack(builder)) - SignatureDefStartOutputsVector(builder, len(self.outputs)) - for i in reversed(range(len(self.outputs))): - builder.PrependUOffsetTRelative(outputslist[i]) - outputs = builder.EndVector() - if self.signatureKey is not None: - signatureKey = builder.CreateString(self.signatureKey) - SignatureDefStart(builder) - if self.inputs is not None: - SignatureDefAddInputs(builder, inputs) - if self.outputs is not None: - SignatureDefAddOutputs(builder, outputs) - if self.signatureKey is not None: - SignatureDefAddSignatureKey(builder, signatureKey) - SignatureDefAddSubgraphIndex(builder, self.subgraphIndex) - signatureDef = SignatureDefEnd(builder) - return signatureDef -# automatically generated by the FlatBuffers compiler, do not modify + @classmethod + def InitFromObj(cls, floorDivOptions): + x = FloorDivOptionsT() + x._UnPack(floorDivOptions) + return x -# namespace: tflite + # FloorDivOptionsT + def _UnPack(self, floorDivOptions): + if floorDivOptions is None: + return -from flatbuffers.compat import import_numpy -np = import_numpy() + # FloorDivOptionsT + def Pack(self, builder): + FloorDivOptionsStart(builder) + floorDivOptions = FloorDivOptionsEnd(builder) + return floorDivOptions -class SkipGramOptions(object): + +class SquareOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SkipGramOptions() + x = SquareOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSkipGramOptions(cls, buf, offset=0): + def GetRootAsSquareOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SkipGramOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SquareOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SkipGramOptions + # SquareOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SkipGramOptions - def NgramSize(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def SquareOptionsStart(builder): + builder.StartObject(0) - # SkipGramOptions - def MaxSkipSize(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def SquareOptionsEnd(builder): + return builder.EndObject() - # SkipGramOptions - def IncludeAllNgrams(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False -def SkipGramOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return SkipGramOptionsStart(builder) -def SkipGramOptionsAddNgramSize(builder, ngramSize): builder.PrependInt32Slot(0, ngramSize, 0) -def AddNgramSize(builder, ngramSize): - return SkipGramOptionsAddNgramSize(builder, ngramSize) -def SkipGramOptionsAddMaxSkipSize(builder, maxSkipSize): builder.PrependInt32Slot(1, maxSkipSize, 0) -def AddMaxSkipSize(builder, maxSkipSize): - return SkipGramOptionsAddMaxSkipSize(builder, maxSkipSize) -def SkipGramOptionsAddIncludeAllNgrams(builder, includeAllNgrams): builder.PrependBoolSlot(2, includeAllNgrams, 0) -def AddIncludeAllNgrams(builder, includeAllNgrams): - return SkipGramOptionsAddIncludeAllNgrams(builder, includeAllNgrams) -def SkipGramOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SkipGramOptionsEnd(builder) -class SkipGramOptionsT(object): +class SquareOptionsT(object): - # SkipGramOptionsT + # SquareOptionsT def __init__(self): - self.ngramSize = 0 # type: int - self.maxSkipSize = 0 # type: int - self.includeAllNgrams = False # type: bool + pass @classmethod def InitFromBuf(cls, buf, pos): - skipGramOptions = SkipGramOptions() - skipGramOptions.Init(buf, pos) - return cls.InitFromObj(skipGramOptions) + squareOptions = SquareOptions() + squareOptions.Init(buf, pos) + return cls.InitFromObj(squareOptions) @classmethod - def InitFromObj(cls, skipGramOptions): - x = SkipGramOptionsT() - x._UnPack(skipGramOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, squareOptions): + x = SquareOptionsT() + x._UnPack(squareOptions) return x - # SkipGramOptionsT - def _UnPack(self, skipGramOptions): - if skipGramOptions is None: + # SquareOptionsT + def _UnPack(self, squareOptions): + if squareOptions is None: return - self.ngramSize = skipGramOptions.NgramSize() - self.maxSkipSize = skipGramOptions.MaxSkipSize() - self.includeAllNgrams = skipGramOptions.IncludeAllNgrams() - # SkipGramOptionsT + # SquareOptionsT def Pack(self, builder): - SkipGramOptionsStart(builder) - SkipGramOptionsAddNgramSize(builder, self.ngramSize) - SkipGramOptionsAddMaxSkipSize(builder, self.maxSkipSize) - SkipGramOptionsAddIncludeAllNgrams(builder, self.includeAllNgrams) - skipGramOptions = SkipGramOptionsEnd(builder) - return skipGramOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SquareOptionsStart(builder) + squareOptions = SquareOptionsEnd(builder) + return squareOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SliceOptions(object): +class ZerosLikeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SliceOptions() + x = ZerosLikeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSliceOptions(cls, buf, offset=0): + def GetRootAsZerosLikeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ZerosLikeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SliceOptions + # ZerosLikeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def SliceOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return SliceOptionsStart(builder) -def SliceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SliceOptionsEnd(builder) +def ZerosLikeOptionsStart(builder): + builder.StartObject(0) -class SliceOptionsT(object): +def ZerosLikeOptionsEnd(builder): + return builder.EndObject() - # SliceOptionsT + + +class ZerosLikeOptionsT(object): + + # ZerosLikeOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - sliceOptions = SliceOptions() - sliceOptions.Init(buf, pos) - return cls.InitFromObj(sliceOptions) + zerosLikeOptions = ZerosLikeOptions() + zerosLikeOptions.Init(buf, pos) + return cls.InitFromObj(zerosLikeOptions) @classmethod - def InitFromObj(cls, sliceOptions): - x = SliceOptionsT() - x._UnPack(sliceOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, zerosLikeOptions): + x = ZerosLikeOptionsT() + x._UnPack(zerosLikeOptions) return x - # SliceOptionsT - def _UnPack(self, sliceOptions): - if sliceOptions is None: + # ZerosLikeOptionsT + def _UnPack(self, zerosLikeOptions): + if zerosLikeOptions is None: return - # SliceOptionsT + # ZerosLikeOptionsT def Pack(self, builder): - SliceOptionsStart(builder) - sliceOptions = SliceOptionsEnd(builder) - return sliceOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ZerosLikeOptionsStart(builder) + zerosLikeOptions = ZerosLikeOptionsEnd(builder) + return zerosLikeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SoftmaxOptions(object): +class FillOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SoftmaxOptions() + x = FillOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSoftmaxOptions(cls, buf, offset=0): + def GetRootAsFillOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SoftmaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def FillOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SoftmaxOptions + # FillOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SoftmaxOptions - def Beta(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 +def FillOptionsStart(builder): + builder.StartObject(0) -def SoftmaxOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return SoftmaxOptionsStart(builder) -def SoftmaxOptionsAddBeta(builder, beta): builder.PrependFloat32Slot(0, beta, 0.0) -def AddBeta(builder, beta): - return SoftmaxOptionsAddBeta(builder, beta) -def SoftmaxOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SoftmaxOptionsEnd(builder) +def FillOptionsEnd(builder): + return builder.EndObject() -class SoftmaxOptionsT(object): - # SoftmaxOptionsT + +class FillOptionsT(object): + + # FillOptionsT def __init__(self): - self.beta = 0.0 # type: float + pass @classmethod def InitFromBuf(cls, buf, pos): - softmaxOptions = SoftmaxOptions() - softmaxOptions.Init(buf, pos) - return cls.InitFromObj(softmaxOptions) + fillOptions = FillOptions() + fillOptions.Init(buf, pos) + return cls.InitFromObj(fillOptions) @classmethod - def InitFromObj(cls, softmaxOptions): - x = SoftmaxOptionsT() - x._UnPack(softmaxOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, fillOptions): + x = FillOptionsT() + x._UnPack(fillOptions) return x - # SoftmaxOptionsT - def _UnPack(self, softmaxOptions): - if softmaxOptions is None: + # FillOptionsT + def _UnPack(self, fillOptions): + if fillOptions is None: return - self.beta = softmaxOptions.Beta() - # SoftmaxOptionsT + # FillOptionsT def Pack(self, builder): - SoftmaxOptionsStart(builder) - SoftmaxOptionsAddBeta(builder, self.beta) - softmaxOptions = SoftmaxOptionsEnd(builder) - return softmaxOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + FillOptionsStart(builder) + fillOptions = FillOptionsEnd(builder) + return fillOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SpaceToBatchNDOptions(object): +class FloorModOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SpaceToBatchNDOptions() + x = FloorModOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSpaceToBatchNDOptions(cls, buf, offset=0): + def GetRootAsFloorModOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SpaceToBatchNDOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def FloorModOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SpaceToBatchNDOptions + # FloorModOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def SpaceToBatchNDOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return SpaceToBatchNDOptionsStart(builder) -def SpaceToBatchNDOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SpaceToBatchNDOptionsEnd(builder) +def FloorModOptionsStart(builder): + builder.StartObject(0) -class SpaceToBatchNDOptionsT(object): +def FloorModOptionsEnd(builder): + return builder.EndObject() - # SpaceToBatchNDOptionsT + + +class FloorModOptionsT(object): + + # FloorModOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - spaceToBatchNdoptions = SpaceToBatchNDOptions() - spaceToBatchNdoptions.Init(buf, pos) - return cls.InitFromObj(spaceToBatchNdoptions) + floorModOptions = FloorModOptions() + floorModOptions.Init(buf, pos) + return cls.InitFromObj(floorModOptions) @classmethod - def InitFromObj(cls, spaceToBatchNdoptions): - x = SpaceToBatchNDOptionsT() - x._UnPack(spaceToBatchNdoptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, floorModOptions): + x = FloorModOptionsT() + x._UnPack(floorModOptions) return x - # SpaceToBatchNDOptionsT - def _UnPack(self, spaceToBatchNdoptions): - if spaceToBatchNdoptions is None: + # FloorModOptionsT + def _UnPack(self, floorModOptions): + if floorModOptions is None: return - # SpaceToBatchNDOptionsT + # FloorModOptionsT def Pack(self, builder): - SpaceToBatchNDOptionsStart(builder) - spaceToBatchNdoptions = SpaceToBatchNDOptionsEnd(builder) - return spaceToBatchNdoptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + FloorModOptionsStart(builder) + floorModOptions = FloorModOptionsEnd(builder) + return floorModOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SpaceToDepthOptions(object): +class RangeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SpaceToDepthOptions() + x = RangeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSpaceToDepthOptions(cls, buf, offset=0): + def GetRootAsRangeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SpaceToDepthOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def RangeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SpaceToDepthOptions + # RangeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SpaceToDepthOptions - def BlockSize(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def RangeOptionsStart(builder): + builder.StartObject(0) -def SpaceToDepthOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return SpaceToDepthOptionsStart(builder) -def SpaceToDepthOptionsAddBlockSize(builder, blockSize): builder.PrependInt32Slot(0, blockSize, 0) -def AddBlockSize(builder, blockSize): - return SpaceToDepthOptionsAddBlockSize(builder, blockSize) -def SpaceToDepthOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SpaceToDepthOptionsEnd(builder) +def RangeOptionsEnd(builder): + return builder.EndObject() -class SpaceToDepthOptionsT(object): - # SpaceToDepthOptionsT + +class RangeOptionsT(object): + + # RangeOptionsT def __init__(self): - self.blockSize = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - spaceToDepthOptions = SpaceToDepthOptions() - spaceToDepthOptions.Init(buf, pos) - return cls.InitFromObj(spaceToDepthOptions) + rangeOptions = RangeOptions() + rangeOptions.Init(buf, pos) + return cls.InitFromObj(rangeOptions) @classmethod - def InitFromObj(cls, spaceToDepthOptions): - x = SpaceToDepthOptionsT() - x._UnPack(spaceToDepthOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, rangeOptions): + x = RangeOptionsT() + x._UnPack(rangeOptions) return x - # SpaceToDepthOptionsT - def _UnPack(self, spaceToDepthOptions): - if spaceToDepthOptions is None: + # RangeOptionsT + def _UnPack(self, rangeOptions): + if rangeOptions is None: return - self.blockSize = spaceToDepthOptions.BlockSize() - # SpaceToDepthOptionsT + # RangeOptionsT def Pack(self, builder): - SpaceToDepthOptionsStart(builder) - SpaceToDepthOptionsAddBlockSize(builder, self.blockSize) - spaceToDepthOptions = SpaceToDepthOptionsEnd(builder) - return spaceToDepthOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class SparseIndexVector(object): - NONE = 0 - Int32Vector = 1 - Uint16Vector = 2 - Uint8Vector = 3 - -def SparseIndexVectorCreator(unionType, table): - from flatbuffers.table import Table - if not isinstance(table, Table): - return None - if unionType == SparseIndexVector().Int32Vector: - return Int32VectorT.InitFromBuf(table.Bytes, table.Pos) - if unionType == SparseIndexVector().Uint16Vector: - return Uint16VectorT.InitFromBuf(table.Bytes, table.Pos) - if unionType == SparseIndexVector().Uint8Vector: - return Uint8VectorT.InitFromBuf(table.Bytes, table.Pos) - return None -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + RangeOptionsStart(builder) + rangeOptions = RangeOptionsEnd(builder) + return rangeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SparseToDenseOptions(object): +class LeakyReluOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SparseToDenseOptions() + x = LeakyReluOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSparseToDenseOptions(cls, buf, offset=0): + def GetRootAsLeakyReluOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SparseToDenseOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def LeakyReluOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SparseToDenseOptions + # LeakyReluOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SparseToDenseOptions - def ValidateIndices(self): + # LeakyReluOptions + def Alpha(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 -def SparseToDenseOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return SparseToDenseOptionsStart(builder) -def SparseToDenseOptionsAddValidateIndices(builder, validateIndices): builder.PrependBoolSlot(0, validateIndices, 0) -def AddValidateIndices(builder, validateIndices): - return SparseToDenseOptionsAddValidateIndices(builder, validateIndices) -def SparseToDenseOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SparseToDenseOptionsEnd(builder) +def LeakyReluOptionsStart(builder): + builder.StartObject(1) -class SparseToDenseOptionsT(object): +def LeakyReluOptionsAddAlpha(builder, alpha): + builder.PrependFloat32Slot(0, alpha, 0.0) - # SparseToDenseOptionsT +def LeakyReluOptionsEnd(builder): + return builder.EndObject() + + + +class LeakyReluOptionsT(object): + + # LeakyReluOptionsT def __init__(self): - self.validateIndices = False # type: bool + self.alpha = 0.0 # type: float @classmethod def InitFromBuf(cls, buf, pos): - sparseToDenseOptions = SparseToDenseOptions() - sparseToDenseOptions.Init(buf, pos) - return cls.InitFromObj(sparseToDenseOptions) + leakyReluOptions = LeakyReluOptions() + leakyReluOptions.Init(buf, pos) + return cls.InitFromObj(leakyReluOptions) @classmethod - def InitFromObj(cls, sparseToDenseOptions): - x = SparseToDenseOptionsT() - x._UnPack(sparseToDenseOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, leakyReluOptions): + x = LeakyReluOptionsT() + x._UnPack(leakyReluOptions) return x - # SparseToDenseOptionsT - def _UnPack(self, sparseToDenseOptions): - if sparseToDenseOptions is None: + # LeakyReluOptionsT + def _UnPack(self, leakyReluOptions): + if leakyReluOptions is None: return - self.validateIndices = sparseToDenseOptions.ValidateIndices() + self.alpha = leakyReluOptions.Alpha() - # SparseToDenseOptionsT + # LeakyReluOptionsT def Pack(self, builder): - SparseToDenseOptionsStart(builder) - SparseToDenseOptionsAddValidateIndices(builder, self.validateIndices) - sparseToDenseOptions = SparseToDenseOptionsEnd(builder) - return sparseToDenseOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + LeakyReluOptionsStart(builder) + LeakyReluOptionsAddAlpha(builder, self.alpha) + leakyReluOptions = LeakyReluOptionsEnd(builder) + return leakyReluOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SparsityParameters(object): +class SquaredDifferenceOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SparsityParameters() + x = SquaredDifferenceOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSparsityParameters(cls, buf, offset=0): + def GetRootAsSquaredDifferenceOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SparsityParametersBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SquaredDifferenceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SparsityParameters + # SquaredDifferenceOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SparsityParameters - def TraversalOrder(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - - # SparsityParameters - def TraversalOrderAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # SparsityParameters - def TraversalOrderLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # SparsityParameters - def TraversalOrderIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - - # SparsityParameters - def BlockMap(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - - # SparsityParameters - def BlockMapAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # SparsityParameters - def BlockMapLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # SparsityParameters - def BlockMapIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 - - # SparsityParameters - def DimMetadata(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = DimensionMetadata() - obj.Init(self._tab.Bytes, x) - return obj - return None - - # SparsityParameters - def DimMetadataLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # SparsityParameters - def DimMetadataIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 +def SquaredDifferenceOptionsStart(builder): + builder.StartObject(0) -def SparsityParametersStart(builder): builder.StartObject(3) -def Start(builder): - return SparsityParametersStart(builder) -def SparsityParametersAddTraversalOrder(builder, traversalOrder): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(traversalOrder), 0) -def AddTraversalOrder(builder, traversalOrder): - return SparsityParametersAddTraversalOrder(builder, traversalOrder) -def SparsityParametersStartTraversalOrderVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartTraversalOrderVector(builder, numElems): - return SparsityParametersStartTraversalOrderVector(builder, numElems) -def SparsityParametersAddBlockMap(builder, blockMap): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blockMap), 0) -def AddBlockMap(builder, blockMap): - return SparsityParametersAddBlockMap(builder, blockMap) -def SparsityParametersStartBlockMapVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartBlockMapVector(builder, numElems): - return SparsityParametersStartBlockMapVector(builder, numElems) -def SparsityParametersAddDimMetadata(builder, dimMetadata): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dimMetadata), 0) -def AddDimMetadata(builder, dimMetadata): - return SparsityParametersAddDimMetadata(builder, dimMetadata) -def SparsityParametersStartDimMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartDimMetadataVector(builder, numElems): - return SparsityParametersStartDimMetadataVector(builder, numElems) -def SparsityParametersEnd(builder): return builder.EndObject() -def End(builder): - return SparsityParametersEnd(builder) -try: - from typing import List -except: - pass +def SquaredDifferenceOptionsEnd(builder): + return builder.EndObject() -class SparsityParametersT(object): - # SparsityParametersT + +class SquaredDifferenceOptionsT(object): + + # SquaredDifferenceOptionsT def __init__(self): - self.traversalOrder = None # type: List[int] - self.blockMap = None # type: List[int] - self.dimMetadata = None # type: List[DimensionMetadataT] + pass @classmethod def InitFromBuf(cls, buf, pos): - sparsityParameters = SparsityParameters() - sparsityParameters.Init(buf, pos) - return cls.InitFromObj(sparsityParameters) + squaredDifferenceOptions = SquaredDifferenceOptions() + squaredDifferenceOptions.Init(buf, pos) + return cls.InitFromObj(squaredDifferenceOptions) @classmethod - def InitFromObj(cls, sparsityParameters): - x = SparsityParametersT() - x._UnPack(sparsityParameters) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, squaredDifferenceOptions): + x = SquaredDifferenceOptionsT() + x._UnPack(squaredDifferenceOptions) return x - # SparsityParametersT - def _UnPack(self, sparsityParameters): - if sparsityParameters is None: + # SquaredDifferenceOptionsT + def _UnPack(self, squaredDifferenceOptions): + if squaredDifferenceOptions is None: return - if not sparsityParameters.TraversalOrderIsNone(): - if np is None: - self.traversalOrder = [] - for i in range(sparsityParameters.TraversalOrderLength()): - self.traversalOrder.append(sparsityParameters.TraversalOrder(i)) - else: - self.traversalOrder = sparsityParameters.TraversalOrderAsNumpy() - if not sparsityParameters.BlockMapIsNone(): - if np is None: - self.blockMap = [] - for i in range(sparsityParameters.BlockMapLength()): - self.blockMap.append(sparsityParameters.BlockMap(i)) - else: - self.blockMap = sparsityParameters.BlockMapAsNumpy() - if not sparsityParameters.DimMetadataIsNone(): - self.dimMetadata = [] - for i in range(sparsityParameters.DimMetadataLength()): - if sparsityParameters.DimMetadata(i) is None: - self.dimMetadata.append(None) - else: - dimensionMetadata_ = DimensionMetadataT.InitFromObj(sparsityParameters.DimMetadata(i)) - self.dimMetadata.append(dimensionMetadata_) - # SparsityParametersT + # SquaredDifferenceOptionsT def Pack(self, builder): - if self.traversalOrder is not None: - if np is not None and type(self.traversalOrder) is np.ndarray: - traversalOrder = builder.CreateNumpyVector(self.traversalOrder) - else: - SparsityParametersStartTraversalOrderVector(builder, len(self.traversalOrder)) - for i in reversed(range(len(self.traversalOrder))): - builder.PrependInt32(self.traversalOrder[i]) - traversalOrder = builder.EndVector() - if self.blockMap is not None: - if np is not None and type(self.blockMap) is np.ndarray: - blockMap = builder.CreateNumpyVector(self.blockMap) - else: - SparsityParametersStartBlockMapVector(builder, len(self.blockMap)) - for i in reversed(range(len(self.blockMap))): - builder.PrependInt32(self.blockMap[i]) - blockMap = builder.EndVector() - if self.dimMetadata is not None: - dimMetadatalist = [] - for i in range(len(self.dimMetadata)): - dimMetadatalist.append(self.dimMetadata[i].Pack(builder)) - SparsityParametersStartDimMetadataVector(builder, len(self.dimMetadata)) - for i in reversed(range(len(self.dimMetadata))): - builder.PrependUOffsetTRelative(dimMetadatalist[i]) - dimMetadata = builder.EndVector() - SparsityParametersStart(builder) - if self.traversalOrder is not None: - SparsityParametersAddTraversalOrder(builder, traversalOrder) - if self.blockMap is not None: - SparsityParametersAddBlockMap(builder, blockMap) - if self.dimMetadata is not None: - SparsityParametersAddDimMetadata(builder, dimMetadata) - sparsityParameters = SparsityParametersEnd(builder) - return sparsityParameters -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SquaredDifferenceOptionsStart(builder) + squaredDifferenceOptions = SquaredDifferenceOptionsEnd(builder) + return squaredDifferenceOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SplitOptions(object): +class MirrorPadOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SplitOptions() + x = MirrorPadOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSplitOptions(cls, buf, offset=0): + def GetRootAsMirrorPadOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SplitOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def MirrorPadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SplitOptions + # MirrorPadOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SplitOptions - def NumSplits(self): + # MirrorPadOptions + def Mode(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 -def SplitOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return SplitOptionsStart(builder) -def SplitOptionsAddNumSplits(builder, numSplits): builder.PrependInt32Slot(0, numSplits, 0) -def AddNumSplits(builder, numSplits): - return SplitOptionsAddNumSplits(builder, numSplits) -def SplitOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SplitOptionsEnd(builder) +def MirrorPadOptionsStart(builder): + builder.StartObject(1) -class SplitOptionsT(object): +def MirrorPadOptionsAddMode(builder, mode): + builder.PrependInt8Slot(0, mode, 0) - # SplitOptionsT +def MirrorPadOptionsEnd(builder): + return builder.EndObject() + + + +class MirrorPadOptionsT(object): + + # MirrorPadOptionsT def __init__(self): - self.numSplits = 0 # type: int + self.mode = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - splitOptions = SplitOptions() - splitOptions.Init(buf, pos) - return cls.InitFromObj(splitOptions) + mirrorPadOptions = MirrorPadOptions() + mirrorPadOptions.Init(buf, pos) + return cls.InitFromObj(mirrorPadOptions) @classmethod - def InitFromObj(cls, splitOptions): - x = SplitOptionsT() - x._UnPack(splitOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, mirrorPadOptions): + x = MirrorPadOptionsT() + x._UnPack(mirrorPadOptions) return x - # SplitOptionsT - def _UnPack(self, splitOptions): - if splitOptions is None: + # MirrorPadOptionsT + def _UnPack(self, mirrorPadOptions): + if mirrorPadOptions is None: return - self.numSplits = splitOptions.NumSplits() + self.mode = mirrorPadOptions.Mode() - # SplitOptionsT + # MirrorPadOptionsT def Pack(self, builder): - SplitOptionsStart(builder) - SplitOptionsAddNumSplits(builder, self.numSplits) - splitOptions = SplitOptionsEnd(builder) - return splitOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + MirrorPadOptionsStart(builder) + MirrorPadOptionsAddMode(builder, self.mode) + mirrorPadOptions = MirrorPadOptionsEnd(builder) + return mirrorPadOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SplitVOptions(object): +class UniqueOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SplitVOptions() + x = UniqueOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSplitVOptions(cls, buf, offset=0): + def GetRootAsUniqueOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SplitVOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def UniqueOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SplitVOptions + # UniqueOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SplitVOptions - def NumSplits(self): + # UniqueOptions + def IdxOutType(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 2 -def SplitVOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return SplitVOptionsStart(builder) -def SplitVOptionsAddNumSplits(builder, numSplits): builder.PrependInt32Slot(0, numSplits, 0) -def AddNumSplits(builder, numSplits): - return SplitVOptionsAddNumSplits(builder, numSplits) -def SplitVOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SplitVOptionsEnd(builder) +def UniqueOptionsStart(builder): + builder.StartObject(1) -class SplitVOptionsT(object): +def UniqueOptionsAddIdxOutType(builder, idxOutType): + builder.PrependInt8Slot(0, idxOutType, 2) - # SplitVOptionsT +def UniqueOptionsEnd(builder): + return builder.EndObject() + + + +class UniqueOptionsT(object): + + # UniqueOptionsT def __init__(self): - self.numSplits = 0 # type: int + self.idxOutType = 2 # type: int @classmethod def InitFromBuf(cls, buf, pos): - splitVoptions = SplitVOptions() - splitVoptions.Init(buf, pos) - return cls.InitFromObj(splitVoptions) + uniqueOptions = UniqueOptions() + uniqueOptions.Init(buf, pos) + return cls.InitFromObj(uniqueOptions) @classmethod - def InitFromObj(cls, splitVoptions): - x = SplitVOptionsT() - x._UnPack(splitVoptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, uniqueOptions): + x = UniqueOptionsT() + x._UnPack(uniqueOptions) return x - # SplitVOptionsT - def _UnPack(self, splitVoptions): - if splitVoptions is None: + # UniqueOptionsT + def _UnPack(self, uniqueOptions): + if uniqueOptions is None: return - self.numSplits = splitVoptions.NumSplits() + self.idxOutType = uniqueOptions.IdxOutType() - # SplitVOptionsT + # UniqueOptionsT def Pack(self, builder): - SplitVOptionsStart(builder) - SplitVOptionsAddNumSplits(builder, self.numSplits) - splitVoptions = SplitVOptionsEnd(builder) - return splitVoptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + UniqueOptionsStart(builder) + UniqueOptionsAddIdxOutType(builder, self.idxOutType) + uniqueOptions = UniqueOptionsEnd(builder) + return uniqueOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SquareOptions(object): +class ReverseV2Options(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SquareOptions() + x = ReverseV2Options() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSquareOptions(cls, buf, offset=0): + def GetRootAsReverseV2Options(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SquareOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ReverseV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SquareOptions + # ReverseV2Options def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def SquareOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return SquareOptionsStart(builder) -def SquareOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SquareOptionsEnd(builder) +def ReverseV2OptionsStart(builder): + builder.StartObject(0) -class SquareOptionsT(object): +def ReverseV2OptionsEnd(builder): + return builder.EndObject() - # SquareOptionsT + + +class ReverseV2OptionsT(object): + + # ReverseV2OptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - squareOptions = SquareOptions() - squareOptions.Init(buf, pos) - return cls.InitFromObj(squareOptions) + reverseV2Options = ReverseV2Options() + reverseV2Options.Init(buf, pos) + return cls.InitFromObj(reverseV2Options) @classmethod - def InitFromObj(cls, squareOptions): - x = SquareOptionsT() - x._UnPack(squareOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, reverseV2Options): + x = ReverseV2OptionsT() + x._UnPack(reverseV2Options) return x - # SquareOptionsT - def _UnPack(self, squareOptions): - if squareOptions is None: + # ReverseV2OptionsT + def _UnPack(self, reverseV2Options): + if reverseV2Options is None: return - # SquareOptionsT + # ReverseV2OptionsT def Pack(self, builder): - SquareOptionsStart(builder) - squareOptions = SquareOptionsEnd(builder) - return squareOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ReverseV2OptionsStart(builder) + reverseV2Options = ReverseV2OptionsEnd(builder) + return reverseV2Options -from flatbuffers.compat import import_numpy -np = import_numpy() -class SquaredDifferenceOptions(object): +class AddNOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SquaredDifferenceOptions() + x = AddNOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSquaredDifferenceOptions(cls, buf, offset=0): + def GetRootAsAddNOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SquaredDifferenceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def AddNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SquaredDifferenceOptions + # AddNOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def SquaredDifferenceOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return SquaredDifferenceOptionsStart(builder) -def SquaredDifferenceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SquaredDifferenceOptionsEnd(builder) +def AddNOptionsStart(builder): + builder.StartObject(0) -class SquaredDifferenceOptionsT(object): +def AddNOptionsEnd(builder): + return builder.EndObject() - # SquaredDifferenceOptionsT + + +class AddNOptionsT(object): + + # AddNOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - squaredDifferenceOptions = SquaredDifferenceOptions() - squaredDifferenceOptions.Init(buf, pos) - return cls.InitFromObj(squaredDifferenceOptions) + addNoptions = AddNOptions() + addNoptions.Init(buf, pos) + return cls.InitFromObj(addNoptions) @classmethod - def InitFromObj(cls, squaredDifferenceOptions): - x = SquaredDifferenceOptionsT() - x._UnPack(squaredDifferenceOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, addNoptions): + x = AddNOptionsT() + x._UnPack(addNoptions) return x - # SquaredDifferenceOptionsT - def _UnPack(self, squaredDifferenceOptions): - if squaredDifferenceOptions is None: + # AddNOptionsT + def _UnPack(self, addNoptions): + if addNoptions is None: return - # SquaredDifferenceOptionsT + # AddNOptionsT def Pack(self, builder): - SquaredDifferenceOptionsStart(builder) - squaredDifferenceOptions = SquaredDifferenceOptionsEnd(builder) - return squaredDifferenceOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + AddNOptionsStart(builder) + addNoptions = AddNOptionsEnd(builder) + return addNoptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SqueezeOptions(object): +class GatherNdOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SqueezeOptions() + x = GatherNdOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSqueezeOptions(cls, buf, offset=0): + def GetRootAsGatherNdOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SqueezeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def GatherNdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SqueezeOptions + # GatherNdOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SqueezeOptions - def SqueezeDims(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - - # SqueezeOptions - def SqueezeDimsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 +def GatherNdOptionsStart(builder): + builder.StartObject(0) - # SqueezeOptions - def SqueezeDimsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def GatherNdOptionsEnd(builder): + return builder.EndObject() - # SqueezeOptions - def SqueezeDimsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 -def SqueezeOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return SqueezeOptionsStart(builder) -def SqueezeOptionsAddSqueezeDims(builder, squeezeDims): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(squeezeDims), 0) -def AddSqueezeDims(builder, squeezeDims): - return SqueezeOptionsAddSqueezeDims(builder, squeezeDims) -def SqueezeOptionsStartSqueezeDimsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartSqueezeDimsVector(builder, numElems): - return SqueezeOptionsStartSqueezeDimsVector(builder, numElems) -def SqueezeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SqueezeOptionsEnd(builder) -try: - from typing import List -except: - pass -class SqueezeOptionsT(object): +class GatherNdOptionsT(object): - # SqueezeOptionsT + # GatherNdOptionsT def __init__(self): - self.squeezeDims = None # type: List[int] + pass @classmethod def InitFromBuf(cls, buf, pos): - squeezeOptions = SqueezeOptions() - squeezeOptions.Init(buf, pos) - return cls.InitFromObj(squeezeOptions) + gatherNdOptions = GatherNdOptions() + gatherNdOptions.Init(buf, pos) + return cls.InitFromObj(gatherNdOptions) @classmethod - def InitFromObj(cls, squeezeOptions): - x = SqueezeOptionsT() - x._UnPack(squeezeOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, gatherNdOptions): + x = GatherNdOptionsT() + x._UnPack(gatherNdOptions) return x - # SqueezeOptionsT - def _UnPack(self, squeezeOptions): - if squeezeOptions is None: + # GatherNdOptionsT + def _UnPack(self, gatherNdOptions): + if gatherNdOptions is None: return - if not squeezeOptions.SqueezeDimsIsNone(): - if np is None: - self.squeezeDims = [] - for i in range(squeezeOptions.SqueezeDimsLength()): - self.squeezeDims.append(squeezeOptions.SqueezeDims(i)) - else: - self.squeezeDims = squeezeOptions.SqueezeDimsAsNumpy() - # SqueezeOptionsT + # GatherNdOptionsT def Pack(self, builder): - if self.squeezeDims is not None: - if np is not None and type(self.squeezeDims) is np.ndarray: - squeezeDims = builder.CreateNumpyVector(self.squeezeDims) - else: - SqueezeOptionsStartSqueezeDimsVector(builder, len(self.squeezeDims)) - for i in reversed(range(len(self.squeezeDims))): - builder.PrependInt32(self.squeezeDims[i]) - squeezeDims = builder.EndVector() - SqueezeOptionsStart(builder) - if self.squeezeDims is not None: - SqueezeOptionsAddSqueezeDims(builder, squeezeDims) - squeezeOptions = SqueezeOptionsEnd(builder) - return squeezeOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + GatherNdOptionsStart(builder) + gatherNdOptions = GatherNdOptionsEnd(builder) + return gatherNdOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloBroadcastInDimOptions(object): +class WhereOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloBroadcastInDimOptions() + x = WhereOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloBroadcastInDimOptions(cls, buf, offset=0): + def GetRootAsWhereOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloBroadcastInDimOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def WhereOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloBroadcastInDimOptions + # WhereOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloBroadcastInDimOptions - def BroadcastDimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloBroadcastInDimOptions - def BroadcastDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 +def WhereOptionsStart(builder): + builder.StartObject(0) - # StablehloBroadcastInDimOptions - def BroadcastDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def WhereOptionsEnd(builder): + return builder.EndObject() - # StablehloBroadcastInDimOptions - def BroadcastDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 -def StablehloBroadcastInDimOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return StablehloBroadcastInDimOptionsStart(builder) -def StablehloBroadcastInDimOptionsAddBroadcastDimensions(builder, broadcastDimensions): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(broadcastDimensions), 0) -def AddBroadcastDimensions(builder, broadcastDimensions): - return StablehloBroadcastInDimOptionsAddBroadcastDimensions(builder, broadcastDimensions) -def StablehloBroadcastInDimOptionsStartBroadcastDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartBroadcastDimensionsVector(builder, numElems): - return StablehloBroadcastInDimOptionsStartBroadcastDimensionsVector(builder, numElems) -def StablehloBroadcastInDimOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloBroadcastInDimOptionsEnd(builder) -try: - from typing import List -except: - pass -class StablehloBroadcastInDimOptionsT(object): +class WhereOptionsT(object): - # StablehloBroadcastInDimOptionsT + # WhereOptionsT def __init__(self): - self.broadcastDimensions = None # type: List[int] + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloBroadcastInDimOptions = StablehloBroadcastInDimOptions() - stablehloBroadcastInDimOptions.Init(buf, pos) - return cls.InitFromObj(stablehloBroadcastInDimOptions) + whereOptions = WhereOptions() + whereOptions.Init(buf, pos) + return cls.InitFromObj(whereOptions) @classmethod - def InitFromObj(cls, stablehloBroadcastInDimOptions): - x = StablehloBroadcastInDimOptionsT() - x._UnPack(stablehloBroadcastInDimOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, whereOptions): + x = WhereOptionsT() + x._UnPack(whereOptions) return x - # StablehloBroadcastInDimOptionsT - def _UnPack(self, stablehloBroadcastInDimOptions): - if stablehloBroadcastInDimOptions is None: + # WhereOptionsT + def _UnPack(self, whereOptions): + if whereOptions is None: return - if not stablehloBroadcastInDimOptions.BroadcastDimensionsIsNone(): - if np is None: - self.broadcastDimensions = [] - for i in range(stablehloBroadcastInDimOptions.BroadcastDimensionsLength()): - self.broadcastDimensions.append(stablehloBroadcastInDimOptions.BroadcastDimensions(i)) - else: - self.broadcastDimensions = stablehloBroadcastInDimOptions.BroadcastDimensionsAsNumpy() - # StablehloBroadcastInDimOptionsT + # WhereOptionsT def Pack(self, builder): - if self.broadcastDimensions is not None: - if np is not None and type(self.broadcastDimensions) is np.ndarray: - broadcastDimensions = builder.CreateNumpyVector(self.broadcastDimensions) - else: - StablehloBroadcastInDimOptionsStartBroadcastDimensionsVector(builder, len(self.broadcastDimensions)) - for i in reversed(range(len(self.broadcastDimensions))): - builder.PrependInt64(self.broadcastDimensions[i]) - broadcastDimensions = builder.EndVector() - StablehloBroadcastInDimOptionsStart(builder) - if self.broadcastDimensions is not None: - StablehloBroadcastInDimOptionsAddBroadcastDimensions(builder, broadcastDimensions) - stablehloBroadcastInDimOptions = StablehloBroadcastInDimOptionsEnd(builder) - return stablehloBroadcastInDimOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + WhereOptionsStart(builder) + whereOptions = WhereOptionsEnd(builder) + return whereOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloCompareOptions(object): +class ReverseSequenceOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloCompareOptions() + x = ReverseSequenceOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloCompareOptions(cls, buf, offset=0): + def GetRootAsReverseSequenceOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloCompareOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ReverseSequenceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloCompareOptions + # ReverseSequenceOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloCompareOptions - def ComparisonDirection(self): + # ReverseSequenceOptions + def SeqDim(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # StablehloCompareOptions - def CompareType(self): + # ReverseSequenceOptions + def BatchDim(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def StablehloCompareOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return StablehloCompareOptionsStart(builder) -def StablehloCompareOptionsAddComparisonDirection(builder, comparisonDirection): builder.PrependUint32Slot(0, comparisonDirection, 0) -def AddComparisonDirection(builder, comparisonDirection): - return StablehloCompareOptionsAddComparisonDirection(builder, comparisonDirection) -def StablehloCompareOptionsAddCompareType(builder, compareType): builder.PrependUint32Slot(1, compareType, 0) -def AddCompareType(builder, compareType): - return StablehloCompareOptionsAddCompareType(builder, compareType) -def StablehloCompareOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloCompareOptionsEnd(builder) +def ReverseSequenceOptionsStart(builder): + builder.StartObject(2) -class StablehloCompareOptionsT(object): +def ReverseSequenceOptionsAddSeqDim(builder, seqDim): + builder.PrependInt32Slot(0, seqDim, 0) - # StablehloCompareOptionsT +def ReverseSequenceOptionsAddBatchDim(builder, batchDim): + builder.PrependInt32Slot(1, batchDim, 0) + +def ReverseSequenceOptionsEnd(builder): + return builder.EndObject() + + + +class ReverseSequenceOptionsT(object): + + # ReverseSequenceOptionsT def __init__(self): - self.comparisonDirection = 0 # type: int - self.compareType = 0 # type: int + self.seqDim = 0 # type: int + self.batchDim = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - stablehloCompareOptions = StablehloCompareOptions() - stablehloCompareOptions.Init(buf, pos) - return cls.InitFromObj(stablehloCompareOptions) + reverseSequenceOptions = ReverseSequenceOptions() + reverseSequenceOptions.Init(buf, pos) + return cls.InitFromObj(reverseSequenceOptions) @classmethod - def InitFromObj(cls, stablehloCompareOptions): - x = StablehloCompareOptionsT() - x._UnPack(stablehloCompareOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, reverseSequenceOptions): + x = ReverseSequenceOptionsT() + x._UnPack(reverseSequenceOptions) return x - # StablehloCompareOptionsT - def _UnPack(self, stablehloCompareOptions): - if stablehloCompareOptions is None: + # ReverseSequenceOptionsT + def _UnPack(self, reverseSequenceOptions): + if reverseSequenceOptions is None: return - self.comparisonDirection = stablehloCompareOptions.ComparisonDirection() - self.compareType = stablehloCompareOptions.CompareType() + self.seqDim = reverseSequenceOptions.SeqDim() + self.batchDim = reverseSequenceOptions.BatchDim() - # StablehloCompareOptionsT + # ReverseSequenceOptionsT def Pack(self, builder): - StablehloCompareOptionsStart(builder) - StablehloCompareOptionsAddComparisonDirection(builder, self.comparisonDirection) - StablehloCompareOptionsAddCompareType(builder, self.compareType) - stablehloCompareOptions = StablehloCompareOptionsEnd(builder) - return stablehloCompareOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class StablehloComparisonDirection(object): - STABLEHLO_COMPARISON_DIRECTION_EQ = 0 - STABLEHLO_COMPARISON_DIRECTION_NE = 1 - STABLEHLO_COMPARISON_DIRECTION_GE = 2 - STABLEHLO_COMPARISON_DIRECTION_GT = 3 - STABLEHLO_COMPARISON_DIRECTION_LE = 4 - STABLEHLO_COMPARISON_DIRECTION_LT = 5 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite - -class StablehloComparisonType(object): - STABLEHLO_COMPARISON_TYPE_NOTYPE = 0 - STABLEHLO_COMPARISON_TYPE_FLOAT = 1 - STABLEHLO_COMPARISON_TYPE_FLOAT_TOTAL_ORDER = 2 - STABLEHLO_COMPARISON_TYPE_SIGNED = 3 - STABLEHLO_COMPARISON_TYPE_UNSIGNED = 4 -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ReverseSequenceOptionsStart(builder) + ReverseSequenceOptionsAddSeqDim(builder, self.seqDim) + ReverseSequenceOptionsAddBatchDim(builder, self.batchDim) + reverseSequenceOptions = ReverseSequenceOptionsEnd(builder) + return reverseSequenceOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloConcatenateOptions(object): +class MatrixDiagOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloConcatenateOptions() + x = MatrixDiagOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloConcatenateOptions(cls, buf, offset=0): + def GetRootAsMatrixDiagOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloConcatenateOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def MatrixDiagOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloConcatenateOptions + # MatrixDiagOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloConcatenateOptions - def Dimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 +def MatrixDiagOptionsStart(builder): + builder.StartObject(0) -def StablehloConcatenateOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return StablehloConcatenateOptionsStart(builder) -def StablehloConcatenateOptionsAddDimension(builder, dimension): builder.PrependInt64Slot(0, dimension, 0) -def AddDimension(builder, dimension): - return StablehloConcatenateOptionsAddDimension(builder, dimension) -def StablehloConcatenateOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloConcatenateOptionsEnd(builder) +def MatrixDiagOptionsEnd(builder): + return builder.EndObject() -class StablehloConcatenateOptionsT(object): - # StablehloConcatenateOptionsT + +class MatrixDiagOptionsT(object): + + # MatrixDiagOptionsT def __init__(self): - self.dimension = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloConcatenateOptions = StablehloConcatenateOptions() - stablehloConcatenateOptions.Init(buf, pos) - return cls.InitFromObj(stablehloConcatenateOptions) + matrixDiagOptions = MatrixDiagOptions() + matrixDiagOptions.Init(buf, pos) + return cls.InitFromObj(matrixDiagOptions) @classmethod - def InitFromObj(cls, stablehloConcatenateOptions): - x = StablehloConcatenateOptionsT() - x._UnPack(stablehloConcatenateOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, matrixDiagOptions): + x = MatrixDiagOptionsT() + x._UnPack(matrixDiagOptions) return x - # StablehloConcatenateOptionsT - def _UnPack(self, stablehloConcatenateOptions): - if stablehloConcatenateOptions is None: + # MatrixDiagOptionsT + def _UnPack(self, matrixDiagOptions): + if matrixDiagOptions is None: return - self.dimension = stablehloConcatenateOptions.Dimension() - # StablehloConcatenateOptionsT + # MatrixDiagOptionsT def Pack(self, builder): - StablehloConcatenateOptionsStart(builder) - StablehloConcatenateOptionsAddDimension(builder, self.dimension) - stablehloConcatenateOptions = StablehloConcatenateOptionsEnd(builder) - return stablehloConcatenateOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + MatrixDiagOptionsStart(builder) + matrixDiagOptions = MatrixDiagOptionsEnd(builder) + return matrixDiagOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloConvolutionOptions(object): +class QuantizeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloConvolutionOptions() + x = QuantizeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloConvolutionOptions(cls, buf, offset=0): + def GetRootAsQuantizeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloConvolutionOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def QuantizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloConvolutionOptions + # QuantizeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloConvolutionOptions - def WindowStrides(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloConvolutionOptions - def WindowStridesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloConvolutionOptions - def WindowStridesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloConvolutionOptions - def WindowStridesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - - # StablehloConvolutionOptions - def Padding(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloConvolutionOptions - def PaddingAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloConvolutionOptions - def PaddingLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloConvolutionOptions - def PaddingIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 - - # StablehloConvolutionOptions - def LhsDilation(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 +def QuantizeOptionsStart(builder): + builder.StartObject(0) - # StablehloConvolutionOptions - def LhsDilationAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 +def QuantizeOptionsEnd(builder): + return builder.EndObject() - # StablehloConvolutionOptions - def LhsDilationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - # StablehloConvolutionOptions - def LhsDilationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 - # StablehloConvolutionOptions - def RhsDilation(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 +class QuantizeOptionsT(object): - # StablehloConvolutionOptions - def RhsDilationAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 + # QuantizeOptionsT + def __init__(self): + pass - # StablehloConvolutionOptions - def RhsDilationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + @classmethod + def InitFromBuf(cls, buf, pos): + quantizeOptions = QuantizeOptions() + quantizeOptions.Init(buf, pos) + return cls.InitFromObj(quantizeOptions) - # StablehloConvolutionOptions - def RhsDilationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - return o == 0 + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # StablehloConvolutionOptions - def WindowReversal(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) - return 0 + @classmethod + def InitFromObj(cls, quantizeOptions): + x = QuantizeOptionsT() + x._UnPack(quantizeOptions) + return x - # StablehloConvolutionOptions - def WindowReversalAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o) - return 0 + # QuantizeOptionsT + def _UnPack(self, quantizeOptions): + if quantizeOptions is None: + return - # StablehloConvolutionOptions - def WindowReversalLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + # QuantizeOptionsT + def Pack(self, builder): + QuantizeOptionsStart(builder) + quantizeOptions = QuantizeOptionsEnd(builder) + return quantizeOptions - # StablehloConvolutionOptions - def WindowReversalIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - return o == 0 - # StablehloConvolutionOptions - def InputBatchDimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 +class MatrixSetDiagOptions(object): + __slots__ = ['_tab'] - # StablehloConvolutionOptions - def InputFeatureDimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MatrixSetDiagOptions() + x.Init(buf, n + offset) + return x - # StablehloConvolutionOptions - def InputSpatialDimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 + @classmethod + def GetRootAsMatrixSetDiagOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def MatrixSetDiagOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloConvolutionOptions - def InputSpatialDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 + # MatrixSetDiagOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) - # StablehloConvolutionOptions - def InputSpatialDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def MatrixSetDiagOptionsStart(builder): + builder.StartObject(0) - # StablehloConvolutionOptions - def InputSpatialDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - return o == 0 +def MatrixSetDiagOptionsEnd(builder): + return builder.EndObject() - # StablehloConvolutionOptions - def KernelInputFeatureDimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 - # StablehloConvolutionOptions - def KernelOutputFeatureDimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 - # StablehloConvolutionOptions - def KernelSpatialDimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 +class MatrixSetDiagOptionsT(object): - # StablehloConvolutionOptions - def KernelSpatialDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 + # MatrixSetDiagOptionsT + def __init__(self): + pass - # StablehloConvolutionOptions - def KernelSpatialDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + @classmethod + def InitFromBuf(cls, buf, pos): + matrixSetDiagOptions = MatrixSetDiagOptions() + matrixSetDiagOptions.Init(buf, pos) + return cls.InitFromObj(matrixSetDiagOptions) - # StablehloConvolutionOptions - def KernelSpatialDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) - return o == 0 + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # StablehloConvolutionOptions - def OutputBatchDimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 + @classmethod + def InitFromObj(cls, matrixSetDiagOptions): + x = MatrixSetDiagOptionsT() + x._UnPack(matrixSetDiagOptions) + return x - # StablehloConvolutionOptions - def OutputFeatureDimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 + # MatrixSetDiagOptionsT + def _UnPack(self, matrixSetDiagOptions): + if matrixSetDiagOptions is None: + return - # StablehloConvolutionOptions - def OutputSpatialDimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 + # MatrixSetDiagOptionsT + def Pack(self, builder): + MatrixSetDiagOptionsStart(builder) + matrixSetDiagOptions = MatrixSetDiagOptionsEnd(builder) + return matrixSetDiagOptions - # StablehloConvolutionOptions - def OutputSpatialDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - # StablehloConvolutionOptions - def OutputSpatialDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class IfOptions(object): + __slots__ = ['_tab'] - # StablehloConvolutionOptions - def OutputSpatialDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) - return o == 0 + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = IfOptions() + x.Init(buf, n + offset) + return x - # StablehloConvolutionOptions - def FeatureGroupCount(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 + @classmethod + def GetRootAsIfOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def IfOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloConvolutionOptions - def BatchGroupCount(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 + # IfOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) - # StablehloConvolutionOptions - def PrecisionConfig(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) + # IfOptions + def ThenSubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # StablehloConvolutionOptions - def PrecisionConfigAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) + # IfOptions + def ElseSubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # StablehloConvolutionOptions - def PrecisionConfigLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def IfOptionsStart(builder): + builder.StartObject(2) + +def IfOptionsAddThenSubgraphIndex(builder, thenSubgraphIndex): + builder.PrependInt32Slot(0, thenSubgraphIndex, 0) - # StablehloConvolutionOptions - def PrecisionConfigIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) - return o == 0 +def IfOptionsAddElseSubgraphIndex(builder, elseSubgraphIndex): + builder.PrependInt32Slot(1, elseSubgraphIndex, 0) -def StablehloConvolutionOptionsStart(builder): builder.StartObject(17) -def Start(builder): - return StablehloConvolutionOptionsStart(builder) -def StablehloConvolutionOptionsAddWindowStrides(builder, windowStrides): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(windowStrides), 0) -def AddWindowStrides(builder, windowStrides): - return StablehloConvolutionOptionsAddWindowStrides(builder, windowStrides) -def StablehloConvolutionOptionsStartWindowStridesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartWindowStridesVector(builder, numElems): - return StablehloConvolutionOptionsStartWindowStridesVector(builder, numElems) -def StablehloConvolutionOptionsAddPadding(builder, padding): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) -def AddPadding(builder, padding): - return StablehloConvolutionOptionsAddPadding(builder, padding) -def StablehloConvolutionOptionsStartPaddingVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartPaddingVector(builder, numElems): - return StablehloConvolutionOptionsStartPaddingVector(builder, numElems) -def StablehloConvolutionOptionsAddLhsDilation(builder, lhsDilation): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(lhsDilation), 0) -def AddLhsDilation(builder, lhsDilation): - return StablehloConvolutionOptionsAddLhsDilation(builder, lhsDilation) -def StablehloConvolutionOptionsStartLhsDilationVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartLhsDilationVector(builder, numElems): - return StablehloConvolutionOptionsStartLhsDilationVector(builder, numElems) -def StablehloConvolutionOptionsAddRhsDilation(builder, rhsDilation): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(rhsDilation), 0) -def AddRhsDilation(builder, rhsDilation): - return StablehloConvolutionOptionsAddRhsDilation(builder, rhsDilation) -def StablehloConvolutionOptionsStartRhsDilationVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartRhsDilationVector(builder, numElems): - return StablehloConvolutionOptionsStartRhsDilationVector(builder, numElems) -def StablehloConvolutionOptionsAddWindowReversal(builder, windowReversal): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(windowReversal), 0) -def AddWindowReversal(builder, windowReversal): - return StablehloConvolutionOptionsAddWindowReversal(builder, windowReversal) -def StablehloConvolutionOptionsStartWindowReversalVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def StartWindowReversalVector(builder, numElems): - return StablehloConvolutionOptionsStartWindowReversalVector(builder, numElems) -def StablehloConvolutionOptionsAddInputBatchDimension(builder, inputBatchDimension): builder.PrependInt64Slot(5, inputBatchDimension, 0) -def AddInputBatchDimension(builder, inputBatchDimension): - return StablehloConvolutionOptionsAddInputBatchDimension(builder, inputBatchDimension) -def StablehloConvolutionOptionsAddInputFeatureDimension(builder, inputFeatureDimension): builder.PrependInt64Slot(6, inputFeatureDimension, 0) -def AddInputFeatureDimension(builder, inputFeatureDimension): - return StablehloConvolutionOptionsAddInputFeatureDimension(builder, inputFeatureDimension) -def StablehloConvolutionOptionsAddInputSpatialDimensions(builder, inputSpatialDimensions): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(inputSpatialDimensions), 0) -def AddInputSpatialDimensions(builder, inputSpatialDimensions): - return StablehloConvolutionOptionsAddInputSpatialDimensions(builder, inputSpatialDimensions) -def StablehloConvolutionOptionsStartInputSpatialDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartInputSpatialDimensionsVector(builder, numElems): - return StablehloConvolutionOptionsStartInputSpatialDimensionsVector(builder, numElems) -def StablehloConvolutionOptionsAddKernelInputFeatureDimension(builder, kernelInputFeatureDimension): builder.PrependInt64Slot(8, kernelInputFeatureDimension, 0) -def AddKernelInputFeatureDimension(builder, kernelInputFeatureDimension): - return StablehloConvolutionOptionsAddKernelInputFeatureDimension(builder, kernelInputFeatureDimension) -def StablehloConvolutionOptionsAddKernelOutputFeatureDimension(builder, kernelOutputFeatureDimension): builder.PrependInt64Slot(9, kernelOutputFeatureDimension, 0) -def AddKernelOutputFeatureDimension(builder, kernelOutputFeatureDimension): - return StablehloConvolutionOptionsAddKernelOutputFeatureDimension(builder, kernelOutputFeatureDimension) -def StablehloConvolutionOptionsAddKernelSpatialDimensions(builder, kernelSpatialDimensions): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(kernelSpatialDimensions), 0) -def AddKernelSpatialDimensions(builder, kernelSpatialDimensions): - return StablehloConvolutionOptionsAddKernelSpatialDimensions(builder, kernelSpatialDimensions) -def StablehloConvolutionOptionsStartKernelSpatialDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartKernelSpatialDimensionsVector(builder, numElems): - return StablehloConvolutionOptionsStartKernelSpatialDimensionsVector(builder, numElems) -def StablehloConvolutionOptionsAddOutputBatchDimension(builder, outputBatchDimension): builder.PrependInt64Slot(11, outputBatchDimension, 0) -def AddOutputBatchDimension(builder, outputBatchDimension): - return StablehloConvolutionOptionsAddOutputBatchDimension(builder, outputBatchDimension) -def StablehloConvolutionOptionsAddOutputFeatureDimension(builder, outputFeatureDimension): builder.PrependInt64Slot(12, outputFeatureDimension, 0) -def AddOutputFeatureDimension(builder, outputFeatureDimension): - return StablehloConvolutionOptionsAddOutputFeatureDimension(builder, outputFeatureDimension) -def StablehloConvolutionOptionsAddOutputSpatialDimensions(builder, outputSpatialDimensions): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(outputSpatialDimensions), 0) -def AddOutputSpatialDimensions(builder, outputSpatialDimensions): - return StablehloConvolutionOptionsAddOutputSpatialDimensions(builder, outputSpatialDimensions) -def StablehloConvolutionOptionsStartOutputSpatialDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartOutputSpatialDimensionsVector(builder, numElems): - return StablehloConvolutionOptionsStartOutputSpatialDimensionsVector(builder, numElems) -def StablehloConvolutionOptionsAddFeatureGroupCount(builder, featureGroupCount): builder.PrependInt64Slot(14, featureGroupCount, 0) -def AddFeatureGroupCount(builder, featureGroupCount): - return StablehloConvolutionOptionsAddFeatureGroupCount(builder, featureGroupCount) -def StablehloConvolutionOptionsAddBatchGroupCount(builder, batchGroupCount): builder.PrependInt64Slot(15, batchGroupCount, 0) -def AddBatchGroupCount(builder, batchGroupCount): - return StablehloConvolutionOptionsAddBatchGroupCount(builder, batchGroupCount) -def StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(precisionConfig), 0) -def AddPrecisionConfig(builder, precisionConfig): - return StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig) -def StablehloConvolutionOptionsStartPrecisionConfigVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartPrecisionConfigVector(builder, numElems): - return StablehloConvolutionOptionsStartPrecisionConfigVector(builder, numElems) -def StablehloConvolutionOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloConvolutionOptionsEnd(builder) -try: - from typing import List -except: - pass +def IfOptionsEnd(builder): + return builder.EndObject() -class StablehloConvolutionOptionsT(object): - # StablehloConvolutionOptionsT + +class IfOptionsT(object): + + # IfOptionsT def __init__(self): - self.windowStrides = None # type: List[int] - self.padding = None # type: List[int] - self.lhsDilation = None # type: List[int] - self.rhsDilation = None # type: List[int] - self.windowReversal = None # type: List[bool] - self.inputBatchDimension = 0 # type: int - self.inputFeatureDimension = 0 # type: int - self.inputSpatialDimensions = None # type: List[int] - self.kernelInputFeatureDimension = 0 # type: int - self.kernelOutputFeatureDimension = 0 # type: int - self.kernelSpatialDimensions = None # type: List[int] - self.outputBatchDimension = 0 # type: int - self.outputFeatureDimension = 0 # type: int - self.outputSpatialDimensions = None # type: List[int] - self.featureGroupCount = 0 # type: int - self.batchGroupCount = 0 # type: int - self.precisionConfig = None # type: List[int] + self.thenSubgraphIndex = 0 # type: int + self.elseSubgraphIndex = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - stablehloConvolutionOptions = StablehloConvolutionOptions() - stablehloConvolutionOptions.Init(buf, pos) - return cls.InitFromObj(stablehloConvolutionOptions) + ifOptions = IfOptions() + ifOptions.Init(buf, pos) + return cls.InitFromObj(ifOptions) @classmethod - def InitFromObj(cls, stablehloConvolutionOptions): - x = StablehloConvolutionOptionsT() - x._UnPack(stablehloConvolutionOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, ifOptions): + x = IfOptionsT() + x._UnPack(ifOptions) return x - # StablehloConvolutionOptionsT - def _UnPack(self, stablehloConvolutionOptions): - if stablehloConvolutionOptions is None: + # IfOptionsT + def _UnPack(self, ifOptions): + if ifOptions is None: return - if not stablehloConvolutionOptions.WindowStridesIsNone(): - if np is None: - self.windowStrides = [] - for i in range(stablehloConvolutionOptions.WindowStridesLength()): - self.windowStrides.append(stablehloConvolutionOptions.WindowStrides(i)) - else: - self.windowStrides = stablehloConvolutionOptions.WindowStridesAsNumpy() - if not stablehloConvolutionOptions.PaddingIsNone(): - if np is None: - self.padding = [] - for i in range(stablehloConvolutionOptions.PaddingLength()): - self.padding.append(stablehloConvolutionOptions.Padding(i)) - else: - self.padding = stablehloConvolutionOptions.PaddingAsNumpy() - if not stablehloConvolutionOptions.LhsDilationIsNone(): - if np is None: - self.lhsDilation = [] - for i in range(stablehloConvolutionOptions.LhsDilationLength()): - self.lhsDilation.append(stablehloConvolutionOptions.LhsDilation(i)) - else: - self.lhsDilation = stablehloConvolutionOptions.LhsDilationAsNumpy() - if not stablehloConvolutionOptions.RhsDilationIsNone(): - if np is None: - self.rhsDilation = [] - for i in range(stablehloConvolutionOptions.RhsDilationLength()): - self.rhsDilation.append(stablehloConvolutionOptions.RhsDilation(i)) - else: - self.rhsDilation = stablehloConvolutionOptions.RhsDilationAsNumpy() - if not stablehloConvolutionOptions.WindowReversalIsNone(): - if np is None: - self.windowReversal = [] - for i in range(stablehloConvolutionOptions.WindowReversalLength()): - self.windowReversal.append(stablehloConvolutionOptions.WindowReversal(i)) - else: - self.windowReversal = stablehloConvolutionOptions.WindowReversalAsNumpy() - self.inputBatchDimension = stablehloConvolutionOptions.InputBatchDimension() - self.inputFeatureDimension = stablehloConvolutionOptions.InputFeatureDimension() - if not stablehloConvolutionOptions.InputSpatialDimensionsIsNone(): - if np is None: - self.inputSpatialDimensions = [] - for i in range(stablehloConvolutionOptions.InputSpatialDimensionsLength()): - self.inputSpatialDimensions.append(stablehloConvolutionOptions.InputSpatialDimensions(i)) - else: - self.inputSpatialDimensions = stablehloConvolutionOptions.InputSpatialDimensionsAsNumpy() - self.kernelInputFeatureDimension = stablehloConvolutionOptions.KernelInputFeatureDimension() - self.kernelOutputFeatureDimension = stablehloConvolutionOptions.KernelOutputFeatureDimension() - if not stablehloConvolutionOptions.KernelSpatialDimensionsIsNone(): - if np is None: - self.kernelSpatialDimensions = [] - for i in range(stablehloConvolutionOptions.KernelSpatialDimensionsLength()): - self.kernelSpatialDimensions.append(stablehloConvolutionOptions.KernelSpatialDimensions(i)) - else: - self.kernelSpatialDimensions = stablehloConvolutionOptions.KernelSpatialDimensionsAsNumpy() - self.outputBatchDimension = stablehloConvolutionOptions.OutputBatchDimension() - self.outputFeatureDimension = stablehloConvolutionOptions.OutputFeatureDimension() - if not stablehloConvolutionOptions.OutputSpatialDimensionsIsNone(): - if np is None: - self.outputSpatialDimensions = [] - for i in range(stablehloConvolutionOptions.OutputSpatialDimensionsLength()): - self.outputSpatialDimensions.append(stablehloConvolutionOptions.OutputSpatialDimensions(i)) - else: - self.outputSpatialDimensions = stablehloConvolutionOptions.OutputSpatialDimensionsAsNumpy() - self.featureGroupCount = stablehloConvolutionOptions.FeatureGroupCount() - self.batchGroupCount = stablehloConvolutionOptions.BatchGroupCount() - if not stablehloConvolutionOptions.PrecisionConfigIsNone(): - if np is None: - self.precisionConfig = [] - for i in range(stablehloConvolutionOptions.PrecisionConfigLength()): - self.precisionConfig.append(stablehloConvolutionOptions.PrecisionConfig(i)) - else: - self.precisionConfig = stablehloConvolutionOptions.PrecisionConfigAsNumpy() + self.thenSubgraphIndex = ifOptions.ThenSubgraphIndex() + self.elseSubgraphIndex = ifOptions.ElseSubgraphIndex() - # StablehloConvolutionOptionsT + # IfOptionsT def Pack(self, builder): - if self.windowStrides is not None: - if np is not None and type(self.windowStrides) is np.ndarray: - windowStrides = builder.CreateNumpyVector(self.windowStrides) - else: - StablehloConvolutionOptionsStartWindowStridesVector(builder, len(self.windowStrides)) - for i in reversed(range(len(self.windowStrides))): - builder.PrependInt64(self.windowStrides[i]) - windowStrides = builder.EndVector() - if self.padding is not None: - if np is not None and type(self.padding) is np.ndarray: - padding = builder.CreateNumpyVector(self.padding) - else: - StablehloConvolutionOptionsStartPaddingVector(builder, len(self.padding)) - for i in reversed(range(len(self.padding))): - builder.PrependInt64(self.padding[i]) - padding = builder.EndVector() - if self.lhsDilation is not None: - if np is not None and type(self.lhsDilation) is np.ndarray: - lhsDilation = builder.CreateNumpyVector(self.lhsDilation) - else: - StablehloConvolutionOptionsStartLhsDilationVector(builder, len(self.lhsDilation)) - for i in reversed(range(len(self.lhsDilation))): - builder.PrependInt64(self.lhsDilation[i]) - lhsDilation = builder.EndVector() - if self.rhsDilation is not None: - if np is not None and type(self.rhsDilation) is np.ndarray: - rhsDilation = builder.CreateNumpyVector(self.rhsDilation) - else: - StablehloConvolutionOptionsStartRhsDilationVector(builder, len(self.rhsDilation)) - for i in reversed(range(len(self.rhsDilation))): - builder.PrependInt64(self.rhsDilation[i]) - rhsDilation = builder.EndVector() - if self.windowReversal is not None: - if np is not None and type(self.windowReversal) is np.ndarray: - windowReversal = builder.CreateNumpyVector(self.windowReversal) - else: - StablehloConvolutionOptionsStartWindowReversalVector(builder, len(self.windowReversal)) - for i in reversed(range(len(self.windowReversal))): - builder.PrependBool(self.windowReversal[i]) - windowReversal = builder.EndVector() - if self.inputSpatialDimensions is not None: - if np is not None and type(self.inputSpatialDimensions) is np.ndarray: - inputSpatialDimensions = builder.CreateNumpyVector(self.inputSpatialDimensions) - else: - StablehloConvolutionOptionsStartInputSpatialDimensionsVector(builder, len(self.inputSpatialDimensions)) - for i in reversed(range(len(self.inputSpatialDimensions))): - builder.PrependInt64(self.inputSpatialDimensions[i]) - inputSpatialDimensions = builder.EndVector() - if self.kernelSpatialDimensions is not None: - if np is not None and type(self.kernelSpatialDimensions) is np.ndarray: - kernelSpatialDimensions = builder.CreateNumpyVector(self.kernelSpatialDimensions) - else: - StablehloConvolutionOptionsStartKernelSpatialDimensionsVector(builder, len(self.kernelSpatialDimensions)) - for i in reversed(range(len(self.kernelSpatialDimensions))): - builder.PrependInt64(self.kernelSpatialDimensions[i]) - kernelSpatialDimensions = builder.EndVector() - if self.outputSpatialDimensions is not None: - if np is not None and type(self.outputSpatialDimensions) is np.ndarray: - outputSpatialDimensions = builder.CreateNumpyVector(self.outputSpatialDimensions) - else: - StablehloConvolutionOptionsStartOutputSpatialDimensionsVector(builder, len(self.outputSpatialDimensions)) - for i in reversed(range(len(self.outputSpatialDimensions))): - builder.PrependInt64(self.outputSpatialDimensions[i]) - outputSpatialDimensions = builder.EndVector() - if self.precisionConfig is not None: - if np is not None and type(self.precisionConfig) is np.ndarray: - precisionConfig = builder.CreateNumpyVector(self.precisionConfig) - else: - StablehloConvolutionOptionsStartPrecisionConfigVector(builder, len(self.precisionConfig)) - for i in reversed(range(len(self.precisionConfig))): - builder.PrependUint32(self.precisionConfig[i]) - precisionConfig = builder.EndVector() - StablehloConvolutionOptionsStart(builder) - if self.windowStrides is not None: - StablehloConvolutionOptionsAddWindowStrides(builder, windowStrides) - if self.padding is not None: - StablehloConvolutionOptionsAddPadding(builder, padding) - if self.lhsDilation is not None: - StablehloConvolutionOptionsAddLhsDilation(builder, lhsDilation) - if self.rhsDilation is not None: - StablehloConvolutionOptionsAddRhsDilation(builder, rhsDilation) - if self.windowReversal is not None: - StablehloConvolutionOptionsAddWindowReversal(builder, windowReversal) - StablehloConvolutionOptionsAddInputBatchDimension(builder, self.inputBatchDimension) - StablehloConvolutionOptionsAddInputFeatureDimension(builder, self.inputFeatureDimension) - if self.inputSpatialDimensions is not None: - StablehloConvolutionOptionsAddInputSpatialDimensions(builder, inputSpatialDimensions) - StablehloConvolutionOptionsAddKernelInputFeatureDimension(builder, self.kernelInputFeatureDimension) - StablehloConvolutionOptionsAddKernelOutputFeatureDimension(builder, self.kernelOutputFeatureDimension) - if self.kernelSpatialDimensions is not None: - StablehloConvolutionOptionsAddKernelSpatialDimensions(builder, kernelSpatialDimensions) - StablehloConvolutionOptionsAddOutputBatchDimension(builder, self.outputBatchDimension) - StablehloConvolutionOptionsAddOutputFeatureDimension(builder, self.outputFeatureDimension) - if self.outputSpatialDimensions is not None: - StablehloConvolutionOptionsAddOutputSpatialDimensions(builder, outputSpatialDimensions) - StablehloConvolutionOptionsAddFeatureGroupCount(builder, self.featureGroupCount) - StablehloConvolutionOptionsAddBatchGroupCount(builder, self.batchGroupCount) - if self.precisionConfig is not None: - StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig) - stablehloConvolutionOptions = StablehloConvolutionOptionsEnd(builder) - return stablehloConvolutionOptions -# automatically generated by the FlatBuffers compiler, do not modify + IfOptionsStart(builder) + IfOptionsAddThenSubgraphIndex(builder, self.thenSubgraphIndex) + IfOptionsAddElseSubgraphIndex(builder, self.elseSubgraphIndex) + ifOptions = IfOptionsEnd(builder) + return ifOptions + + +class CallOnceOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CallOnceOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsCallOnceOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def CallOnceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # CallOnceOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) -# namespace: tflite + # CallOnceOptions + def InitSubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 -from flatbuffers.compat import import_numpy -np = import_numpy() +def CallOnceOptionsStart(builder): + builder.StartObject(1) -class StablehloCustomCallOptions(object): +def CallOnceOptionsAddInitSubgraphIndex(builder, initSubgraphIndex): + builder.PrependInt32Slot(0, initSubgraphIndex, 0) + +def CallOnceOptionsEnd(builder): + return builder.EndObject() + + + +class CallOnceOptionsT(object): + + # CallOnceOptionsT + def __init__(self): + self.initSubgraphIndex = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + callOnceOptions = CallOnceOptions() + callOnceOptions.Init(buf, pos) + return cls.InitFromObj(callOnceOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, callOnceOptions): + x = CallOnceOptionsT() + x._UnPack(callOnceOptions) + return x + + # CallOnceOptionsT + def _UnPack(self, callOnceOptions): + if callOnceOptions is None: + return + self.initSubgraphIndex = callOnceOptions.InitSubgraphIndex() + + # CallOnceOptionsT + def Pack(self, builder): + CallOnceOptionsStart(builder) + CallOnceOptionsAddInitSubgraphIndex(builder, self.initSubgraphIndex) + callOnceOptions = CallOnceOptionsEnd(builder) + return callOnceOptions + + +class WhileOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloCustomCallOptions() + x = WhileOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloCustomCallOptions(cls, buf, offset=0): + def GetRootAsWhileOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloCustomCallOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def WhileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloCustomCallOptions + # WhileOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloCustomCallOptions - def CallTargetName(self): + # WhileOptions + def CondSubgraphIndex(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.String(o + self._tab.Pos) - return None + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 - # StablehloCustomCallOptions - def HasSideEffect(self): + # WhileOptions + def BodySubgraphIndex(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - - # StablehloCustomCallOptions - def BackendConfig(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None - - # StablehloCustomCallOptions - def ApiVersion(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # StablehloCustomCallOptions - def CalledComputations(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 +def WhileOptionsStart(builder): + builder.StartObject(2) - # StablehloCustomCallOptions - def CalledComputationsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 +def WhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex): + builder.PrependInt32Slot(0, condSubgraphIndex, 0) - # StablehloCustomCallOptions - def CalledComputationsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def WhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): + builder.PrependInt32Slot(1, bodySubgraphIndex, 0) - # StablehloCustomCallOptions - def CalledComputationsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - return o == 0 +def WhileOptionsEnd(builder): + return builder.EndObject() + + + +class WhileOptionsT(object): + + # WhileOptionsT + def __init__(self): + self.condSubgraphIndex = 0 # type: int + self.bodySubgraphIndex = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + whileOptions = WhileOptions() + whileOptions.Init(buf, pos) + return cls.InitFromObj(whileOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, whileOptions): + x = WhileOptionsT() + x._UnPack(whileOptions) + return x + + # WhileOptionsT + def _UnPack(self, whileOptions): + if whileOptions is None: + return + self.condSubgraphIndex = whileOptions.CondSubgraphIndex() + self.bodySubgraphIndex = whileOptions.BodySubgraphIndex() + + # WhileOptionsT + def Pack(self, builder): + WhileOptionsStart(builder) + WhileOptionsAddCondSubgraphIndex(builder, self.condSubgraphIndex) + WhileOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex) + whileOptions = WhileOptionsEnd(builder) + return whileOptions + + +class NonMaxSuppressionV4Options(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = NonMaxSuppressionV4Options() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsNonMaxSuppressionV4Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def NonMaxSuppressionV4OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # NonMaxSuppressionV4Options + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def NonMaxSuppressionV4OptionsStart(builder): + builder.StartObject(0) + +def NonMaxSuppressionV4OptionsEnd(builder): + return builder.EndObject() + + + +class NonMaxSuppressionV4OptionsT(object): + + # NonMaxSuppressionV4OptionsT + def __init__(self): + pass + + @classmethod + def InitFromBuf(cls, buf, pos): + nonMaxSuppressionV4Options = NonMaxSuppressionV4Options() + nonMaxSuppressionV4Options.Init(buf, pos) + return cls.InitFromObj(nonMaxSuppressionV4Options) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, nonMaxSuppressionV4Options): + x = NonMaxSuppressionV4OptionsT() + x._UnPack(nonMaxSuppressionV4Options) + return x + + # NonMaxSuppressionV4OptionsT + def _UnPack(self, nonMaxSuppressionV4Options): + if nonMaxSuppressionV4Options is None: + return + + # NonMaxSuppressionV4OptionsT + def Pack(self, builder): + NonMaxSuppressionV4OptionsStart(builder) + nonMaxSuppressionV4Options = NonMaxSuppressionV4OptionsEnd(builder) + return nonMaxSuppressionV4Options + + +class NonMaxSuppressionV5Options(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = NonMaxSuppressionV5Options() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsNonMaxSuppressionV5Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def NonMaxSuppressionV5OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # NonMaxSuppressionV5Options + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def NonMaxSuppressionV5OptionsStart(builder): + builder.StartObject(0) + +def NonMaxSuppressionV5OptionsEnd(builder): + return builder.EndObject() + + + +class NonMaxSuppressionV5OptionsT(object): + + # NonMaxSuppressionV5OptionsT + def __init__(self): + pass + + @classmethod + def InitFromBuf(cls, buf, pos): + nonMaxSuppressionV5Options = NonMaxSuppressionV5Options() + nonMaxSuppressionV5Options.Init(buf, pos) + return cls.InitFromObj(nonMaxSuppressionV5Options) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, nonMaxSuppressionV5Options): + x = NonMaxSuppressionV5OptionsT() + x._UnPack(nonMaxSuppressionV5Options) + return x + + # NonMaxSuppressionV5OptionsT + def _UnPack(self, nonMaxSuppressionV5Options): + if nonMaxSuppressionV5Options is None: + return + + # NonMaxSuppressionV5OptionsT + def Pack(self, builder): + NonMaxSuppressionV5OptionsStart(builder) + nonMaxSuppressionV5Options = NonMaxSuppressionV5OptionsEnd(builder) + return nonMaxSuppressionV5Options + + +class ScatterNdOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ScatterNdOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsScatterNdOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ScatterNdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloCustomCallOptions - def CustomAttributes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) - return 0 + # ScatterNdOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) - # StablehloCustomCallOptions - def CustomAttributesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) - return 0 +def ScatterNdOptionsStart(builder): + builder.StartObject(0) - # StablehloCustomCallOptions - def CustomAttributesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def ScatterNdOptionsEnd(builder): + return builder.EndObject() - # StablehloCustomCallOptions - def CustomAttributesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - return o == 0 -def StablehloCustomCallOptionsStart(builder): builder.StartObject(6) -def Start(builder): - return StablehloCustomCallOptionsStart(builder) -def StablehloCustomCallOptionsAddCallTargetName(builder, callTargetName): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(callTargetName), 0) -def AddCallTargetName(builder, callTargetName): - return StablehloCustomCallOptionsAddCallTargetName(builder, callTargetName) -def StablehloCustomCallOptionsAddHasSideEffect(builder, hasSideEffect): builder.PrependBoolSlot(1, hasSideEffect, 0) -def AddHasSideEffect(builder, hasSideEffect): - return StablehloCustomCallOptionsAddHasSideEffect(builder, hasSideEffect) -def StablehloCustomCallOptionsAddBackendConfig(builder, backendConfig): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(backendConfig), 0) -def AddBackendConfig(builder, backendConfig): - return StablehloCustomCallOptionsAddBackendConfig(builder, backendConfig) -def StablehloCustomCallOptionsAddApiVersion(builder, apiVersion): builder.PrependInt32Slot(3, apiVersion, 0) -def AddApiVersion(builder, apiVersion): - return StablehloCustomCallOptionsAddApiVersion(builder, apiVersion) -def StablehloCustomCallOptionsAddCalledComputations(builder, calledComputations): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(calledComputations), 0) -def AddCalledComputations(builder, calledComputations): - return StablehloCustomCallOptionsAddCalledComputations(builder, calledComputations) -def StablehloCustomCallOptionsStartCalledComputationsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartCalledComputationsVector(builder, numElems): - return StablehloCustomCallOptionsStartCalledComputationsVector(builder, numElems) -def StablehloCustomCallOptionsAddCustomAttributes(builder, customAttributes): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customAttributes), 0) -def AddCustomAttributes(builder, customAttributes): - return StablehloCustomCallOptionsAddCustomAttributes(builder, customAttributes) -def StablehloCustomCallOptionsStartCustomAttributesVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def StartCustomAttributesVector(builder, numElems): - return StablehloCustomCallOptionsStartCustomAttributesVector(builder, numElems) -def StablehloCustomCallOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloCustomCallOptionsEnd(builder) -try: - from typing import List -except: - pass -class StablehloCustomCallOptionsT(object): +class ScatterNdOptionsT(object): - # StablehloCustomCallOptionsT + # ScatterNdOptionsT def __init__(self): - self.callTargetName = None # type: str - self.hasSideEffect = False # type: bool - self.backendConfig = None # type: str - self.apiVersion = 0 # type: int - self.calledComputations = None # type: List[int] - self.customAttributes = None # type: List[int] + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloCustomCallOptions = StablehloCustomCallOptions() - stablehloCustomCallOptions.Init(buf, pos) - return cls.InitFromObj(stablehloCustomCallOptions) + scatterNdOptions = ScatterNdOptions() + scatterNdOptions.Init(buf, pos) + return cls.InitFromObj(scatterNdOptions) @classmethod - def InitFromObj(cls, stablehloCustomCallOptions): - x = StablehloCustomCallOptionsT() - x._UnPack(stablehloCustomCallOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, scatterNdOptions): + x = ScatterNdOptionsT() + x._UnPack(scatterNdOptions) return x - # StablehloCustomCallOptionsT - def _UnPack(self, stablehloCustomCallOptions): - if stablehloCustomCallOptions is None: + # ScatterNdOptionsT + def _UnPack(self, scatterNdOptions): + if scatterNdOptions is None: return - self.callTargetName = stablehloCustomCallOptions.CallTargetName() - self.hasSideEffect = stablehloCustomCallOptions.HasSideEffect() - self.backendConfig = stablehloCustomCallOptions.BackendConfig() - self.apiVersion = stablehloCustomCallOptions.ApiVersion() - if not stablehloCustomCallOptions.CalledComputationsIsNone(): - if np is None: - self.calledComputations = [] - for i in range(stablehloCustomCallOptions.CalledComputationsLength()): - self.calledComputations.append(stablehloCustomCallOptions.CalledComputations(i)) - else: - self.calledComputations = stablehloCustomCallOptions.CalledComputationsAsNumpy() - if not stablehloCustomCallOptions.CustomAttributesIsNone(): - if np is None: - self.customAttributes = [] - for i in range(stablehloCustomCallOptions.CustomAttributesLength()): - self.customAttributes.append(stablehloCustomCallOptions.CustomAttributes(i)) - else: - self.customAttributes = stablehloCustomCallOptions.CustomAttributesAsNumpy() - # StablehloCustomCallOptionsT + # ScatterNdOptionsT def Pack(self, builder): - if self.callTargetName is not None: - callTargetName = builder.CreateString(self.callTargetName) - if self.backendConfig is not None: - backendConfig = builder.CreateString(self.backendConfig) - if self.calledComputations is not None: - if np is not None and type(self.calledComputations) is np.ndarray: - calledComputations = builder.CreateNumpyVector(self.calledComputations) - else: - StablehloCustomCallOptionsStartCalledComputationsVector(builder, len(self.calledComputations)) - for i in reversed(range(len(self.calledComputations))): - builder.PrependInt32(self.calledComputations[i]) - calledComputations = builder.EndVector() - if self.customAttributes is not None: - if np is not None and type(self.customAttributes) is np.ndarray: - customAttributes = builder.CreateNumpyVector(self.customAttributes) - else: - StablehloCustomCallOptionsStartCustomAttributesVector(builder, len(self.customAttributes)) - for i in reversed(range(len(self.customAttributes))): - builder.PrependUint8(self.customAttributes[i]) - customAttributes = builder.EndVector() - StablehloCustomCallOptionsStart(builder) - if self.callTargetName is not None: - StablehloCustomCallOptionsAddCallTargetName(builder, callTargetName) - StablehloCustomCallOptionsAddHasSideEffect(builder, self.hasSideEffect) - if self.backendConfig is not None: - StablehloCustomCallOptionsAddBackendConfig(builder, backendConfig) - StablehloCustomCallOptionsAddApiVersion(builder, self.apiVersion) - if self.calledComputations is not None: - StablehloCustomCallOptionsAddCalledComputations(builder, calledComputations) - if self.customAttributes is not None: - StablehloCustomCallOptionsAddCustomAttributes(builder, customAttributes) - stablehloCustomCallOptions = StablehloCustomCallOptionsEnd(builder) - return stablehloCustomCallOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ScatterNdOptionsStart(builder) + scatterNdOptions = ScatterNdOptionsEnd(builder) + return scatterNdOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloDotGeneralOptions(object): +class SelectV2Options(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloDotGeneralOptions() + x = SelectV2Options() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloDotGeneralOptions(cls, buf, offset=0): + def GetRootAsSelectV2Options(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloDotGeneralOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SelectV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloDotGeneralOptions + # SelectV2Options def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloDotGeneralOptions - def LhsBatchingDimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloDotGeneralOptions - def LhsBatchingDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloDotGeneralOptions - def LhsBatchingDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def SelectV2OptionsStart(builder): + builder.StartObject(0) - # StablehloDotGeneralOptions - def LhsBatchingDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 +def SelectV2OptionsEnd(builder): + return builder.EndObject() - # StablehloDotGeneralOptions - def RhsBatchingDimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - # StablehloDotGeneralOptions - def RhsBatchingDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - # StablehloDotGeneralOptions - def RhsBatchingDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class SelectV2OptionsT(object): - # StablehloDotGeneralOptions - def RhsBatchingDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 + # SelectV2OptionsT + def __init__(self): + pass - # StablehloDotGeneralOptions - def LhsContractingDimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 + @classmethod + def InitFromBuf(cls, buf, pos): + selectV2Options = SelectV2Options() + selectV2Options.Init(buf, pos) + return cls.InitFromObj(selectV2Options) - # StablehloDotGeneralOptions - def LhsContractingDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # StablehloDotGeneralOptions - def LhsContractingDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + @classmethod + def InitFromObj(cls, selectV2Options): + x = SelectV2OptionsT() + x._UnPack(selectV2Options) + return x - # StablehloDotGeneralOptions - def LhsContractingDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 + # SelectV2OptionsT + def _UnPack(self, selectV2Options): + if selectV2Options is None: + return - # StablehloDotGeneralOptions - def RhsContractingDimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 + # SelectV2OptionsT + def Pack(self, builder): + SelectV2OptionsStart(builder) + selectV2Options = SelectV2OptionsEnd(builder) + return selectV2Options - # StablehloDotGeneralOptions - def RhsContractingDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - # StablehloDotGeneralOptions - def RhsContractingDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class DensifyOptions(object): + __slots__ = ['_tab'] - # StablehloDotGeneralOptions - def RhsContractingDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - return o == 0 + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = DensifyOptions() + x.Init(buf, n + offset) + return x - # StablehloDotGeneralOptions - def PrecisionConfig(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 + @classmethod + def GetRootAsDensifyOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def DensifyOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloDotGeneralOptions - def PrecisionConfigAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o) - return 0 + # DensifyOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) - # StablehloDotGeneralOptions - def PrecisionConfigLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def DensifyOptionsStart(builder): + builder.StartObject(0) - # StablehloDotGeneralOptions - def PrecisionConfigIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - return o == 0 +def DensifyOptionsEnd(builder): + return builder.EndObject() -def StablehloDotGeneralOptionsStart(builder): builder.StartObject(5) -def Start(builder): - return StablehloDotGeneralOptionsStart(builder) -def StablehloDotGeneralOptionsAddLhsBatchingDimensions(builder, lhsBatchingDimensions): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(lhsBatchingDimensions), 0) -def AddLhsBatchingDimensions(builder, lhsBatchingDimensions): - return StablehloDotGeneralOptionsAddLhsBatchingDimensions(builder, lhsBatchingDimensions) -def StablehloDotGeneralOptionsStartLhsBatchingDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartLhsBatchingDimensionsVector(builder, numElems): - return StablehloDotGeneralOptionsStartLhsBatchingDimensionsVector(builder, numElems) -def StablehloDotGeneralOptionsAddRhsBatchingDimensions(builder, rhsBatchingDimensions): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(rhsBatchingDimensions), 0) -def AddRhsBatchingDimensions(builder, rhsBatchingDimensions): - return StablehloDotGeneralOptionsAddRhsBatchingDimensions(builder, rhsBatchingDimensions) -def StablehloDotGeneralOptionsStartRhsBatchingDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartRhsBatchingDimensionsVector(builder, numElems): - return StablehloDotGeneralOptionsStartRhsBatchingDimensionsVector(builder, numElems) -def StablehloDotGeneralOptionsAddLhsContractingDimensions(builder, lhsContractingDimensions): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(lhsContractingDimensions), 0) -def AddLhsContractingDimensions(builder, lhsContractingDimensions): - return StablehloDotGeneralOptionsAddLhsContractingDimensions(builder, lhsContractingDimensions) -def StablehloDotGeneralOptionsStartLhsContractingDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartLhsContractingDimensionsVector(builder, numElems): - return StablehloDotGeneralOptionsStartLhsContractingDimensionsVector(builder, numElems) -def StablehloDotGeneralOptionsAddRhsContractingDimensions(builder, rhsContractingDimensions): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(rhsContractingDimensions), 0) -def AddRhsContractingDimensions(builder, rhsContractingDimensions): - return StablehloDotGeneralOptionsAddRhsContractingDimensions(builder, rhsContractingDimensions) -def StablehloDotGeneralOptionsStartRhsContractingDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartRhsContractingDimensionsVector(builder, numElems): - return StablehloDotGeneralOptionsStartRhsContractingDimensionsVector(builder, numElems) -def StablehloDotGeneralOptionsAddPrecisionConfig(builder, precisionConfig): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(precisionConfig), 0) -def AddPrecisionConfig(builder, precisionConfig): - return StablehloDotGeneralOptionsAddPrecisionConfig(builder, precisionConfig) -def StablehloDotGeneralOptionsStartPrecisionConfigVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartPrecisionConfigVector(builder, numElems): - return StablehloDotGeneralOptionsStartPrecisionConfigVector(builder, numElems) -def StablehloDotGeneralOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloDotGeneralOptionsEnd(builder) -try: - from typing import List -except: - pass -class StablehloDotGeneralOptionsT(object): - # StablehloDotGeneralOptionsT +class DensifyOptionsT(object): + + # DensifyOptionsT def __init__(self): - self.lhsBatchingDimensions = None # type: List[int] - self.rhsBatchingDimensions = None # type: List[int] - self.lhsContractingDimensions = None # type: List[int] - self.rhsContractingDimensions = None # type: List[int] - self.precisionConfig = None # type: List[int] + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloDotGeneralOptions = StablehloDotGeneralOptions() - stablehloDotGeneralOptions.Init(buf, pos) - return cls.InitFromObj(stablehloDotGeneralOptions) + densifyOptions = DensifyOptions() + densifyOptions.Init(buf, pos) + return cls.InitFromObj(densifyOptions) @classmethod - def InitFromObj(cls, stablehloDotGeneralOptions): - x = StablehloDotGeneralOptionsT() - x._UnPack(stablehloDotGeneralOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, densifyOptions): + x = DensifyOptionsT() + x._UnPack(densifyOptions) return x - # StablehloDotGeneralOptionsT - def _UnPack(self, stablehloDotGeneralOptions): - if stablehloDotGeneralOptions is None: + # DensifyOptionsT + def _UnPack(self, densifyOptions): + if densifyOptions is None: return - if not stablehloDotGeneralOptions.LhsBatchingDimensionsIsNone(): - if np is None: - self.lhsBatchingDimensions = [] - for i in range(stablehloDotGeneralOptions.LhsBatchingDimensionsLength()): - self.lhsBatchingDimensions.append(stablehloDotGeneralOptions.LhsBatchingDimensions(i)) - else: - self.lhsBatchingDimensions = stablehloDotGeneralOptions.LhsBatchingDimensionsAsNumpy() - if not stablehloDotGeneralOptions.RhsBatchingDimensionsIsNone(): - if np is None: - self.rhsBatchingDimensions = [] - for i in range(stablehloDotGeneralOptions.RhsBatchingDimensionsLength()): - self.rhsBatchingDimensions.append(stablehloDotGeneralOptions.RhsBatchingDimensions(i)) - else: - self.rhsBatchingDimensions = stablehloDotGeneralOptions.RhsBatchingDimensionsAsNumpy() - if not stablehloDotGeneralOptions.LhsContractingDimensionsIsNone(): - if np is None: - self.lhsContractingDimensions = [] - for i in range(stablehloDotGeneralOptions.LhsContractingDimensionsLength()): - self.lhsContractingDimensions.append(stablehloDotGeneralOptions.LhsContractingDimensions(i)) - else: - self.lhsContractingDimensions = stablehloDotGeneralOptions.LhsContractingDimensionsAsNumpy() - if not stablehloDotGeneralOptions.RhsContractingDimensionsIsNone(): - if np is None: - self.rhsContractingDimensions = [] - for i in range(stablehloDotGeneralOptions.RhsContractingDimensionsLength()): - self.rhsContractingDimensions.append(stablehloDotGeneralOptions.RhsContractingDimensions(i)) - else: - self.rhsContractingDimensions = stablehloDotGeneralOptions.RhsContractingDimensionsAsNumpy() - if not stablehloDotGeneralOptions.PrecisionConfigIsNone(): - if np is None: - self.precisionConfig = [] - for i in range(stablehloDotGeneralOptions.PrecisionConfigLength()): - self.precisionConfig.append(stablehloDotGeneralOptions.PrecisionConfig(i)) - else: - self.precisionConfig = stablehloDotGeneralOptions.PrecisionConfigAsNumpy() - # StablehloDotGeneralOptionsT + # DensifyOptionsT def Pack(self, builder): - if self.lhsBatchingDimensions is not None: - if np is not None and type(self.lhsBatchingDimensions) is np.ndarray: - lhsBatchingDimensions = builder.CreateNumpyVector(self.lhsBatchingDimensions) - else: - StablehloDotGeneralOptionsStartLhsBatchingDimensionsVector(builder, len(self.lhsBatchingDimensions)) - for i in reversed(range(len(self.lhsBatchingDimensions))): - builder.PrependInt64(self.lhsBatchingDimensions[i]) - lhsBatchingDimensions = builder.EndVector() - if self.rhsBatchingDimensions is not None: - if np is not None and type(self.rhsBatchingDimensions) is np.ndarray: - rhsBatchingDimensions = builder.CreateNumpyVector(self.rhsBatchingDimensions) - else: - StablehloDotGeneralOptionsStartRhsBatchingDimensionsVector(builder, len(self.rhsBatchingDimensions)) - for i in reversed(range(len(self.rhsBatchingDimensions))): - builder.PrependInt64(self.rhsBatchingDimensions[i]) - rhsBatchingDimensions = builder.EndVector() - if self.lhsContractingDimensions is not None: - if np is not None and type(self.lhsContractingDimensions) is np.ndarray: - lhsContractingDimensions = builder.CreateNumpyVector(self.lhsContractingDimensions) - else: - StablehloDotGeneralOptionsStartLhsContractingDimensionsVector(builder, len(self.lhsContractingDimensions)) - for i in reversed(range(len(self.lhsContractingDimensions))): - builder.PrependInt64(self.lhsContractingDimensions[i]) - lhsContractingDimensions = builder.EndVector() - if self.rhsContractingDimensions is not None: - if np is not None and type(self.rhsContractingDimensions) is np.ndarray: - rhsContractingDimensions = builder.CreateNumpyVector(self.rhsContractingDimensions) - else: - StablehloDotGeneralOptionsStartRhsContractingDimensionsVector(builder, len(self.rhsContractingDimensions)) - for i in reversed(range(len(self.rhsContractingDimensions))): - builder.PrependInt64(self.rhsContractingDimensions[i]) - rhsContractingDimensions = builder.EndVector() - if self.precisionConfig is not None: - if np is not None and type(self.precisionConfig) is np.ndarray: - precisionConfig = builder.CreateNumpyVector(self.precisionConfig) - else: - StablehloDotGeneralOptionsStartPrecisionConfigVector(builder, len(self.precisionConfig)) - for i in reversed(range(len(self.precisionConfig))): - builder.PrependUint32(self.precisionConfig[i]) - precisionConfig = builder.EndVector() - StablehloDotGeneralOptionsStart(builder) - if self.lhsBatchingDimensions is not None: - StablehloDotGeneralOptionsAddLhsBatchingDimensions(builder, lhsBatchingDimensions) - if self.rhsBatchingDimensions is not None: - StablehloDotGeneralOptionsAddRhsBatchingDimensions(builder, rhsBatchingDimensions) - if self.lhsContractingDimensions is not None: - StablehloDotGeneralOptionsAddLhsContractingDimensions(builder, lhsContractingDimensions) - if self.rhsContractingDimensions is not None: - StablehloDotGeneralOptionsAddRhsContractingDimensions(builder, rhsContractingDimensions) - if self.precisionConfig is not None: - StablehloDotGeneralOptionsAddPrecisionConfig(builder, precisionConfig) - stablehloDotGeneralOptions = StablehloDotGeneralOptionsEnd(builder) - return stablehloDotGeneralOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + DensifyOptionsStart(builder) + densifyOptions = DensifyOptionsEnd(builder) + return densifyOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloDynamicSliceOptions(object): +class SegmentSumOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloDynamicSliceOptions() + x = SegmentSumOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloDynamicSliceOptions(cls, buf, offset=0): + def GetRootAsSegmentSumOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloDynamicSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SegmentSumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloDynamicSliceOptions + # SegmentSumOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloDynamicSliceOptions - def SliceSizes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloDynamicSliceOptions - def SliceSizesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 +def SegmentSumOptionsStart(builder): + builder.StartObject(0) - # StablehloDynamicSliceOptions - def SliceSizesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def SegmentSumOptionsEnd(builder): + return builder.EndObject() - # StablehloDynamicSliceOptions - def SliceSizesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 -def StablehloDynamicSliceOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return StablehloDynamicSliceOptionsStart(builder) -def StablehloDynamicSliceOptionsAddSliceSizes(builder, sliceSizes): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(sliceSizes), 0) -def AddSliceSizes(builder, sliceSizes): - return StablehloDynamicSliceOptionsAddSliceSizes(builder, sliceSizes) -def StablehloDynamicSliceOptionsStartSliceSizesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartSliceSizesVector(builder, numElems): - return StablehloDynamicSliceOptionsStartSliceSizesVector(builder, numElems) -def StablehloDynamicSliceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloDynamicSliceOptionsEnd(builder) -try: - from typing import List -except: - pass -class StablehloDynamicSliceOptionsT(object): +class SegmentSumOptionsT(object): - # StablehloDynamicSliceOptionsT + # SegmentSumOptionsT def __init__(self): - self.sliceSizes = None # type: List[int] + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloDynamicSliceOptions = StablehloDynamicSliceOptions() - stablehloDynamicSliceOptions.Init(buf, pos) - return cls.InitFromObj(stablehloDynamicSliceOptions) + segmentSumOptions = SegmentSumOptions() + segmentSumOptions.Init(buf, pos) + return cls.InitFromObj(segmentSumOptions) @classmethod - def InitFromObj(cls, stablehloDynamicSliceOptions): - x = StablehloDynamicSliceOptionsT() - x._UnPack(stablehloDynamicSliceOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, segmentSumOptions): + x = SegmentSumOptionsT() + x._UnPack(segmentSumOptions) return x - # StablehloDynamicSliceOptionsT - def _UnPack(self, stablehloDynamicSliceOptions): - if stablehloDynamicSliceOptions is None: + # SegmentSumOptionsT + def _UnPack(self, segmentSumOptions): + if segmentSumOptions is None: return - if not stablehloDynamicSliceOptions.SliceSizesIsNone(): - if np is None: - self.sliceSizes = [] - for i in range(stablehloDynamicSliceOptions.SliceSizesLength()): - self.sliceSizes.append(stablehloDynamicSliceOptions.SliceSizes(i)) - else: - self.sliceSizes = stablehloDynamicSliceOptions.SliceSizesAsNumpy() - # StablehloDynamicSliceOptionsT + # SegmentSumOptionsT def Pack(self, builder): - if self.sliceSizes is not None: - if np is not None and type(self.sliceSizes) is np.ndarray: - sliceSizes = builder.CreateNumpyVector(self.sliceSizes) - else: - StablehloDynamicSliceOptionsStartSliceSizesVector(builder, len(self.sliceSizes)) - for i in reversed(range(len(self.sliceSizes))): - builder.PrependInt64(self.sliceSizes[i]) - sliceSizes = builder.EndVector() - StablehloDynamicSliceOptionsStart(builder) - if self.sliceSizes is not None: - StablehloDynamicSliceOptionsAddSliceSizes(builder, sliceSizes) - stablehloDynamicSliceOptions = StablehloDynamicSliceOptionsEnd(builder) - return stablehloDynamicSliceOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + SegmentSumOptionsStart(builder) + segmentSumOptions = SegmentSumOptionsEnd(builder) + return segmentSumOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloGatherOptions(object): +class BatchMatMulOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloGatherOptions() + x = BatchMatMulOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloGatherOptions(cls, buf, offset=0): + def GetRootAsBatchMatMulOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloGatherOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def BatchMatMulOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloGatherOptions + # BatchMatMulOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloGatherOptions - def OffsetDims(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloGatherOptions - def OffsetDimsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloGatherOptions - def OffsetDimsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloGatherOptions - def OffsetDimsIsNone(self): + # BatchMatMulOptions + def AdjX(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - - # StablehloGatherOptions - def CollapsedSliceDims(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloGatherOptions - def CollapsedSliceDimsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloGatherOptions - def CollapsedSliceDimsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.VectorLen(o) - return 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # StablehloGatherOptions - def CollapsedSliceDimsIsNone(self): + # BatchMatMulOptions + def AdjY(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 - - # StablehloGatherOptions - def StartIndexMap(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloGatherOptions - def StartIndexMapAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # StablehloGatherOptions - def StartIndexMapLength(self): + # BatchMatMulOptions + def AsymmetricQuantizeInputs(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloGatherOptions - def StartIndexMapIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # StablehloGatherOptions - def IndexVectorDim(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 +def BatchMatMulOptionsStart(builder): + builder.StartObject(3) - # StablehloGatherOptions - def SliceSizes(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 +def BatchMatMulOptionsAddAdjX(builder, adjX): + builder.PrependBoolSlot(0, adjX, 0) - # StablehloGatherOptions - def SliceSizesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 +def BatchMatMulOptionsAddAdjY(builder, adjY): + builder.PrependBoolSlot(1, adjY, 0) - # StablehloGatherOptions - def SliceSizesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) - # StablehloGatherOptions - def SliceSizesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - return o == 0 +def BatchMatMulOptionsEnd(builder): + return builder.EndObject() - # StablehloGatherOptions - def IndicesAreSorted(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False -def StablehloGatherOptionsStart(builder): builder.StartObject(6) -def Start(builder): - return StablehloGatherOptionsStart(builder) -def StablehloGatherOptionsAddOffsetDims(builder, offsetDims): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(offsetDims), 0) -def AddOffsetDims(builder, offsetDims): - return StablehloGatherOptionsAddOffsetDims(builder, offsetDims) -def StablehloGatherOptionsStartOffsetDimsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartOffsetDimsVector(builder, numElems): - return StablehloGatherOptionsStartOffsetDimsVector(builder, numElems) -def StablehloGatherOptionsAddCollapsedSliceDims(builder, collapsedSliceDims): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(collapsedSliceDims), 0) -def AddCollapsedSliceDims(builder, collapsedSliceDims): - return StablehloGatherOptionsAddCollapsedSliceDims(builder, collapsedSliceDims) -def StablehloGatherOptionsStartCollapsedSliceDimsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartCollapsedSliceDimsVector(builder, numElems): - return StablehloGatherOptionsStartCollapsedSliceDimsVector(builder, numElems) -def StablehloGatherOptionsAddStartIndexMap(builder, startIndexMap): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(startIndexMap), 0) -def AddStartIndexMap(builder, startIndexMap): - return StablehloGatherOptionsAddStartIndexMap(builder, startIndexMap) -def StablehloGatherOptionsStartStartIndexMapVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartStartIndexMapVector(builder, numElems): - return StablehloGatherOptionsStartStartIndexMapVector(builder, numElems) -def StablehloGatherOptionsAddIndexVectorDim(builder, indexVectorDim): builder.PrependInt64Slot(3, indexVectorDim, 0) -def AddIndexVectorDim(builder, indexVectorDim): - return StablehloGatherOptionsAddIndexVectorDim(builder, indexVectorDim) -def StablehloGatherOptionsAddSliceSizes(builder, sliceSizes): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(sliceSizes), 0) -def AddSliceSizes(builder, sliceSizes): - return StablehloGatherOptionsAddSliceSizes(builder, sliceSizes) -def StablehloGatherOptionsStartSliceSizesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartSliceSizesVector(builder, numElems): - return StablehloGatherOptionsStartSliceSizesVector(builder, numElems) -def StablehloGatherOptionsAddIndicesAreSorted(builder, indicesAreSorted): builder.PrependBoolSlot(5, indicesAreSorted, 0) -def AddIndicesAreSorted(builder, indicesAreSorted): - return StablehloGatherOptionsAddIndicesAreSorted(builder, indicesAreSorted) -def StablehloGatherOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloGatherOptionsEnd(builder) -try: - from typing import List -except: - pass -class StablehloGatherOptionsT(object): +class BatchMatMulOptionsT(object): - # StablehloGatherOptionsT + # BatchMatMulOptionsT def __init__(self): - self.offsetDims = None # type: List[int] - self.collapsedSliceDims = None # type: List[int] - self.startIndexMap = None # type: List[int] - self.indexVectorDim = 0 # type: int - self.sliceSizes = None # type: List[int] - self.indicesAreSorted = False # type: bool + self.adjX = False # type: bool + self.adjY = False # type: bool + self.asymmetricQuantizeInputs = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - stablehloGatherOptions = StablehloGatherOptions() - stablehloGatherOptions.Init(buf, pos) - return cls.InitFromObj(stablehloGatherOptions) + batchMatMulOptions = BatchMatMulOptions() + batchMatMulOptions.Init(buf, pos) + return cls.InitFromObj(batchMatMulOptions) @classmethod - def InitFromObj(cls, stablehloGatherOptions): - x = StablehloGatherOptionsT() - x._UnPack(stablehloGatherOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, batchMatMulOptions): + x = BatchMatMulOptionsT() + x._UnPack(batchMatMulOptions) return x - # StablehloGatherOptionsT - def _UnPack(self, stablehloGatherOptions): - if stablehloGatherOptions is None: + # BatchMatMulOptionsT + def _UnPack(self, batchMatMulOptions): + if batchMatMulOptions is None: return - if not stablehloGatherOptions.OffsetDimsIsNone(): - if np is None: - self.offsetDims = [] - for i in range(stablehloGatherOptions.OffsetDimsLength()): - self.offsetDims.append(stablehloGatherOptions.OffsetDims(i)) - else: - self.offsetDims = stablehloGatherOptions.OffsetDimsAsNumpy() - if not stablehloGatherOptions.CollapsedSliceDimsIsNone(): - if np is None: - self.collapsedSliceDims = [] - for i in range(stablehloGatherOptions.CollapsedSliceDimsLength()): - self.collapsedSliceDims.append(stablehloGatherOptions.CollapsedSliceDims(i)) - else: - self.collapsedSliceDims = stablehloGatherOptions.CollapsedSliceDimsAsNumpy() - if not stablehloGatherOptions.StartIndexMapIsNone(): - if np is None: - self.startIndexMap = [] - for i in range(stablehloGatherOptions.StartIndexMapLength()): - self.startIndexMap.append(stablehloGatherOptions.StartIndexMap(i)) - else: - self.startIndexMap = stablehloGatherOptions.StartIndexMapAsNumpy() - self.indexVectorDim = stablehloGatherOptions.IndexVectorDim() - if not stablehloGatherOptions.SliceSizesIsNone(): - if np is None: - self.sliceSizes = [] - for i in range(stablehloGatherOptions.SliceSizesLength()): - self.sliceSizes.append(stablehloGatherOptions.SliceSizes(i)) - else: - self.sliceSizes = stablehloGatherOptions.SliceSizesAsNumpy() - self.indicesAreSorted = stablehloGatherOptions.IndicesAreSorted() + self.adjX = batchMatMulOptions.AdjX() + self.adjY = batchMatMulOptions.AdjY() + self.asymmetricQuantizeInputs = batchMatMulOptions.AsymmetricQuantizeInputs() - # StablehloGatherOptionsT + # BatchMatMulOptionsT def Pack(self, builder): - if self.offsetDims is not None: - if np is not None and type(self.offsetDims) is np.ndarray: - offsetDims = builder.CreateNumpyVector(self.offsetDims) - else: - StablehloGatherOptionsStartOffsetDimsVector(builder, len(self.offsetDims)) - for i in reversed(range(len(self.offsetDims))): - builder.PrependInt64(self.offsetDims[i]) - offsetDims = builder.EndVector() - if self.collapsedSliceDims is not None: - if np is not None and type(self.collapsedSliceDims) is np.ndarray: - collapsedSliceDims = builder.CreateNumpyVector(self.collapsedSliceDims) - else: - StablehloGatherOptionsStartCollapsedSliceDimsVector(builder, len(self.collapsedSliceDims)) - for i in reversed(range(len(self.collapsedSliceDims))): - builder.PrependInt64(self.collapsedSliceDims[i]) - collapsedSliceDims = builder.EndVector() - if self.startIndexMap is not None: - if np is not None and type(self.startIndexMap) is np.ndarray: - startIndexMap = builder.CreateNumpyVector(self.startIndexMap) - else: - StablehloGatherOptionsStartStartIndexMapVector(builder, len(self.startIndexMap)) - for i in reversed(range(len(self.startIndexMap))): - builder.PrependInt64(self.startIndexMap[i]) - startIndexMap = builder.EndVector() - if self.sliceSizes is not None: - if np is not None and type(self.sliceSizes) is np.ndarray: - sliceSizes = builder.CreateNumpyVector(self.sliceSizes) - else: - StablehloGatherOptionsStartSliceSizesVector(builder, len(self.sliceSizes)) - for i in reversed(range(len(self.sliceSizes))): - builder.PrependInt64(self.sliceSizes[i]) - sliceSizes = builder.EndVector() - StablehloGatherOptionsStart(builder) - if self.offsetDims is not None: - StablehloGatherOptionsAddOffsetDims(builder, offsetDims) - if self.collapsedSliceDims is not None: - StablehloGatherOptionsAddCollapsedSliceDims(builder, collapsedSliceDims) - if self.startIndexMap is not None: - StablehloGatherOptionsAddStartIndexMap(builder, startIndexMap) - StablehloGatherOptionsAddIndexVectorDim(builder, self.indexVectorDim) - if self.sliceSizes is not None: - StablehloGatherOptionsAddSliceSizes(builder, sliceSizes) - StablehloGatherOptionsAddIndicesAreSorted(builder, self.indicesAreSorted) - stablehloGatherOptions = StablehloGatherOptionsEnd(builder) - return stablehloGatherOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + BatchMatMulOptionsStart(builder) + BatchMatMulOptionsAddAdjX(builder, self.adjX) + BatchMatMulOptionsAddAdjY(builder, self.adjY) + BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) + batchMatMulOptions = BatchMatMulOptionsEnd(builder) + return batchMatMulOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloIotaOptions(object): +class CumsumOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloIotaOptions() + x = CumsumOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloIotaOptions(cls, buf, offset=0): + def GetRootAsCumsumOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloIotaOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def CumsumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloIotaOptions + # CumsumOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloIotaOptions - def IotaDimension(self): + # CumsumOptions + def Exclusive(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # CumsumOptions + def Reverse(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False -def StablehloIotaOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return StablehloIotaOptionsStart(builder) -def StablehloIotaOptionsAddIotaDimension(builder, iotaDimension): builder.PrependInt64Slot(0, iotaDimension, 0) -def AddIotaDimension(builder, iotaDimension): - return StablehloIotaOptionsAddIotaDimension(builder, iotaDimension) -def StablehloIotaOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloIotaOptionsEnd(builder) +def CumsumOptionsStart(builder): + builder.StartObject(2) -class StablehloIotaOptionsT(object): +def CumsumOptionsAddExclusive(builder, exclusive): + builder.PrependBoolSlot(0, exclusive, 0) - # StablehloIotaOptionsT +def CumsumOptionsAddReverse(builder, reverse): + builder.PrependBoolSlot(1, reverse, 0) + +def CumsumOptionsEnd(builder): + return builder.EndObject() + + + +class CumsumOptionsT(object): + + # CumsumOptionsT def __init__(self): - self.iotaDimension = 0 # type: int + self.exclusive = False # type: bool + self.reverse = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - stablehloIotaOptions = StablehloIotaOptions() - stablehloIotaOptions.Init(buf, pos) - return cls.InitFromObj(stablehloIotaOptions) + cumsumOptions = CumsumOptions() + cumsumOptions.Init(buf, pos) + return cls.InitFromObj(cumsumOptions) @classmethod - def InitFromObj(cls, stablehloIotaOptions): - x = StablehloIotaOptionsT() - x._UnPack(stablehloIotaOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, cumsumOptions): + x = CumsumOptionsT() + x._UnPack(cumsumOptions) return x - # StablehloIotaOptionsT - def _UnPack(self, stablehloIotaOptions): - if stablehloIotaOptions is None: + # CumsumOptionsT + def _UnPack(self, cumsumOptions): + if cumsumOptions is None: return - self.iotaDimension = stablehloIotaOptions.IotaDimension() + self.exclusive = cumsumOptions.Exclusive() + self.reverse = cumsumOptions.Reverse() - # StablehloIotaOptionsT + # CumsumOptionsT def Pack(self, builder): - StablehloIotaOptionsStart(builder) - StablehloIotaOptionsAddIotaDimension(builder, self.iotaDimension) - stablehloIotaOptions = StablehloIotaOptionsEnd(builder) - return stablehloIotaOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + CumsumOptionsStart(builder) + CumsumOptionsAddExclusive(builder, self.exclusive) + CumsumOptionsAddReverse(builder, self.reverse) + cumsumOptions = CumsumOptionsEnd(builder) + return cumsumOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloPadOptions(object): +class BroadcastToOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloPadOptions() + x = BroadcastToOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloPadOptions(cls, buf, offset=0): + def GetRootAsBroadcastToOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloPadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def BroadcastToOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloPadOptions + # BroadcastToOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloPadOptions - def EdgePaddingLow(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloPadOptions - def EdgePaddingLowAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloPadOptions - def EdgePaddingLowLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloPadOptions - def EdgePaddingLowIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - - # StablehloPadOptions - def EdgePaddingHigh(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloPadOptions - def EdgePaddingHighAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloPadOptions - def EdgePaddingHighLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloPadOptions - def EdgePaddingHighIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 - - # StablehloPadOptions - def InteriorPadding(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloPadOptions - def InteriorPaddingAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloPadOptions - def InteriorPaddingLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloPadOptions - def InteriorPaddingIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 - -def StablehloPadOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return StablehloPadOptionsStart(builder) -def StablehloPadOptionsAddEdgePaddingLow(builder, edgePaddingLow): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(edgePaddingLow), 0) -def AddEdgePaddingLow(builder, edgePaddingLow): - return StablehloPadOptionsAddEdgePaddingLow(builder, edgePaddingLow) -def StablehloPadOptionsStartEdgePaddingLowVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartEdgePaddingLowVector(builder, numElems): - return StablehloPadOptionsStartEdgePaddingLowVector(builder, numElems) -def StablehloPadOptionsAddEdgePaddingHigh(builder, edgePaddingHigh): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(edgePaddingHigh), 0) -def AddEdgePaddingHigh(builder, edgePaddingHigh): - return StablehloPadOptionsAddEdgePaddingHigh(builder, edgePaddingHigh) -def StablehloPadOptionsStartEdgePaddingHighVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartEdgePaddingHighVector(builder, numElems): - return StablehloPadOptionsStartEdgePaddingHighVector(builder, numElems) -def StablehloPadOptionsAddInteriorPadding(builder, interiorPadding): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(interiorPadding), 0) -def AddInteriorPadding(builder, interiorPadding): - return StablehloPadOptionsAddInteriorPadding(builder, interiorPadding) -def StablehloPadOptionsStartInteriorPaddingVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartInteriorPaddingVector(builder, numElems): - return StablehloPadOptionsStartInteriorPaddingVector(builder, numElems) -def StablehloPadOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloPadOptionsEnd(builder) -try: - from typing import List -except: - pass +def BroadcastToOptionsStart(builder): + builder.StartObject(0) -class StablehloPadOptionsT(object): - - # StablehloPadOptionsT - def __init__(self): - self.edgePaddingLow = None # type: List[int] - self.edgePaddingHigh = None # type: List[int] - self.interiorPadding = None # type: List[int] - - @classmethod - def InitFromBuf(cls, buf, pos): - stablehloPadOptions = StablehloPadOptions() - stablehloPadOptions.Init(buf, pos) - return cls.InitFromObj(stablehloPadOptions) - - @classmethod - def InitFromObj(cls, stablehloPadOptions): - x = StablehloPadOptionsT() - x._UnPack(stablehloPadOptions) - return x +def BroadcastToOptionsEnd(builder): + return builder.EndObject() - # StablehloPadOptionsT - def _UnPack(self, stablehloPadOptions): - if stablehloPadOptions is None: - return - if not stablehloPadOptions.EdgePaddingLowIsNone(): - if np is None: - self.edgePaddingLow = [] - for i in range(stablehloPadOptions.EdgePaddingLowLength()): - self.edgePaddingLow.append(stablehloPadOptions.EdgePaddingLow(i)) - else: - self.edgePaddingLow = stablehloPadOptions.EdgePaddingLowAsNumpy() - if not stablehloPadOptions.EdgePaddingHighIsNone(): - if np is None: - self.edgePaddingHigh = [] - for i in range(stablehloPadOptions.EdgePaddingHighLength()): - self.edgePaddingHigh.append(stablehloPadOptions.EdgePaddingHigh(i)) - else: - self.edgePaddingHigh = stablehloPadOptions.EdgePaddingHighAsNumpy() - if not stablehloPadOptions.InteriorPaddingIsNone(): - if np is None: - self.interiorPadding = [] - for i in range(stablehloPadOptions.InteriorPaddingLength()): - self.interiorPadding.append(stablehloPadOptions.InteriorPadding(i)) - else: - self.interiorPadding = stablehloPadOptions.InteriorPaddingAsNumpy() - # StablehloPadOptionsT - def Pack(self, builder): - if self.edgePaddingLow is not None: - if np is not None and type(self.edgePaddingLow) is np.ndarray: - edgePaddingLow = builder.CreateNumpyVector(self.edgePaddingLow) - else: - StablehloPadOptionsStartEdgePaddingLowVector(builder, len(self.edgePaddingLow)) - for i in reversed(range(len(self.edgePaddingLow))): - builder.PrependInt64(self.edgePaddingLow[i]) - edgePaddingLow = builder.EndVector() - if self.edgePaddingHigh is not None: - if np is not None and type(self.edgePaddingHigh) is np.ndarray: - edgePaddingHigh = builder.CreateNumpyVector(self.edgePaddingHigh) - else: - StablehloPadOptionsStartEdgePaddingHighVector(builder, len(self.edgePaddingHigh)) - for i in reversed(range(len(self.edgePaddingHigh))): - builder.PrependInt64(self.edgePaddingHigh[i]) - edgePaddingHigh = builder.EndVector() - if self.interiorPadding is not None: - if np is not None and type(self.interiorPadding) is np.ndarray: - interiorPadding = builder.CreateNumpyVector(self.interiorPadding) - else: - StablehloPadOptionsStartInteriorPaddingVector(builder, len(self.interiorPadding)) - for i in reversed(range(len(self.interiorPadding))): - builder.PrependInt64(self.interiorPadding[i]) - interiorPadding = builder.EndVector() - StablehloPadOptionsStart(builder) - if self.edgePaddingLow is not None: - StablehloPadOptionsAddEdgePaddingLow(builder, edgePaddingLow) - if self.edgePaddingHigh is not None: - StablehloPadOptionsAddEdgePaddingHigh(builder, edgePaddingHigh) - if self.interiorPadding is not None: - StablehloPadOptionsAddInteriorPadding(builder, interiorPadding) - stablehloPadOptions = StablehloPadOptionsEnd(builder) - return stablehloPadOptions -# automatically generated by the FlatBuffers compiler, do not modify -# namespace: tflite +class BroadcastToOptionsT(object): -class StablehloPrecisionConfig(object): - DEFAULT = 0 - HIGH = 1 - HIGHEST = 2 -# automatically generated by the FlatBuffers compiler, do not modify + # BroadcastToOptionsT + def __init__(self): + pass -# namespace: tflite + @classmethod + def InitFromBuf(cls, buf, pos): + broadcastToOptions = BroadcastToOptions() + broadcastToOptions.Init(buf, pos) + return cls.InitFromObj(broadcastToOptions) -from flatbuffers.compat import import_numpy -np = import_numpy() + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) -class StablehloReduceOptions(object): + @classmethod + def InitFromObj(cls, broadcastToOptions): + x = BroadcastToOptionsT() + x._UnPack(broadcastToOptions) + return x + + # BroadcastToOptionsT + def _UnPack(self, broadcastToOptions): + if broadcastToOptions is None: + return + + # BroadcastToOptionsT + def Pack(self, builder): + BroadcastToOptionsStart(builder) + broadcastToOptions = BroadcastToOptionsEnd(builder) + return broadcastToOptions + + +class Rfft2dOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloReduceOptions() + x = Rfft2dOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloReduceOptions(cls, buf, offset=0): + def GetRootAsRfft2dOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloReduceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def Rfft2dOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloReduceOptions + # Rfft2dOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloReduceOptions - def Dimensions(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloReduceOptions - def DimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloReduceOptions - def DimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def Rfft2dOptionsStart(builder): + builder.StartObject(0) - # StablehloReduceOptions - def DimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 +def Rfft2dOptionsEnd(builder): + return builder.EndObject() - # StablehloReduceOptions - def BodySubgraphIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 -def StablehloReduceOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return StablehloReduceOptionsStart(builder) -def StablehloReduceOptionsAddDimensions(builder, dimensions): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(dimensions), 0) -def AddDimensions(builder, dimensions): - return StablehloReduceOptionsAddDimensions(builder, dimensions) -def StablehloReduceOptionsStartDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartDimensionsVector(builder, numElems): - return StablehloReduceOptionsStartDimensionsVector(builder, numElems) -def StablehloReduceOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): builder.PrependInt32Slot(1, bodySubgraphIndex, 0) -def AddBodySubgraphIndex(builder, bodySubgraphIndex): - return StablehloReduceOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex) -def StablehloReduceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloReduceOptionsEnd(builder) -try: - from typing import List -except: - pass -class StablehloReduceOptionsT(object): +class Rfft2dOptionsT(object): - # StablehloReduceOptionsT + # Rfft2dOptionsT def __init__(self): - self.dimensions = None # type: List[int] - self.bodySubgraphIndex = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloReduceOptions = StablehloReduceOptions() - stablehloReduceOptions.Init(buf, pos) - return cls.InitFromObj(stablehloReduceOptions) + rfft2dOptions = Rfft2dOptions() + rfft2dOptions.Init(buf, pos) + return cls.InitFromObj(rfft2dOptions) @classmethod - def InitFromObj(cls, stablehloReduceOptions): - x = StablehloReduceOptionsT() - x._UnPack(stablehloReduceOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, rfft2dOptions): + x = Rfft2dOptionsT() + x._UnPack(rfft2dOptions) return x - # StablehloReduceOptionsT - def _UnPack(self, stablehloReduceOptions): - if stablehloReduceOptions is None: + # Rfft2dOptionsT + def _UnPack(self, rfft2dOptions): + if rfft2dOptions is None: return - if not stablehloReduceOptions.DimensionsIsNone(): - if np is None: - self.dimensions = [] - for i in range(stablehloReduceOptions.DimensionsLength()): - self.dimensions.append(stablehloReduceOptions.Dimensions(i)) - else: - self.dimensions = stablehloReduceOptions.DimensionsAsNumpy() - self.bodySubgraphIndex = stablehloReduceOptions.BodySubgraphIndex() - # StablehloReduceOptionsT + # Rfft2dOptionsT def Pack(self, builder): - if self.dimensions is not None: - if np is not None and type(self.dimensions) is np.ndarray: - dimensions = builder.CreateNumpyVector(self.dimensions) - else: - StablehloReduceOptionsStartDimensionsVector(builder, len(self.dimensions)) - for i in reversed(range(len(self.dimensions))): - builder.PrependInt64(self.dimensions[i]) - dimensions = builder.EndVector() - StablehloReduceOptionsStart(builder) - if self.dimensions is not None: - StablehloReduceOptionsAddDimensions(builder, dimensions) - StablehloReduceOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex) - stablehloReduceOptions = StablehloReduceOptionsEnd(builder) - return stablehloReduceOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + Rfft2dOptionsStart(builder) + rfft2dOptions = Rfft2dOptionsEnd(builder) + return rfft2dOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloReduceWindowOptions(object): +class HashtableOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloReduceWindowOptions() + x = HashtableOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloReduceWindowOptions(cls, buf, offset=0): + def GetRootAsHashtableOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloReduceWindowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def HashtableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloReduceWindowOptions + # HashtableOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloReduceWindowOptions - def WindowDimensions(self, j): + # HashtableOptions + def TableId(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # StablehloReduceWindowOptions - def WindowDimensionsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # HashtableOptions + def KeyDtype(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # StablehloReduceWindowOptions - def WindowDimensionsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # HashtableOptions + def ValueDtype(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.VectorLen(o) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # StablehloReduceWindowOptions - def WindowDimensionsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 +def HashtableOptionsStart(builder): + builder.StartObject(3) - # StablehloReduceWindowOptions - def WindowStrides(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 +def HashtableOptionsAddTableId(builder, tableId): + builder.PrependInt32Slot(0, tableId, 0) - # StablehloReduceWindowOptions - def WindowStridesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 +def HashtableOptionsAddKeyDtype(builder, keyDtype): + builder.PrependInt8Slot(1, keyDtype, 0) + +def HashtableOptionsAddValueDtype(builder, valueDtype): + builder.PrependInt8Slot(2, valueDtype, 0) + +def HashtableOptionsEnd(builder): + return builder.EndObject() + + + +class HashtableOptionsT(object): + + # HashtableOptionsT + def __init__(self): + self.tableId = 0 # type: int + self.keyDtype = 0 # type: int + self.valueDtype = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + hashtableOptions = HashtableOptions() + hashtableOptions.Init(buf, pos) + return cls.InitFromObj(hashtableOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, hashtableOptions): + x = HashtableOptionsT() + x._UnPack(hashtableOptions) + return x + + # HashtableOptionsT + def _UnPack(self, hashtableOptions): + if hashtableOptions is None: + return + self.tableId = hashtableOptions.TableId() + self.keyDtype = hashtableOptions.KeyDtype() + self.valueDtype = hashtableOptions.ValueDtype() + + # HashtableOptionsT + def Pack(self, builder): + HashtableOptionsStart(builder) + HashtableOptionsAddTableId(builder, self.tableId) + HashtableOptionsAddKeyDtype(builder, self.keyDtype) + HashtableOptionsAddValueDtype(builder, self.valueDtype) + hashtableOptions = HashtableOptionsEnd(builder) + return hashtableOptions + + +class HashtableFindOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = HashtableFindOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsHashtableFindOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def HashtableFindOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # HashtableFindOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) - # StablehloReduceWindowOptions - def WindowStridesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def HashtableFindOptionsStart(builder): + builder.StartObject(0) - # StablehloReduceWindowOptions - def WindowStridesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 +def HashtableFindOptionsEnd(builder): + return builder.EndObject() - # StablehloReduceWindowOptions - def BaseDilations(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - # StablehloReduceWindowOptions - def BaseDilationsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - # StablehloReduceWindowOptions - def BaseDilationsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class HashtableFindOptionsT(object): - # StablehloReduceWindowOptions - def BaseDilationsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 + # HashtableFindOptionsT + def __init__(self): + pass - # StablehloReduceWindowOptions - def WindowDilations(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 + @classmethod + def InitFromBuf(cls, buf, pos): + hashtableFindOptions = HashtableFindOptions() + hashtableFindOptions.Init(buf, pos) + return cls.InitFromObj(hashtableFindOptions) - # StablehloReduceWindowOptions - def WindowDilationsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # StablehloReduceWindowOptions - def WindowDilationsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + @classmethod + def InitFromObj(cls, hashtableFindOptions): + x = HashtableFindOptionsT() + x._UnPack(hashtableFindOptions) + return x - # StablehloReduceWindowOptions - def WindowDilationsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - return o == 0 + # HashtableFindOptionsT + def _UnPack(self, hashtableFindOptions): + if hashtableFindOptions is None: + return - # StablehloReduceWindowOptions - def Padding(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 + # HashtableFindOptionsT + def Pack(self, builder): + HashtableFindOptionsStart(builder) + hashtableFindOptions = HashtableFindOptionsEnd(builder) + return hashtableFindOptions - # StablehloReduceWindowOptions - def PaddingAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - # StablehloReduceWindowOptions - def PaddingLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class HashtableImportOptions(object): + __slots__ = ['_tab'] - # StablehloReduceWindowOptions - def PaddingIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - return o == 0 + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = HashtableImportOptions() + x.Init(buf, n + offset) + return x - # StablehloReduceWindowOptions - def BodySubgraphIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 + @classmethod + def GetRootAsHashtableImportOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def HashtableImportOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) -def StablehloReduceWindowOptionsStart(builder): builder.StartObject(6) -def Start(builder): - return StablehloReduceWindowOptionsStart(builder) -def StablehloReduceWindowOptionsAddWindowDimensions(builder, windowDimensions): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(windowDimensions), 0) -def AddWindowDimensions(builder, windowDimensions): - return StablehloReduceWindowOptionsAddWindowDimensions(builder, windowDimensions) -def StablehloReduceWindowOptionsStartWindowDimensionsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartWindowDimensionsVector(builder, numElems): - return StablehloReduceWindowOptionsStartWindowDimensionsVector(builder, numElems) -def StablehloReduceWindowOptionsAddWindowStrides(builder, windowStrides): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(windowStrides), 0) -def AddWindowStrides(builder, windowStrides): - return StablehloReduceWindowOptionsAddWindowStrides(builder, windowStrides) -def StablehloReduceWindowOptionsStartWindowStridesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartWindowStridesVector(builder, numElems): - return StablehloReduceWindowOptionsStartWindowStridesVector(builder, numElems) -def StablehloReduceWindowOptionsAddBaseDilations(builder, baseDilations): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(baseDilations), 0) -def AddBaseDilations(builder, baseDilations): - return StablehloReduceWindowOptionsAddBaseDilations(builder, baseDilations) -def StablehloReduceWindowOptionsStartBaseDilationsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartBaseDilationsVector(builder, numElems): - return StablehloReduceWindowOptionsStartBaseDilationsVector(builder, numElems) -def StablehloReduceWindowOptionsAddWindowDilations(builder, windowDilations): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(windowDilations), 0) -def AddWindowDilations(builder, windowDilations): - return StablehloReduceWindowOptionsAddWindowDilations(builder, windowDilations) -def StablehloReduceWindowOptionsStartWindowDilationsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartWindowDilationsVector(builder, numElems): - return StablehloReduceWindowOptionsStartWindowDilationsVector(builder, numElems) -def StablehloReduceWindowOptionsAddPadding(builder, padding): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) -def AddPadding(builder, padding): - return StablehloReduceWindowOptionsAddPadding(builder, padding) -def StablehloReduceWindowOptionsStartPaddingVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartPaddingVector(builder, numElems): - return StablehloReduceWindowOptionsStartPaddingVector(builder, numElems) -def StablehloReduceWindowOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): builder.PrependInt32Slot(5, bodySubgraphIndex, 0) -def AddBodySubgraphIndex(builder, bodySubgraphIndex): - return StablehloReduceWindowOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex) -def StablehloReduceWindowOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloReduceWindowOptionsEnd(builder) -try: - from typing import List -except: - pass + # HashtableImportOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) -class StablehloReduceWindowOptionsT(object): +def HashtableImportOptionsStart(builder): + builder.StartObject(0) - # StablehloReduceWindowOptionsT +def HashtableImportOptionsEnd(builder): + return builder.EndObject() + + + +class HashtableImportOptionsT(object): + + # HashtableImportOptionsT def __init__(self): - self.windowDimensions = None # type: List[int] - self.windowStrides = None # type: List[int] - self.baseDilations = None # type: List[int] - self.windowDilations = None # type: List[int] - self.padding = None # type: List[int] - self.bodySubgraphIndex = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloReduceWindowOptions = StablehloReduceWindowOptions() - stablehloReduceWindowOptions.Init(buf, pos) - return cls.InitFromObj(stablehloReduceWindowOptions) + hashtableImportOptions = HashtableImportOptions() + hashtableImportOptions.Init(buf, pos) + return cls.InitFromObj(hashtableImportOptions) @classmethod - def InitFromObj(cls, stablehloReduceWindowOptions): - x = StablehloReduceWindowOptionsT() - x._UnPack(stablehloReduceWindowOptions) - return x - - # StablehloReduceWindowOptionsT - def _UnPack(self, stablehloReduceWindowOptions): - if stablehloReduceWindowOptions is None: - return - if not stablehloReduceWindowOptions.WindowDimensionsIsNone(): - if np is None: - self.windowDimensions = [] - for i in range(stablehloReduceWindowOptions.WindowDimensionsLength()): - self.windowDimensions.append(stablehloReduceWindowOptions.WindowDimensions(i)) - else: - self.windowDimensions = stablehloReduceWindowOptions.WindowDimensionsAsNumpy() - if not stablehloReduceWindowOptions.WindowStridesIsNone(): - if np is None: - self.windowStrides = [] - for i in range(stablehloReduceWindowOptions.WindowStridesLength()): - self.windowStrides.append(stablehloReduceWindowOptions.WindowStrides(i)) - else: - self.windowStrides = stablehloReduceWindowOptions.WindowStridesAsNumpy() - if not stablehloReduceWindowOptions.BaseDilationsIsNone(): - if np is None: - self.baseDilations = [] - for i in range(stablehloReduceWindowOptions.BaseDilationsLength()): - self.baseDilations.append(stablehloReduceWindowOptions.BaseDilations(i)) - else: - self.baseDilations = stablehloReduceWindowOptions.BaseDilationsAsNumpy() - if not stablehloReduceWindowOptions.WindowDilationsIsNone(): - if np is None: - self.windowDilations = [] - for i in range(stablehloReduceWindowOptions.WindowDilationsLength()): - self.windowDilations.append(stablehloReduceWindowOptions.WindowDilations(i)) - else: - self.windowDilations = stablehloReduceWindowOptions.WindowDilationsAsNumpy() - if not stablehloReduceWindowOptions.PaddingIsNone(): - if np is None: - self.padding = [] - for i in range(stablehloReduceWindowOptions.PaddingLength()): - self.padding.append(stablehloReduceWindowOptions.Padding(i)) - else: - self.padding = stablehloReduceWindowOptions.PaddingAsNumpy() - self.bodySubgraphIndex = stablehloReduceWindowOptions.BodySubgraphIndex() + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # StablehloReduceWindowOptionsT - def Pack(self, builder): - if self.windowDimensions is not None: - if np is not None and type(self.windowDimensions) is np.ndarray: - windowDimensions = builder.CreateNumpyVector(self.windowDimensions) - else: - StablehloReduceWindowOptionsStartWindowDimensionsVector(builder, len(self.windowDimensions)) - for i in reversed(range(len(self.windowDimensions))): - builder.PrependInt64(self.windowDimensions[i]) - windowDimensions = builder.EndVector() - if self.windowStrides is not None: - if np is not None and type(self.windowStrides) is np.ndarray: - windowStrides = builder.CreateNumpyVector(self.windowStrides) - else: - StablehloReduceWindowOptionsStartWindowStridesVector(builder, len(self.windowStrides)) - for i in reversed(range(len(self.windowStrides))): - builder.PrependInt64(self.windowStrides[i]) - windowStrides = builder.EndVector() - if self.baseDilations is not None: - if np is not None and type(self.baseDilations) is np.ndarray: - baseDilations = builder.CreateNumpyVector(self.baseDilations) - else: - StablehloReduceWindowOptionsStartBaseDilationsVector(builder, len(self.baseDilations)) - for i in reversed(range(len(self.baseDilations))): - builder.PrependInt64(self.baseDilations[i]) - baseDilations = builder.EndVector() - if self.windowDilations is not None: - if np is not None and type(self.windowDilations) is np.ndarray: - windowDilations = builder.CreateNumpyVector(self.windowDilations) - else: - StablehloReduceWindowOptionsStartWindowDilationsVector(builder, len(self.windowDilations)) - for i in reversed(range(len(self.windowDilations))): - builder.PrependInt64(self.windowDilations[i]) - windowDilations = builder.EndVector() - if self.padding is not None: - if np is not None and type(self.padding) is np.ndarray: - padding = builder.CreateNumpyVector(self.padding) - else: - StablehloReduceWindowOptionsStartPaddingVector(builder, len(self.padding)) - for i in reversed(range(len(self.padding))): - builder.PrependInt64(self.padding[i]) - padding = builder.EndVector() - StablehloReduceWindowOptionsStart(builder) - if self.windowDimensions is not None: - StablehloReduceWindowOptionsAddWindowDimensions(builder, windowDimensions) - if self.windowStrides is not None: - StablehloReduceWindowOptionsAddWindowStrides(builder, windowStrides) - if self.baseDilations is not None: - StablehloReduceWindowOptionsAddBaseDilations(builder, baseDilations) - if self.windowDilations is not None: - StablehloReduceWindowOptionsAddWindowDilations(builder, windowDilations) - if self.padding is not None: - StablehloReduceWindowOptionsAddPadding(builder, padding) - StablehloReduceWindowOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex) - stablehloReduceWindowOptions = StablehloReduceWindowOptionsEnd(builder) - return stablehloReduceWindowOptions -# automatically generated by the FlatBuffers compiler, do not modify + @classmethod + def InitFromObj(cls, hashtableImportOptions): + x = HashtableImportOptionsT() + x._UnPack(hashtableImportOptions) + return x -# namespace: tflite + # HashtableImportOptionsT + def _UnPack(self, hashtableImportOptions): + if hashtableImportOptions is None: + return -from flatbuffers.compat import import_numpy -np = import_numpy() + # HashtableImportOptionsT + def Pack(self, builder): + HashtableImportOptionsStart(builder) + hashtableImportOptions = HashtableImportOptionsEnd(builder) + return hashtableImportOptions -class StablehloRngBitGeneratorOptions(object): + +class HashtableSizeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloRngBitGeneratorOptions() + x = HashtableSizeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloRngBitGeneratorOptions(cls, buf, offset=0): + def GetRootAsHashtableSizeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloRngBitGeneratorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def HashtableSizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloRngBitGeneratorOptions + # HashtableSizeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloRngBitGeneratorOptions - def Algorithm(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def HashtableSizeOptionsStart(builder): + builder.StartObject(0) -def StablehloRngBitGeneratorOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return StablehloRngBitGeneratorOptionsStart(builder) -def StablehloRngBitGeneratorOptionsAddAlgorithm(builder, algorithm): builder.PrependInt8Slot(0, algorithm, 0) -def AddAlgorithm(builder, algorithm): - return StablehloRngBitGeneratorOptionsAddAlgorithm(builder, algorithm) -def StablehloRngBitGeneratorOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloRngBitGeneratorOptionsEnd(builder) +def HashtableSizeOptionsEnd(builder): + return builder.EndObject() -class StablehloRngBitGeneratorOptionsT(object): - # StablehloRngBitGeneratorOptionsT + +class HashtableSizeOptionsT(object): + + # HashtableSizeOptionsT def __init__(self): - self.algorithm = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptions() - stablehloRngBitGeneratorOptions.Init(buf, pos) - return cls.InitFromObj(stablehloRngBitGeneratorOptions) + hashtableSizeOptions = HashtableSizeOptions() + hashtableSizeOptions.Init(buf, pos) + return cls.InitFromObj(hashtableSizeOptions) @classmethod - def InitFromObj(cls, stablehloRngBitGeneratorOptions): - x = StablehloRngBitGeneratorOptionsT() - x._UnPack(stablehloRngBitGeneratorOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, hashtableSizeOptions): + x = HashtableSizeOptionsT() + x._UnPack(hashtableSizeOptions) return x - # StablehloRngBitGeneratorOptionsT - def _UnPack(self, stablehloRngBitGeneratorOptions): - if stablehloRngBitGeneratorOptions is None: + # HashtableSizeOptionsT + def _UnPack(self, hashtableSizeOptions): + if hashtableSizeOptions is None: return - self.algorithm = stablehloRngBitGeneratorOptions.Algorithm() - # StablehloRngBitGeneratorOptionsT + # HashtableSizeOptionsT def Pack(self, builder): - StablehloRngBitGeneratorOptionsStart(builder) - StablehloRngBitGeneratorOptionsAddAlgorithm(builder, self.algorithm) - stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptionsEnd(builder) - return stablehloRngBitGeneratorOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + HashtableSizeOptionsStart(builder) + hashtableSizeOptions = HashtableSizeOptionsEnd(builder) + return hashtableSizeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloScatterOptions(object): +class VarHandleOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloScatterOptions() + x = VarHandleOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloScatterOptions(cls, buf, offset=0): + def GetRootAsVarHandleOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloScatterOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def VarHandleOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloScatterOptions + # VarHandleOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloScatterOptions - def IndicesAreSorted(self): + # VarHandleOptions + def Container(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - - # StablehloScatterOptions - def UpdateWindowDims(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloScatterOptions - def UpdateWindowDimsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloScatterOptions - def UpdateWindowDimsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + return self._tab.String(o + self._tab.Pos) + return None - # StablehloScatterOptions - def UpdateWindowDimsIsNone(self): + # VarHandleOptions + def SharedName(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 - - # StablehloScatterOptions - def InsertedWindowDims(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloScatterOptions - def InsertedWindowDimsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloScatterOptions - def InsertedWindowDimsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloScatterOptions - def InsertedWindowDimsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 - - # StablehloScatterOptions - def ScatterDimsToOperandDims(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloScatterOptions - def ScatterDimsToOperandDimsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 + return self._tab.String(o + self._tab.Pos) + return None - # StablehloScatterOptions - def ScatterDimsToOperandDimsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def VarHandleOptionsStart(builder): + builder.StartObject(2) - # StablehloScatterOptions - def ScatterDimsToOperandDimsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - return o == 0 +def VarHandleOptionsAddContainer(builder, container): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(container), 0) - # StablehloScatterOptions - def IndexVectorDim(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 +def VarHandleOptionsAddSharedName(builder, sharedName): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(sharedName), 0) - # StablehloScatterOptions - def UniqueIndices(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def VarHandleOptionsEnd(builder): + return builder.EndObject() - # StablehloScatterOptions - def UpdateComputationSubgraphIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 -def StablehloScatterOptionsStart(builder): builder.StartObject(7) -def Start(builder): - return StablehloScatterOptionsStart(builder) -def StablehloScatterOptionsAddIndicesAreSorted(builder, indicesAreSorted): builder.PrependBoolSlot(0, indicesAreSorted, 0) -def AddIndicesAreSorted(builder, indicesAreSorted): - return StablehloScatterOptionsAddIndicesAreSorted(builder, indicesAreSorted) -def StablehloScatterOptionsAddUpdateWindowDims(builder, updateWindowDims): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(updateWindowDims), 0) -def AddUpdateWindowDims(builder, updateWindowDims): - return StablehloScatterOptionsAddUpdateWindowDims(builder, updateWindowDims) -def StablehloScatterOptionsStartUpdateWindowDimsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartUpdateWindowDimsVector(builder, numElems): - return StablehloScatterOptionsStartUpdateWindowDimsVector(builder, numElems) -def StablehloScatterOptionsAddInsertedWindowDims(builder, insertedWindowDims): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(insertedWindowDims), 0) -def AddInsertedWindowDims(builder, insertedWindowDims): - return StablehloScatterOptionsAddInsertedWindowDims(builder, insertedWindowDims) -def StablehloScatterOptionsStartInsertedWindowDimsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartInsertedWindowDimsVector(builder, numElems): - return StablehloScatterOptionsStartInsertedWindowDimsVector(builder, numElems) -def StablehloScatterOptionsAddScatterDimsToOperandDims(builder, scatterDimsToOperandDims): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(scatterDimsToOperandDims), 0) -def AddScatterDimsToOperandDims(builder, scatterDimsToOperandDims): - return StablehloScatterOptionsAddScatterDimsToOperandDims(builder, scatterDimsToOperandDims) -def StablehloScatterOptionsStartScatterDimsToOperandDimsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartScatterDimsToOperandDimsVector(builder, numElems): - return StablehloScatterOptionsStartScatterDimsToOperandDimsVector(builder, numElems) -def StablehloScatterOptionsAddIndexVectorDim(builder, indexVectorDim): builder.PrependInt64Slot(4, indexVectorDim, 0) -def AddIndexVectorDim(builder, indexVectorDim): - return StablehloScatterOptionsAddIndexVectorDim(builder, indexVectorDim) -def StablehloScatterOptionsAddUniqueIndices(builder, uniqueIndices): builder.PrependBoolSlot(5, uniqueIndices, 0) -def AddUniqueIndices(builder, uniqueIndices): - return StablehloScatterOptionsAddUniqueIndices(builder, uniqueIndices) -def StablehloScatterOptionsAddUpdateComputationSubgraphIndex(builder, updateComputationSubgraphIndex): builder.PrependInt32Slot(6, updateComputationSubgraphIndex, 0) -def AddUpdateComputationSubgraphIndex(builder, updateComputationSubgraphIndex): - return StablehloScatterOptionsAddUpdateComputationSubgraphIndex(builder, updateComputationSubgraphIndex) -def StablehloScatterOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloScatterOptionsEnd(builder) -try: - from typing import List -except: - pass -class StablehloScatterOptionsT(object): +class VarHandleOptionsT(object): - # StablehloScatterOptionsT + # VarHandleOptionsT def __init__(self): - self.indicesAreSorted = False # type: bool - self.updateWindowDims = None # type: List[int] - self.insertedWindowDims = None # type: List[int] - self.scatterDimsToOperandDims = None # type: List[int] - self.indexVectorDim = 0 # type: int - self.uniqueIndices = False # type: bool - self.updateComputationSubgraphIndex = 0 # type: int + self.container = None # type: str + self.sharedName = None # type: str @classmethod def InitFromBuf(cls, buf, pos): - stablehloScatterOptions = StablehloScatterOptions() - stablehloScatterOptions.Init(buf, pos) - return cls.InitFromObj(stablehloScatterOptions) + varHandleOptions = VarHandleOptions() + varHandleOptions.Init(buf, pos) + return cls.InitFromObj(varHandleOptions) @classmethod - def InitFromObj(cls, stablehloScatterOptions): - x = StablehloScatterOptionsT() - x._UnPack(stablehloScatterOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, varHandleOptions): + x = VarHandleOptionsT() + x._UnPack(varHandleOptions) return x - # StablehloScatterOptionsT - def _UnPack(self, stablehloScatterOptions): - if stablehloScatterOptions is None: + # VarHandleOptionsT + def _UnPack(self, varHandleOptions): + if varHandleOptions is None: return - self.indicesAreSorted = stablehloScatterOptions.IndicesAreSorted() - if not stablehloScatterOptions.UpdateWindowDimsIsNone(): - if np is None: - self.updateWindowDims = [] - for i in range(stablehloScatterOptions.UpdateWindowDimsLength()): - self.updateWindowDims.append(stablehloScatterOptions.UpdateWindowDims(i)) - else: - self.updateWindowDims = stablehloScatterOptions.UpdateWindowDimsAsNumpy() - if not stablehloScatterOptions.InsertedWindowDimsIsNone(): - if np is None: - self.insertedWindowDims = [] - for i in range(stablehloScatterOptions.InsertedWindowDimsLength()): - self.insertedWindowDims.append(stablehloScatterOptions.InsertedWindowDims(i)) - else: - self.insertedWindowDims = stablehloScatterOptions.InsertedWindowDimsAsNumpy() - if not stablehloScatterOptions.ScatterDimsToOperandDimsIsNone(): - if np is None: - self.scatterDimsToOperandDims = [] - for i in range(stablehloScatterOptions.ScatterDimsToOperandDimsLength()): - self.scatterDimsToOperandDims.append(stablehloScatterOptions.ScatterDimsToOperandDims(i)) - else: - self.scatterDimsToOperandDims = stablehloScatterOptions.ScatterDimsToOperandDimsAsNumpy() - self.indexVectorDim = stablehloScatterOptions.IndexVectorDim() - self.uniqueIndices = stablehloScatterOptions.UniqueIndices() - self.updateComputationSubgraphIndex = stablehloScatterOptions.UpdateComputationSubgraphIndex() + self.container = varHandleOptions.Container() + self.sharedName = varHandleOptions.SharedName() - # StablehloScatterOptionsT + # VarHandleOptionsT def Pack(self, builder): - if self.updateWindowDims is not None: - if np is not None and type(self.updateWindowDims) is np.ndarray: - updateWindowDims = builder.CreateNumpyVector(self.updateWindowDims) - else: - StablehloScatterOptionsStartUpdateWindowDimsVector(builder, len(self.updateWindowDims)) - for i in reversed(range(len(self.updateWindowDims))): - builder.PrependInt64(self.updateWindowDims[i]) - updateWindowDims = builder.EndVector() - if self.insertedWindowDims is not None: - if np is not None and type(self.insertedWindowDims) is np.ndarray: - insertedWindowDims = builder.CreateNumpyVector(self.insertedWindowDims) - else: - StablehloScatterOptionsStartInsertedWindowDimsVector(builder, len(self.insertedWindowDims)) - for i in reversed(range(len(self.insertedWindowDims))): - builder.PrependInt64(self.insertedWindowDims[i]) - insertedWindowDims = builder.EndVector() - if self.scatterDimsToOperandDims is not None: - if np is not None and type(self.scatterDimsToOperandDims) is np.ndarray: - scatterDimsToOperandDims = builder.CreateNumpyVector(self.scatterDimsToOperandDims) - else: - StablehloScatterOptionsStartScatterDimsToOperandDimsVector(builder, len(self.scatterDimsToOperandDims)) - for i in reversed(range(len(self.scatterDimsToOperandDims))): - builder.PrependInt64(self.scatterDimsToOperandDims[i]) - scatterDimsToOperandDims = builder.EndVector() - StablehloScatterOptionsStart(builder) - StablehloScatterOptionsAddIndicesAreSorted(builder, self.indicesAreSorted) - if self.updateWindowDims is not None: - StablehloScatterOptionsAddUpdateWindowDims(builder, updateWindowDims) - if self.insertedWindowDims is not None: - StablehloScatterOptionsAddInsertedWindowDims(builder, insertedWindowDims) - if self.scatterDimsToOperandDims is not None: - StablehloScatterOptionsAddScatterDimsToOperandDims(builder, scatterDimsToOperandDims) - StablehloScatterOptionsAddIndexVectorDim(builder, self.indexVectorDim) - StablehloScatterOptionsAddUniqueIndices(builder, self.uniqueIndices) - StablehloScatterOptionsAddUpdateComputationSubgraphIndex(builder, self.updateComputationSubgraphIndex) - stablehloScatterOptions = StablehloScatterOptionsEnd(builder) - return stablehloScatterOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.container is not None: + container = builder.CreateString(self.container) + if self.sharedName is not None: + sharedName = builder.CreateString(self.sharedName) + VarHandleOptionsStart(builder) + if self.container is not None: + VarHandleOptionsAddContainer(builder, container) + if self.sharedName is not None: + VarHandleOptionsAddSharedName(builder, sharedName) + varHandleOptions = VarHandleOptionsEnd(builder) + return varHandleOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloSliceOptions(object): +class ReadVariableOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloSliceOptions() + x = ReadVariableOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloSliceOptions(cls, buf, offset=0): + def GetRootAsReadVariableOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ReadVariableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloSliceOptions + # ReadVariableOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloSliceOptions - def StartIndices(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloSliceOptions - def StartIndicesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloSliceOptions - def StartIndicesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloSliceOptions - def StartIndicesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - - # StablehloSliceOptions - def LimitIndices(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloSliceOptions - def LimitIndicesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 - - # StablehloSliceOptions - def LimitIndicesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # StablehloSliceOptions - def LimitIndicesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 - - # StablehloSliceOptions - def Strides(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) - return 0 - - # StablehloSliceOptions - def StridesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) - return 0 +def ReadVariableOptionsStart(builder): + builder.StartObject(0) - # StablehloSliceOptions - def StridesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def ReadVariableOptionsEnd(builder): + return builder.EndObject() - # StablehloSliceOptions - def StridesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 -def StablehloSliceOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return StablehloSliceOptionsStart(builder) -def StablehloSliceOptionsAddStartIndices(builder, startIndices): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(startIndices), 0) -def AddStartIndices(builder, startIndices): - return StablehloSliceOptionsAddStartIndices(builder, startIndices) -def StablehloSliceOptionsStartStartIndicesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartStartIndicesVector(builder, numElems): - return StablehloSliceOptionsStartStartIndicesVector(builder, numElems) -def StablehloSliceOptionsAddLimitIndices(builder, limitIndices): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(limitIndices), 0) -def AddLimitIndices(builder, limitIndices): - return StablehloSliceOptionsAddLimitIndices(builder, limitIndices) -def StablehloSliceOptionsStartLimitIndicesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartLimitIndicesVector(builder, numElems): - return StablehloSliceOptionsStartLimitIndicesVector(builder, numElems) -def StablehloSliceOptionsAddStrides(builder, strides): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(strides), 0) -def AddStrides(builder, strides): - return StablehloSliceOptionsAddStrides(builder, strides) -def StablehloSliceOptionsStartStridesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartStridesVector(builder, numElems): - return StablehloSliceOptionsStartStridesVector(builder, numElems) -def StablehloSliceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloSliceOptionsEnd(builder) -try: - from typing import List -except: - pass -class StablehloSliceOptionsT(object): +class ReadVariableOptionsT(object): - # StablehloSliceOptionsT + # ReadVariableOptionsT def __init__(self): - self.startIndices = None # type: List[int] - self.limitIndices = None # type: List[int] - self.strides = None # type: List[int] + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloSliceOptions = StablehloSliceOptions() - stablehloSliceOptions.Init(buf, pos) - return cls.InitFromObj(stablehloSliceOptions) + readVariableOptions = ReadVariableOptions() + readVariableOptions.Init(buf, pos) + return cls.InitFromObj(readVariableOptions) @classmethod - def InitFromObj(cls, stablehloSliceOptions): - x = StablehloSliceOptionsT() - x._UnPack(stablehloSliceOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, readVariableOptions): + x = ReadVariableOptionsT() + x._UnPack(readVariableOptions) return x - # StablehloSliceOptionsT - def _UnPack(self, stablehloSliceOptions): - if stablehloSliceOptions is None: + # ReadVariableOptionsT + def _UnPack(self, readVariableOptions): + if readVariableOptions is None: return - if not stablehloSliceOptions.StartIndicesIsNone(): - if np is None: - self.startIndices = [] - for i in range(stablehloSliceOptions.StartIndicesLength()): - self.startIndices.append(stablehloSliceOptions.StartIndices(i)) - else: - self.startIndices = stablehloSliceOptions.StartIndicesAsNumpy() - if not stablehloSliceOptions.LimitIndicesIsNone(): - if np is None: - self.limitIndices = [] - for i in range(stablehloSliceOptions.LimitIndicesLength()): - self.limitIndices.append(stablehloSliceOptions.LimitIndices(i)) - else: - self.limitIndices = stablehloSliceOptions.LimitIndicesAsNumpy() - if not stablehloSliceOptions.StridesIsNone(): - if np is None: - self.strides = [] - for i in range(stablehloSliceOptions.StridesLength()): - self.strides.append(stablehloSliceOptions.Strides(i)) - else: - self.strides = stablehloSliceOptions.StridesAsNumpy() - # StablehloSliceOptionsT + # ReadVariableOptionsT def Pack(self, builder): - if self.startIndices is not None: - if np is not None and type(self.startIndices) is np.ndarray: - startIndices = builder.CreateNumpyVector(self.startIndices) - else: - StablehloSliceOptionsStartStartIndicesVector(builder, len(self.startIndices)) - for i in reversed(range(len(self.startIndices))): - builder.PrependInt64(self.startIndices[i]) - startIndices = builder.EndVector() - if self.limitIndices is not None: - if np is not None and type(self.limitIndices) is np.ndarray: - limitIndices = builder.CreateNumpyVector(self.limitIndices) - else: - StablehloSliceOptionsStartLimitIndicesVector(builder, len(self.limitIndices)) - for i in reversed(range(len(self.limitIndices))): - builder.PrependInt64(self.limitIndices[i]) - limitIndices = builder.EndVector() - if self.strides is not None: - if np is not None and type(self.strides) is np.ndarray: - strides = builder.CreateNumpyVector(self.strides) - else: - StablehloSliceOptionsStartStridesVector(builder, len(self.strides)) - for i in reversed(range(len(self.strides))): - builder.PrependInt64(self.strides[i]) - strides = builder.EndVector() - StablehloSliceOptionsStart(builder) - if self.startIndices is not None: - StablehloSliceOptionsAddStartIndices(builder, startIndices) - if self.limitIndices is not None: - StablehloSliceOptionsAddLimitIndices(builder, limitIndices) - if self.strides is not None: - StablehloSliceOptionsAddStrides(builder, strides) - stablehloSliceOptions = StablehloSliceOptionsEnd(builder) - return stablehloSliceOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ReadVariableOptionsStart(builder) + readVariableOptions = ReadVariableOptionsEnd(builder) + return readVariableOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloSortOptions(object): +class AssignVariableOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloSortOptions() + x = AssignVariableOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloSortOptions(cls, buf, offset=0): + def GetRootAsAssignVariableOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloSortOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def AssignVariableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloSortOptions + # AssignVariableOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloSortOptions - def Dimension(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) - return 0 - - # StablehloSortOptions - def IsStable(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def AssignVariableOptionsStart(builder): + builder.StartObject(0) - # StablehloSortOptions - def ComparatorSubgraphIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def AssignVariableOptionsEnd(builder): + return builder.EndObject() -def StablehloSortOptionsStart(builder): builder.StartObject(3) -def Start(builder): - return StablehloSortOptionsStart(builder) -def StablehloSortOptionsAddDimension(builder, dimension): builder.PrependInt64Slot(0, dimension, 0) -def AddDimension(builder, dimension): - return StablehloSortOptionsAddDimension(builder, dimension) -def StablehloSortOptionsAddIsStable(builder, isStable): builder.PrependBoolSlot(1, isStable, 0) -def AddIsStable(builder, isStable): - return StablehloSortOptionsAddIsStable(builder, isStable) -def StablehloSortOptionsAddComparatorSubgraphIndex(builder, comparatorSubgraphIndex): builder.PrependInt32Slot(2, comparatorSubgraphIndex, 0) -def AddComparatorSubgraphIndex(builder, comparatorSubgraphIndex): - return StablehloSortOptionsAddComparatorSubgraphIndex(builder, comparatorSubgraphIndex) -def StablehloSortOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloSortOptionsEnd(builder) -class StablehloSortOptionsT(object): - # StablehloSortOptionsT +class AssignVariableOptionsT(object): + + # AssignVariableOptionsT def __init__(self): - self.dimension = 0 # type: int - self.isStable = False # type: bool - self.comparatorSubgraphIndex = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - stablehloSortOptions = StablehloSortOptions() - stablehloSortOptions.Init(buf, pos) - return cls.InitFromObj(stablehloSortOptions) + assignVariableOptions = AssignVariableOptions() + assignVariableOptions.Init(buf, pos) + return cls.InitFromObj(assignVariableOptions) @classmethod - def InitFromObj(cls, stablehloSortOptions): - x = StablehloSortOptionsT() - x._UnPack(stablehloSortOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, assignVariableOptions): + x = AssignVariableOptionsT() + x._UnPack(assignVariableOptions) return x - # StablehloSortOptionsT - def _UnPack(self, stablehloSortOptions): - if stablehloSortOptions is None: + # AssignVariableOptionsT + def _UnPack(self, assignVariableOptions): + if assignVariableOptions is None: return - self.dimension = stablehloSortOptions.Dimension() - self.isStable = stablehloSortOptions.IsStable() - self.comparatorSubgraphIndex = stablehloSortOptions.ComparatorSubgraphIndex() - # StablehloSortOptionsT + # AssignVariableOptionsT def Pack(self, builder): - StablehloSortOptionsStart(builder) - StablehloSortOptionsAddDimension(builder, self.dimension) - StablehloSortOptionsAddIsStable(builder, self.isStable) - StablehloSortOptionsAddComparatorSubgraphIndex(builder, self.comparatorSubgraphIndex) - stablehloSortOptions = StablehloSortOptionsEnd(builder) - return stablehloSortOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + AssignVariableOptionsStart(builder) + assignVariableOptions = AssignVariableOptionsEnd(builder) + return assignVariableOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloTransposeOptions(object): +class RandomOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloTransposeOptions() + x = RandomOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloTransposeOptions(cls, buf, offset=0): + def GetRootAsRandomOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloTransposeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def RandomOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloTransposeOptions + # RandomOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloTransposeOptions - def Permutation(self, j): + # RandomOptions + def Seed(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) return 0 - # StablehloTransposeOptions - def PermutationAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # RandomOptions + def Seed2(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o) + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) return 0 - # StablehloTransposeOptions - def PermutationLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def RandomOptionsStart(builder): + builder.StartObject(2) - # StablehloTransposeOptions - def PermutationIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 +def RandomOptionsAddSeed(builder, seed): + builder.PrependInt64Slot(0, seed, 0) -def StablehloTransposeOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return StablehloTransposeOptionsStart(builder) -def StablehloTransposeOptionsAddPermutation(builder, permutation): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(permutation), 0) -def AddPermutation(builder, permutation): - return StablehloTransposeOptionsAddPermutation(builder, permutation) -def StablehloTransposeOptionsStartPermutationVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def StartPermutationVector(builder, numElems): - return StablehloTransposeOptionsStartPermutationVector(builder, numElems) -def StablehloTransposeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloTransposeOptionsEnd(builder) -try: - from typing import List -except: - pass +def RandomOptionsAddSeed2(builder, seed2): + builder.PrependInt64Slot(1, seed2, 0) -class StablehloTransposeOptionsT(object): +def RandomOptionsEnd(builder): + return builder.EndObject() - # StablehloTransposeOptionsT + + +class RandomOptionsT(object): + + # RandomOptionsT def __init__(self): - self.permutation = None # type: List[int] + self.seed = 0 # type: int + self.seed2 = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - stablehloTransposeOptions = StablehloTransposeOptions() - stablehloTransposeOptions.Init(buf, pos) - return cls.InitFromObj(stablehloTransposeOptions) + randomOptions = RandomOptions() + randomOptions.Init(buf, pos) + return cls.InitFromObj(randomOptions) @classmethod - def InitFromObj(cls, stablehloTransposeOptions): - x = StablehloTransposeOptionsT() - x._UnPack(stablehloTransposeOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, randomOptions): + x = RandomOptionsT() + x._UnPack(randomOptions) return x - # StablehloTransposeOptionsT - def _UnPack(self, stablehloTransposeOptions): - if stablehloTransposeOptions is None: + # RandomOptionsT + def _UnPack(self, randomOptions): + if randomOptions is None: return - if not stablehloTransposeOptions.PermutationIsNone(): - if np is None: - self.permutation = [] - for i in range(stablehloTransposeOptions.PermutationLength()): - self.permutation.append(stablehloTransposeOptions.Permutation(i)) - else: - self.permutation = stablehloTransposeOptions.PermutationAsNumpy() + self.seed = randomOptions.Seed() + self.seed2 = randomOptions.Seed2() - # StablehloTransposeOptionsT + # RandomOptionsT def Pack(self, builder): - if self.permutation is not None: - if np is not None and type(self.permutation) is np.ndarray: - permutation = builder.CreateNumpyVector(self.permutation) - else: - StablehloTransposeOptionsStartPermutationVector(builder, len(self.permutation)) - for i in reversed(range(len(self.permutation))): - builder.PrependInt64(self.permutation[i]) - permutation = builder.EndVector() - StablehloTransposeOptionsStart(builder) - if self.permutation is not None: - StablehloTransposeOptionsAddPermutation(builder, permutation) - stablehloTransposeOptions = StablehloTransposeOptionsEnd(builder) - return stablehloTransposeOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + RandomOptionsStart(builder) + RandomOptionsAddSeed(builder, self.seed) + RandomOptionsAddSeed2(builder, self.seed2) + randomOptions = RandomOptionsEnd(builder) + return randomOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StablehloWhileOptions(object): +class BucketizeOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StablehloWhileOptions() + x = BucketizeOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStablehloWhileOptions(cls, buf, offset=0): + def GetRootAsBucketizeOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StablehloWhileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def BucketizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StablehloWhileOptions + # BucketizeOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StablehloWhileOptions - def CondSubgraphIndex(self): + # BucketizeOptions + def Boundaries(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) return 0 - # StablehloWhileOptions - def BodySubgraphIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + # BucketizeOptions + def BoundariesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) + return 0 + + # BucketizeOptions + def BoundariesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) return 0 -def StablehloWhileOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return StablehloWhileOptionsStart(builder) -def StablehloWhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex): builder.PrependInt32Slot(0, condSubgraphIndex, 0) -def AddCondSubgraphIndex(builder, condSubgraphIndex): - return StablehloWhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex) -def StablehloWhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): builder.PrependInt32Slot(1, bodySubgraphIndex, 0) -def AddBodySubgraphIndex(builder, bodySubgraphIndex): - return StablehloWhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex) -def StablehloWhileOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StablehloWhileOptionsEnd(builder) + # BucketizeOptions + def BoundariesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 -class StablehloWhileOptionsT(object): +def BucketizeOptionsStart(builder): + builder.StartObject(1) - # StablehloWhileOptionsT +def BucketizeOptionsAddBoundaries(builder, boundaries): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(boundaries), 0) + +def BucketizeOptionsStartBoundariesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def BucketizeOptionsEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class BucketizeOptionsT(object): + + # BucketizeOptionsT def __init__(self): - self.condSubgraphIndex = 0 # type: int - self.bodySubgraphIndex = 0 # type: int + self.boundaries = None # type: List[float] @classmethod def InitFromBuf(cls, buf, pos): - stablehloWhileOptions = StablehloWhileOptions() - stablehloWhileOptions.Init(buf, pos) - return cls.InitFromObj(stablehloWhileOptions) + bucketizeOptions = BucketizeOptions() + bucketizeOptions.Init(buf, pos) + return cls.InitFromObj(bucketizeOptions) @classmethod - def InitFromObj(cls, stablehloWhileOptions): - x = StablehloWhileOptionsT() - x._UnPack(stablehloWhileOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, bucketizeOptions): + x = BucketizeOptionsT() + x._UnPack(bucketizeOptions) return x - # StablehloWhileOptionsT - def _UnPack(self, stablehloWhileOptions): - if stablehloWhileOptions is None: + # BucketizeOptionsT + def _UnPack(self, bucketizeOptions): + if bucketizeOptions is None: return - self.condSubgraphIndex = stablehloWhileOptions.CondSubgraphIndex() - self.bodySubgraphIndex = stablehloWhileOptions.BodySubgraphIndex() - - # StablehloWhileOptionsT - def Pack(self, builder): - StablehloWhileOptionsStart(builder) - StablehloWhileOptionsAddCondSubgraphIndex(builder, self.condSubgraphIndex) - StablehloWhileOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex) - stablehloWhileOptions = StablehloWhileOptionsEnd(builder) - return stablehloWhileOptions -# automatically generated by the FlatBuffers compiler, do not modify + if not bucketizeOptions.BoundariesIsNone(): + if np is None: + self.boundaries = [] + for i in range(bucketizeOptions.BoundariesLength()): + self.boundaries.append(bucketizeOptions.Boundaries(i)) + else: + self.boundaries = bucketizeOptions.BoundariesAsNumpy() -# namespace: tflite + # BucketizeOptionsT + def Pack(self, builder): + if self.boundaries is not None: + if np is not None and type(self.boundaries) is np.ndarray: + boundaries = builder.CreateNumpyVector(self.boundaries) + else: + BucketizeOptionsStartBoundariesVector(builder, len(self.boundaries)) + for i in reversed(range(len(self.boundaries))): + builder.PrependFloat32(self.boundaries[i]) + boundaries = builder.EndVector() + BucketizeOptionsStart(builder) + if self.boundaries is not None: + BucketizeOptionsAddBoundaries(builder, boundaries) + bucketizeOptions = BucketizeOptionsEnd(builder) + return bucketizeOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class StridedSliceOptions(object): +class GeluOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = StridedSliceOptions() + x = GeluOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsStridedSliceOptions(cls, buf, offset=0): + def GetRootAsGeluOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def StridedSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def GeluOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # StridedSliceOptions + # GeluOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # StridedSliceOptions - def BeginMask(self): + # GeluOptions + def Approximate(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 - - # StridedSliceOptions - def EndMask(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False - # StridedSliceOptions - def EllipsisMask(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def GeluOptionsStart(builder): + builder.StartObject(1) - # StridedSliceOptions - def NewAxisMask(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def GeluOptionsAddApproximate(builder, approximate): + builder.PrependBoolSlot(0, approximate, 0) - # StridedSliceOptions - def ShrinkAxisMask(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def GeluOptionsEnd(builder): + return builder.EndObject() - # StridedSliceOptions - def Offset(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False -def StridedSliceOptionsStart(builder): builder.StartObject(6) -def Start(builder): - return StridedSliceOptionsStart(builder) -def StridedSliceOptionsAddBeginMask(builder, beginMask): builder.PrependInt32Slot(0, beginMask, 0) -def AddBeginMask(builder, beginMask): - return StridedSliceOptionsAddBeginMask(builder, beginMask) -def StridedSliceOptionsAddEndMask(builder, endMask): builder.PrependInt32Slot(1, endMask, 0) -def AddEndMask(builder, endMask): - return StridedSliceOptionsAddEndMask(builder, endMask) -def StridedSliceOptionsAddEllipsisMask(builder, ellipsisMask): builder.PrependInt32Slot(2, ellipsisMask, 0) -def AddEllipsisMask(builder, ellipsisMask): - return StridedSliceOptionsAddEllipsisMask(builder, ellipsisMask) -def StridedSliceOptionsAddNewAxisMask(builder, newAxisMask): builder.PrependInt32Slot(3, newAxisMask, 0) -def AddNewAxisMask(builder, newAxisMask): - return StridedSliceOptionsAddNewAxisMask(builder, newAxisMask) -def StridedSliceOptionsAddShrinkAxisMask(builder, shrinkAxisMask): builder.PrependInt32Slot(4, shrinkAxisMask, 0) -def AddShrinkAxisMask(builder, shrinkAxisMask): - return StridedSliceOptionsAddShrinkAxisMask(builder, shrinkAxisMask) -def StridedSliceOptionsAddOffset(builder, offset): builder.PrependBoolSlot(5, offset, 0) -def AddOffset(builder, offset): - return StridedSliceOptionsAddOffset(builder, offset) -def StridedSliceOptionsEnd(builder): return builder.EndObject() -def End(builder): - return StridedSliceOptionsEnd(builder) -class StridedSliceOptionsT(object): +class GeluOptionsT(object): - # StridedSliceOptionsT + # GeluOptionsT def __init__(self): - self.beginMask = 0 # type: int - self.endMask = 0 # type: int - self.ellipsisMask = 0 # type: int - self.newAxisMask = 0 # type: int - self.shrinkAxisMask = 0 # type: int - self.offset = False # type: bool + self.approximate = False # type: bool @classmethod def InitFromBuf(cls, buf, pos): - stridedSliceOptions = StridedSliceOptions() - stridedSliceOptions.Init(buf, pos) - return cls.InitFromObj(stridedSliceOptions) + geluOptions = GeluOptions() + geluOptions.Init(buf, pos) + return cls.InitFromObj(geluOptions) @classmethod - def InitFromObj(cls, stridedSliceOptions): - x = StridedSliceOptionsT() - x._UnPack(stridedSliceOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, geluOptions): + x = GeluOptionsT() + x._UnPack(geluOptions) return x - # StridedSliceOptionsT - def _UnPack(self, stridedSliceOptions): - if stridedSliceOptions is None: + # GeluOptionsT + def _UnPack(self, geluOptions): + if geluOptions is None: return - self.beginMask = stridedSliceOptions.BeginMask() - self.endMask = stridedSliceOptions.EndMask() - self.ellipsisMask = stridedSliceOptions.EllipsisMask() - self.newAxisMask = stridedSliceOptions.NewAxisMask() - self.shrinkAxisMask = stridedSliceOptions.ShrinkAxisMask() - self.offset = stridedSliceOptions.Offset() + self.approximate = geluOptions.Approximate() - # StridedSliceOptionsT + # GeluOptionsT def Pack(self, builder): - StridedSliceOptionsStart(builder) - StridedSliceOptionsAddBeginMask(builder, self.beginMask) - StridedSliceOptionsAddEndMask(builder, self.endMask) - StridedSliceOptionsAddEllipsisMask(builder, self.ellipsisMask) - StridedSliceOptionsAddNewAxisMask(builder, self.newAxisMask) - StridedSliceOptionsAddShrinkAxisMask(builder, self.shrinkAxisMask) - StridedSliceOptionsAddOffset(builder, self.offset) - stridedSliceOptions = StridedSliceOptionsEnd(builder) - return stridedSliceOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + GeluOptionsStart(builder) + GeluOptionsAddApproximate(builder, self.approximate) + geluOptions = GeluOptionsEnd(builder) + return geluOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SubGraph(object): +class DynamicUpdateSliceOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SubGraph() + x = DynamicUpdateSliceOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSubGraph(cls, buf, offset=0): + def GetRootAsDynamicUpdateSliceOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SubGraphBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def DynamicUpdateSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SubGraph + # DynamicUpdateSliceOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SubGraph - def Tensors(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = Tensor() - obj.Init(self._tab.Bytes, x) - return obj - return None +def DynamicUpdateSliceOptionsStart(builder): + builder.StartObject(0) - # SubGraph - def TensorsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def DynamicUpdateSliceOptionsEnd(builder): + return builder.EndObject() - # SubGraph - def TensorsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - # SubGraph - def Inputs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - # SubGraph - def InputsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 +class DynamicUpdateSliceOptionsT(object): - # SubGraph - def InputsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + # DynamicUpdateSliceOptionsT + def __init__(self): + pass - # SubGraph - def InputsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 + @classmethod + def InitFromBuf(cls, buf, pos): + dynamicUpdateSliceOptions = DynamicUpdateSliceOptions() + dynamicUpdateSliceOptions.Init(buf, pos) + return cls.InitFromObj(dynamicUpdateSliceOptions) - # SubGraph - def Outputs(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # SubGraph - def OutputsAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 + @classmethod + def InitFromObj(cls, dynamicUpdateSliceOptions): + x = DynamicUpdateSliceOptionsT() + x._UnPack(dynamicUpdateSliceOptions) + return x - # SubGraph - def OutputsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + # DynamicUpdateSliceOptionsT + def _UnPack(self, dynamicUpdateSliceOptions): + if dynamicUpdateSliceOptions is None: + return - # SubGraph - def OutputsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 + # DynamicUpdateSliceOptionsT + def Pack(self, builder): + DynamicUpdateSliceOptionsStart(builder) + dynamicUpdateSliceOptions = DynamicUpdateSliceOptionsEnd(builder) + return dynamicUpdateSliceOptions - # SubGraph - def Operators(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = Operator() - obj.Init(self._tab.Bytes, x) - return obj - return None - # SubGraph - def OperatorsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +class UnsortedSegmentProdOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = UnsortedSegmentProdOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsUnsortedSegmentProdOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def UnsortedSegmentProdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # UnsortedSegmentProdOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def UnsortedSegmentProdOptionsStart(builder): + builder.StartObject(0) - # SubGraph - def OperatorsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - return o == 0 +def UnsortedSegmentProdOptionsEnd(builder): + return builder.EndObject() - # SubGraph - def Name(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None -def SubGraphStart(builder): builder.StartObject(5) -def Start(builder): - return SubGraphStart(builder) -def SubGraphAddTensors(builder, tensors): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) -def AddTensors(builder, tensors): - return SubGraphAddTensors(builder, tensors) -def SubGraphStartTensorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartTensorsVector(builder, numElems): - return SubGraphStartTensorsVector(builder, numElems) -def SubGraphAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) -def AddInputs(builder, inputs): - return SubGraphAddInputs(builder, inputs) -def SubGraphStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartInputsVector(builder, numElems): - return SubGraphStartInputsVector(builder, numElems) -def SubGraphAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) -def AddOutputs(builder, outputs): - return SubGraphAddOutputs(builder, outputs) -def SubGraphStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartOutputsVector(builder, numElems): - return SubGraphStartOutputsVector(builder, numElems) -def SubGraphAddOperators(builder, operators): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) -def AddOperators(builder, operators): - return SubGraphAddOperators(builder, operators) -def SubGraphStartOperatorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartOperatorsVector(builder, numElems): - return SubGraphStartOperatorsVector(builder, numElems) -def SubGraphAddName(builder, name): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def AddName(builder, name): - return SubGraphAddName(builder, name) -def SubGraphEnd(builder): return builder.EndObject() -def End(builder): - return SubGraphEnd(builder) -try: - from typing import List -except: - pass -class SubGraphT(object): +class UnsortedSegmentProdOptionsT(object): - # SubGraphT + # UnsortedSegmentProdOptionsT def __init__(self): - self.tensors = None # type: List[TensorT] - self.inputs = None # type: List[int] - self.outputs = None # type: List[int] - self.operators = None # type: List[OperatorT] - self.name = None # type: str + pass @classmethod def InitFromBuf(cls, buf, pos): - subGraph = SubGraph() - subGraph.Init(buf, pos) - return cls.InitFromObj(subGraph) + unsortedSegmentProdOptions = UnsortedSegmentProdOptions() + unsortedSegmentProdOptions.Init(buf, pos) + return cls.InitFromObj(unsortedSegmentProdOptions) @classmethod - def InitFromObj(cls, subGraph): - x = SubGraphT() - x._UnPack(subGraph) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, unsortedSegmentProdOptions): + x = UnsortedSegmentProdOptionsT() + x._UnPack(unsortedSegmentProdOptions) return x - # SubGraphT - def _UnPack(self, subGraph): - if subGraph is None: + # UnsortedSegmentProdOptionsT + def _UnPack(self, unsortedSegmentProdOptions): + if unsortedSegmentProdOptions is None: return - if not subGraph.TensorsIsNone(): - self.tensors = [] - for i in range(subGraph.TensorsLength()): - if subGraph.Tensors(i) is None: - self.tensors.append(None) - else: - tensor_ = TensorT.InitFromObj(subGraph.Tensors(i)) - self.tensors.append(tensor_) - if not subGraph.InputsIsNone(): - if np is None: - self.inputs = [] - for i in range(subGraph.InputsLength()): - self.inputs.append(subGraph.Inputs(i)) - else: - self.inputs = subGraph.InputsAsNumpy() - if not subGraph.OutputsIsNone(): - if np is None: - self.outputs = [] - for i in range(subGraph.OutputsLength()): - self.outputs.append(subGraph.Outputs(i)) - else: - self.outputs = subGraph.OutputsAsNumpy() - if not subGraph.OperatorsIsNone(): - self.operators = [] - for i in range(subGraph.OperatorsLength()): - if subGraph.Operators(i) is None: - self.operators.append(None) - else: - operator_ = OperatorT.InitFromObj(subGraph.Operators(i)) - self.operators.append(operator_) - self.name = subGraph.Name() - # SubGraphT + # UnsortedSegmentProdOptionsT def Pack(self, builder): - if self.tensors is not None: - tensorslist = [] - for i in range(len(self.tensors)): - tensorslist.append(self.tensors[i].Pack(builder)) - SubGraphStartTensorsVector(builder, len(self.tensors)) - for i in reversed(range(len(self.tensors))): - builder.PrependUOffsetTRelative(tensorslist[i]) - tensors = builder.EndVector() - if self.inputs is not None: - if np is not None and type(self.inputs) is np.ndarray: - inputs = builder.CreateNumpyVector(self.inputs) - else: - SubGraphStartInputsVector(builder, len(self.inputs)) - for i in reversed(range(len(self.inputs))): - builder.PrependInt32(self.inputs[i]) - inputs = builder.EndVector() - if self.outputs is not None: - if np is not None and type(self.outputs) is np.ndarray: - outputs = builder.CreateNumpyVector(self.outputs) - else: - SubGraphStartOutputsVector(builder, len(self.outputs)) - for i in reversed(range(len(self.outputs))): - builder.PrependInt32(self.outputs[i]) - outputs = builder.EndVector() - if self.operators is not None: - operatorslist = [] - for i in range(len(self.operators)): - operatorslist.append(self.operators[i].Pack(builder)) - SubGraphStartOperatorsVector(builder, len(self.operators)) - for i in reversed(range(len(self.operators))): - builder.PrependUOffsetTRelative(operatorslist[i]) - operators = builder.EndVector() - if self.name is not None: - name = builder.CreateString(self.name) - SubGraphStart(builder) - if self.tensors is not None: - SubGraphAddTensors(builder, tensors) - if self.inputs is not None: - SubGraphAddInputs(builder, inputs) - if self.outputs is not None: - SubGraphAddOutputs(builder, outputs) - if self.operators is not None: - SubGraphAddOperators(builder, operators) - if self.name is not None: - SubGraphAddName(builder, name) - subGraph = SubGraphEnd(builder) - return subGraph -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + UnsortedSegmentProdOptionsStart(builder) + unsortedSegmentProdOptions = UnsortedSegmentProdOptionsEnd(builder) + return unsortedSegmentProdOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class SubOptions(object): +class UnsortedSegmentMaxOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SubOptions() + x = UnsortedSegmentMaxOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsSubOptions(cls, buf, offset=0): + def GetRootAsUnsortedSegmentMaxOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def SubOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def UnsortedSegmentMaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # SubOptions + # UnsortedSegmentMaxOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # SubOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def UnsortedSegmentMaxOptionsStart(builder): + builder.StartObject(0) - # SubOptions - def PotScaleInt16(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return True +def UnsortedSegmentMaxOptionsEnd(builder): + return builder.EndObject() -def SubOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return SubOptionsStart(builder) -def SubOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return SubOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def SubOptionsAddPotScaleInt16(builder, potScaleInt16): builder.PrependBoolSlot(1, potScaleInt16, 1) -def AddPotScaleInt16(builder, potScaleInt16): - return SubOptionsAddPotScaleInt16(builder, potScaleInt16) -def SubOptionsEnd(builder): return builder.EndObject() -def End(builder): - return SubOptionsEnd(builder) -class SubOptionsT(object): - # SubOptionsT +class UnsortedSegmentMaxOptionsT(object): + + # UnsortedSegmentMaxOptionsT def __init__(self): - self.fusedActivationFunction = 0 # type: int - self.potScaleInt16 = True # type: bool + pass @classmethod def InitFromBuf(cls, buf, pos): - subOptions = SubOptions() - subOptions.Init(buf, pos) - return cls.InitFromObj(subOptions) + unsortedSegmentMaxOptions = UnsortedSegmentMaxOptions() + unsortedSegmentMaxOptions.Init(buf, pos) + return cls.InitFromObj(unsortedSegmentMaxOptions) @classmethod - def InitFromObj(cls, subOptions): - x = SubOptionsT() - x._UnPack(subOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, unsortedSegmentMaxOptions): + x = UnsortedSegmentMaxOptionsT() + x._UnPack(unsortedSegmentMaxOptions) return x - # SubOptionsT - def _UnPack(self, subOptions): - if subOptions is None: + # UnsortedSegmentMaxOptionsT + def _UnPack(self, unsortedSegmentMaxOptions): + if unsortedSegmentMaxOptions is None: return - self.fusedActivationFunction = subOptions.FusedActivationFunction() - self.potScaleInt16 = subOptions.PotScaleInt16() - # SubOptionsT + # UnsortedSegmentMaxOptionsT def Pack(self, builder): - SubOptionsStart(builder) - SubOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - SubOptionsAddPotScaleInt16(builder, self.potScaleInt16) - subOptions = SubOptionsEnd(builder) - return subOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + UnsortedSegmentMaxOptionsStart(builder) + unsortedSegmentMaxOptions = UnsortedSegmentMaxOptionsEnd(builder) + return unsortedSegmentMaxOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class Tensor(object): +class UnsortedSegmentSumOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Tensor() + x = UnsortedSegmentSumOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsTensor(cls, buf, offset=0): + def GetRootAsUnsortedSegmentSumOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def TensorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def UnsortedSegmentSumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Tensor + # UnsortedSegmentSumOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # Tensor - def Shape(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 +def UnsortedSegmentSumOptionsStart(builder): + builder.StartObject(0) - # Tensor - def ShapeAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 +def UnsortedSegmentSumOptionsEnd(builder): + return builder.EndObject() - # Tensor - def ShapeLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - # Tensor - def ShapeIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - # Tensor - def Type(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +class UnsortedSegmentSumOptionsT(object): - # Tensor - def Buffer(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) - return 0 + # UnsortedSegmentSumOptionsT + def __init__(self): + pass + + @classmethod + def InitFromBuf(cls, buf, pos): + unsortedSegmentSumOptions = UnsortedSegmentSumOptions() + unsortedSegmentSumOptions.Init(buf, pos) + return cls.InitFromObj(unsortedSegmentSumOptions) - # Tensor - def Name(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) - # Tensor - def Quantization(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - x = self._tab.Indirect(o + self._tab.Pos) - obj = QuantizationParameters() - obj.Init(self._tab.Bytes, x) - return obj - return None + @classmethod + def InitFromObj(cls, unsortedSegmentSumOptions): + x = UnsortedSegmentSumOptionsT() + x._UnPack(unsortedSegmentSumOptions) + return x - # Tensor - def IsVariable(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False + # UnsortedSegmentSumOptionsT + def _UnPack(self, unsortedSegmentSumOptions): + if unsortedSegmentSumOptions is None: + return - # Tensor - def Sparsity(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - x = self._tab.Indirect(o + self._tab.Pos) - obj = SparsityParameters() - obj.Init(self._tab.Bytes, x) - return obj - return None + # UnsortedSegmentSumOptionsT + def Pack(self, builder): + UnsortedSegmentSumOptionsStart(builder) + unsortedSegmentSumOptions = UnsortedSegmentSumOptionsEnd(builder) + return unsortedSegmentSumOptions - # Tensor - def ShapeSignature(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - # Tensor - def ShapeSignatureAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 +class ATan2Options(object): + __slots__ = ['_tab'] - # Tensor - def ShapeSignatureLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - if o != 0: - return self._tab.VectorLen(o) - return 0 + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ATan2Options() + x.Init(buf, n + offset) + return x - # Tensor - def ShapeSignatureIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) - return o == 0 + @classmethod + def GetRootAsATan2Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ATan2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Tensor - def HasRank(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False + # ATan2Options + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) - # Tensor - def VariantTensors(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) - if o != 0: - x = self._tab.Vector(o) - x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 - x = self._tab.Indirect(x) - obj = VariantSubType() - obj.Init(self._tab.Bytes, x) - return obj - return None +def ATan2OptionsStart(builder): + builder.StartObject(0) - # Tensor - def VariantTensorsLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def ATan2OptionsEnd(builder): + return builder.EndObject() - # Tensor - def VariantTensorsIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) - return o == 0 -def TensorStart(builder): builder.StartObject(10) -def Start(builder): - return TensorStart(builder) -def TensorAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) -def AddShape(builder, shape): - return TensorAddShape(builder, shape) -def TensorStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartShapeVector(builder, numElems): - return TensorStartShapeVector(builder, numElems) -def TensorAddType(builder, type): builder.PrependInt8Slot(1, type, 0) -def AddType(builder, type): - return TensorAddType(builder, type) -def TensorAddBuffer(builder, buffer): builder.PrependUint32Slot(2, buffer, 0) -def AddBuffer(builder, buffer): - return TensorAddBuffer(builder, buffer) -def TensorAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def AddName(builder, name): - return TensorAddName(builder, name) -def TensorAddQuantization(builder, quantization): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(quantization), 0) -def AddQuantization(builder, quantization): - return TensorAddQuantization(builder, quantization) -def TensorAddIsVariable(builder, isVariable): builder.PrependBoolSlot(5, isVariable, 0) -def AddIsVariable(builder, isVariable): - return TensorAddIsVariable(builder, isVariable) -def TensorAddSparsity(builder, sparsity): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(sparsity), 0) -def AddSparsity(builder, sparsity): - return TensorAddSparsity(builder, sparsity) -def TensorAddShapeSignature(builder, shapeSignature): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(shapeSignature), 0) -def AddShapeSignature(builder, shapeSignature): - return TensorAddShapeSignature(builder, shapeSignature) -def TensorStartShapeSignatureVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartShapeSignatureVector(builder, numElems): - return TensorStartShapeSignatureVector(builder, numElems) -def TensorAddHasRank(builder, hasRank): builder.PrependBoolSlot(8, hasRank, 0) -def AddHasRank(builder, hasRank): - return TensorAddHasRank(builder, hasRank) -def TensorAddVariantTensors(builder, variantTensors): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(variantTensors), 0) -def AddVariantTensors(builder, variantTensors): - return TensorAddVariantTensors(builder, variantTensors) -def TensorStartVariantTensorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartVariantTensorsVector(builder, numElems): - return TensorStartVariantTensorsVector(builder, numElems) -def TensorEnd(builder): return builder.EndObject() -def End(builder): - return TensorEnd(builder) -try: - from typing import List, Optional -except: - pass -class TensorT(object): +class ATan2OptionsT(object): - # TensorT + # ATan2OptionsT def __init__(self): - self.shape = None # type: List[int] - self.type = 0 # type: int - self.buffer = 0 # type: int - self.name = None # type: str - self.quantization = None # type: Optional[QuantizationParametersT] - self.isVariable = False # type: bool - self.sparsity = None # type: Optional[SparsityParametersT] - self.shapeSignature = None # type: List[int] - self.hasRank = False # type: bool - self.variantTensors = None # type: List[VariantSubTypeT] + pass @classmethod def InitFromBuf(cls, buf, pos): - tensor = Tensor() - tensor.Init(buf, pos) - return cls.InitFromObj(tensor) + atan2Options = ATan2Options() + atan2Options.Init(buf, pos) + return cls.InitFromObj(atan2Options) @classmethod - def InitFromObj(cls, tensor): - x = TensorT() - x._UnPack(tensor) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, atan2Options): + x = ATan2OptionsT() + x._UnPack(atan2Options) return x - # TensorT - def _UnPack(self, tensor): - if tensor is None: + # ATan2OptionsT + def _UnPack(self, atan2Options): + if atan2Options is None: return - if not tensor.ShapeIsNone(): - if np is None: - self.shape = [] - for i in range(tensor.ShapeLength()): - self.shape.append(tensor.Shape(i)) - else: - self.shape = tensor.ShapeAsNumpy() - self.type = tensor.Type() - self.buffer = tensor.Buffer() - self.name = tensor.Name() - if tensor.Quantization() is not None: - self.quantization = QuantizationParametersT.InitFromObj(tensor.Quantization()) - self.isVariable = tensor.IsVariable() - if tensor.Sparsity() is not None: - self.sparsity = SparsityParametersT.InitFromObj(tensor.Sparsity()) - if not tensor.ShapeSignatureIsNone(): - if np is None: - self.shapeSignature = [] - for i in range(tensor.ShapeSignatureLength()): - self.shapeSignature.append(tensor.ShapeSignature(i)) - else: - self.shapeSignature = tensor.ShapeSignatureAsNumpy() - self.hasRank = tensor.HasRank() - if not tensor.VariantTensorsIsNone(): - self.variantTensors = [] - for i in range(tensor.VariantTensorsLength()): - if tensor.VariantTensors(i) is None: - self.variantTensors.append(None) - else: - variantSubType_ = VariantSubTypeT.InitFromObj(tensor.VariantTensors(i)) - self.variantTensors.append(variantSubType_) - # TensorT + # ATan2OptionsT def Pack(self, builder): - if self.shape is not None: - if np is not None and type(self.shape) is np.ndarray: - shape = builder.CreateNumpyVector(self.shape) - else: - TensorStartShapeVector(builder, len(self.shape)) - for i in reversed(range(len(self.shape))): - builder.PrependInt32(self.shape[i]) - shape = builder.EndVector() - if self.name is not None: - name = builder.CreateString(self.name) - if self.quantization is not None: - quantization = self.quantization.Pack(builder) - if self.sparsity is not None: - sparsity = self.sparsity.Pack(builder) - if self.shapeSignature is not None: - if np is not None and type(self.shapeSignature) is np.ndarray: - shapeSignature = builder.CreateNumpyVector(self.shapeSignature) - else: - TensorStartShapeSignatureVector(builder, len(self.shapeSignature)) - for i in reversed(range(len(self.shapeSignature))): - builder.PrependInt32(self.shapeSignature[i]) - shapeSignature = builder.EndVector() - if self.variantTensors is not None: - variantTensorslist = [] - for i in range(len(self.variantTensors)): - variantTensorslist.append(self.variantTensors[i].Pack(builder)) - TensorStartVariantTensorsVector(builder, len(self.variantTensors)) - for i in reversed(range(len(self.variantTensors))): - builder.PrependUOffsetTRelative(variantTensorslist[i]) - variantTensors = builder.EndVector() - TensorStart(builder) - if self.shape is not None: - TensorAddShape(builder, shape) - TensorAddType(builder, self.type) - TensorAddBuffer(builder, self.buffer) - if self.name is not None: - TensorAddName(builder, name) - if self.quantization is not None: - TensorAddQuantization(builder, quantization) - TensorAddIsVariable(builder, self.isVariable) - if self.sparsity is not None: - TensorAddSparsity(builder, sparsity) - if self.shapeSignature is not None: - TensorAddShapeSignature(builder, shapeSignature) - TensorAddHasRank(builder, self.hasRank) - if self.variantTensors is not None: - TensorAddVariantTensors(builder, variantTensors) - tensor = TensorEnd(builder) - return tensor -# automatically generated by the FlatBuffers compiler, do not modify + ATan2OptionsStart(builder) + atan2Options = ATan2OptionsEnd(builder) + return atan2Options + + +class UnsortedSegmentMinOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = UnsortedSegmentMinOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsUnsortedSegmentMinOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def UnsortedSegmentMinOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # UnsortedSegmentMinOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) -# namespace: tflite +def UnsortedSegmentMinOptionsStart(builder): + builder.StartObject(0) -from flatbuffers.compat import import_numpy -np = import_numpy() +def UnsortedSegmentMinOptionsEnd(builder): + return builder.EndObject() -class TensorMap(object): + + +class UnsortedSegmentMinOptionsT(object): + + # UnsortedSegmentMinOptionsT + def __init__(self): + pass + + @classmethod + def InitFromBuf(cls, buf, pos): + unsortedSegmentMinOptions = UnsortedSegmentMinOptions() + unsortedSegmentMinOptions.Init(buf, pos) + return cls.InitFromObj(unsortedSegmentMinOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, unsortedSegmentMinOptions): + x = UnsortedSegmentMinOptionsT() + x._UnPack(unsortedSegmentMinOptions) + return x + + # UnsortedSegmentMinOptionsT + def _UnPack(self, unsortedSegmentMinOptions): + if unsortedSegmentMinOptions is None: + return + + # UnsortedSegmentMinOptionsT + def Pack(self, builder): + UnsortedSegmentMinOptionsStart(builder) + unsortedSegmentMinOptions = UnsortedSegmentMinOptionsEnd(builder) + return unsortedSegmentMinOptions + + +class SignOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = TensorMap() + x = SignOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsTensorMap(cls, buf, offset=0): + def GetRootAsSignOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def TensorMapBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SignOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # TensorMap + # SignOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # TensorMap - def Name(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.String(o + self._tab.Pos) - return None +def SignOptionsStart(builder): + builder.StartObject(0) - # TensorMap - def TensorIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) - return 0 +def SignOptionsEnd(builder): + return builder.EndObject() -def TensorMapStart(builder): builder.StartObject(2) -def Start(builder): - return TensorMapStart(builder) -def TensorMapAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def AddName(builder, name): - return TensorMapAddName(builder, name) -def TensorMapAddTensorIndex(builder, tensorIndex): builder.PrependUint32Slot(1, tensorIndex, 0) -def AddTensorIndex(builder, tensorIndex): - return TensorMapAddTensorIndex(builder, tensorIndex) -def TensorMapEnd(builder): return builder.EndObject() -def End(builder): - return TensorMapEnd(builder) -class TensorMapT(object): - # TensorMapT +class SignOptionsT(object): + + # SignOptionsT def __init__(self): - self.name = None # type: str - self.tensorIndex = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - tensorMap = TensorMap() - tensorMap.Init(buf, pos) - return cls.InitFromObj(tensorMap) + signOptions = SignOptions() + signOptions.Init(buf, pos) + return cls.InitFromObj(signOptions) @classmethod - def InitFromObj(cls, tensorMap): - x = TensorMapT() - x._UnPack(tensorMap) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, signOptions): + x = SignOptionsT() + x._UnPack(signOptions) return x - # TensorMapT - def _UnPack(self, tensorMap): - if tensorMap is None: + # SignOptionsT + def _UnPack(self, signOptions): + if signOptions is None: return - self.name = tensorMap.Name() - self.tensorIndex = tensorMap.TensorIndex() - # TensorMapT + # SignOptionsT def Pack(self, builder): - if self.name is not None: - name = builder.CreateString(self.name) - TensorMapStart(builder) - if self.name is not None: - TensorMapAddName(builder, name) - TensorMapAddTensorIndex(builder, self.tensorIndex) - tensorMap = TensorMapEnd(builder) - return tensorMap -# automatically generated by the FlatBuffers compiler, do not modify + SignOptionsStart(builder) + signOptions = SignOptionsEnd(builder) + return signOptions -# namespace: tflite -class TensorType(object): - FLOAT32 = 0 - FLOAT16 = 1 - INT32 = 2 - UINT8 = 3 - INT64 = 4 - STRING = 5 - BOOL = 6 - INT16 = 7 - COMPLEX64 = 8 - INT8 = 9 - FLOAT64 = 10 - COMPLEX128 = 11 - UINT64 = 12 - RESOURCE = 13 - VARIANT = 14 - UINT32 = 15 - UINT16 = 16 - INT4 = 17 -# automatically generated by the FlatBuffers compiler, do not modify +class BitcastOptions(object): + __slots__ = ['_tab'] -# namespace: tflite + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BitcastOptions() + x.Init(buf, n + offset) + return x -from flatbuffers.compat import import_numpy -np = import_numpy() + @classmethod + def GetRootAsBitcastOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def BitcastOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) -class TileOptions(object): + # BitcastOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def BitcastOptionsStart(builder): + builder.StartObject(0) + +def BitcastOptionsEnd(builder): + return builder.EndObject() + + + +class BitcastOptionsT(object): + + # BitcastOptionsT + def __init__(self): + pass + + @classmethod + def InitFromBuf(cls, buf, pos): + bitcastOptions = BitcastOptions() + bitcastOptions.Init(buf, pos) + return cls.InitFromObj(bitcastOptions) + + @classmethod + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, bitcastOptions): + x = BitcastOptionsT() + x._UnPack(bitcastOptions) + return x + + # BitcastOptionsT + def _UnPack(self, bitcastOptions): + if bitcastOptions is None: + return + + # BitcastOptionsT + def Pack(self, builder): + BitcastOptionsStart(builder) + bitcastOptions = BitcastOptionsEnd(builder) + return bitcastOptions + + +class BitwiseXorOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = TileOptions() + x = BitwiseXorOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsTileOptions(cls, buf, offset=0): + def GetRootAsBitwiseXorOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def TileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def BitwiseXorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # TileOptions + # BitwiseXorOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def TileOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return TileOptionsStart(builder) -def TileOptionsEnd(builder): return builder.EndObject() -def End(builder): - return TileOptionsEnd(builder) +def BitwiseXorOptionsStart(builder): + builder.StartObject(0) -class TileOptionsT(object): +def BitwiseXorOptionsEnd(builder): + return builder.EndObject() - # TileOptionsT + + +class BitwiseXorOptionsT(object): + + # BitwiseXorOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - tileOptions = TileOptions() - tileOptions.Init(buf, pos) - return cls.InitFromObj(tileOptions) + bitwiseXorOptions = BitwiseXorOptions() + bitwiseXorOptions.Init(buf, pos) + return cls.InitFromObj(bitwiseXorOptions) @classmethod - def InitFromObj(cls, tileOptions): - x = TileOptionsT() - x._UnPack(tileOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, bitwiseXorOptions): + x = BitwiseXorOptionsT() + x._UnPack(bitwiseXorOptions) return x - # TileOptionsT - def _UnPack(self, tileOptions): - if tileOptions is None: + # BitwiseXorOptionsT + def _UnPack(self, bitwiseXorOptions): + if bitwiseXorOptions is None: return - # TileOptionsT + # BitwiseXorOptionsT def Pack(self, builder): - TileOptionsStart(builder) - tileOptions = TileOptionsEnd(builder) - return tileOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + BitwiseXorOptionsStart(builder) + bitwiseXorOptions = BitwiseXorOptionsEnd(builder) + return bitwiseXorOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class TopKV2Options(object): +class RightShiftOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = TopKV2Options() + x = RightShiftOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsTopKV2Options(cls, buf, offset=0): + def GetRootAsRightShiftOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def TopKV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def RightShiftOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # TopKV2Options + # RightShiftOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def TopKV2OptionsStart(builder): builder.StartObject(0) -def Start(builder): - return TopKV2OptionsStart(builder) -def TopKV2OptionsEnd(builder): return builder.EndObject() -def End(builder): - return TopKV2OptionsEnd(builder) +def RightShiftOptionsStart(builder): + builder.StartObject(0) -class TopKV2OptionsT(object): +def RightShiftOptionsEnd(builder): + return builder.EndObject() - # TopKV2OptionsT + + +class RightShiftOptionsT(object): + + # RightShiftOptionsT def __init__(self): pass @classmethod def InitFromBuf(cls, buf, pos): - topKv2options = TopKV2Options() - topKv2options.Init(buf, pos) - return cls.InitFromObj(topKv2options) + rightShiftOptions = RightShiftOptions() + rightShiftOptions.Init(buf, pos) + return cls.InitFromObj(rightShiftOptions) @classmethod - def InitFromObj(cls, topKv2options): - x = TopKV2OptionsT() - x._UnPack(topKv2options) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, rightShiftOptions): + x = RightShiftOptionsT() + x._UnPack(rightShiftOptions) return x - # TopKV2OptionsT - def _UnPack(self, topKv2options): - if topKv2options is None: + # RightShiftOptionsT + def _UnPack(self, rightShiftOptions): + if rightShiftOptions is None: return - # TopKV2OptionsT + # RightShiftOptionsT def Pack(self, builder): - TopKV2OptionsStart(builder) - topKv2options = TopKV2OptionsEnd(builder) - return topKv2options -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + RightShiftOptionsStart(builder) + rightShiftOptions = RightShiftOptionsEnd(builder) + return rightShiftOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class TransposeConvOptions(object): +class DilateOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = TransposeConvOptions() + x = DilateOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsTransposeConvOptions(cls, buf, offset=0): + def GetRootAsDilateOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def TransposeConvOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def DilateOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # TransposeConvOptions + # DilateOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # TransposeConvOptions - def Padding(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 - - # TransposeConvOptions - def StrideW(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 - - # TransposeConvOptions - def StrideH(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 +def DilateOptionsStart(builder): + builder.StartObject(0) - # TransposeConvOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 +def DilateOptionsEnd(builder): + return builder.EndObject() - # TransposeConvOptions - def QuantizedBiasType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 -def TransposeConvOptionsStart(builder): builder.StartObject(5) -def Start(builder): - return TransposeConvOptionsStart(builder) -def TransposeConvOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) -def AddPadding(builder, padding): - return TransposeConvOptionsAddPadding(builder, padding) -def TransposeConvOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0) -def AddStrideW(builder, strideW): - return TransposeConvOptionsAddStrideW(builder, strideW) -def TransposeConvOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0) -def AddStrideH(builder, strideH): - return TransposeConvOptionsAddStrideH(builder, strideH) -def TransposeConvOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(3, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return TransposeConvOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def TransposeConvOptionsAddQuantizedBiasType(builder, quantizedBiasType): builder.PrependInt8Slot(4, quantizedBiasType, 0) -def AddQuantizedBiasType(builder, quantizedBiasType): - return TransposeConvOptionsAddQuantizedBiasType(builder, quantizedBiasType) -def TransposeConvOptionsEnd(builder): return builder.EndObject() -def End(builder): - return TransposeConvOptionsEnd(builder) -class TransposeConvOptionsT(object): +class DilateOptionsT(object): - # TransposeConvOptionsT + # DilateOptionsT def __init__(self): - self.padding = 0 # type: int - self.strideW = 0 # type: int - self.strideH = 0 # type: int - self.fusedActivationFunction = 0 # type: int - self.quantizedBiasType = 0 # type: int + pass @classmethod def InitFromBuf(cls, buf, pos): - transposeConvOptions = TransposeConvOptions() - transposeConvOptions.Init(buf, pos) - return cls.InitFromObj(transposeConvOptions) + dilateOptions = DilateOptions() + dilateOptions.Init(buf, pos) + return cls.InitFromObj(dilateOptions) @classmethod - def InitFromObj(cls, transposeConvOptions): - x = TransposeConvOptionsT() - x._UnPack(transposeConvOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, dilateOptions): + x = DilateOptionsT() + x._UnPack(dilateOptions) return x - # TransposeConvOptionsT - def _UnPack(self, transposeConvOptions): - if transposeConvOptions is None: + # DilateOptionsT + def _UnPack(self, dilateOptions): + if dilateOptions is None: return - self.padding = transposeConvOptions.Padding() - self.strideW = transposeConvOptions.StrideW() - self.strideH = transposeConvOptions.StrideH() - self.fusedActivationFunction = transposeConvOptions.FusedActivationFunction() - self.quantizedBiasType = transposeConvOptions.QuantizedBiasType() - # TransposeConvOptionsT + # DilateOptionsT def Pack(self, builder): - TransposeConvOptionsStart(builder) - TransposeConvOptionsAddPadding(builder, self.padding) - TransposeConvOptionsAddStrideW(builder, self.strideW) - TransposeConvOptionsAddStrideH(builder, self.strideH) - TransposeConvOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - TransposeConvOptionsAddQuantizedBiasType(builder, self.quantizedBiasType) - transposeConvOptions = TransposeConvOptionsEnd(builder) - return transposeConvOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + DilateOptionsStart(builder) + dilateOptions = DilateOptionsEnd(builder) + return dilateOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class TransposeOptions(object): +class ReduceWindowOptions(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = TransposeOptions() + x = ReduceWindowOptions() x.Init(buf, n + offset) return x @classmethod - def GetRootAsTransposeOptions(cls, buf, offset=0): + def GetRootAsReduceWindowOptions(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def TransposeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ReduceWindowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # TransposeOptions + # ReduceWindowOptions def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def TransposeOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return TransposeOptionsStart(builder) -def TransposeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return TransposeOptionsEnd(builder) + # ReduceWindowOptions + def ReduceFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def ReduceWindowOptionsStart(builder): + builder.StartObject(1) -class TransposeOptionsT(object): +def ReduceWindowOptionsAddReduceFunction(builder, reduceFunction): + builder.PrependInt32Slot(0, reduceFunction, 0) - # TransposeOptionsT +def ReduceWindowOptionsEnd(builder): + return builder.EndObject() + + + +class ReduceWindowOptionsT(object): + + # ReduceWindowOptionsT def __init__(self): - pass + self.reduceFunction = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - transposeOptions = TransposeOptions() - transposeOptions.Init(buf, pos) - return cls.InitFromObj(transposeOptions) + reduceWindowOptions = ReduceWindowOptions() + reduceWindowOptions.Init(buf, pos) + return cls.InitFromObj(reduceWindowOptions) @classmethod - def InitFromObj(cls, transposeOptions): - x = TransposeOptionsT() - x._UnPack(transposeOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, reduceWindowOptions): + x = ReduceWindowOptionsT() + x._UnPack(reduceWindowOptions) return x - # TransposeOptionsT - def _UnPack(self, transposeOptions): - if transposeOptions is None: + # ReduceWindowOptionsT + def _UnPack(self, reduceWindowOptions): + if reduceWindowOptions is None: return + self.reduceFunction = reduceWindowOptions.ReduceFunction() - # TransposeOptionsT + # ReduceWindowOptionsT def Pack(self, builder): - TransposeOptionsStart(builder) - transposeOptions = TransposeOptionsEnd(builder) - return transposeOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + ReduceWindowOptionsStart(builder) + ReduceWindowOptionsAddReduceFunction(builder, self.reduceFunction) + reduceWindowOptions = ReduceWindowOptionsEnd(builder) + return reduceWindowOptions -from flatbuffers.compat import import_numpy -np = import_numpy() -class Uint16Vector(object): +class OperatorCode(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Uint16Vector() + x = OperatorCode() x.Init(buf, n + offset) return x @classmethod - def GetRootAsUint16Vector(cls, buf, offset=0): + def GetRootAsOperatorCode(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def Uint16VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def OperatorCodeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Uint16Vector + # OperatorCode def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # Uint16Vector - def Values(self, j): + # OperatorCode + def DeprecatedBuiltinCode(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Uint16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 0 - # Uint16Vector - def ValuesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # OperatorCode + def CustomCode(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint16Flags, o) - return 0 + return self._tab.String(o + self._tab.Pos) + return None - # Uint16Vector - def ValuesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # OperatorCode + def Version(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.VectorLen(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 1 + + # OperatorCode + def BuiltinCode(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 - # Uint16Vector - def ValuesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 +def OperatorCodeStart(builder): + builder.StartObject(4) -def Uint16VectorStart(builder): builder.StartObject(1) -def Start(builder): - return Uint16VectorStart(builder) -def Uint16VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) -def AddValues(builder, values): - return Uint16VectorAddValues(builder, values) -def Uint16VectorStartValuesVector(builder, numElems): return builder.StartVector(2, numElems, 2) -def StartValuesVector(builder, numElems): - return Uint16VectorStartValuesVector(builder, numElems) -def Uint16VectorEnd(builder): return builder.EndObject() -def End(builder): - return Uint16VectorEnd(builder) -try: - from typing import List -except: - pass +def OperatorCodeAddDeprecatedBuiltinCode(builder, deprecatedBuiltinCode): + builder.PrependInt8Slot(0, deprecatedBuiltinCode, 0) -class Uint16VectorT(object): +def OperatorCodeAddCustomCode(builder, customCode): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(customCode), 0) - # Uint16VectorT +def OperatorCodeAddVersion(builder, version): + builder.PrependInt32Slot(2, version, 1) + +def OperatorCodeAddBuiltinCode(builder, builtinCode): + builder.PrependInt32Slot(3, builtinCode, 0) + +def OperatorCodeEnd(builder): + return builder.EndObject() + + + +class OperatorCodeT(object): + + # OperatorCodeT def __init__(self): - self.values = None # type: List[int] + self.deprecatedBuiltinCode = 0 # type: int + self.customCode = None # type: str + self.version = 1 # type: int + self.builtinCode = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - uint16vector = Uint16Vector() - uint16vector.Init(buf, pos) - return cls.InitFromObj(uint16vector) + operatorCode = OperatorCode() + operatorCode.Init(buf, pos) + return cls.InitFromObj(operatorCode) @classmethod - def InitFromObj(cls, uint16vector): - x = Uint16VectorT() - x._UnPack(uint16vector) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, operatorCode): + x = OperatorCodeT() + x._UnPack(operatorCode) return x - # Uint16VectorT - def _UnPack(self, uint16vector): - if uint16vector is None: - return - if not uint16vector.ValuesIsNone(): - if np is None: - self.values = [] - for i in range(uint16vector.ValuesLength()): - self.values.append(uint16vector.Values(i)) - else: - self.values = uint16vector.ValuesAsNumpy() + # OperatorCodeT + def _UnPack(self, operatorCode): + if operatorCode is None: + return + self.deprecatedBuiltinCode = operatorCode.DeprecatedBuiltinCode() + self.customCode = operatorCode.CustomCode() + self.version = operatorCode.Version() + self.builtinCode = operatorCode.BuiltinCode() - # Uint16VectorT + # OperatorCodeT def Pack(self, builder): - if self.values is not None: - if np is not None and type(self.values) is np.ndarray: - values = builder.CreateNumpyVector(self.values) - else: - Uint16VectorStartValuesVector(builder, len(self.values)) - for i in reversed(range(len(self.values))): - builder.PrependUint16(self.values[i]) - values = builder.EndVector() - Uint16VectorStart(builder) - if self.values is not None: - Uint16VectorAddValues(builder, values) - uint16vector = Uint16VectorEnd(builder) - return uint16vector -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.customCode is not None: + customCode = builder.CreateString(self.customCode) + OperatorCodeStart(builder) + OperatorCodeAddDeprecatedBuiltinCode(builder, self.deprecatedBuiltinCode) + if self.customCode is not None: + OperatorCodeAddCustomCode(builder, customCode) + OperatorCodeAddVersion(builder, self.version) + OperatorCodeAddBuiltinCode(builder, self.builtinCode) + operatorCode = OperatorCodeEnd(builder) + return operatorCode -from flatbuffers.compat import import_numpy -np = import_numpy() -class Uint8Vector(object): +class Operator(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = Uint8Vector() + x = Operator() x.Init(buf, n + offset) return x @classmethod - def GetRootAsUint8Vector(cls, buf, offset=0): + def GetRootAsOperator(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def Uint8VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def OperatorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # Uint8Vector + # Operator def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # Uint8Vector - def Values(self, j): + # Operator + def OpcodeIndex(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # Operator + def Inputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) return 0 - # Uint8Vector - def ValuesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # Operator + def InputsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) return 0 - # Uint8Vector - def ValuesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # Operator + def InputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.VectorLen(o) return 0 - # Uint8Vector - def ValuesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # Operator + def InputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) return o == 0 -def Uint8VectorStart(builder): builder.StartObject(1) -def Start(builder): - return Uint8VectorStart(builder) -def Uint8VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) -def AddValues(builder, values): - return Uint8VectorAddValues(builder, values) -def Uint8VectorStartValuesVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def StartValuesVector(builder, numElems): - return Uint8VectorStartValuesVector(builder, numElems) -def Uint8VectorEnd(builder): return builder.EndObject() -def End(builder): - return Uint8VectorEnd(builder) -try: - from typing import List -except: - pass + # Operator + def Outputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 -class Uint8VectorT(object): + # Operator + def OutputsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 - # Uint8VectorT - def __init__(self): - self.values = None # type: List[int] + # Operator + def OutputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 - @classmethod - def InitFromBuf(cls, buf, pos): - uint8vector = Uint8Vector() - uint8vector.Init(buf, pos) - return cls.InitFromObj(uint8vector) + # Operator + def OutputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 - @classmethod - def InitFromObj(cls, uint8vector): - x = Uint8VectorT() - x._UnPack(uint8vector) - return x + # Operator + def BuiltinOptionsType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 - # Uint8VectorT - def _UnPack(self, uint8vector): - if uint8vector is None: - return - if not uint8vector.ValuesIsNone(): - if np is None: - self.values = [] - for i in range(uint8vector.ValuesLength()): - self.values.append(uint8vector.Values(i)) - else: - self.values = uint8vector.ValuesAsNumpy() + # Operator + def BuiltinOptions(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None - # Uint8VectorT - def Pack(self, builder): - if self.values is not None: - if np is not None and type(self.values) is np.ndarray: - values = builder.CreateNumpyVector(self.values) - else: - Uint8VectorStartValuesVector(builder, len(self.values)) - for i in reversed(range(len(self.values))): - builder.PrependUint8(self.values[i]) - values = builder.EndVector() - Uint8VectorStart(builder) - if self.values is not None: - Uint8VectorAddValues(builder, values) - uint8vector = Uint8VectorEnd(builder) - return uint8vector -# automatically generated by the FlatBuffers compiler, do not modify + # Operator + def CustomOptions(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 -# namespace: tflite + # Operator + def CustomOptionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 -from flatbuffers.compat import import_numpy -np = import_numpy() + # Operator + def CustomOptionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.VectorLen(o) + return 0 -class UnidirectionalSequenceLSTMOptions(object): - __slots__ = ['_tab'] + # Operator + def CustomOptionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + return o == 0 - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = UnidirectionalSequenceLSTMOptions() - x.Init(buf, n + offset) - return x + # Operator + def CustomOptionsFormat(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 - @classmethod - def GetRootAsUnidirectionalSequenceLSTMOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def UnidirectionalSequenceLSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + # Operator + def MutatingVariableInputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 - # UnidirectionalSequenceLSTMOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) + # Operator + def MutatingVariableInputsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o) + return 0 - # UnidirectionalSequenceLSTMOptions - def FusedActivationFunction(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # Operator + def MutatingVariableInputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return self._tab.VectorLen(o) + return 0 + + # Operator + def MutatingVariableInputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + return o == 0 + + # Operator + def Intermediates(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Operator + def IntermediatesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Operator + def IntermediatesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Operator + def IntermediatesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + return o == 0 + + # Operator + def LargeCustomOptionsOffset(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) return 0 - # UnidirectionalSequenceLSTMOptions - def CellClip(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + # Operator + def LargeCustomOptionsSize(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return 0 - # UnidirectionalSequenceLSTMOptions - def ProjClip(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + # Operator + def BuiltinOptions2Type(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 - # UnidirectionalSequenceLSTMOptions - def TimeMajor(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + # Operator + def BuiltinOptions2(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None - # UnidirectionalSequenceLSTMOptions - def AsymmetricQuantizeInputs(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def OperatorStart(builder): + builder.StartObject(13) - # UnidirectionalSequenceLSTMOptions - def DiagonalRecurrentTensors(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False +def OperatorAddOpcodeIndex(builder, opcodeIndex): + builder.PrependUint32Slot(0, opcodeIndex, 0) -def UnidirectionalSequenceLSTMOptionsStart(builder): builder.StartObject(6) -def Start(builder): - return UnidirectionalSequenceLSTMOptionsStart(builder) -def UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) -def AddFusedActivationFunction(builder, fusedActivationFunction): - return UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction) -def UnidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) -def AddCellClip(builder, cellClip): - return UnidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip) -def UnidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) -def AddProjClip(builder, projClip): - return UnidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip) -def UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(3, timeMajor, 0) -def AddTimeMajor(builder, timeMajor): - return UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor) -def UnidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(4, asymmetricQuantizeInputs, 0) -def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): - return UnidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) -def UnidirectionalSequenceLSTMOptionsAddDiagonalRecurrentTensors(builder, diagonalRecurrentTensors): builder.PrependBoolSlot(5, diagonalRecurrentTensors, 0) -def AddDiagonalRecurrentTensors(builder, diagonalRecurrentTensors): - return UnidirectionalSequenceLSTMOptionsAddDiagonalRecurrentTensors(builder, diagonalRecurrentTensors) -def UnidirectionalSequenceLSTMOptionsEnd(builder): return builder.EndObject() -def End(builder): - return UnidirectionalSequenceLSTMOptionsEnd(builder) +def OperatorAddInputs(builder, inputs): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) -class UnidirectionalSequenceLSTMOptionsT(object): +def OperatorStartInputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - # UnidirectionalSequenceLSTMOptionsT - def __init__(self): - self.fusedActivationFunction = 0 # type: int - self.cellClip = 0.0 # type: float - self.projClip = 0.0 # type: float - self.timeMajor = False # type: bool - self.asymmetricQuantizeInputs = False # type: bool - self.diagonalRecurrentTensors = False # type: bool +def OperatorAddOutputs(builder, outputs): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) - @classmethod - def InitFromBuf(cls, buf, pos): - unidirectionalSequenceLstmoptions = UnidirectionalSequenceLSTMOptions() - unidirectionalSequenceLstmoptions.Init(buf, pos) - return cls.InitFromObj(unidirectionalSequenceLstmoptions) +def OperatorStartOutputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - @classmethod - def InitFromObj(cls, unidirectionalSequenceLstmoptions): - x = UnidirectionalSequenceLSTMOptionsT() - x._UnPack(unidirectionalSequenceLstmoptions) - return x +def OperatorAddBuiltinOptionsType(builder, builtinOptionsType): + builder.PrependUint8Slot(3, builtinOptionsType, 0) - # UnidirectionalSequenceLSTMOptionsT - def _UnPack(self, unidirectionalSequenceLstmoptions): - if unidirectionalSequenceLstmoptions is None: - return - self.fusedActivationFunction = unidirectionalSequenceLstmoptions.FusedActivationFunction() - self.cellClip = unidirectionalSequenceLstmoptions.CellClip() - self.projClip = unidirectionalSequenceLstmoptions.ProjClip() - self.timeMajor = unidirectionalSequenceLstmoptions.TimeMajor() - self.asymmetricQuantizeInputs = unidirectionalSequenceLstmoptions.AsymmetricQuantizeInputs() - self.diagonalRecurrentTensors = unidirectionalSequenceLstmoptions.DiagonalRecurrentTensors() +def OperatorAddBuiltinOptions(builder, builtinOptions): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions), 0) - # UnidirectionalSequenceLSTMOptionsT - def Pack(self, builder): - UnidirectionalSequenceLSTMOptionsStart(builder) - UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction) - UnidirectionalSequenceLSTMOptionsAddCellClip(builder, self.cellClip) - UnidirectionalSequenceLSTMOptionsAddProjClip(builder, self.projClip) - UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, self.timeMajor) - UnidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs) - UnidirectionalSequenceLSTMOptionsAddDiagonalRecurrentTensors(builder, self.diagonalRecurrentTensors) - unidirectionalSequenceLstmoptions = UnidirectionalSequenceLSTMOptionsEnd(builder) - return unidirectionalSequenceLstmoptions -# automatically generated by the FlatBuffers compiler, do not modify +def OperatorAddCustomOptions(builder, customOptions): + builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customOptions), 0) -# namespace: tflite +def OperatorStartCustomOptionsVector(builder, numElems): + return builder.StartVector(1, numElems, 1) -from flatbuffers.compat import import_numpy -np = import_numpy() +def OperatorAddCustomOptionsFormat(builder, customOptionsFormat): + builder.PrependInt8Slot(6, customOptionsFormat, 0) -class UniqueOptions(object): - __slots__ = ['_tab'] +def OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs): + builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(mutatingVariableInputs), 0) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = UniqueOptions() - x.Init(buf, n + offset) - return x +def OperatorStartMutatingVariableInputsVector(builder, numElems): + return builder.StartVector(1, numElems, 1) - @classmethod - def GetRootAsUniqueOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def UniqueOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def OperatorAddIntermediates(builder, intermediates): + builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(intermediates), 0) - # UniqueOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def OperatorStartIntermediatesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - # UniqueOptions - def IdxOutType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 2 +def OperatorAddLargeCustomOptionsOffset(builder, largeCustomOptionsOffset): + builder.PrependUint64Slot(9, largeCustomOptionsOffset, 0) -def UniqueOptionsStart(builder): builder.StartObject(1) -def Start(builder): - return UniqueOptionsStart(builder) -def UniqueOptionsAddIdxOutType(builder, idxOutType): builder.PrependInt8Slot(0, idxOutType, 2) -def AddIdxOutType(builder, idxOutType): - return UniqueOptionsAddIdxOutType(builder, idxOutType) -def UniqueOptionsEnd(builder): return builder.EndObject() -def End(builder): - return UniqueOptionsEnd(builder) +def OperatorAddLargeCustomOptionsSize(builder, largeCustomOptionsSize): + builder.PrependUint64Slot(10, largeCustomOptionsSize, 0) -class UniqueOptionsT(object): +def OperatorAddBuiltinOptions2Type(builder, builtinOptions2Type): + builder.PrependUint8Slot(11, builtinOptions2Type, 0) - # UniqueOptionsT +def OperatorAddBuiltinOptions2(builder, builtinOptions2): + builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions2), 0) + +def OperatorEnd(builder): + return builder.EndObject() + + +try: + from typing import List, Union +except: + pass + +class OperatorT(object): + + # OperatorT def __init__(self): - self.idxOutType = 2 # type: int + self.opcodeIndex = 0 # type: int + self.inputs = None # type: List[int] + self.outputs = None # type: List[int] + self.builtinOptionsType = 0 # type: int + self.builtinOptions = None # type: Union[None, Conv2DOptionsT, DepthwiseConv2DOptionsT, ConcatEmbeddingsOptionsT, LSHProjectionOptionsT, Pool2DOptionsT, SVDFOptionsT, RNNOptionsT, FullyConnectedOptionsT, SoftmaxOptionsT, ConcatenationOptionsT, AddOptionsT, L2NormOptionsT, LocalResponseNormalizationOptionsT, LSTMOptionsT, ResizeBilinearOptionsT, CallOptionsT, ReshapeOptionsT, SkipGramOptionsT, SpaceToDepthOptionsT, EmbeddingLookupSparseOptionsT, MulOptionsT, PadOptionsT, GatherOptionsT, BatchToSpaceNDOptionsT, SpaceToBatchNDOptionsT, TransposeOptionsT, ReducerOptionsT, SubOptionsT, DivOptionsT, SqueezeOptionsT, SequenceRNNOptionsT, StridedSliceOptionsT, ExpOptionsT, TopKV2OptionsT, SplitOptionsT, LogSoftmaxOptionsT, CastOptionsT, DequantizeOptionsT, MaximumMinimumOptionsT, ArgMaxOptionsT, LessOptionsT, NegOptionsT, PadV2OptionsT, GreaterOptionsT, GreaterEqualOptionsT, LessEqualOptionsT, SelectOptionsT, SliceOptionsT, TransposeConvOptionsT, SparseToDenseOptionsT, TileOptionsT, ExpandDimsOptionsT, EqualOptionsT, NotEqualOptionsT, ShapeOptionsT, PowOptionsT, ArgMinOptionsT, FakeQuantOptionsT, PackOptionsT, LogicalOrOptionsT, OneHotOptionsT, LogicalAndOptionsT, LogicalNotOptionsT, UnpackOptionsT, FloorDivOptionsT, SquareOptionsT, ZerosLikeOptionsT, FillOptionsT, BidirectionalSequenceLSTMOptionsT, BidirectionalSequenceRNNOptionsT, UnidirectionalSequenceLSTMOptionsT, FloorModOptionsT, RangeOptionsT, ResizeNearestNeighborOptionsT, LeakyReluOptionsT, SquaredDifferenceOptionsT, MirrorPadOptionsT, AbsOptionsT, SplitVOptionsT, UniqueOptionsT, ReverseV2OptionsT, AddNOptionsT, GatherNdOptionsT, CosOptionsT, WhereOptionsT, RankOptionsT, ReverseSequenceOptionsT, MatrixDiagOptionsT, QuantizeOptionsT, MatrixSetDiagOptionsT, HardSwishOptionsT, IfOptionsT, WhileOptionsT, DepthToSpaceOptionsT, NonMaxSuppressionV4OptionsT, NonMaxSuppressionV5OptionsT, ScatterNdOptionsT, SelectV2OptionsT, DensifyOptionsT, SegmentSumOptionsT, BatchMatMulOptionsT, CumsumOptionsT, CallOnceOptionsT, BroadcastToOptionsT, Rfft2dOptionsT, Conv3DOptionsT, HashtableOptionsT, HashtableFindOptionsT, HashtableImportOptionsT, HashtableSizeOptionsT, VarHandleOptionsT, ReadVariableOptionsT, AssignVariableOptionsT, RandomOptionsT, BucketizeOptionsT, GeluOptionsT, DynamicUpdateSliceOptionsT, UnsortedSegmentProdOptionsT, UnsortedSegmentMaxOptionsT, UnsortedSegmentMinOptionsT, UnsortedSegmentSumOptionsT, ATan2OptionsT, SignOptionsT, BitcastOptionsT, BitwiseXorOptionsT, RightShiftOptionsT] + self.customOptions = None # type: List[int] + self.customOptionsFormat = 0 # type: int + self.mutatingVariableInputs = None # type: List[bool] + self.intermediates = None # type: List[int] + self.largeCustomOptionsOffset = 0 # type: int + self.largeCustomOptionsSize = 0 # type: int + self.builtinOptions2Type = 0 # type: int + self.builtinOptions2 = None # type: Union[None, StablehloConcatenateOptionsT, StablehloBroadcastInDimOptionsT, StablehloSliceOptionsT, StablehloConvolutionOptionsT, StablehloCustomCallOptionsT, StablehloReduceOptionsT, StablehloScatterOptionsT, StablehloCompareOptionsT, StablehloDynamicSliceOptionsT, StablehloPadOptionsT, StablehloIotaOptionsT, StablehloDotGeneralOptionsT, StablehloReduceWindowOptionsT, StablehloSortOptionsT, StablehloWhileOptionsT, StablehloGatherOptionsT, StablehloTransposeOptionsT, DilateOptionsT, StablehloRngBitGeneratorOptionsT, ReduceWindowOptionsT] @classmethod def InitFromBuf(cls, buf, pos): - uniqueOptions = UniqueOptions() - uniqueOptions.Init(buf, pos) - return cls.InitFromObj(uniqueOptions) + operator = Operator() + operator.Init(buf, pos) + return cls.InitFromObj(operator) @classmethod - def InitFromObj(cls, uniqueOptions): - x = UniqueOptionsT() - x._UnPack(uniqueOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, operator): + x = OperatorT() + x._UnPack(operator) return x - # UniqueOptionsT - def _UnPack(self, uniqueOptions): - if uniqueOptions is None: + # OperatorT + def _UnPack(self, operator): + if operator is None: return - self.idxOutType = uniqueOptions.IdxOutType() + self.opcodeIndex = operator.OpcodeIndex() + if not operator.InputsIsNone(): + if np is None: + self.inputs = [] + for i in range(operator.InputsLength()): + self.inputs.append(operator.Inputs(i)) + else: + self.inputs = operator.InputsAsNumpy() + if not operator.OutputsIsNone(): + if np is None: + self.outputs = [] + for i in range(operator.OutputsLength()): + self.outputs.append(operator.Outputs(i)) + else: + self.outputs = operator.OutputsAsNumpy() + self.builtinOptionsType = operator.BuiltinOptionsType() + self.builtinOptions = BuiltinOptionsCreator(self.builtinOptionsType, operator.BuiltinOptions()) + if not operator.CustomOptionsIsNone(): + if np is None: + self.customOptions = [] + for i in range(operator.CustomOptionsLength()): + self.customOptions.append(operator.CustomOptions(i)) + else: + self.customOptions = operator.CustomOptionsAsNumpy() + self.customOptionsFormat = operator.CustomOptionsFormat() + if not operator.MutatingVariableInputsIsNone(): + if np is None: + self.mutatingVariableInputs = [] + for i in range(operator.MutatingVariableInputsLength()): + self.mutatingVariableInputs.append(operator.MutatingVariableInputs(i)) + else: + self.mutatingVariableInputs = operator.MutatingVariableInputsAsNumpy() + if not operator.IntermediatesIsNone(): + if np is None: + self.intermediates = [] + for i in range(operator.IntermediatesLength()): + self.intermediates.append(operator.Intermediates(i)) + else: + self.intermediates = operator.IntermediatesAsNumpy() + self.largeCustomOptionsOffset = operator.LargeCustomOptionsOffset() + self.largeCustomOptionsSize = operator.LargeCustomOptionsSize() + self.builtinOptions2Type = operator.BuiltinOptions2Type() + self.builtinOptions2 = BuiltinOptions2Creator(self.builtinOptions2Type, operator.BuiltinOptions2()) - # UniqueOptionsT + # OperatorT def Pack(self, builder): - UniqueOptionsStart(builder) - UniqueOptionsAddIdxOutType(builder, self.idxOutType) - uniqueOptions = UniqueOptionsEnd(builder) - return uniqueOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.inputs is not None: + if np is not None and type(self.inputs) is np.ndarray: + inputs = builder.CreateNumpyVector(self.inputs) + else: + OperatorStartInputsVector(builder, len(self.inputs)) + for i in reversed(range(len(self.inputs))): + builder.PrependInt32(self.inputs[i]) + inputs = builder.EndVector() + if self.outputs is not None: + if np is not None and type(self.outputs) is np.ndarray: + outputs = builder.CreateNumpyVector(self.outputs) + else: + OperatorStartOutputsVector(builder, len(self.outputs)) + for i in reversed(range(len(self.outputs))): + builder.PrependInt32(self.outputs[i]) + outputs = builder.EndVector() + if self.builtinOptions is not None: + builtinOptions = self.builtinOptions.Pack(builder) + if self.customOptions is not None: + if np is not None and type(self.customOptions) is np.ndarray: + customOptions = builder.CreateNumpyVector(self.customOptions) + else: + OperatorStartCustomOptionsVector(builder, len(self.customOptions)) + for i in reversed(range(len(self.customOptions))): + builder.PrependUint8(self.customOptions[i]) + customOptions = builder.EndVector() + if self.mutatingVariableInputs is not None: + if np is not None and type(self.mutatingVariableInputs) is np.ndarray: + mutatingVariableInputs = builder.CreateNumpyVector(self.mutatingVariableInputs) + else: + OperatorStartMutatingVariableInputsVector(builder, len(self.mutatingVariableInputs)) + for i in reversed(range(len(self.mutatingVariableInputs))): + builder.PrependBool(self.mutatingVariableInputs[i]) + mutatingVariableInputs = builder.EndVector() + if self.intermediates is not None: + if np is not None and type(self.intermediates) is np.ndarray: + intermediates = builder.CreateNumpyVector(self.intermediates) + else: + OperatorStartIntermediatesVector(builder, len(self.intermediates)) + for i in reversed(range(len(self.intermediates))): + builder.PrependInt32(self.intermediates[i]) + intermediates = builder.EndVector() + if self.builtinOptions2 is not None: + builtinOptions2 = self.builtinOptions2.Pack(builder) + OperatorStart(builder) + OperatorAddOpcodeIndex(builder, self.opcodeIndex) + if self.inputs is not None: + OperatorAddInputs(builder, inputs) + if self.outputs is not None: + OperatorAddOutputs(builder, outputs) + OperatorAddBuiltinOptionsType(builder, self.builtinOptionsType) + if self.builtinOptions is not None: + OperatorAddBuiltinOptions(builder, builtinOptions) + if self.customOptions is not None: + OperatorAddCustomOptions(builder, customOptions) + OperatorAddCustomOptionsFormat(builder, self.customOptionsFormat) + if self.mutatingVariableInputs is not None: + OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs) + if self.intermediates is not None: + OperatorAddIntermediates(builder, intermediates) + OperatorAddLargeCustomOptionsOffset(builder, self.largeCustomOptionsOffset) + OperatorAddLargeCustomOptionsSize(builder, self.largeCustomOptionsSize) + OperatorAddBuiltinOptions2Type(builder, self.builtinOptions2Type) + if self.builtinOptions2 is not None: + OperatorAddBuiltinOptions2(builder, builtinOptions2) + operator = OperatorEnd(builder) + return operator -from flatbuffers.compat import import_numpy -np = import_numpy() -class UnpackOptions(object): +class SubGraph(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = UnpackOptions() + x = SubGraph() x.Init(buf, n + offset) return x @classmethod - def GetRootAsUnpackOptions(cls, buf, offset=0): + def GetRootAsSubGraph(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def UnpackOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SubGraphBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # UnpackOptions + # SubGraph def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # UnpackOptions - def Num(self): + # SubGraph + def Tensors(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = Tensor() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # SubGraph + def TensorsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) return 0 - # UnpackOptions - def Axis(self): + # SubGraph + def TensorsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # SubGraph + def Inputs(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) return 0 -def UnpackOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return UnpackOptionsStart(builder) -def UnpackOptionsAddNum(builder, num): builder.PrependInt32Slot(0, num, 0) -def AddNum(builder, num): - return UnpackOptionsAddNum(builder, num) -def UnpackOptionsAddAxis(builder, axis): builder.PrependInt32Slot(1, axis, 0) -def AddAxis(builder, axis): - return UnpackOptionsAddAxis(builder, axis) -def UnpackOptionsEnd(builder): return builder.EndObject() -def End(builder): - return UnpackOptionsEnd(builder) + # SubGraph + def InputsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 -class UnpackOptionsT(object): + # SubGraph + def InputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 - # UnpackOptionsT + # SubGraph + def InputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # SubGraph + def Outputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # SubGraph + def OutputsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # SubGraph + def OutputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SubGraph + def OutputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # SubGraph + def Operators(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = Operator() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # SubGraph + def OperatorsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SubGraph + def OperatorsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + + # SubGraph + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def SubGraphStart(builder): + builder.StartObject(5) + +def SubGraphAddTensors(builder, tensors): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) + +def SubGraphStartTensorsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def SubGraphAddInputs(builder, inputs): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) + +def SubGraphStartInputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def SubGraphAddOutputs(builder, outputs): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) + +def SubGraphStartOutputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def SubGraphAddOperators(builder, operators): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) + +def SubGraphStartOperatorsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def SubGraphAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def SubGraphEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class SubGraphT(object): + + # SubGraphT def __init__(self): - self.num = 0 # type: int - self.axis = 0 # type: int + self.tensors = None # type: List[TensorT] + self.inputs = None # type: List[int] + self.outputs = None # type: List[int] + self.operators = None # type: List[OperatorT] + self.name = None # type: str @classmethod def InitFromBuf(cls, buf, pos): - unpackOptions = UnpackOptions() - unpackOptions.Init(buf, pos) - return cls.InitFromObj(unpackOptions) + subGraph = SubGraph() + subGraph.Init(buf, pos) + return cls.InitFromObj(subGraph) @classmethod - def InitFromObj(cls, unpackOptions): - x = UnpackOptionsT() - x._UnPack(unpackOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, subGraph): + x = SubGraphT() + x._UnPack(subGraph) return x - # UnpackOptionsT - def _UnPack(self, unpackOptions): - if unpackOptions is None: + # SubGraphT + def _UnPack(self, subGraph): + if subGraph is None: return - self.num = unpackOptions.Num() - self.axis = unpackOptions.Axis() + if not subGraph.TensorsIsNone(): + self.tensors = [] + for i in range(subGraph.TensorsLength()): + if subGraph.Tensors(i) is None: + self.tensors.append(None) + else: + tensor_ = TensorT.InitFromObj(subGraph.Tensors(i)) + self.tensors.append(tensor_) + if not subGraph.InputsIsNone(): + if np is None: + self.inputs = [] + for i in range(subGraph.InputsLength()): + self.inputs.append(subGraph.Inputs(i)) + else: + self.inputs = subGraph.InputsAsNumpy() + if not subGraph.OutputsIsNone(): + if np is None: + self.outputs = [] + for i in range(subGraph.OutputsLength()): + self.outputs.append(subGraph.Outputs(i)) + else: + self.outputs = subGraph.OutputsAsNumpy() + if not subGraph.OperatorsIsNone(): + self.operators = [] + for i in range(subGraph.OperatorsLength()): + if subGraph.Operators(i) is None: + self.operators.append(None) + else: + operator_ = OperatorT.InitFromObj(subGraph.Operators(i)) + self.operators.append(operator_) + self.name = subGraph.Name() - # UnpackOptionsT + # SubGraphT def Pack(self, builder): - UnpackOptionsStart(builder) - UnpackOptionsAddNum(builder, self.num) - UnpackOptionsAddAxis(builder, self.axis) - unpackOptions = UnpackOptionsEnd(builder) - return unpackOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.tensors is not None: + tensorslist = [] + for i in range(len(self.tensors)): + tensorslist.append(self.tensors[i].Pack(builder)) + SubGraphStartTensorsVector(builder, len(self.tensors)) + for i in reversed(range(len(self.tensors))): + builder.PrependUOffsetTRelative(tensorslist[i]) + tensors = builder.EndVector() + if self.inputs is not None: + if np is not None and type(self.inputs) is np.ndarray: + inputs = builder.CreateNumpyVector(self.inputs) + else: + SubGraphStartInputsVector(builder, len(self.inputs)) + for i in reversed(range(len(self.inputs))): + builder.PrependInt32(self.inputs[i]) + inputs = builder.EndVector() + if self.outputs is not None: + if np is not None and type(self.outputs) is np.ndarray: + outputs = builder.CreateNumpyVector(self.outputs) + else: + SubGraphStartOutputsVector(builder, len(self.outputs)) + for i in reversed(range(len(self.outputs))): + builder.PrependInt32(self.outputs[i]) + outputs = builder.EndVector() + if self.operators is not None: + operatorslist = [] + for i in range(len(self.operators)): + operatorslist.append(self.operators[i].Pack(builder)) + SubGraphStartOperatorsVector(builder, len(self.operators)) + for i in reversed(range(len(self.operators))): + builder.PrependUOffsetTRelative(operatorslist[i]) + operators = builder.EndVector() + if self.name is not None: + name = builder.CreateString(self.name) + SubGraphStart(builder) + if self.tensors is not None: + SubGraphAddTensors(builder, tensors) + if self.inputs is not None: + SubGraphAddInputs(builder, inputs) + if self.outputs is not None: + SubGraphAddOutputs(builder, outputs) + if self.operators is not None: + SubGraphAddOperators(builder, operators) + if self.name is not None: + SubGraphAddName(builder, name) + subGraph = SubGraphEnd(builder) + return subGraph -from flatbuffers.compat import import_numpy -np = import_numpy() -class UnsortedSegmentMaxOptions(object): +class Buffer(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = UnsortedSegmentMaxOptions() + x = Buffer() x.Init(buf, n + offset) return x @classmethod - def GetRootAsUnsortedSegmentMaxOptions(cls, buf, offset=0): + def GetRootAsBuffer(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def UnsortedSegmentMaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def BufferBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # UnsortedSegmentMaxOptions + # Buffer def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def UnsortedSegmentMaxOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return UnsortedSegmentMaxOptionsStart(builder) -def UnsortedSegmentMaxOptionsEnd(builder): return builder.EndObject() -def End(builder): - return UnsortedSegmentMaxOptionsEnd(builder) + # Buffer + def Data(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 -class UnsortedSegmentMaxOptionsT(object): + # Buffer + def DataAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 - # UnsortedSegmentMaxOptionsT - def __init__(self): - pass + # Buffer + def DataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 - @classmethod - def InitFromBuf(cls, buf, pos): - unsortedSegmentMaxOptions = UnsortedSegmentMaxOptions() - unsortedSegmentMaxOptions.Init(buf, pos) - return cls.InitFromObj(unsortedSegmentMaxOptions) + # Buffer + def DataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 - @classmethod - def InitFromObj(cls, unsortedSegmentMaxOptions): - x = UnsortedSegmentMaxOptionsT() - x._UnPack(unsortedSegmentMaxOptions) - return x + # Buffer + def Offset(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return 0 - # UnsortedSegmentMaxOptionsT - def _UnPack(self, unsortedSegmentMaxOptions): - if unsortedSegmentMaxOptions is None: - return + # Buffer + def Size(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return 0 - # UnsortedSegmentMaxOptionsT - def Pack(self, builder): - UnsortedSegmentMaxOptionsStart(builder) - unsortedSegmentMaxOptions = UnsortedSegmentMaxOptionsEnd(builder) - return unsortedSegmentMaxOptions -# automatically generated by the FlatBuffers compiler, do not modify +def BufferStart(builder): + builder.StartObject(3) -# namespace: tflite +def BufferAddData(builder, data): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) -from flatbuffers.compat import import_numpy -np = import_numpy() +def BufferStartDataVector(builder, numElems): + return builder.StartVector(1, numElems, 1) -class UnsortedSegmentMinOptions(object): - __slots__ = ['_tab'] +def BufferAddOffset(builder, offset): + builder.PrependUint64Slot(1, offset, 0) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = UnsortedSegmentMinOptions() - x.Init(buf, n + offset) - return x +def BufferAddSize(builder, size): + builder.PrependUint64Slot(2, size, 0) - @classmethod - def GetRootAsUnsortedSegmentMinOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def UnsortedSegmentMinOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def BufferEnd(builder): + return builder.EndObject() - # UnsortedSegmentMinOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) -def UnsortedSegmentMinOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return UnsortedSegmentMinOptionsStart(builder) -def UnsortedSegmentMinOptionsEnd(builder): return builder.EndObject() -def End(builder): - return UnsortedSegmentMinOptionsEnd(builder) +try: + from typing import List +except: + pass -class UnsortedSegmentMinOptionsT(object): +class BufferT(object): - # UnsortedSegmentMinOptionsT + # BufferT def __init__(self): - pass + self.data = None # type: List[int] + self.offset = 0 # type: int + self.size = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - unsortedSegmentMinOptions = UnsortedSegmentMinOptions() - unsortedSegmentMinOptions.Init(buf, pos) - return cls.InitFromObj(unsortedSegmentMinOptions) + buffer = Buffer() + buffer.Init(buf, pos) + return cls.InitFromObj(buffer) @classmethod - def InitFromObj(cls, unsortedSegmentMinOptions): - x = UnsortedSegmentMinOptionsT() - x._UnPack(unsortedSegmentMinOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, buffer): + x = BufferT() + x._UnPack(buffer) return x - # UnsortedSegmentMinOptionsT - def _UnPack(self, unsortedSegmentMinOptions): - if unsortedSegmentMinOptions is None: + # BufferT + def _UnPack(self, buffer): + if buffer is None: return + if not buffer.DataIsNone(): + if np is None: + self.data = [] + for i in range(buffer.DataLength()): + self.data.append(buffer.Data(i)) + else: + self.data = buffer.DataAsNumpy() + self.offset = buffer.Offset() + self.size = buffer.Size() - # UnsortedSegmentMinOptionsT + # BufferT def Pack(self, builder): - UnsortedSegmentMinOptionsStart(builder) - unsortedSegmentMinOptions = UnsortedSegmentMinOptionsEnd(builder) - return unsortedSegmentMinOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.data is not None: + if np is not None and type(self.data) is np.ndarray: + data = builder.CreateNumpyVector(self.data) + else: + BufferStartDataVector(builder, len(self.data)) + for i in reversed(range(len(self.data))): + builder.PrependUint8(self.data[i]) + data = builder.EndVector() + BufferStart(builder) + if self.data is not None: + BufferAddData(builder, data) + BufferAddOffset(builder, self.offset) + BufferAddSize(builder, self.size) + buffer = BufferEnd(builder) + return buffer -from flatbuffers.compat import import_numpy -np = import_numpy() -class UnsortedSegmentProdOptions(object): +class Metadata(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = UnsortedSegmentProdOptions() + x = Metadata() x.Init(buf, n + offset) return x @classmethod - def GetRootAsUnsortedSegmentProdOptions(cls, buf, offset=0): + def GetRootAsMetadata(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def UnsortedSegmentProdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def MetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # UnsortedSegmentProdOptions + # Metadata def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def UnsortedSegmentProdOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return UnsortedSegmentProdOptionsStart(builder) -def UnsortedSegmentProdOptionsEnd(builder): return builder.EndObject() -def End(builder): - return UnsortedSegmentProdOptionsEnd(builder) - -class UnsortedSegmentProdOptionsT(object): - - # UnsortedSegmentProdOptionsT - def __init__(self): - pass - - @classmethod - def InitFromBuf(cls, buf, pos): - unsortedSegmentProdOptions = UnsortedSegmentProdOptions() - unsortedSegmentProdOptions.Init(buf, pos) - return cls.InitFromObj(unsortedSegmentProdOptions) - - @classmethod - def InitFromObj(cls, unsortedSegmentProdOptions): - x = UnsortedSegmentProdOptionsT() - x._UnPack(unsortedSegmentProdOptions) - return x - - # UnsortedSegmentProdOptionsT - def _UnPack(self, unsortedSegmentProdOptions): - if unsortedSegmentProdOptions is None: - return - - # UnsortedSegmentProdOptionsT - def Pack(self, builder): - UnsortedSegmentProdOptionsStart(builder) - unsortedSegmentProdOptions = UnsortedSegmentProdOptionsEnd(builder) - return unsortedSegmentProdOptions -# automatically generated by the FlatBuffers compiler, do not modify + # Metadata + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None -# namespace: tflite + # Metadata + def Buffer(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 -from flatbuffers.compat import import_numpy -np = import_numpy() +def MetadataStart(builder): + builder.StartObject(2) -class UnsortedSegmentSumOptions(object): - __slots__ = ['_tab'] +def MetadataAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = UnsortedSegmentSumOptions() - x.Init(buf, n + offset) - return x +def MetadataAddBuffer(builder, buffer): + builder.PrependUint32Slot(1, buffer, 0) - @classmethod - def GetRootAsUnsortedSegmentSumOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def UnsortedSegmentSumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def MetadataEnd(builder): + return builder.EndObject() - # UnsortedSegmentSumOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) -def UnsortedSegmentSumOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return UnsortedSegmentSumOptionsStart(builder) -def UnsortedSegmentSumOptionsEnd(builder): return builder.EndObject() -def End(builder): - return UnsortedSegmentSumOptionsEnd(builder) -class UnsortedSegmentSumOptionsT(object): +class MetadataT(object): - # UnsortedSegmentSumOptionsT + # MetadataT def __init__(self): - pass + self.name = None # type: str + self.buffer = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - unsortedSegmentSumOptions = UnsortedSegmentSumOptions() - unsortedSegmentSumOptions.Init(buf, pos) - return cls.InitFromObj(unsortedSegmentSumOptions) + metadata = Metadata() + metadata.Init(buf, pos) + return cls.InitFromObj(metadata) @classmethod - def InitFromObj(cls, unsortedSegmentSumOptions): - x = UnsortedSegmentSumOptionsT() - x._UnPack(unsortedSegmentSumOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, metadata): + x = MetadataT() + x._UnPack(metadata) return x - # UnsortedSegmentSumOptionsT - def _UnPack(self, unsortedSegmentSumOptions): - if unsortedSegmentSumOptions is None: + # MetadataT + def _UnPack(self, metadata): + if metadata is None: return + self.name = metadata.Name() + self.buffer = metadata.Buffer() - # UnsortedSegmentSumOptionsT + # MetadataT def Pack(self, builder): - UnsortedSegmentSumOptionsStart(builder) - unsortedSegmentSumOptions = UnsortedSegmentSumOptionsEnd(builder) - return unsortedSegmentSumOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.name is not None: + name = builder.CreateString(self.name) + MetadataStart(builder) + if self.name is not None: + MetadataAddName(builder, name) + MetadataAddBuffer(builder, self.buffer) + metadata = MetadataEnd(builder) + return metadata -from flatbuffers.compat import import_numpy -np = import_numpy() -class VarHandleOptions(object): +class TensorMap(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = VarHandleOptions() + x = TensorMap() x.Init(buf, n + offset) return x @classmethod - def GetRootAsVarHandleOptions(cls, buf, offset=0): + def GetRootAsTensorMap(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def VarHandleOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def TensorMapBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # VarHandleOptions + # TensorMap def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # VarHandleOptions - def Container(self): + # TensorMap + def Name(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.String(o + self._tab.Pos) return None - # VarHandleOptions - def SharedName(self): + # TensorMap + def TensorIndex(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.String(o + self._tab.Pos) - return None + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 -def VarHandleOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return VarHandleOptionsStart(builder) -def VarHandleOptionsAddContainer(builder, container): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(container), 0) -def AddContainer(builder, container): - return VarHandleOptionsAddContainer(builder, container) -def VarHandleOptionsAddSharedName(builder, sharedName): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(sharedName), 0) -def AddSharedName(builder, sharedName): - return VarHandleOptionsAddSharedName(builder, sharedName) -def VarHandleOptionsEnd(builder): return builder.EndObject() -def End(builder): - return VarHandleOptionsEnd(builder) +def TensorMapStart(builder): + builder.StartObject(2) -class VarHandleOptionsT(object): +def TensorMapAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) - # VarHandleOptionsT +def TensorMapAddTensorIndex(builder, tensorIndex): + builder.PrependUint32Slot(1, tensorIndex, 0) + +def TensorMapEnd(builder): + return builder.EndObject() + + + +class TensorMapT(object): + + # TensorMapT def __init__(self): - self.container = None # type: str - self.sharedName = None # type: str + self.name = None # type: str + self.tensorIndex = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - varHandleOptions = VarHandleOptions() - varHandleOptions.Init(buf, pos) - return cls.InitFromObj(varHandleOptions) + tensorMap = TensorMap() + tensorMap.Init(buf, pos) + return cls.InitFromObj(tensorMap) @classmethod - def InitFromObj(cls, varHandleOptions): - x = VarHandleOptionsT() - x._UnPack(varHandleOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, tensorMap): + x = TensorMapT() + x._UnPack(tensorMap) return x - # VarHandleOptionsT - def _UnPack(self, varHandleOptions): - if varHandleOptions is None: + # TensorMapT + def _UnPack(self, tensorMap): + if tensorMap is None: return - self.container = varHandleOptions.Container() - self.sharedName = varHandleOptions.SharedName() + self.name = tensorMap.Name() + self.tensorIndex = tensorMap.TensorIndex() - # VarHandleOptionsT + # TensorMapT def Pack(self, builder): - if self.container is not None: - container = builder.CreateString(self.container) - if self.sharedName is not None: - sharedName = builder.CreateString(self.sharedName) - VarHandleOptionsStart(builder) - if self.container is not None: - VarHandleOptionsAddContainer(builder, container) - if self.sharedName is not None: - VarHandleOptionsAddSharedName(builder, sharedName) - varHandleOptions = VarHandleOptionsEnd(builder) - return varHandleOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.name is not None: + name = builder.CreateString(self.name) + TensorMapStart(builder) + if self.name is not None: + TensorMapAddName(builder, name) + TensorMapAddTensorIndex(builder, self.tensorIndex) + tensorMap = TensorMapEnd(builder) + return tensorMap -from flatbuffers.compat import import_numpy -np = import_numpy() -class VariantSubType(object): +class SignatureDef(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = VariantSubType() + x = SignatureDef() x.Init(buf, n + offset) return x @classmethod - def GetRootAsVariantSubType(cls, buf, offset=0): + def GetRootAsSignatureDef(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def VariantSubTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def SignatureDefBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # VariantSubType + # SignatureDef def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # VariantSubType - def Shape(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 - - # VariantSubType - def ShapeAsNumpy(self): + # SignatureDef + def Inputs(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = TensorMap() + obj.Init(self._tab.Bytes, x) + return obj + return None - # VariantSubType - def ShapeLength(self): + # SignatureDef + def InputsLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 - # VariantSubType - def ShapeIsNone(self): + # SignatureDef + def InputsIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) return o == 0 - # VariantSubType - def Type(self): + # SignatureDef + def Outputs(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) - return 0 + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = TensorMap() + obj.Init(self._tab.Bytes, x) + return obj + return None - # VariantSubType - def HasRank(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + # SignatureDef + def OutputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - -def VariantSubTypeStart(builder): builder.StartObject(3) -def Start(builder): - return VariantSubTypeStart(builder) -def VariantSubTypeAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) -def AddShape(builder, shape): - return VariantSubTypeAddShape(builder, shape) -def VariantSubTypeStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def StartShapeVector(builder, numElems): - return VariantSubTypeStartShapeVector(builder, numElems) -def VariantSubTypeAddType(builder, type): builder.PrependInt8Slot(1, type, 0) -def AddType(builder, type): - return VariantSubTypeAddType(builder, type) -def VariantSubTypeAddHasRank(builder, hasRank): builder.PrependBoolSlot(2, hasRank, 0) -def AddHasRank(builder, hasRank): - return VariantSubTypeAddHasRank(builder, hasRank) -def VariantSubTypeEnd(builder): return builder.EndObject() -def End(builder): - return VariantSubTypeEnd(builder) -try: - from typing import List -except: - pass - -class VariantSubTypeT(object): - - # VariantSubTypeT - def __init__(self): - self.shape = None # type: List[int] - self.type = 0 # type: int - self.hasRank = False # type: bool - - @classmethod - def InitFromBuf(cls, buf, pos): - variantSubType = VariantSubType() - variantSubType.Init(buf, pos) - return cls.InitFromObj(variantSubType) - - @classmethod - def InitFromObj(cls, variantSubType): - x = VariantSubTypeT() - x._UnPack(variantSubType) - return x + return self._tab.VectorLen(o) + return 0 - # VariantSubTypeT - def _UnPack(self, variantSubType): - if variantSubType is None: - return - if not variantSubType.ShapeIsNone(): - if np is None: - self.shape = [] - for i in range(variantSubType.ShapeLength()): - self.shape.append(variantSubType.Shape(i)) - else: - self.shape = variantSubType.ShapeAsNumpy() - self.type = variantSubType.Type() - self.hasRank = variantSubType.HasRank() + # SignatureDef + def OutputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 - # VariantSubTypeT - def Pack(self, builder): - if self.shape is not None: - if np is not None and type(self.shape) is np.ndarray: - shape = builder.CreateNumpyVector(self.shape) - else: - VariantSubTypeStartShapeVector(builder, len(self.shape)) - for i in reversed(range(len(self.shape))): - builder.PrependInt32(self.shape[i]) - shape = builder.EndVector() - VariantSubTypeStart(builder) - if self.shape is not None: - VariantSubTypeAddShape(builder, shape) - VariantSubTypeAddType(builder, self.type) - VariantSubTypeAddHasRank(builder, self.hasRank) - variantSubType = VariantSubTypeEnd(builder) - return variantSubType -# automatically generated by the FlatBuffers compiler, do not modify + # SignatureDef + def SignatureKey(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None -# namespace: tflite + # SignatureDef + def SubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 -from flatbuffers.compat import import_numpy -np = import_numpy() +def SignatureDefStart(builder): + builder.StartObject(5) -class WhereOptions(object): - __slots__ = ['_tab'] +def SignatureDefAddInputs(builder, inputs): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = WhereOptions() - x.Init(buf, n + offset) - return x +def SignatureDefStartInputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - @classmethod - def GetRootAsWhereOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def WhereOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def SignatureDefAddOutputs(builder, outputs): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) - # WhereOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def SignatureDefStartOutputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) -def WhereOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return WhereOptionsStart(builder) -def WhereOptionsEnd(builder): return builder.EndObject() -def End(builder): - return WhereOptionsEnd(builder) +def SignatureDefAddSignatureKey(builder, signatureKey): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(signatureKey), 0) -class WhereOptionsT(object): +def SignatureDefAddSubgraphIndex(builder, subgraphIndex): + builder.PrependUint32Slot(4, subgraphIndex, 0) - # WhereOptionsT +def SignatureDefEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class SignatureDefT(object): + + # SignatureDefT def __init__(self): - pass + self.inputs = None # type: List[TensorMapT] + self.outputs = None # type: List[TensorMapT] + self.signatureKey = None # type: str + self.subgraphIndex = 0 # type: int @classmethod def InitFromBuf(cls, buf, pos): - whereOptions = WhereOptions() - whereOptions.Init(buf, pos) - return cls.InitFromObj(whereOptions) + signatureDef = SignatureDef() + signatureDef.Init(buf, pos) + return cls.InitFromObj(signatureDef) @classmethod - def InitFromObj(cls, whereOptions): - x = WhereOptionsT() - x._UnPack(whereOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, signatureDef): + x = SignatureDefT() + x._UnPack(signatureDef) return x - # WhereOptionsT - def _UnPack(self, whereOptions): - if whereOptions is None: + # SignatureDefT + def _UnPack(self, signatureDef): + if signatureDef is None: return + if not signatureDef.InputsIsNone(): + self.inputs = [] + for i in range(signatureDef.InputsLength()): + if signatureDef.Inputs(i) is None: + self.inputs.append(None) + else: + tensorMap_ = TensorMapT.InitFromObj(signatureDef.Inputs(i)) + self.inputs.append(tensorMap_) + if not signatureDef.OutputsIsNone(): + self.outputs = [] + for i in range(signatureDef.OutputsLength()): + if signatureDef.Outputs(i) is None: + self.outputs.append(None) + else: + tensorMap_ = TensorMapT.InitFromObj(signatureDef.Outputs(i)) + self.outputs.append(tensorMap_) + self.signatureKey = signatureDef.SignatureKey() + self.subgraphIndex = signatureDef.SubgraphIndex() - # WhereOptionsT + # SignatureDefT def Pack(self, builder): - WhereOptionsStart(builder) - whereOptions = WhereOptionsEnd(builder) - return whereOptions -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tflite + if self.inputs is not None: + inputslist = [] + for i in range(len(self.inputs)): + inputslist.append(self.inputs[i].Pack(builder)) + SignatureDefStartInputsVector(builder, len(self.inputs)) + for i in reversed(range(len(self.inputs))): + builder.PrependUOffsetTRelative(inputslist[i]) + inputs = builder.EndVector() + if self.outputs is not None: + outputslist = [] + for i in range(len(self.outputs)): + outputslist.append(self.outputs[i].Pack(builder)) + SignatureDefStartOutputsVector(builder, len(self.outputs)) + for i in reversed(range(len(self.outputs))): + builder.PrependUOffsetTRelative(outputslist[i]) + outputs = builder.EndVector() + if self.signatureKey is not None: + signatureKey = builder.CreateString(self.signatureKey) + SignatureDefStart(builder) + if self.inputs is not None: + SignatureDefAddInputs(builder, inputs) + if self.outputs is not None: + SignatureDefAddOutputs(builder, outputs) + if self.signatureKey is not None: + SignatureDefAddSignatureKey(builder, signatureKey) + SignatureDefAddSubgraphIndex(builder, self.subgraphIndex) + signatureDef = SignatureDefEnd(builder) + return signatureDef -from flatbuffers.compat import import_numpy -np = import_numpy() -class WhileOptions(object): +class Model(object): __slots__ = ['_tab'] @classmethod def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = WhileOptions() + x = Model() x.Init(buf, n + offset) return x @classmethod - def GetRootAsWhileOptions(cls, buf, offset=0): + def GetRootAsModel(cls, buf, offset=0): """This method is deprecated. Please switch to GetRootAs.""" return cls.GetRootAs(buf, offset) @classmethod - def WhileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + def ModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) - # WhileOptions + # Model def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) - # WhileOptions - def CondSubgraphIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + # Model + def Version(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # Model + def OperatorCodes(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = OperatorCode() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Model + def OperatorCodesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Model + def OperatorCodesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # Model + def Subgraphs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = SubGraph() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Model + def SubgraphsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Model + def SubgraphsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # Model + def Description(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # Model + def Buffers(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = Buffer() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Model + def BuffersLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Model + def BuffersIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 + + # Model + def MetadataBuffer(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Model + def MetadataBufferAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Model + def MetadataBufferLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Model + def MetadataBufferIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + return o == 0 + + # Model + def Metadata(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = Metadata() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Model + def MetadataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return self._tab.VectorLen(o) return 0 - # WhileOptions - def BodySubgraphIndex(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + # Model + def MetadataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + return o == 0 + + # Model + def SignatureDefs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = SignatureDef() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Model + def SignatureDefsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.VectorLen(o) return 0 -def WhileOptionsStart(builder): builder.StartObject(2) -def Start(builder): - return WhileOptionsStart(builder) -def WhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex): builder.PrependInt32Slot(0, condSubgraphIndex, 0) -def AddCondSubgraphIndex(builder, condSubgraphIndex): - return WhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex) -def WhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): builder.PrependInt32Slot(1, bodySubgraphIndex, 0) -def AddBodySubgraphIndex(builder, bodySubgraphIndex): - return WhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex) -def WhileOptionsEnd(builder): return builder.EndObject() -def End(builder): - return WhileOptionsEnd(builder) + # Model + def SignatureDefsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + return o == 0 -class WhileOptionsT(object): +def ModelStart(builder): + builder.StartObject(8) - # WhileOptionsT - def __init__(self): - self.condSubgraphIndex = 0 # type: int - self.bodySubgraphIndex = 0 # type: int +def ModelAddVersion(builder, version): + builder.PrependUint32Slot(0, version, 0) - @classmethod - def InitFromBuf(cls, buf, pos): - whileOptions = WhileOptions() - whileOptions.Init(buf, pos) - return cls.InitFromObj(whileOptions) +def ModelAddOperatorCodes(builder, operatorCodes): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operatorCodes), 0) - @classmethod - def InitFromObj(cls, whileOptions): - x = WhileOptionsT() - x._UnPack(whileOptions) - return x +def ModelStartOperatorCodesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - # WhileOptionsT - def _UnPack(self, whileOptions): - if whileOptions is None: - return - self.condSubgraphIndex = whileOptions.CondSubgraphIndex() - self.bodySubgraphIndex = whileOptions.BodySubgraphIndex() +def ModelAddSubgraphs(builder, subgraphs): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subgraphs), 0) - # WhileOptionsT - def Pack(self, builder): - WhileOptionsStart(builder) - WhileOptionsAddCondSubgraphIndex(builder, self.condSubgraphIndex) - WhileOptionsAddBodySubgraphIndex(builder, self.bodySubgraphIndex) - whileOptions = WhileOptionsEnd(builder) - return whileOptions -# automatically generated by the FlatBuffers compiler, do not modify +def ModelStartSubgraphsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) -# namespace: tflite +def ModelAddDescription(builder, description): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0) -from flatbuffers.compat import import_numpy -np = import_numpy() +def ModelAddBuffers(builder, buffers): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(buffers), 0) -class ZerosLikeOptions(object): - __slots__ = ['_tab'] +def ModelStartBuffersVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - @classmethod - def GetRootAs(cls, buf, offset=0): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ZerosLikeOptions() - x.Init(buf, n + offset) - return x +def ModelAddMetadataBuffer(builder, metadataBuffer): + builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(metadataBuffer), 0) - @classmethod - def GetRootAsZerosLikeOptions(cls, buf, offset=0): - """This method is deprecated. Please switch to GetRootAs.""" - return cls.GetRootAs(buf, offset) - @classmethod - def ZerosLikeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) +def ModelStartMetadataBufferVector(builder, numElems): + return builder.StartVector(4, numElems, 4) - # ZerosLikeOptions - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) +def ModelAddMetadata(builder, metadata): + builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(metadata), 0) -def ZerosLikeOptionsStart(builder): builder.StartObject(0) -def Start(builder): - return ZerosLikeOptionsStart(builder) -def ZerosLikeOptionsEnd(builder): return builder.EndObject() -def End(builder): - return ZerosLikeOptionsEnd(builder) +def ModelStartMetadataVector(builder, numElems): + return builder.StartVector(4, numElems, 4) -class ZerosLikeOptionsT(object): +def ModelAddSignatureDefs(builder, signatureDefs): + builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(signatureDefs), 0) - # ZerosLikeOptionsT +def ModelStartSignatureDefsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def ModelEnd(builder): + return builder.EndObject() + + +try: + from typing import List +except: + pass + +class ModelT(object): + + # ModelT def __init__(self): - pass + self.version = 0 # type: int + self.operatorCodes = None # type: List[OperatorCodeT] + self.subgraphs = None # type: List[SubGraphT] + self.description = None # type: str + self.buffers = None # type: List[BufferT] + self.metadataBuffer = None # type: List[int] + self.metadata = None # type: List[MetadataT] + self.signatureDefs = None # type: List[SignatureDefT] @classmethod def InitFromBuf(cls, buf, pos): - zerosLikeOptions = ZerosLikeOptions() - zerosLikeOptions.Init(buf, pos) - return cls.InitFromObj(zerosLikeOptions) + model = Model() + model.Init(buf, pos) + return cls.InitFromObj(model) @classmethod - def InitFromObj(cls, zerosLikeOptions): - x = ZerosLikeOptionsT() - x._UnPack(zerosLikeOptions) + def InitFromPackedBuf(cls, buf, pos=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos) + return cls.InitFromBuf(buf, pos+n) + + @classmethod + def InitFromObj(cls, model): + x = ModelT() + x._UnPack(model) return x - # ZerosLikeOptionsT - def _UnPack(self, zerosLikeOptions): - if zerosLikeOptions is None: + # ModelT + def _UnPack(self, model): + if model is None: return + self.version = model.Version() + if not model.OperatorCodesIsNone(): + self.operatorCodes = [] + for i in range(model.OperatorCodesLength()): + if model.OperatorCodes(i) is None: + self.operatorCodes.append(None) + else: + operatorCode_ = OperatorCodeT.InitFromObj(model.OperatorCodes(i)) + self.operatorCodes.append(operatorCode_) + if not model.SubgraphsIsNone(): + self.subgraphs = [] + for i in range(model.SubgraphsLength()): + if model.Subgraphs(i) is None: + self.subgraphs.append(None) + else: + subGraph_ = SubGraphT.InitFromObj(model.Subgraphs(i)) + self.subgraphs.append(subGraph_) + self.description = model.Description() + if not model.BuffersIsNone(): + self.buffers = [] + for i in range(model.BuffersLength()): + if model.Buffers(i) is None: + self.buffers.append(None) + else: + buffer_ = BufferT.InitFromObj(model.Buffers(i)) + self.buffers.append(buffer_) + if not model.MetadataBufferIsNone(): + if np is None: + self.metadataBuffer = [] + for i in range(model.MetadataBufferLength()): + self.metadataBuffer.append(model.MetadataBuffer(i)) + else: + self.metadataBuffer = model.MetadataBufferAsNumpy() + if not model.MetadataIsNone(): + self.metadata = [] + for i in range(model.MetadataLength()): + if model.Metadata(i) is None: + self.metadata.append(None) + else: + metadata_ = MetadataT.InitFromObj(model.Metadata(i)) + self.metadata.append(metadata_) + if not model.SignatureDefsIsNone(): + self.signatureDefs = [] + for i in range(model.SignatureDefsLength()): + if model.SignatureDefs(i) is None: + self.signatureDefs.append(None) + else: + signatureDef_ = SignatureDefT.InitFromObj(model.SignatureDefs(i)) + self.signatureDefs.append(signatureDef_) - # ZerosLikeOptionsT + # ModelT def Pack(self, builder): - ZerosLikeOptionsStart(builder) - zerosLikeOptions = ZerosLikeOptionsEnd(builder) - return zerosLikeOptions + if self.operatorCodes is not None: + operatorCodeslist = [] + for i in range(len(self.operatorCodes)): + operatorCodeslist.append(self.operatorCodes[i].Pack(builder)) + ModelStartOperatorCodesVector(builder, len(self.operatorCodes)) + for i in reversed(range(len(self.operatorCodes))): + builder.PrependUOffsetTRelative(operatorCodeslist[i]) + operatorCodes = builder.EndVector() + if self.subgraphs is not None: + subgraphslist = [] + for i in range(len(self.subgraphs)): + subgraphslist.append(self.subgraphs[i].Pack(builder)) + ModelStartSubgraphsVector(builder, len(self.subgraphs)) + for i in reversed(range(len(self.subgraphs))): + builder.PrependUOffsetTRelative(subgraphslist[i]) + subgraphs = builder.EndVector() + if self.description is not None: + description = builder.CreateString(self.description) + if self.buffers is not None: + bufferslist = [] + for i in range(len(self.buffers)): + bufferslist.append(self.buffers[i].Pack(builder)) + ModelStartBuffersVector(builder, len(self.buffers)) + for i in reversed(range(len(self.buffers))): + builder.PrependUOffsetTRelative(bufferslist[i]) + buffers = builder.EndVector() + if self.metadataBuffer is not None: + if np is not None and type(self.metadataBuffer) is np.ndarray: + metadataBuffer = builder.CreateNumpyVector(self.metadataBuffer) + else: + ModelStartMetadataBufferVector(builder, len(self.metadataBuffer)) + for i in reversed(range(len(self.metadataBuffer))): + builder.PrependInt32(self.metadataBuffer[i]) + metadataBuffer = builder.EndVector() + if self.metadata is not None: + metadatalist = [] + for i in range(len(self.metadata)): + metadatalist.append(self.metadata[i].Pack(builder)) + ModelStartMetadataVector(builder, len(self.metadata)) + for i in reversed(range(len(self.metadata))): + builder.PrependUOffsetTRelative(metadatalist[i]) + metadata = builder.EndVector() + if self.signatureDefs is not None: + signatureDefslist = [] + for i in range(len(self.signatureDefs)): + signatureDefslist.append(self.signatureDefs[i].Pack(builder)) + ModelStartSignatureDefsVector(builder, len(self.signatureDefs)) + for i in reversed(range(len(self.signatureDefs))): + builder.PrependUOffsetTRelative(signatureDefslist[i]) + signatureDefs = builder.EndVector() + ModelStart(builder) + ModelAddVersion(builder, self.version) + if self.operatorCodes is not None: + ModelAddOperatorCodes(builder, operatorCodes) + if self.subgraphs is not None: + ModelAddSubgraphs(builder, subgraphs) + if self.description is not None: + ModelAddDescription(builder, description) + if self.buffers is not None: + ModelAddBuffers(builder, buffers) + if self.metadataBuffer is not None: + ModelAddMetadataBuffer(builder, metadataBuffer) + if self.metadata is not None: + ModelAddMetadata(builder, metadata) + if self.signatureDefs is not None: + ModelAddSignatureDefs(builder, signatureDefs) + model = ModelEnd(builder) + return model + + diff --git a/tensorflow/lite/schema/schema_generated.h b/tensorflow/lite/schema/schema_generated.h index e8adbfd8f30..758e6eebd42 100755 --- a/tensorflow/lite/schema/schema_generated.h +++ b/tensorflow/lite/schema/schema_generated.h @@ -8,9 +8,9 @@ // Ensure the included flatbuffers.h is the same version as when this file was // generated, otherwise it may not be compatible. -static_assert(FLATBUFFERS_VERSION_MAJOR == 2 && - FLATBUFFERS_VERSION_MINOR == 0 && - FLATBUFFERS_VERSION_REVISION == 6, +static_assert(FLATBUFFERS_VERSION_MAJOR == 23 && + FLATBUFFERS_VERSION_MINOR == 5 && + FLATBUFFERS_VERSION_REVISION == 26, "Non-compatible flatbuffers version included"); namespace tflite { @@ -740,7 +740,7 @@ inline const char * const *EnumNamesTensorType() { } inline const char *EnumNameTensorType(TensorType e) { - if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_INT4)) return ""; + if (::flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_INT4)) return ""; const size_t index = static_cast(e); return EnumNamesTensorType()[index]; } @@ -770,7 +770,7 @@ inline const char * const *EnumNamesQuantizationDetails() { } inline const char *EnumNameQuantizationDetails(QuantizationDetails e) { - if (flatbuffers::IsOutRange(e, QuantizationDetails_NONE, QuantizationDetails_CustomQuantization)) return ""; + if (::flatbuffers::IsOutRange(e, QuantizationDetails_NONE, QuantizationDetails_CustomQuantization)) return ""; const size_t index = static_cast(e); return EnumNamesQuantizationDetails()[index]; } @@ -818,8 +818,8 @@ struct QuantizationDetailsUnion { } } - static void *UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver); - flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + static void *UnPack(const void *obj, QuantizationDetails type, const ::flatbuffers::resolver_function_t *resolver); + ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; tflite::CustomQuantizationT *AsCustomQuantization() { return type == QuantizationDetails_CustomQuantization ? @@ -831,8 +831,8 @@ struct QuantizationDetailsUnion { } }; -bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type); -bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +bool VerifyQuantizationDetails(::flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type); +bool VerifyQuantizationDetailsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types); enum DimensionType : int8_t { DimensionType_DENSE = 0, @@ -859,7 +859,7 @@ inline const char * const *EnumNamesDimensionType() { } inline const char *EnumNameDimensionType(DimensionType e) { - if (flatbuffers::IsOutRange(e, DimensionType_DENSE, DimensionType_SPARSE_CSR)) return ""; + if (::flatbuffers::IsOutRange(e, DimensionType_DENSE, DimensionType_SPARSE_CSR)) return ""; const size_t index = static_cast(e); return EnumNamesDimensionType()[index]; } @@ -895,7 +895,7 @@ inline const char * const *EnumNamesSparseIndexVector() { } inline const char *EnumNameSparseIndexVector(SparseIndexVector e) { - if (flatbuffers::IsOutRange(e, SparseIndexVector_NONE, SparseIndexVector_Uint8Vector)) return ""; + if (::flatbuffers::IsOutRange(e, SparseIndexVector_NONE, SparseIndexVector_Uint8Vector)) return ""; const size_t index = static_cast(e); return EnumNamesSparseIndexVector()[index]; } @@ -959,8 +959,8 @@ struct SparseIndexVectorUnion { } } - static void *UnPack(const void *obj, SparseIndexVector type, const flatbuffers::resolver_function_t *resolver); - flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + static void *UnPack(const void *obj, SparseIndexVector type, const ::flatbuffers::resolver_function_t *resolver); + ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; tflite::Int32VectorT *AsInt32Vector() { return type == SparseIndexVector_Int32Vector ? @@ -988,8 +988,8 @@ struct SparseIndexVectorUnion { } }; -bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type); -bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +bool VerifySparseIndexVector(::flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type); +bool VerifySparseIndexVectorVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types); enum BuiltinOperator : int32_t { BuiltinOperator_ADD = 0, @@ -1628,7 +1628,7 @@ inline const char * const *EnumNamesBuiltinOperator() { } inline const char *EnumNameBuiltinOperator(BuiltinOperator e) { - if (flatbuffers::IsOutRange(e, BuiltinOperator_ADD, BuiltinOperator_REDUCE_WINDOW)) return ""; + if (::flatbuffers::IsOutRange(e, BuiltinOperator_ADD, BuiltinOperator_REDUCE_WINDOW)) return ""; const size_t index = static_cast(e); return EnumNamesBuiltinOperator()[index]; } @@ -2033,7 +2033,7 @@ inline const char * const *EnumNamesBuiltinOptions() { } inline const char *EnumNameBuiltinOptions(BuiltinOptions e) { - if (flatbuffers::IsOutRange(e, BuiltinOptions_NONE, BuiltinOptions_RightShiftOptions)) return ""; + if (::flatbuffers::IsOutRange(e, BuiltinOptions_NONE, BuiltinOptions_RightShiftOptions)) return ""; const size_t index = static_cast(e); return EnumNamesBuiltinOptions()[index]; } @@ -3081,8 +3081,8 @@ struct BuiltinOptionsUnion { } } - static void *UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver); - flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + static void *UnPack(const void *obj, BuiltinOptions type, const ::flatbuffers::resolver_function_t *resolver); + ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; tflite::Conv2DOptionsT *AsConv2DOptions() { return type == BuiltinOptions_Conv2DOptions ? @@ -4094,8 +4094,8 @@ struct BuiltinOptionsUnion { } }; -bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type); -bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +bool VerifyBuiltinOptions(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type); +bool VerifyBuiltinOptionsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types); enum BuiltinOptions2 : uint8_t { BuiltinOptions2_NONE = 0, @@ -4179,7 +4179,7 @@ inline const char * const *EnumNamesBuiltinOptions2() { } inline const char *EnumNameBuiltinOptions2(BuiltinOptions2 e) { - if (flatbuffers::IsOutRange(e, BuiltinOptions2_NONE, BuiltinOptions2_ReduceWindowOptions)) return ""; + if (::flatbuffers::IsOutRange(e, BuiltinOptions2_NONE, BuiltinOptions2_ReduceWindowOptions)) return ""; const size_t index = static_cast(e); return EnumNamesBuiltinOptions2()[index]; } @@ -4379,8 +4379,8 @@ struct BuiltinOptions2Union { } } - static void *UnPack(const void *obj, BuiltinOptions2 type, const flatbuffers::resolver_function_t *resolver); - flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + static void *UnPack(const void *obj, BuiltinOptions2 type, const ::flatbuffers::resolver_function_t *resolver); + ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; tflite::StablehloConcatenateOptionsT *AsStablehloConcatenateOptions() { return type == BuiltinOptions2_StablehloConcatenateOptions ? @@ -4544,8 +4544,8 @@ struct BuiltinOptions2Union { } }; -bool VerifyBuiltinOptions2(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions2 type); -bool VerifyBuiltinOptions2Vector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +bool VerifyBuiltinOptions2(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions2 type); +bool VerifyBuiltinOptions2Vector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types); enum StablehloPrecisionConfig : uint32_t { StablehloPrecisionConfig_DEFAULT = 0, @@ -4575,7 +4575,7 @@ inline const char * const *EnumNamesStablehloPrecisionConfig() { } inline const char *EnumNameStablehloPrecisionConfig(StablehloPrecisionConfig e) { - if (flatbuffers::IsOutRange(e, StablehloPrecisionConfig_DEFAULT, StablehloPrecisionConfig_HIGHEST)) return ""; + if (::flatbuffers::IsOutRange(e, StablehloPrecisionConfig_DEFAULT, StablehloPrecisionConfig_HIGHEST)) return ""; const size_t index = static_cast(e); return EnumNamesStablehloPrecisionConfig()[index]; } @@ -4617,7 +4617,7 @@ inline const char * const *EnumNamesStablehloComparisonDirection() { } inline const char *EnumNameStablehloComparisonDirection(StablehloComparisonDirection e) { - if (flatbuffers::IsOutRange(e, StablehloComparisonDirection_STABLEHLO_COMPARISON_DIRECTION_EQ, StablehloComparisonDirection_STABLEHLO_COMPARISON_DIRECTION_LT)) return ""; + if (::flatbuffers::IsOutRange(e, StablehloComparisonDirection_STABLEHLO_COMPARISON_DIRECTION_EQ, StablehloComparisonDirection_STABLEHLO_COMPARISON_DIRECTION_LT)) return ""; const size_t index = static_cast(e); return EnumNamesStablehloComparisonDirection()[index]; } @@ -4656,7 +4656,7 @@ inline const char * const *EnumNamesStablehloComparisonType() { } inline const char *EnumNameStablehloComparisonType(StablehloComparisonType e) { - if (flatbuffers::IsOutRange(e, StablehloComparisonType_STABLEHLO_COMPARISON_TYPE_NOTYPE, StablehloComparisonType_STABLEHLO_COMPARISON_TYPE_UNSIGNED)) return ""; + if (::flatbuffers::IsOutRange(e, StablehloComparisonType_STABLEHLO_COMPARISON_TYPE_NOTYPE, StablehloComparisonType_STABLEHLO_COMPARISON_TYPE_UNSIGNED)) return ""; const size_t index = static_cast(e); return EnumNamesStablehloComparisonType()[index]; } @@ -4689,7 +4689,7 @@ inline const char * const *EnumNamesRngAlgorithm() { } inline const char *EnumNameRngAlgorithm(RngAlgorithm e) { - if (flatbuffers::IsOutRange(e, RngAlgorithm_DEFAULT, RngAlgorithm_THREEFRY)) return ""; + if (::flatbuffers::IsOutRange(e, RngAlgorithm_DEFAULT, RngAlgorithm_THREEFRY)) return ""; const size_t index = static_cast(e); return EnumNamesRngAlgorithm()[index]; } @@ -4719,7 +4719,7 @@ inline const char * const *EnumNamesPadding() { } inline const char *EnumNamePadding(Padding e) { - if (flatbuffers::IsOutRange(e, Padding_SAME, Padding_VALID)) return ""; + if (::flatbuffers::IsOutRange(e, Padding_SAME, Padding_VALID)) return ""; const size_t index = static_cast(e); return EnumNamesPadding()[index]; } @@ -4761,7 +4761,7 @@ inline const char * const *EnumNamesActivationFunctionType() { } inline const char *EnumNameActivationFunctionType(ActivationFunctionType e) { - if (flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT)) return ""; + if (::flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT)) return ""; const size_t index = static_cast(e); return EnumNamesActivationFunctionType()[index]; } @@ -4794,7 +4794,7 @@ inline const char * const *EnumNamesLSHProjectionType() { } inline const char *EnumNameLSHProjectionType(LSHProjectionType e) { - if (flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE)) return ""; + if (::flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE)) return ""; const size_t index = static_cast(e); return EnumNamesLSHProjectionType()[index]; } @@ -4824,7 +4824,7 @@ inline const char * const *EnumNamesFullyConnectedOptionsWeightsFormat() { } inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e) { - if (flatbuffers::IsOutRange(e, FullyConnectedOptionsWeightsFormat_DEFAULT, FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8)) return ""; + if (::flatbuffers::IsOutRange(e, FullyConnectedOptionsWeightsFormat_DEFAULT, FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8)) return ""; const size_t index = static_cast(e); return EnumNamesFullyConnectedOptionsWeightsFormat()[index]; } @@ -4854,7 +4854,7 @@ inline const char * const *EnumNamesLSTMKernelType() { } inline const char *EnumNameLSTMKernelType(LSTMKernelType e) { - if (flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC)) return ""; + if (::flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC)) return ""; const size_t index = static_cast(e); return EnumNamesLSTMKernelType()[index]; } @@ -4887,7 +4887,7 @@ inline const char * const *EnumNamesCombinerType() { } inline const char *EnumNameCombinerType(CombinerType e) { - if (flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN)) return ""; + if (::flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN)) return ""; const size_t index = static_cast(e); return EnumNamesCombinerType()[index]; } @@ -4917,7 +4917,7 @@ inline const char * const *EnumNamesMirrorPadMode() { } inline const char *EnumNameMirrorPadMode(MirrorPadMode e) { - if (flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC)) return ""; + if (::flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC)) return ""; const size_t index = static_cast(e); return EnumNamesMirrorPadMode()[index]; } @@ -4962,7 +4962,7 @@ inline const char * const *EnumNamesReduceWindowFunction() { } inline const char *EnumNameReduceWindowFunction(ReduceWindowFunction e) { - if (flatbuffers::IsOutRange(e, ReduceWindowFunction_UNSUPPORTED, ReduceWindowFunction_ANY)) return ""; + if (::flatbuffers::IsOutRange(e, ReduceWindowFunction_UNSUPPORTED, ReduceWindowFunction_ANY)) return ""; const size_t index = static_cast(e); return EnumNamesReduceWindowFunction()[index]; } @@ -4989,64 +4989,64 @@ inline const char * const *EnumNamesCustomOptionsFormat() { } inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e) { - if (flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS)) return ""; + if (::flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS)) return ""; const size_t index = static_cast(e); return EnumNamesCustomOptionsFormat()[index]; } -struct CustomQuantizationT : public flatbuffers::NativeTable { +struct CustomQuantizationT : public ::flatbuffers::NativeTable { typedef CustomQuantization TableType; std::vector custom{}; }; -struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef CustomQuantizationT NativeTableType; typedef CustomQuantizationBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_CUSTOM = 4 }; - const flatbuffers::Vector *custom() const { - return GetPointer *>(VT_CUSTOM); + const ::flatbuffers::Vector *custom() const { + return GetPointer *>(VT_CUSTOM); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CUSTOM) && verifier.VerifyVector(custom()) && verifier.EndTable(); } - CustomQuantizationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + CustomQuantizationT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CustomQuantizationT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct CustomQuantizationBuilder { typedef CustomQuantization Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_custom(flatbuffers::Offset> custom) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_custom(::flatbuffers::Offset<::flatbuffers::Vector> custom) { fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom); } - explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit CustomQuantizationBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateCustomQuantization( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> custom = 0) { +inline ::flatbuffers::Offset CreateCustomQuantization( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> custom = 0) { CustomQuantizationBuilder builder_(_fbb); builder_.add_custom(custom); return builder_.Finish(); } -inline flatbuffers::Offset CreateCustomQuantizationDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateCustomQuantizationDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *custom = nullptr) { if (custom) { _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), 16); } auto custom__ = custom ? _fbb.CreateVector(*custom) : 0; @@ -5055,9 +5055,9 @@ inline flatbuffers::Offset CreateCustomQuantizationDirect( custom__); } -flatbuffers::Offset CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateCustomQuantization(::flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct QuantizationParametersT : public flatbuffers::NativeTable { +struct QuantizationParametersT : public ::flatbuffers::NativeTable { typedef QuantizationParameters TableType; std::vector min{}; std::vector max{}; @@ -5067,7 +5067,7 @@ struct QuantizationParametersT : public flatbuffers::NativeTable { int32_t quantized_dimension = 0; }; -struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef QuantizationParametersT NativeTableType; typedef QuantizationParametersBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -5079,17 +5079,17 @@ struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab VT_DETAILS = 14, VT_QUANTIZED_DIMENSION = 16 }; - const flatbuffers::Vector *min() const { - return GetPointer *>(VT_MIN); + const ::flatbuffers::Vector *min() const { + return GetPointer *>(VT_MIN); } - const flatbuffers::Vector *max() const { - return GetPointer *>(VT_MAX); + const ::flatbuffers::Vector *max() const { + return GetPointer *>(VT_MAX); } - const flatbuffers::Vector *scale() const { - return GetPointer *>(VT_SCALE); + const ::flatbuffers::Vector *scale() const { + return GetPointer *>(VT_SCALE); } - const flatbuffers::Vector *zero_point() const { - return GetPointer *>(VT_ZERO_POINT); + const ::flatbuffers::Vector *zero_point() const { + return GetPointer *>(VT_ZERO_POINT); } tflite::QuantizationDetails details_type() const { return static_cast(GetField(VT_DETAILS_TYPE, 0)); @@ -5104,7 +5104,7 @@ struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab int32_t quantized_dimension() const { return GetField(VT_QUANTIZED_DIMENSION, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_MIN) && verifier.VerifyVector(min()) && @@ -5120,9 +5120,9 @@ struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab VerifyField(verifier, VT_QUANTIZED_DIMENSION, 4) && verifier.EndTable(); } - QuantizationParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + QuantizationParametersT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(QuantizationParametersT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; template<> inline const tflite::CustomQuantization *QuantizationParameters::details_as() const { @@ -5131,48 +5131,48 @@ template<> inline const tflite::CustomQuantization *QuantizationParameters::deta struct QuantizationParametersBuilder { typedef QuantizationParameters Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_min(flatbuffers::Offset> min) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_min(::flatbuffers::Offset<::flatbuffers::Vector> min) { fbb_.AddOffset(QuantizationParameters::VT_MIN, min); } - void add_max(flatbuffers::Offset> max) { + void add_max(::flatbuffers::Offset<::flatbuffers::Vector> max) { fbb_.AddOffset(QuantizationParameters::VT_MAX, max); } - void add_scale(flatbuffers::Offset> scale) { + void add_scale(::flatbuffers::Offset<::flatbuffers::Vector> scale) { fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale); } - void add_zero_point(flatbuffers::Offset> zero_point) { + void add_zero_point(::flatbuffers::Offset<::flatbuffers::Vector> zero_point) { fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point); } void add_details_type(tflite::QuantizationDetails details_type) { fbb_.AddElement(QuantizationParameters::VT_DETAILS_TYPE, static_cast(details_type), 0); } - void add_details(flatbuffers::Offset details) { + void add_details(::flatbuffers::Offset details) { fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details); } void add_quantized_dimension(int32_t quantized_dimension) { fbb_.AddElement(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, 0); } - explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit QuantizationParametersBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateQuantizationParameters( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> min = 0, - flatbuffers::Offset> max = 0, - flatbuffers::Offset> scale = 0, - flatbuffers::Offset> zero_point = 0, +inline ::flatbuffers::Offset CreateQuantizationParameters( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> min = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> max = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> scale = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> zero_point = 0, tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE, - flatbuffers::Offset details = 0, + ::flatbuffers::Offset details = 0, int32_t quantized_dimension = 0) { QuantizationParametersBuilder builder_(_fbb); builder_.add_quantized_dimension(quantized_dimension); @@ -5185,14 +5185,14 @@ inline flatbuffers::Offset CreateQuantizationParameters( return builder_.Finish(); } -inline flatbuffers::Offset CreateQuantizationParametersDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateQuantizationParametersDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *min = nullptr, const std::vector *max = nullptr, const std::vector *scale = nullptr, const std::vector *zero_point = nullptr, tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE, - flatbuffers::Offset details = 0, + ::flatbuffers::Offset details = 0, int32_t quantized_dimension = 0) { auto min__ = min ? _fbb.CreateVector(*min) : 0; auto max__ = max ? _fbb.CreateVector(*max) : 0; @@ -5209,61 +5209,61 @@ inline flatbuffers::Offset CreateQuantizationParametersD quantized_dimension); } -flatbuffers::Offset CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateQuantizationParameters(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct Int32VectorT : public flatbuffers::NativeTable { +struct Int32VectorT : public ::flatbuffers::NativeTable { typedef Int32Vector TableType; std::vector values{}; }; -struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Int32Vector FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef Int32VectorT NativeTableType; typedef Int32VectorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUES = 4 }; - const flatbuffers::Vector *values() const { - return GetPointer *>(VT_VALUES); + const ::flatbuffers::Vector *values() const { + return GetPointer *>(VT_VALUES); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) && verifier.VerifyVector(values()) && verifier.EndTable(); } - Int32VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(Int32VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + Int32VectorT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Int32VectorT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct Int32VectorBuilder { typedef Int32Vector Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_values(flatbuffers::Offset> values) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_values(::flatbuffers::Offset<::flatbuffers::Vector> values) { fbb_.AddOffset(Int32Vector::VT_VALUES, values); } - explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit Int32VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateInt32Vector( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> values = 0) { +inline ::flatbuffers::Offset CreateInt32Vector( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> values = 0) { Int32VectorBuilder builder_(_fbb); builder_.add_values(values); return builder_.Finish(); } -inline flatbuffers::Offset CreateInt32VectorDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateInt32VectorDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *values = nullptr) { auto values__ = values ? _fbb.CreateVector(*values) : 0; return tflite::CreateInt32Vector( @@ -5271,61 +5271,61 @@ inline flatbuffers::Offset CreateInt32VectorDirect( values__); } -flatbuffers::Offset CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateInt32Vector(::flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct Uint16VectorT : public flatbuffers::NativeTable { +struct Uint16VectorT : public ::flatbuffers::NativeTable { typedef Uint16Vector TableType; std::vector values{}; }; -struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef Uint16VectorT NativeTableType; typedef Uint16VectorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUES = 4 }; - const flatbuffers::Vector *values() const { - return GetPointer *>(VT_VALUES); + const ::flatbuffers::Vector *values() const { + return GetPointer *>(VT_VALUES); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) && verifier.VerifyVector(values()) && verifier.EndTable(); } - Uint16VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(Uint16VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + Uint16VectorT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Uint16VectorT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct Uint16VectorBuilder { typedef Uint16Vector Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_values(flatbuffers::Offset> values) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_values(::flatbuffers::Offset<::flatbuffers::Vector> values) { fbb_.AddOffset(Uint16Vector::VT_VALUES, values); } - explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit Uint16VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUint16Vector( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> values = 0) { +inline ::flatbuffers::Offset CreateUint16Vector( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> values = 0) { Uint16VectorBuilder builder_(_fbb); builder_.add_values(values); return builder_.Finish(); } -inline flatbuffers::Offset CreateUint16VectorDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateUint16VectorDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *values = nullptr) { if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), 4); } auto values__ = values ? _fbb.CreateVector(*values) : 0; @@ -5334,61 +5334,61 @@ inline flatbuffers::Offset CreateUint16VectorDirect( values__); } -flatbuffers::Offset CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUint16Vector(::flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct Uint8VectorT : public flatbuffers::NativeTable { +struct Uint8VectorT : public ::flatbuffers::NativeTable { typedef Uint8Vector TableType; std::vector values{}; }; -struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef Uint8VectorT NativeTableType; typedef Uint8VectorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUES = 4 }; - const flatbuffers::Vector *values() const { - return GetPointer *>(VT_VALUES); + const ::flatbuffers::Vector *values() const { + return GetPointer *>(VT_VALUES); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) && verifier.VerifyVector(values()) && verifier.EndTable(); } - Uint8VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(Uint8VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + Uint8VectorT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Uint8VectorT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct Uint8VectorBuilder { typedef Uint8Vector Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_values(flatbuffers::Offset> values) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_values(::flatbuffers::Offset<::flatbuffers::Vector> values) { fbb_.AddOffset(Uint8Vector::VT_VALUES, values); } - explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit Uint8VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUint8Vector( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> values = 0) { +inline ::flatbuffers::Offset CreateUint8Vector( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> values = 0) { Uint8VectorBuilder builder_(_fbb); builder_.add_values(values); return builder_.Finish(); } -inline flatbuffers::Offset CreateUint8VectorDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateUint8VectorDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *values = nullptr) { if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), 4); } auto values__ = values ? _fbb.CreateVector(*values) : 0; @@ -5397,9 +5397,9 @@ inline flatbuffers::Offset CreateUint8VectorDirect( values__); } -flatbuffers::Offset CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUint8Vector(::flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct DimensionMetadataT : public flatbuffers::NativeTable { +struct DimensionMetadataT : public ::flatbuffers::NativeTable { typedef DimensionMetadata TableType; tflite::DimensionType format = tflite::DimensionType_DENSE; int32_t dense_size = 0; @@ -5407,7 +5407,7 @@ struct DimensionMetadataT : public flatbuffers::NativeTable { tflite::SparseIndexVectorUnion array_indices{}; }; -struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DimensionMetadataT NativeTableType; typedef DimensionMetadataBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -5456,7 +5456,7 @@ struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const tflite::Uint8Vector *array_indices_as_Uint8Vector() const { return array_indices_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast(array_indices()) : nullptr; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FORMAT, 1) && VerifyField(verifier, VT_DENSE_SIZE, 4) && @@ -5468,9 +5468,9 @@ struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) && verifier.EndTable(); } - DimensionMetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DimensionMetadataT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DimensionMetadataT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; template<> inline const tflite::Int32Vector *DimensionMetadata::array_segments_as() const { @@ -5499,8 +5499,8 @@ template<> inline const tflite::Uint8Vector *DimensionMetadata::array_indices_as struct DimensionMetadataBuilder { typedef DimensionMetadata Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_format(tflite::DimensionType format) { fbb_.AddElement(DimensionMetadata::VT_FORMAT, static_cast(format), 0); } @@ -5510,34 +5510,34 @@ struct DimensionMetadataBuilder { void add_array_segments_type(tflite::SparseIndexVector array_segments_type) { fbb_.AddElement(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE, static_cast(array_segments_type), 0); } - void add_array_segments(flatbuffers::Offset array_segments) { + void add_array_segments(::flatbuffers::Offset array_segments) { fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments); } void add_array_indices_type(tflite::SparseIndexVector array_indices_type) { fbb_.AddElement(DimensionMetadata::VT_ARRAY_INDICES_TYPE, static_cast(array_indices_type), 0); } - void add_array_indices(flatbuffers::Offset array_indices) { + void add_array_indices(::flatbuffers::Offset array_indices) { fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices); } - explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit DimensionMetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDimensionMetadata( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateDimensionMetadata( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::DimensionType format = tflite::DimensionType_DENSE, int32_t dense_size = 0, tflite::SparseIndexVector array_segments_type = tflite::SparseIndexVector_NONE, - flatbuffers::Offset array_segments = 0, + ::flatbuffers::Offset array_segments = 0, tflite::SparseIndexVector array_indices_type = tflite::SparseIndexVector_NONE, - flatbuffers::Offset array_indices = 0) { + ::flatbuffers::Offset array_indices = 0) { DimensionMetadataBuilder builder_(_fbb); builder_.add_array_indices(array_indices); builder_.add_array_segments(array_segments); @@ -5548,9 +5548,9 @@ inline flatbuffers::Offset CreateDimensionMetadata( return builder_.Finish(); } -flatbuffers::Offset CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateDimensionMetadata(::flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SparsityParametersT : public flatbuffers::NativeTable { +struct SparsityParametersT : public ::flatbuffers::NativeTable { typedef SparsityParameters TableType; std::vector traversal_order{}; std::vector block_map{}; @@ -5561,7 +5561,7 @@ struct SparsityParametersT : public flatbuffers::NativeTable { SparsityParametersT &operator=(SparsityParametersT o) FLATBUFFERS_NOEXCEPT; }; -struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SparsityParametersT NativeTableType; typedef SparsityParametersBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -5569,16 +5569,16 @@ struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_BLOCK_MAP = 6, VT_DIM_METADATA = 8 }; - const flatbuffers::Vector *traversal_order() const { - return GetPointer *>(VT_TRAVERSAL_ORDER); + const ::flatbuffers::Vector *traversal_order() const { + return GetPointer *>(VT_TRAVERSAL_ORDER); } - const flatbuffers::Vector *block_map() const { - return GetPointer *>(VT_BLOCK_MAP); + const ::flatbuffers::Vector *block_map() const { + return GetPointer *>(VT_BLOCK_MAP); } - const flatbuffers::Vector> *dim_metadata() const { - return GetPointer> *>(VT_DIM_METADATA); + const ::flatbuffers::Vector<::flatbuffers::Offset> *dim_metadata() const { + return GetPointer> *>(VT_DIM_METADATA); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TRAVERSAL_ORDER) && verifier.VerifyVector(traversal_order()) && @@ -5589,40 +5589,40 @@ struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyVectorOfTables(dim_metadata()) && verifier.EndTable(); } - SparsityParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SparsityParametersT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SparsityParametersT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SparsityParametersBuilder { typedef SparsityParameters Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_traversal_order(flatbuffers::Offset> traversal_order) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_traversal_order(::flatbuffers::Offset<::flatbuffers::Vector> traversal_order) { fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order); } - void add_block_map(flatbuffers::Offset> block_map) { + void add_block_map(::flatbuffers::Offset<::flatbuffers::Vector> block_map) { fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map); } - void add_dim_metadata(flatbuffers::Offset>> dim_metadata) { + void add_dim_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> dim_metadata) { fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata); } - explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SparsityParametersBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSparsityParameters( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> traversal_order = 0, - flatbuffers::Offset> block_map = 0, - flatbuffers::Offset>> dim_metadata = 0) { +inline ::flatbuffers::Offset CreateSparsityParameters( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> traversal_order = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> block_map = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> dim_metadata = 0) { SparsityParametersBuilder builder_(_fbb); builder_.add_dim_metadata(dim_metadata); builder_.add_block_map(block_map); @@ -5630,14 +5630,14 @@ inline flatbuffers::Offset CreateSparsityParameters( return builder_.Finish(); } -inline flatbuffers::Offset CreateSparsityParametersDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSparsityParametersDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *traversal_order = nullptr, const std::vector *block_map = nullptr, - const std::vector> *dim_metadata = nullptr) { + const std::vector<::flatbuffers::Offset> *dim_metadata = nullptr) { auto traversal_order__ = traversal_order ? _fbb.CreateVector(*traversal_order) : 0; auto block_map__ = block_map ? _fbb.CreateVector(*block_map) : 0; - auto dim_metadata__ = dim_metadata ? _fbb.CreateVector>(*dim_metadata) : 0; + auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<::flatbuffers::Offset>(*dim_metadata) : 0; return tflite::CreateSparsityParameters( _fbb, traversal_order__, @@ -5645,16 +5645,16 @@ inline flatbuffers::Offset CreateSparsityParametersDirect( dim_metadata__); } -flatbuffers::Offset CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSparsityParameters(::flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct VariantSubTypeT : public flatbuffers::NativeTable { +struct VariantSubTypeT : public ::flatbuffers::NativeTable { typedef VariantSubType TableType; std::vector shape{}; tflite::TensorType type = tflite::TensorType_FLOAT32; bool has_rank = false; }; -struct VariantSubType FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct VariantSubType FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef VariantSubTypeT NativeTableType; typedef VariantSubTypeBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -5662,8 +5662,8 @@ struct VariantSubType FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_TYPE = 6, VT_HAS_RANK = 8 }; - const flatbuffers::Vector *shape() const { - return GetPointer *>(VT_SHAPE); + const ::flatbuffers::Vector *shape() const { + return GetPointer *>(VT_SHAPE); } tflite::TensorType type() const { return static_cast(GetField(VT_TYPE, 0)); @@ -5671,7 +5671,7 @@ struct VariantSubType FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool has_rank() const { return GetField(VT_HAS_RANK, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SHAPE) && verifier.VerifyVector(shape()) && @@ -5679,16 +5679,16 @@ struct VariantSubType FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_HAS_RANK, 1) && verifier.EndTable(); } - VariantSubTypeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(VariantSubTypeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + VariantSubTypeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(VariantSubTypeT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct VariantSubTypeBuilder { typedef VariantSubType Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_shape(flatbuffers::Offset> shape) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_shape(::flatbuffers::Offset<::flatbuffers::Vector> shape) { fbb_.AddOffset(VariantSubType::VT_SHAPE, shape); } void add_type(tflite::TensorType type) { @@ -5697,20 +5697,20 @@ struct VariantSubTypeBuilder { void add_has_rank(bool has_rank) { fbb_.AddElement(VariantSubType::VT_HAS_RANK, static_cast(has_rank), 0); } - explicit VariantSubTypeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VariantSubTypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateVariantSubType( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> shape = 0, +inline ::flatbuffers::Offset CreateVariantSubType( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> shape = 0, tflite::TensorType type = tflite::TensorType_FLOAT32, bool has_rank = false) { VariantSubTypeBuilder builder_(_fbb); @@ -5720,8 +5720,8 @@ inline flatbuffers::Offset CreateVariantSubType( return builder_.Finish(); } -inline flatbuffers::Offset CreateVariantSubTypeDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateVariantSubTypeDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *shape = nullptr, tflite::TensorType type = tflite::TensorType_FLOAT32, bool has_rank = false) { @@ -5733,9 +5733,9 @@ inline flatbuffers::Offset CreateVariantSubTypeDirect( has_rank); } -flatbuffers::Offset CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateVariantSubType(::flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct TensorT : public flatbuffers::NativeTable { +struct TensorT : public ::flatbuffers::NativeTable { typedef Tensor TableType; std::vector shape{}; tflite::TensorType type = tflite::TensorType_FLOAT32; @@ -5753,7 +5753,7 @@ struct TensorT : public flatbuffers::NativeTable { TensorT &operator=(TensorT o) FLATBUFFERS_NOEXCEPT; }; -struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Tensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef TensorT NativeTableType; typedef TensorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -5768,8 +5768,8 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_HAS_RANK = 20, VT_VARIANT_TENSORS = 22 }; - const flatbuffers::Vector *shape() const { - return GetPointer *>(VT_SHAPE); + const ::flatbuffers::Vector *shape() const { + return GetPointer *>(VT_SHAPE); } tflite::TensorType type() const { return static_cast(GetField(VT_TYPE, 0)); @@ -5777,8 +5777,8 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { uint32_t buffer() const { return GetField(VT_BUFFER, 0); } - const flatbuffers::String *name() const { - return GetPointer(VT_NAME); + const ::flatbuffers::String *name() const { + return GetPointer(VT_NAME); } const tflite::QuantizationParameters *quantization() const { return GetPointer(VT_QUANTIZATION); @@ -5789,16 +5789,16 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const tflite::SparsityParameters *sparsity() const { return GetPointer(VT_SPARSITY); } - const flatbuffers::Vector *shape_signature() const { - return GetPointer *>(VT_SHAPE_SIGNATURE); + const ::flatbuffers::Vector *shape_signature() const { + return GetPointer *>(VT_SHAPE_SIGNATURE); } bool has_rank() const { return GetField(VT_HAS_RANK, 0) != 0; } - const flatbuffers::Vector> *variant_tensors() const { - return GetPointer> *>(VT_VARIANT_TENSORS); + const ::flatbuffers::Vector<::flatbuffers::Offset> *variant_tensors() const { + return GetPointer> *>(VT_VARIANT_TENSORS); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SHAPE) && verifier.VerifyVector(shape()) && @@ -5819,16 +5819,16 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyVectorOfTables(variant_tensors()) && verifier.EndTable(); } - TensorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + TensorT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TensorT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct TensorBuilder { typedef Tensor Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_shape(flatbuffers::Offset> shape) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_shape(::flatbuffers::Offset<::flatbuffers::Vector> shape) { fbb_.AddOffset(Tensor::VT_SHAPE, shape); } void add_type(tflite::TensorType type) { @@ -5837,50 +5837,50 @@ struct TensorBuilder { void add_buffer(uint32_t buffer) { fbb_.AddElement(Tensor::VT_BUFFER, buffer, 0); } - void add_name(flatbuffers::Offset name) { + void add_name(::flatbuffers::Offset<::flatbuffers::String> name) { fbb_.AddOffset(Tensor::VT_NAME, name); } - void add_quantization(flatbuffers::Offset quantization) { + void add_quantization(::flatbuffers::Offset quantization) { fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization); } void add_is_variable(bool is_variable) { fbb_.AddElement(Tensor::VT_IS_VARIABLE, static_cast(is_variable), 0); } - void add_sparsity(flatbuffers::Offset sparsity) { + void add_sparsity(::flatbuffers::Offset sparsity) { fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity); } - void add_shape_signature(flatbuffers::Offset> shape_signature) { + void add_shape_signature(::flatbuffers::Offset<::flatbuffers::Vector> shape_signature) { fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature); } void add_has_rank(bool has_rank) { fbb_.AddElement(Tensor::VT_HAS_RANK, static_cast(has_rank), 0); } - void add_variant_tensors(flatbuffers::Offset>> variant_tensors) { + void add_variant_tensors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> variant_tensors) { fbb_.AddOffset(Tensor::VT_VARIANT_TENSORS, variant_tensors); } - explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTensor( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> shape = 0, +inline ::flatbuffers::Offset CreateTensor( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> shape = 0, tflite::TensorType type = tflite::TensorType_FLOAT32, uint32_t buffer = 0, - flatbuffers::Offset name = 0, - flatbuffers::Offset quantization = 0, + ::flatbuffers::Offset<::flatbuffers::String> name = 0, + ::flatbuffers::Offset quantization = 0, bool is_variable = false, - flatbuffers::Offset sparsity = 0, - flatbuffers::Offset> shape_signature = 0, + ::flatbuffers::Offset sparsity = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> shape_signature = 0, bool has_rank = false, - flatbuffers::Offset>> variant_tensors = 0) { + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> variant_tensors = 0) { TensorBuilder builder_(_fbb); builder_.add_variant_tensors(variant_tensors); builder_.add_shape_signature(shape_signature); @@ -5895,22 +5895,22 @@ inline flatbuffers::Offset CreateTensor( return builder_.Finish(); } -inline flatbuffers::Offset CreateTensorDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateTensorDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *shape = nullptr, tflite::TensorType type = tflite::TensorType_FLOAT32, uint32_t buffer = 0, const char *name = nullptr, - flatbuffers::Offset quantization = 0, + ::flatbuffers::Offset quantization = 0, bool is_variable = false, - flatbuffers::Offset sparsity = 0, + ::flatbuffers::Offset sparsity = 0, const std::vector *shape_signature = nullptr, bool has_rank = false, - const std::vector> *variant_tensors = nullptr) { + const std::vector<::flatbuffers::Offset> *variant_tensors = nullptr) { auto shape__ = shape ? _fbb.CreateVector(*shape) : 0; auto name__ = name ? _fbb.CreateString(name) : 0; auto shape_signature__ = shape_signature ? _fbb.CreateVector(*shape_signature) : 0; - auto variant_tensors__ = variant_tensors ? _fbb.CreateVector>(*variant_tensors) : 0; + auto variant_tensors__ = variant_tensors ? _fbb.CreateVector<::flatbuffers::Offset>(*variant_tensors) : 0; return tflite::CreateTensor( _fbb, shape__, @@ -5925,9 +5925,9 @@ inline flatbuffers::Offset CreateTensorDirect( variant_tensors__); } -flatbuffers::Offset CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateTensor(::flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloGatherOptionsT : public flatbuffers::NativeTable { +struct StablehloGatherOptionsT : public ::flatbuffers::NativeTable { typedef StablehloGatherOptions TableType; std::vector offset_dims{}; std::vector collapsed_slice_dims{}; @@ -5937,7 +5937,7 @@ struct StablehloGatherOptionsT : public flatbuffers::NativeTable { bool indices_are_sorted = false; }; -struct StablehloGatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloGatherOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloGatherOptionsT NativeTableType; typedef StablehloGatherOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -5948,25 +5948,25 @@ struct StablehloGatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab VT_SLICE_SIZES = 12, VT_INDICES_ARE_SORTED = 14 }; - const flatbuffers::Vector *offset_dims() const { - return GetPointer *>(VT_OFFSET_DIMS); + const ::flatbuffers::Vector *offset_dims() const { + return GetPointer *>(VT_OFFSET_DIMS); } - const flatbuffers::Vector *collapsed_slice_dims() const { - return GetPointer *>(VT_COLLAPSED_SLICE_DIMS); + const ::flatbuffers::Vector *collapsed_slice_dims() const { + return GetPointer *>(VT_COLLAPSED_SLICE_DIMS); } - const flatbuffers::Vector *start_index_map() const { - return GetPointer *>(VT_START_INDEX_MAP); + const ::flatbuffers::Vector *start_index_map() const { + return GetPointer *>(VT_START_INDEX_MAP); } int64_t index_vector_dim() const { return GetField(VT_INDEX_VECTOR_DIM, 0); } - const flatbuffers::Vector *slice_sizes() const { - return GetPointer *>(VT_SLICE_SIZES); + const ::flatbuffers::Vector *slice_sizes() const { + return GetPointer *>(VT_SLICE_SIZES); } bool indices_are_sorted() const { return GetField(VT_INDICES_ARE_SORTED, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_OFFSET_DIMS) && verifier.VerifyVector(offset_dims()) && @@ -5980,51 +5980,51 @@ struct StablehloGatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab VerifyField(verifier, VT_INDICES_ARE_SORTED, 1) && verifier.EndTable(); } - StablehloGatherOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloGatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloGatherOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloGatherOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloGatherOptionsBuilder { typedef StablehloGatherOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_offset_dims(flatbuffers::Offset> offset_dims) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_offset_dims(::flatbuffers::Offset<::flatbuffers::Vector> offset_dims) { fbb_.AddOffset(StablehloGatherOptions::VT_OFFSET_DIMS, offset_dims); } - void add_collapsed_slice_dims(flatbuffers::Offset> collapsed_slice_dims) { + void add_collapsed_slice_dims(::flatbuffers::Offset<::flatbuffers::Vector> collapsed_slice_dims) { fbb_.AddOffset(StablehloGatherOptions::VT_COLLAPSED_SLICE_DIMS, collapsed_slice_dims); } - void add_start_index_map(flatbuffers::Offset> start_index_map) { + void add_start_index_map(::flatbuffers::Offset<::flatbuffers::Vector> start_index_map) { fbb_.AddOffset(StablehloGatherOptions::VT_START_INDEX_MAP, start_index_map); } void add_index_vector_dim(int64_t index_vector_dim) { fbb_.AddElement(StablehloGatherOptions::VT_INDEX_VECTOR_DIM, index_vector_dim, 0); } - void add_slice_sizes(flatbuffers::Offset> slice_sizes) { + void add_slice_sizes(::flatbuffers::Offset<::flatbuffers::Vector> slice_sizes) { fbb_.AddOffset(StablehloGatherOptions::VT_SLICE_SIZES, slice_sizes); } void add_indices_are_sorted(bool indices_are_sorted) { fbb_.AddElement(StablehloGatherOptions::VT_INDICES_ARE_SORTED, static_cast(indices_are_sorted), 0); } - explicit StablehloGatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloGatherOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloGatherOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> offset_dims = 0, - flatbuffers::Offset> collapsed_slice_dims = 0, - flatbuffers::Offset> start_index_map = 0, +inline ::flatbuffers::Offset CreateStablehloGatherOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> offset_dims = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> collapsed_slice_dims = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> start_index_map = 0, int64_t index_vector_dim = 0, - flatbuffers::Offset> slice_sizes = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> slice_sizes = 0, bool indices_are_sorted = false) { StablehloGatherOptionsBuilder builder_(_fbb); builder_.add_index_vector_dim(index_vector_dim); @@ -6036,8 +6036,8 @@ inline flatbuffers::Offset CreateStablehloGatherOptions( return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloGatherOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloGatherOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *offset_dims = nullptr, const std::vector *collapsed_slice_dims = nullptr, const std::vector *start_index_map = nullptr, @@ -6058,61 +6058,61 @@ inline flatbuffers::Offset CreateStablehloGatherOptionsD indices_are_sorted); } -flatbuffers::Offset CreateStablehloGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloGatherOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloTransposeOptionsT : public flatbuffers::NativeTable { +struct StablehloTransposeOptionsT : public ::flatbuffers::NativeTable { typedef StablehloTransposeOptions TableType; std::vector permutation{}; }; -struct StablehloTransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloTransposeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloTransposeOptionsT NativeTableType; typedef StablehloTransposeOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_PERMUTATION = 4 }; - const flatbuffers::Vector *permutation() const { - return GetPointer *>(VT_PERMUTATION); + const ::flatbuffers::Vector *permutation() const { + return GetPointer *>(VT_PERMUTATION); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_PERMUTATION) && verifier.VerifyVector(permutation()) && verifier.EndTable(); } - StablehloTransposeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloTransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloTransposeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloTransposeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloTransposeOptionsBuilder { typedef StablehloTransposeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_permutation(flatbuffers::Offset> permutation) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_permutation(::flatbuffers::Offset<::flatbuffers::Vector> permutation) { fbb_.AddOffset(StablehloTransposeOptions::VT_PERMUTATION, permutation); } - explicit StablehloTransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloTransposeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloTransposeOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> permutation = 0) { +inline ::flatbuffers::Offset CreateStablehloTransposeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> permutation = 0) { StablehloTransposeOptionsBuilder builder_(_fbb); builder_.add_permutation(permutation); return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloTransposeOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloTransposeOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *permutation = nullptr) { auto permutation__ = permutation ? _fbb.CreateVector(*permutation) : 0; return tflite::CreateStablehloTransposeOptions( @@ -6120,9 +6120,9 @@ inline flatbuffers::Offset CreateStablehloTransposeOp permutation__); } -flatbuffers::Offset CreateStablehloTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloTransposeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloDotGeneralOptionsT : public flatbuffers::NativeTable { +struct StablehloDotGeneralOptionsT : public ::flatbuffers::NativeTable { typedef StablehloDotGeneralOptions TableType; std::vector lhs_batching_dimensions{}; std::vector rhs_batching_dimensions{}; @@ -6131,7 +6131,7 @@ struct StablehloDotGeneralOptionsT : public flatbuffers::NativeTable { std::vector precision_config{}; }; -struct StablehloDotGeneralOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloDotGeneralOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloDotGeneralOptionsT NativeTableType; typedef StablehloDotGeneralOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6141,22 +6141,22 @@ struct StablehloDotGeneralOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers: VT_RHS_CONTRACTING_DIMENSIONS = 10, VT_PRECISION_CONFIG = 12 }; - const flatbuffers::Vector *lhs_batching_dimensions() const { - return GetPointer *>(VT_LHS_BATCHING_DIMENSIONS); + const ::flatbuffers::Vector *lhs_batching_dimensions() const { + return GetPointer *>(VT_LHS_BATCHING_DIMENSIONS); } - const flatbuffers::Vector *rhs_batching_dimensions() const { - return GetPointer *>(VT_RHS_BATCHING_DIMENSIONS); + const ::flatbuffers::Vector *rhs_batching_dimensions() const { + return GetPointer *>(VT_RHS_BATCHING_DIMENSIONS); } - const flatbuffers::Vector *lhs_contracting_dimensions() const { - return GetPointer *>(VT_LHS_CONTRACTING_DIMENSIONS); + const ::flatbuffers::Vector *lhs_contracting_dimensions() const { + return GetPointer *>(VT_LHS_CONTRACTING_DIMENSIONS); } - const flatbuffers::Vector *rhs_contracting_dimensions() const { - return GetPointer *>(VT_RHS_CONTRACTING_DIMENSIONS); + const ::flatbuffers::Vector *rhs_contracting_dimensions() const { + return GetPointer *>(VT_RHS_CONTRACTING_DIMENSIONS); } - const flatbuffers::Vector *precision_config() const { - return GetPointer *>(VT_PRECISION_CONFIG); + const ::flatbuffers::Vector *precision_config() const { + return GetPointer *>(VT_PRECISION_CONFIG); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_LHS_BATCHING_DIMENSIONS) && verifier.VerifyVector(lhs_batching_dimensions()) && @@ -6170,48 +6170,48 @@ struct StablehloDotGeneralOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers: verifier.VerifyVector(precision_config()) && verifier.EndTable(); } - StablehloDotGeneralOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloDotGeneralOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloDotGeneralOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloDotGeneralOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloDotGeneralOptionsBuilder { typedef StablehloDotGeneralOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_lhs_batching_dimensions(flatbuffers::Offset> lhs_batching_dimensions) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_lhs_batching_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> lhs_batching_dimensions) { fbb_.AddOffset(StablehloDotGeneralOptions::VT_LHS_BATCHING_DIMENSIONS, lhs_batching_dimensions); } - void add_rhs_batching_dimensions(flatbuffers::Offset> rhs_batching_dimensions) { + void add_rhs_batching_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> rhs_batching_dimensions) { fbb_.AddOffset(StablehloDotGeneralOptions::VT_RHS_BATCHING_DIMENSIONS, rhs_batching_dimensions); } - void add_lhs_contracting_dimensions(flatbuffers::Offset> lhs_contracting_dimensions) { + void add_lhs_contracting_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> lhs_contracting_dimensions) { fbb_.AddOffset(StablehloDotGeneralOptions::VT_LHS_CONTRACTING_DIMENSIONS, lhs_contracting_dimensions); } - void add_rhs_contracting_dimensions(flatbuffers::Offset> rhs_contracting_dimensions) { + void add_rhs_contracting_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> rhs_contracting_dimensions) { fbb_.AddOffset(StablehloDotGeneralOptions::VT_RHS_CONTRACTING_DIMENSIONS, rhs_contracting_dimensions); } - void add_precision_config(flatbuffers::Offset> precision_config) { + void add_precision_config(::flatbuffers::Offset<::flatbuffers::Vector> precision_config) { fbb_.AddOffset(StablehloDotGeneralOptions::VT_PRECISION_CONFIG, precision_config); } - explicit StablehloDotGeneralOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloDotGeneralOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloDotGeneralOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> lhs_batching_dimensions = 0, - flatbuffers::Offset> rhs_batching_dimensions = 0, - flatbuffers::Offset> lhs_contracting_dimensions = 0, - flatbuffers::Offset> rhs_contracting_dimensions = 0, - flatbuffers::Offset> precision_config = 0) { +inline ::flatbuffers::Offset CreateStablehloDotGeneralOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> lhs_batching_dimensions = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> rhs_batching_dimensions = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> lhs_contracting_dimensions = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> rhs_contracting_dimensions = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> precision_config = 0) { StablehloDotGeneralOptionsBuilder builder_(_fbb); builder_.add_precision_config(precision_config); builder_.add_rhs_contracting_dimensions(rhs_contracting_dimensions); @@ -6221,8 +6221,8 @@ inline flatbuffers::Offset CreateStablehloDotGeneral return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloDotGeneralOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloDotGeneralOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *lhs_batching_dimensions = nullptr, const std::vector *rhs_batching_dimensions = nullptr, const std::vector *lhs_contracting_dimensions = nullptr, @@ -6242,9 +6242,9 @@ inline flatbuffers::Offset CreateStablehloDotGeneral precision_config__); } -flatbuffers::Offset CreateStablehloDotGeneralOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloDotGeneralOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloReduceWindowOptionsT : public flatbuffers::NativeTable { +struct StablehloReduceWindowOptionsT : public ::flatbuffers::NativeTable { typedef StablehloReduceWindowOptions TableType; std::vector window_dimensions{}; std::vector window_strides{}; @@ -6254,7 +6254,7 @@ struct StablehloReduceWindowOptionsT : public flatbuffers::NativeTable { int32_t body_subgraph_index = 0; }; -struct StablehloReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloReduceWindowOptionsT NativeTableType; typedef StablehloReduceWindowOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6265,25 +6265,25 @@ struct StablehloReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffer VT_PADDING = 12, VT_BODY_SUBGRAPH_INDEX = 14 }; - const flatbuffers::Vector *window_dimensions() const { - return GetPointer *>(VT_WINDOW_DIMENSIONS); + const ::flatbuffers::Vector *window_dimensions() const { + return GetPointer *>(VT_WINDOW_DIMENSIONS); } - const flatbuffers::Vector *window_strides() const { - return GetPointer *>(VT_WINDOW_STRIDES); + const ::flatbuffers::Vector *window_strides() const { + return GetPointer *>(VT_WINDOW_STRIDES); } - const flatbuffers::Vector *base_dilations() const { - return GetPointer *>(VT_BASE_DILATIONS); + const ::flatbuffers::Vector *base_dilations() const { + return GetPointer *>(VT_BASE_DILATIONS); } - const flatbuffers::Vector *window_dilations() const { - return GetPointer *>(VT_WINDOW_DILATIONS); + const ::flatbuffers::Vector *window_dilations() const { + return GetPointer *>(VT_WINDOW_DILATIONS); } - const flatbuffers::Vector *padding() const { - return GetPointer *>(VT_PADDING); + const ::flatbuffers::Vector *padding() const { + return GetPointer *>(VT_PADDING); } int32_t body_subgraph_index() const { return GetField(VT_BODY_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WINDOW_DIMENSIONS) && verifier.VerifyVector(window_dimensions()) && @@ -6298,51 +6298,51 @@ struct StablehloReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffer VerifyField(verifier, VT_BODY_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - StablehloReduceWindowOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloReduceWindowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloReduceWindowOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloReduceWindowOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloReduceWindowOptionsBuilder { typedef StablehloReduceWindowOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_window_dimensions(flatbuffers::Offset> window_dimensions) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_window_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> window_dimensions) { fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_DIMENSIONS, window_dimensions); } - void add_window_strides(flatbuffers::Offset> window_strides) { + void add_window_strides(::flatbuffers::Offset<::flatbuffers::Vector> window_strides) { fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_STRIDES, window_strides); } - void add_base_dilations(flatbuffers::Offset> base_dilations) { + void add_base_dilations(::flatbuffers::Offset<::flatbuffers::Vector> base_dilations) { fbb_.AddOffset(StablehloReduceWindowOptions::VT_BASE_DILATIONS, base_dilations); } - void add_window_dilations(flatbuffers::Offset> window_dilations) { + void add_window_dilations(::flatbuffers::Offset<::flatbuffers::Vector> window_dilations) { fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_DILATIONS, window_dilations); } - void add_padding(flatbuffers::Offset> padding) { + void add_padding(::flatbuffers::Offset<::flatbuffers::Vector> padding) { fbb_.AddOffset(StablehloReduceWindowOptions::VT_PADDING, padding); } void add_body_subgraph_index(int32_t body_subgraph_index) { fbb_.AddElement(StablehloReduceWindowOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0); } - explicit StablehloReduceWindowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloReduceWindowOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloReduceWindowOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> window_dimensions = 0, - flatbuffers::Offset> window_strides = 0, - flatbuffers::Offset> base_dilations = 0, - flatbuffers::Offset> window_dilations = 0, - flatbuffers::Offset> padding = 0, +inline ::flatbuffers::Offset CreateStablehloReduceWindowOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> window_dimensions = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> window_strides = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> base_dilations = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> window_dilations = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> padding = 0, int32_t body_subgraph_index = 0) { StablehloReduceWindowOptionsBuilder builder_(_fbb); builder_.add_body_subgraph_index(body_subgraph_index); @@ -6354,8 +6354,8 @@ inline flatbuffers::Offset CreateStablehloReduceWi return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloReduceWindowOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloReduceWindowOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *window_dimensions = nullptr, const std::vector *window_strides = nullptr, const std::vector *base_dilations = nullptr, @@ -6377,15 +6377,15 @@ inline flatbuffers::Offset CreateStablehloReduceWi body_subgraph_index); } -flatbuffers::Offset CreateStablehloReduceWindowOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloReduceWindowOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloWhileOptionsT : public flatbuffers::NativeTable { +struct StablehloWhileOptionsT : public ::flatbuffers::NativeTable { typedef StablehloWhileOptions TableType; int32_t cond_subgraph_index = 0; int32_t body_subgraph_index = 0; }; -struct StablehloWhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloWhileOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloWhileOptionsT NativeTableType; typedef StablehloWhileOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6398,40 +6398,40 @@ struct StablehloWhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tabl int32_t body_subgraph_index() const { return GetField(VT_BODY_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_COND_SUBGRAPH_INDEX, 4) && VerifyField(verifier, VT_BODY_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - StablehloWhileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloWhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloWhileOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloWhileOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloWhileOptionsBuilder { typedef StablehloWhileOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_cond_subgraph_index(int32_t cond_subgraph_index) { fbb_.AddElement(StablehloWhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0); } void add_body_subgraph_index(int32_t body_subgraph_index) { fbb_.AddElement(StablehloWhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0); } - explicit StablehloWhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloWhileOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloWhileOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloWhileOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t cond_subgraph_index = 0, int32_t body_subgraph_index = 0) { StablehloWhileOptionsBuilder builder_(_fbb); @@ -6440,16 +6440,16 @@ inline flatbuffers::Offset CreateStablehloWhileOptions( return builder_.Finish(); } -flatbuffers::Offset CreateStablehloWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloWhileOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloSortOptionsT : public flatbuffers::NativeTable { +struct StablehloSortOptionsT : public ::flatbuffers::NativeTable { typedef StablehloSortOptions TableType; int64_t dimension = 0; bool is_stable = false; int32_t comparator_subgraph_index = 0; }; -struct StablehloSortOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloSortOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloSortOptionsT NativeTableType; typedef StablehloSortOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6466,22 +6466,22 @@ struct StablehloSortOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table int32_t comparator_subgraph_index() const { return GetField(VT_COMPARATOR_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_DIMENSION, 8) && VerifyField(verifier, VT_IS_STABLE, 1) && VerifyField(verifier, VT_COMPARATOR_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - StablehloSortOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloSortOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloSortOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloSortOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloSortOptionsBuilder { typedef StablehloSortOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_dimension(int64_t dimension) { fbb_.AddElement(StablehloSortOptions::VT_DIMENSION, dimension, 0); } @@ -6491,19 +6491,19 @@ struct StablehloSortOptionsBuilder { void add_comparator_subgraph_index(int32_t comparator_subgraph_index) { fbb_.AddElement(StablehloSortOptions::VT_COMPARATOR_SUBGRAPH_INDEX, comparator_subgraph_index, 0); } - explicit StablehloSortOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloSortOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloSortOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloSortOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int64_t dimension = 0, bool is_stable = false, int32_t comparator_subgraph_index = 0) { @@ -6514,14 +6514,14 @@ inline flatbuffers::Offset CreateStablehloSortOptions( return builder_.Finish(); } -flatbuffers::Offset CreateStablehloSortOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloSortOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloConcatenateOptionsT : public flatbuffers::NativeTable { +struct StablehloConcatenateOptionsT : public ::flatbuffers::NativeTable { typedef StablehloConcatenateOptions TableType; int64_t dimension = 0; }; -struct StablehloConcatenateOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloConcatenateOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloConcatenateOptionsT NativeTableType; typedef StablehloConcatenateOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6530,97 +6530,97 @@ struct StablehloConcatenateOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers int64_t dimension() const { return GetField(VT_DIMENSION, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_DIMENSION, 8) && verifier.EndTable(); } - StablehloConcatenateOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloConcatenateOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloConcatenateOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloConcatenateOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloConcatenateOptionsBuilder { typedef StablehloConcatenateOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_dimension(int64_t dimension) { fbb_.AddElement(StablehloConcatenateOptions::VT_DIMENSION, dimension, 0); } - explicit StablehloConcatenateOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloConcatenateOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloConcatenateOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloConcatenateOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int64_t dimension = 0) { StablehloConcatenateOptionsBuilder builder_(_fbb); builder_.add_dimension(dimension); return builder_.Finish(); } -flatbuffers::Offset CreateStablehloConcatenateOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloConcatenateOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloBroadcastInDimOptionsT : public flatbuffers::NativeTable { +struct StablehloBroadcastInDimOptionsT : public ::flatbuffers::NativeTable { typedef StablehloBroadcastInDimOptions TableType; std::vector broadcast_dimensions{}; }; -struct StablehloBroadcastInDimOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloBroadcastInDimOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloBroadcastInDimOptionsT NativeTableType; typedef StablehloBroadcastInDimOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BROADCAST_DIMENSIONS = 4 }; - const flatbuffers::Vector *broadcast_dimensions() const { - return GetPointer *>(VT_BROADCAST_DIMENSIONS); + const ::flatbuffers::Vector *broadcast_dimensions() const { + return GetPointer *>(VT_BROADCAST_DIMENSIONS); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BROADCAST_DIMENSIONS) && verifier.VerifyVector(broadcast_dimensions()) && verifier.EndTable(); } - StablehloBroadcastInDimOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloBroadcastInDimOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloBroadcastInDimOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloBroadcastInDimOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloBroadcastInDimOptionsBuilder { typedef StablehloBroadcastInDimOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_broadcast_dimensions(flatbuffers::Offset> broadcast_dimensions) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_broadcast_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> broadcast_dimensions) { fbb_.AddOffset(StablehloBroadcastInDimOptions::VT_BROADCAST_DIMENSIONS, broadcast_dimensions); } - explicit StablehloBroadcastInDimOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloBroadcastInDimOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloBroadcastInDimOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> broadcast_dimensions = 0) { +inline ::flatbuffers::Offset CreateStablehloBroadcastInDimOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> broadcast_dimensions = 0) { StablehloBroadcastInDimOptionsBuilder builder_(_fbb); builder_.add_broadcast_dimensions(broadcast_dimensions); return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloBroadcastInDimOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloBroadcastInDimOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *broadcast_dimensions = nullptr) { auto broadcast_dimensions__ = broadcast_dimensions ? _fbb.CreateVector(*broadcast_dimensions) : 0; return tflite::CreateStablehloBroadcastInDimOptions( @@ -6628,15 +6628,15 @@ inline flatbuffers::Offset CreateStablehloBroadc broadcast_dimensions__); } -flatbuffers::Offset CreateStablehloBroadcastInDimOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloBroadcastInDimOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloCompareOptionsT : public flatbuffers::NativeTable { +struct StablehloCompareOptionsT : public ::flatbuffers::NativeTable { typedef StablehloCompareOptions TableType; tflite::StablehloComparisonDirection comparison_direction = tflite::StablehloComparisonDirection_STABLEHLO_COMPARISON_DIRECTION_EQ; tflite::StablehloComparisonType compare_type = tflite::StablehloComparisonType_STABLEHLO_COMPARISON_TYPE_NOTYPE; }; -struct StablehloCompareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloCompareOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloCompareOptionsT NativeTableType; typedef StablehloCompareOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6649,40 +6649,40 @@ struct StablehloCompareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta tflite::StablehloComparisonType compare_type() const { return static_cast(GetField(VT_COMPARE_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_COMPARISON_DIRECTION, 4) && VerifyField(verifier, VT_COMPARE_TYPE, 4) && verifier.EndTable(); } - StablehloCompareOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloCompareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloCompareOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloCompareOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloCompareOptionsBuilder { typedef StablehloCompareOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_comparison_direction(tflite::StablehloComparisonDirection comparison_direction) { fbb_.AddElement(StablehloCompareOptions::VT_COMPARISON_DIRECTION, static_cast(comparison_direction), 0); } void add_compare_type(tflite::StablehloComparisonType compare_type) { fbb_.AddElement(StablehloCompareOptions::VT_COMPARE_TYPE, static_cast(compare_type), 0); } - explicit StablehloCompareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloCompareOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloCompareOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloCompareOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::StablehloComparisonDirection comparison_direction = tflite::StablehloComparisonDirection_STABLEHLO_COMPARISON_DIRECTION_EQ, tflite::StablehloComparisonType compare_type = tflite::StablehloComparisonType_STABLEHLO_COMPARISON_TYPE_NOTYPE) { StablehloCompareOptionsBuilder builder_(_fbb); @@ -6691,61 +6691,61 @@ inline flatbuffers::Offset CreateStablehloCompareOption return builder_.Finish(); } -flatbuffers::Offset CreateStablehloCompareOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloCompareOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloDynamicSliceOptionsT : public flatbuffers::NativeTable { +struct StablehloDynamicSliceOptionsT : public ::flatbuffers::NativeTable { typedef StablehloDynamicSliceOptions TableType; std::vector slice_sizes{}; }; -struct StablehloDynamicSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloDynamicSliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloDynamicSliceOptionsT NativeTableType; typedef StablehloDynamicSliceOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_SLICE_SIZES = 4 }; - const flatbuffers::Vector *slice_sizes() const { - return GetPointer *>(VT_SLICE_SIZES); + const ::flatbuffers::Vector *slice_sizes() const { + return GetPointer *>(VT_SLICE_SIZES); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SLICE_SIZES) && verifier.VerifyVector(slice_sizes()) && verifier.EndTable(); } - StablehloDynamicSliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloDynamicSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloDynamicSliceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloDynamicSliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloDynamicSliceOptionsBuilder { typedef StablehloDynamicSliceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_slice_sizes(flatbuffers::Offset> slice_sizes) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_slice_sizes(::flatbuffers::Offset<::flatbuffers::Vector> slice_sizes) { fbb_.AddOffset(StablehloDynamicSliceOptions::VT_SLICE_SIZES, slice_sizes); } - explicit StablehloDynamicSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloDynamicSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloDynamicSliceOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> slice_sizes = 0) { +inline ::flatbuffers::Offset CreateStablehloDynamicSliceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> slice_sizes = 0) { StablehloDynamicSliceOptionsBuilder builder_(_fbb); builder_.add_slice_sizes(slice_sizes); return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloDynamicSliceOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloDynamicSliceOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *slice_sizes = nullptr) { auto slice_sizes__ = slice_sizes ? _fbb.CreateVector(*slice_sizes) : 0; return tflite::CreateStablehloDynamicSliceOptions( @@ -6753,16 +6753,16 @@ inline flatbuffers::Offset CreateStablehloDynamicS slice_sizes__); } -flatbuffers::Offset CreateStablehloDynamicSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloDynamicSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloPadOptionsT : public flatbuffers::NativeTable { +struct StablehloPadOptionsT : public ::flatbuffers::NativeTable { typedef StablehloPadOptions TableType; std::vector edge_padding_low{}; std::vector edge_padding_high{}; std::vector interior_padding{}; }; -struct StablehloPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloPadOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloPadOptionsT NativeTableType; typedef StablehloPadOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6770,16 +6770,16 @@ struct StablehloPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table VT_EDGE_PADDING_HIGH = 6, VT_INTERIOR_PADDING = 8 }; - const flatbuffers::Vector *edge_padding_low() const { - return GetPointer *>(VT_EDGE_PADDING_LOW); + const ::flatbuffers::Vector *edge_padding_low() const { + return GetPointer *>(VT_EDGE_PADDING_LOW); } - const flatbuffers::Vector *edge_padding_high() const { - return GetPointer *>(VT_EDGE_PADDING_HIGH); + const ::flatbuffers::Vector *edge_padding_high() const { + return GetPointer *>(VT_EDGE_PADDING_HIGH); } - const flatbuffers::Vector *interior_padding() const { - return GetPointer *>(VT_INTERIOR_PADDING); + const ::flatbuffers::Vector *interior_padding() const { + return GetPointer *>(VT_INTERIOR_PADDING); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_EDGE_PADDING_LOW) && verifier.VerifyVector(edge_padding_low()) && @@ -6789,40 +6789,40 @@ struct StablehloPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table verifier.VerifyVector(interior_padding()) && verifier.EndTable(); } - StablehloPadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloPadOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloPadOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloPadOptionsBuilder { typedef StablehloPadOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_edge_padding_low(flatbuffers::Offset> edge_padding_low) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_edge_padding_low(::flatbuffers::Offset<::flatbuffers::Vector> edge_padding_low) { fbb_.AddOffset(StablehloPadOptions::VT_EDGE_PADDING_LOW, edge_padding_low); } - void add_edge_padding_high(flatbuffers::Offset> edge_padding_high) { + void add_edge_padding_high(::flatbuffers::Offset<::flatbuffers::Vector> edge_padding_high) { fbb_.AddOffset(StablehloPadOptions::VT_EDGE_PADDING_HIGH, edge_padding_high); } - void add_interior_padding(flatbuffers::Offset> interior_padding) { + void add_interior_padding(::flatbuffers::Offset<::flatbuffers::Vector> interior_padding) { fbb_.AddOffset(StablehloPadOptions::VT_INTERIOR_PADDING, interior_padding); } - explicit StablehloPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloPadOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloPadOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> edge_padding_low = 0, - flatbuffers::Offset> edge_padding_high = 0, - flatbuffers::Offset> interior_padding = 0) { +inline ::flatbuffers::Offset CreateStablehloPadOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> edge_padding_low = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> edge_padding_high = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> interior_padding = 0) { StablehloPadOptionsBuilder builder_(_fbb); builder_.add_interior_padding(interior_padding); builder_.add_edge_padding_high(edge_padding_high); @@ -6830,8 +6830,8 @@ inline flatbuffers::Offset CreateStablehloPadOptions( return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloPadOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloPadOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *edge_padding_low = nullptr, const std::vector *edge_padding_high = nullptr, const std::vector *interior_padding = nullptr) { @@ -6845,14 +6845,14 @@ inline flatbuffers::Offset CreateStablehloPadOptionsDirect( interior_padding__); } -flatbuffers::Offset CreateStablehloPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloPadOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloIotaOptionsT : public flatbuffers::NativeTable { +struct StablehloIotaOptionsT : public ::flatbuffers::NativeTable { typedef StablehloIotaOptions TableType; int64_t iota_dimension = 0; }; -struct StablehloIotaOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloIotaOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloIotaOptionsT NativeTableType; typedef StablehloIotaOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6861,45 +6861,45 @@ struct StablehloIotaOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table int64_t iota_dimension() const { return GetField(VT_IOTA_DIMENSION, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_IOTA_DIMENSION, 8) && verifier.EndTable(); } - StablehloIotaOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloIotaOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloIotaOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloIotaOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloIotaOptionsBuilder { typedef StablehloIotaOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_iota_dimension(int64_t iota_dimension) { fbb_.AddElement(StablehloIotaOptions::VT_IOTA_DIMENSION, iota_dimension, 0); } - explicit StablehloIotaOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloIotaOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloIotaOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloIotaOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int64_t iota_dimension = 0) { StablehloIotaOptionsBuilder builder_(_fbb); builder_.add_iota_dimension(iota_dimension); return builder_.Finish(); } -flatbuffers::Offset CreateStablehloIotaOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloIotaOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloCustomCallOptionsT : public flatbuffers::NativeTable { +struct StablehloCustomCallOptionsT : public ::flatbuffers::NativeTable { typedef StablehloCustomCallOptions TableType; std::string call_target_name{}; bool has_side_effect = false; @@ -6909,7 +6909,7 @@ struct StablehloCustomCallOptionsT : public flatbuffers::NativeTable { std::vector custom_attributes{}; }; -struct StablehloCustomCallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloCustomCallOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloCustomCallOptionsT NativeTableType; typedef StablehloCustomCallOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6920,25 +6920,25 @@ struct StablehloCustomCallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers: VT_CALLED_COMPUTATIONS = 12, VT_CUSTOM_ATTRIBUTES = 14 }; - const flatbuffers::String *call_target_name() const { - return GetPointer(VT_CALL_TARGET_NAME); + const ::flatbuffers::String *call_target_name() const { + return GetPointer(VT_CALL_TARGET_NAME); } bool has_side_effect() const { return GetField(VT_HAS_SIDE_EFFECT, 0) != 0; } - const flatbuffers::String *backend_config() const { - return GetPointer(VT_BACKEND_CONFIG); + const ::flatbuffers::String *backend_config() const { + return GetPointer(VT_BACKEND_CONFIG); } int32_t api_version() const { return GetField(VT_API_VERSION, 0); } - const flatbuffers::Vector *called_computations() const { - return GetPointer *>(VT_CALLED_COMPUTATIONS); + const ::flatbuffers::Vector *called_computations() const { + return GetPointer *>(VT_CALLED_COMPUTATIONS); } - const flatbuffers::Vector *custom_attributes() const { - return GetPointer *>(VT_CUSTOM_ATTRIBUTES); + const ::flatbuffers::Vector *custom_attributes() const { + return GetPointer *>(VT_CUSTOM_ATTRIBUTES); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CALL_TARGET_NAME) && verifier.VerifyString(call_target_name()) && @@ -6952,52 +6952,52 @@ struct StablehloCustomCallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers: verifier.VerifyVector(custom_attributes()) && verifier.EndTable(); } - StablehloCustomCallOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloCustomCallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloCustomCallOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloCustomCallOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloCustomCallOptionsBuilder { typedef StablehloCustomCallOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_call_target_name(flatbuffers::Offset call_target_name) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_call_target_name(::flatbuffers::Offset<::flatbuffers::String> call_target_name) { fbb_.AddOffset(StablehloCustomCallOptions::VT_CALL_TARGET_NAME, call_target_name); } void add_has_side_effect(bool has_side_effect) { fbb_.AddElement(StablehloCustomCallOptions::VT_HAS_SIDE_EFFECT, static_cast(has_side_effect), 0); } - void add_backend_config(flatbuffers::Offset backend_config) { + void add_backend_config(::flatbuffers::Offset<::flatbuffers::String> backend_config) { fbb_.AddOffset(StablehloCustomCallOptions::VT_BACKEND_CONFIG, backend_config); } void add_api_version(int32_t api_version) { fbb_.AddElement(StablehloCustomCallOptions::VT_API_VERSION, api_version, 0); } - void add_called_computations(flatbuffers::Offset> called_computations) { + void add_called_computations(::flatbuffers::Offset<::flatbuffers::Vector> called_computations) { fbb_.AddOffset(StablehloCustomCallOptions::VT_CALLED_COMPUTATIONS, called_computations); } - void add_custom_attributes(flatbuffers::Offset> custom_attributes) { + void add_custom_attributes(::flatbuffers::Offset<::flatbuffers::Vector> custom_attributes) { fbb_.AddOffset(StablehloCustomCallOptions::VT_CUSTOM_ATTRIBUTES, custom_attributes); } - explicit StablehloCustomCallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloCustomCallOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloCustomCallOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset call_target_name = 0, +inline ::flatbuffers::Offset CreateStablehloCustomCallOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::String> call_target_name = 0, bool has_side_effect = false, - flatbuffers::Offset backend_config = 0, + ::flatbuffers::Offset<::flatbuffers::String> backend_config = 0, int32_t api_version = 0, - flatbuffers::Offset> called_computations = 0, - flatbuffers::Offset> custom_attributes = 0) { + ::flatbuffers::Offset<::flatbuffers::Vector> called_computations = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> custom_attributes = 0) { StablehloCustomCallOptionsBuilder builder_(_fbb); builder_.add_custom_attributes(custom_attributes); builder_.add_called_computations(called_computations); @@ -7008,8 +7008,8 @@ inline flatbuffers::Offset CreateStablehloCustomCall return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloCustomCallOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloCustomCallOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const char *call_target_name = nullptr, bool has_side_effect = false, const char *backend_config = nullptr, @@ -7030,63 +7030,63 @@ inline flatbuffers::Offset CreateStablehloCustomCall custom_attributes__); } -flatbuffers::Offset CreateStablehloCustomCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloCustomCallOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloReduceOptionsT : public flatbuffers::NativeTable { +struct StablehloReduceOptionsT : public ::flatbuffers::NativeTable { typedef StablehloReduceOptions TableType; std::vector dimensions{}; int32_t body_subgraph_index = 0; }; -struct StablehloReduceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloReduceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloReduceOptionsT NativeTableType; typedef StablehloReduceOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_DIMENSIONS = 4, VT_BODY_SUBGRAPH_INDEX = 6 }; - const flatbuffers::Vector *dimensions() const { - return GetPointer *>(VT_DIMENSIONS); + const ::flatbuffers::Vector *dimensions() const { + return GetPointer *>(VT_DIMENSIONS); } int32_t body_subgraph_index() const { return GetField(VT_BODY_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DIMENSIONS) && verifier.VerifyVector(dimensions()) && VerifyField(verifier, VT_BODY_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - StablehloReduceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloReduceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloReduceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloReduceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloReduceOptionsBuilder { typedef StablehloReduceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_dimensions(flatbuffers::Offset> dimensions) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> dimensions) { fbb_.AddOffset(StablehloReduceOptions::VT_DIMENSIONS, dimensions); } void add_body_subgraph_index(int32_t body_subgraph_index) { fbb_.AddElement(StablehloReduceOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0); } - explicit StablehloReduceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloReduceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloReduceOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> dimensions = 0, +inline ::flatbuffers::Offset CreateStablehloReduceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> dimensions = 0, int32_t body_subgraph_index = 0) { StablehloReduceOptionsBuilder builder_(_fbb); builder_.add_body_subgraph_index(body_subgraph_index); @@ -7094,8 +7094,8 @@ inline flatbuffers::Offset CreateStablehloReduceOptions( return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloReduceOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloReduceOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *dimensions = nullptr, int32_t body_subgraph_index = 0) { auto dimensions__ = dimensions ? _fbb.CreateVector(*dimensions) : 0; @@ -7105,16 +7105,16 @@ inline flatbuffers::Offset CreateStablehloReduceOptionsD body_subgraph_index); } -flatbuffers::Offset CreateStablehloReduceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloReduceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloSliceOptionsT : public flatbuffers::NativeTable { +struct StablehloSliceOptionsT : public ::flatbuffers::NativeTable { typedef StablehloSliceOptions TableType; std::vector start_indices{}; std::vector limit_indices{}; std::vector strides{}; }; -struct StablehloSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloSliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloSliceOptionsT NativeTableType; typedef StablehloSliceOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -7122,16 +7122,16 @@ struct StablehloSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tabl VT_LIMIT_INDICES = 6, VT_STRIDES = 8 }; - const flatbuffers::Vector *start_indices() const { - return GetPointer *>(VT_START_INDICES); + const ::flatbuffers::Vector *start_indices() const { + return GetPointer *>(VT_START_INDICES); } - const flatbuffers::Vector *limit_indices() const { - return GetPointer *>(VT_LIMIT_INDICES); + const ::flatbuffers::Vector *limit_indices() const { + return GetPointer *>(VT_LIMIT_INDICES); } - const flatbuffers::Vector *strides() const { - return GetPointer *>(VT_STRIDES); + const ::flatbuffers::Vector *strides() const { + return GetPointer *>(VT_STRIDES); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_START_INDICES) && verifier.VerifyVector(start_indices()) && @@ -7141,40 +7141,40 @@ struct StablehloSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tabl verifier.VerifyVector(strides()) && verifier.EndTable(); } - StablehloSliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloSliceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloSliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloSliceOptionsBuilder { typedef StablehloSliceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_start_indices(flatbuffers::Offset> start_indices) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_start_indices(::flatbuffers::Offset<::flatbuffers::Vector> start_indices) { fbb_.AddOffset(StablehloSliceOptions::VT_START_INDICES, start_indices); } - void add_limit_indices(flatbuffers::Offset> limit_indices) { + void add_limit_indices(::flatbuffers::Offset<::flatbuffers::Vector> limit_indices) { fbb_.AddOffset(StablehloSliceOptions::VT_LIMIT_INDICES, limit_indices); } - void add_strides(flatbuffers::Offset> strides) { + void add_strides(::flatbuffers::Offset<::flatbuffers::Vector> strides) { fbb_.AddOffset(StablehloSliceOptions::VT_STRIDES, strides); } - explicit StablehloSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloSliceOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> start_indices = 0, - flatbuffers::Offset> limit_indices = 0, - flatbuffers::Offset> strides = 0) { +inline ::flatbuffers::Offset CreateStablehloSliceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> start_indices = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> limit_indices = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> strides = 0) { StablehloSliceOptionsBuilder builder_(_fbb); builder_.add_strides(strides); builder_.add_limit_indices(limit_indices); @@ -7182,8 +7182,8 @@ inline flatbuffers::Offset CreateStablehloSliceOptions( return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloSliceOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloSliceOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *start_indices = nullptr, const std::vector *limit_indices = nullptr, const std::vector *strides = nullptr) { @@ -7197,9 +7197,9 @@ inline flatbuffers::Offset CreateStablehloSliceOptionsDir strides__); } -flatbuffers::Offset CreateStablehloSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloConvolutionOptionsT : public flatbuffers::NativeTable { +struct StablehloConvolutionOptionsT : public ::flatbuffers::NativeTable { typedef StablehloConvolutionOptions TableType; std::vector window_strides{}; std::vector padding{}; @@ -7220,7 +7220,7 @@ struct StablehloConvolutionOptionsT : public flatbuffers::NativeTable { std::vector precision_config{}; }; -struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloConvolutionOptionsT NativeTableType; typedef StablehloConvolutionOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -7242,20 +7242,20 @@ struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers VT_BATCH_GROUP_COUNT = 34, VT_PRECISION_CONFIG = 36 }; - const flatbuffers::Vector *window_strides() const { - return GetPointer *>(VT_WINDOW_STRIDES); + const ::flatbuffers::Vector *window_strides() const { + return GetPointer *>(VT_WINDOW_STRIDES); } - const flatbuffers::Vector *padding() const { - return GetPointer *>(VT_PADDING); + const ::flatbuffers::Vector *padding() const { + return GetPointer *>(VT_PADDING); } - const flatbuffers::Vector *lhs_dilation() const { - return GetPointer *>(VT_LHS_DILATION); + const ::flatbuffers::Vector *lhs_dilation() const { + return GetPointer *>(VT_LHS_DILATION); } - const flatbuffers::Vector *rhs_dilation() const { - return GetPointer *>(VT_RHS_DILATION); + const ::flatbuffers::Vector *rhs_dilation() const { + return GetPointer *>(VT_RHS_DILATION); } - const flatbuffers::Vector *window_reversal() const { - return GetPointer *>(VT_WINDOW_REVERSAL); + const ::flatbuffers::Vector *window_reversal() const { + return GetPointer *>(VT_WINDOW_REVERSAL); } int64_t input_batch_dimension() const { return GetField(VT_INPUT_BATCH_DIMENSION, 0); @@ -7263,8 +7263,8 @@ struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers int64_t input_feature_dimension() const { return GetField(VT_INPUT_FEATURE_DIMENSION, 0); } - const flatbuffers::Vector *input_spatial_dimensions() const { - return GetPointer *>(VT_INPUT_SPATIAL_DIMENSIONS); + const ::flatbuffers::Vector *input_spatial_dimensions() const { + return GetPointer *>(VT_INPUT_SPATIAL_DIMENSIONS); } int64_t kernel_input_feature_dimension() const { return GetField(VT_KERNEL_INPUT_FEATURE_DIMENSION, 0); @@ -7272,8 +7272,8 @@ struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers int64_t kernel_output_feature_dimension() const { return GetField(VT_KERNEL_OUTPUT_FEATURE_DIMENSION, 0); } - const flatbuffers::Vector *kernel_spatial_dimensions() const { - return GetPointer *>(VT_KERNEL_SPATIAL_DIMENSIONS); + const ::flatbuffers::Vector *kernel_spatial_dimensions() const { + return GetPointer *>(VT_KERNEL_SPATIAL_DIMENSIONS); } int64_t output_batch_dimension() const { return GetField(VT_OUTPUT_BATCH_DIMENSION, 0); @@ -7281,8 +7281,8 @@ struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers int64_t output_feature_dimension() const { return GetField(VT_OUTPUT_FEATURE_DIMENSION, 0); } - const flatbuffers::Vector *output_spatial_dimensions() const { - return GetPointer *>(VT_OUTPUT_SPATIAL_DIMENSIONS); + const ::flatbuffers::Vector *output_spatial_dimensions() const { + return GetPointer *>(VT_OUTPUT_SPATIAL_DIMENSIONS); } int64_t feature_group_count() const { return GetField(VT_FEATURE_GROUP_COUNT, 0); @@ -7290,10 +7290,10 @@ struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers int64_t batch_group_count() const { return GetField(VT_BATCH_GROUP_COUNT, 0); } - const flatbuffers::Vector *precision_config() const { - return GetPointer *>(VT_PRECISION_CONFIG); + const ::flatbuffers::Vector *precision_config() const { + return GetPointer *>(VT_PRECISION_CONFIG); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WINDOW_STRIDES) && verifier.VerifyVector(window_strides()) && @@ -7323,28 +7323,28 @@ struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers verifier.VerifyVector(precision_config()) && verifier.EndTable(); } - StablehloConvolutionOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloConvolutionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloConvolutionOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloConvolutionOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloConvolutionOptionsBuilder { typedef StablehloConvolutionOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_window_strides(flatbuffers::Offset> window_strides) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_window_strides(::flatbuffers::Offset<::flatbuffers::Vector> window_strides) { fbb_.AddOffset(StablehloConvolutionOptions::VT_WINDOW_STRIDES, window_strides); } - void add_padding(flatbuffers::Offset> padding) { + void add_padding(::flatbuffers::Offset<::flatbuffers::Vector> padding) { fbb_.AddOffset(StablehloConvolutionOptions::VT_PADDING, padding); } - void add_lhs_dilation(flatbuffers::Offset> lhs_dilation) { + void add_lhs_dilation(::flatbuffers::Offset<::flatbuffers::Vector> lhs_dilation) { fbb_.AddOffset(StablehloConvolutionOptions::VT_LHS_DILATION, lhs_dilation); } - void add_rhs_dilation(flatbuffers::Offset> rhs_dilation) { + void add_rhs_dilation(::flatbuffers::Offset<::flatbuffers::Vector> rhs_dilation) { fbb_.AddOffset(StablehloConvolutionOptions::VT_RHS_DILATION, rhs_dilation); } - void add_window_reversal(flatbuffers::Offset> window_reversal) { + void add_window_reversal(::flatbuffers::Offset<::flatbuffers::Vector> window_reversal) { fbb_.AddOffset(StablehloConvolutionOptions::VT_WINDOW_REVERSAL, window_reversal); } void add_input_batch_dimension(int64_t input_batch_dimension) { @@ -7353,7 +7353,7 @@ struct StablehloConvolutionOptionsBuilder { void add_input_feature_dimension(int64_t input_feature_dimension) { fbb_.AddElement(StablehloConvolutionOptions::VT_INPUT_FEATURE_DIMENSION, input_feature_dimension, 0); } - void add_input_spatial_dimensions(flatbuffers::Offset> input_spatial_dimensions) { + void add_input_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> input_spatial_dimensions) { fbb_.AddOffset(StablehloConvolutionOptions::VT_INPUT_SPATIAL_DIMENSIONS, input_spatial_dimensions); } void add_kernel_input_feature_dimension(int64_t kernel_input_feature_dimension) { @@ -7362,7 +7362,7 @@ struct StablehloConvolutionOptionsBuilder { void add_kernel_output_feature_dimension(int64_t kernel_output_feature_dimension) { fbb_.AddElement(StablehloConvolutionOptions::VT_KERNEL_OUTPUT_FEATURE_DIMENSION, kernel_output_feature_dimension, 0); } - void add_kernel_spatial_dimensions(flatbuffers::Offset> kernel_spatial_dimensions) { + void add_kernel_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> kernel_spatial_dimensions) { fbb_.AddOffset(StablehloConvolutionOptions::VT_KERNEL_SPATIAL_DIMENSIONS, kernel_spatial_dimensions); } void add_output_batch_dimension(int64_t output_batch_dimension) { @@ -7371,7 +7371,7 @@ struct StablehloConvolutionOptionsBuilder { void add_output_feature_dimension(int64_t output_feature_dimension) { fbb_.AddElement(StablehloConvolutionOptions::VT_OUTPUT_FEATURE_DIMENSION, output_feature_dimension, 0); } - void add_output_spatial_dimensions(flatbuffers::Offset> output_spatial_dimensions) { + void add_output_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector> output_spatial_dimensions) { fbb_.AddOffset(StablehloConvolutionOptions::VT_OUTPUT_SPATIAL_DIMENSIONS, output_spatial_dimensions); } void add_feature_group_count(int64_t feature_group_count) { @@ -7380,39 +7380,39 @@ struct StablehloConvolutionOptionsBuilder { void add_batch_group_count(int64_t batch_group_count) { fbb_.AddElement(StablehloConvolutionOptions::VT_BATCH_GROUP_COUNT, batch_group_count, 0); } - void add_precision_config(flatbuffers::Offset> precision_config) { + void add_precision_config(::flatbuffers::Offset<::flatbuffers::Vector> precision_config) { fbb_.AddOffset(StablehloConvolutionOptions::VT_PRECISION_CONFIG, precision_config); } - explicit StablehloConvolutionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloConvolutionOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloConvolutionOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> window_strides = 0, - flatbuffers::Offset> padding = 0, - flatbuffers::Offset> lhs_dilation = 0, - flatbuffers::Offset> rhs_dilation = 0, - flatbuffers::Offset> window_reversal = 0, +inline ::flatbuffers::Offset CreateStablehloConvolutionOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> window_strides = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> padding = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> lhs_dilation = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> rhs_dilation = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> window_reversal = 0, int64_t input_batch_dimension = 0, int64_t input_feature_dimension = 0, - flatbuffers::Offset> input_spatial_dimensions = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> input_spatial_dimensions = 0, int64_t kernel_input_feature_dimension = 0, int64_t kernel_output_feature_dimension = 0, - flatbuffers::Offset> kernel_spatial_dimensions = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> kernel_spatial_dimensions = 0, int64_t output_batch_dimension = 0, int64_t output_feature_dimension = 0, - flatbuffers::Offset> output_spatial_dimensions = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> output_spatial_dimensions = 0, int64_t feature_group_count = 0, int64_t batch_group_count = 0, - flatbuffers::Offset> precision_config = 0) { + ::flatbuffers::Offset<::flatbuffers::Vector> precision_config = 0) { StablehloConvolutionOptionsBuilder builder_(_fbb); builder_.add_batch_group_count(batch_group_count); builder_.add_feature_group_count(feature_group_count); @@ -7434,8 +7434,8 @@ inline flatbuffers::Offset CreateStablehloConvoluti return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloConvolutionOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloConvolutionOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *window_strides = nullptr, const std::vector *padding = nullptr, const std::vector *lhs_dilation = nullptr, @@ -7483,9 +7483,9 @@ inline flatbuffers::Offset CreateStablehloConvoluti precision_config__); } -flatbuffers::Offset CreateStablehloConvolutionOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloConvolutionOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloScatterOptionsT : public flatbuffers::NativeTable { +struct StablehloScatterOptionsT : public ::flatbuffers::NativeTable { typedef StablehloScatterOptions TableType; bool indices_are_sorted = false; std::vector update_window_dims{}; @@ -7496,7 +7496,7 @@ struct StablehloScatterOptionsT : public flatbuffers::NativeTable { int32_t update_computation_subgraph_index = 0; }; -struct StablehloScatterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloScatterOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloScatterOptionsT NativeTableType; typedef StablehloScatterOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -7511,14 +7511,14 @@ struct StablehloScatterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta bool indices_are_sorted() const { return GetField(VT_INDICES_ARE_SORTED, 0) != 0; } - const flatbuffers::Vector *update_window_dims() const { - return GetPointer *>(VT_UPDATE_WINDOW_DIMS); + const ::flatbuffers::Vector *update_window_dims() const { + return GetPointer *>(VT_UPDATE_WINDOW_DIMS); } - const flatbuffers::Vector *inserted_window_dims() const { - return GetPointer *>(VT_INSERTED_WINDOW_DIMS); + const ::flatbuffers::Vector *inserted_window_dims() const { + return GetPointer *>(VT_INSERTED_WINDOW_DIMS); } - const flatbuffers::Vector *scatter_dims_to_operand_dims() const { - return GetPointer *>(VT_SCATTER_DIMS_TO_OPERAND_DIMS); + const ::flatbuffers::Vector *scatter_dims_to_operand_dims() const { + return GetPointer *>(VT_SCATTER_DIMS_TO_OPERAND_DIMS); } int64_t index_vector_dim() const { return GetField(VT_INDEX_VECTOR_DIM, 0); @@ -7529,7 +7529,7 @@ struct StablehloScatterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta int32_t update_computation_subgraph_index() const { return GetField(VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INDICES_ARE_SORTED, 1) && VerifyOffset(verifier, VT_UPDATE_WINDOW_DIMS) && @@ -7543,25 +7543,25 @@ struct StablehloScatterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta VerifyField(verifier, VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - StablehloScatterOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloScatterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloScatterOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloScatterOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloScatterOptionsBuilder { typedef StablehloScatterOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_indices_are_sorted(bool indices_are_sorted) { fbb_.AddElement(StablehloScatterOptions::VT_INDICES_ARE_SORTED, static_cast(indices_are_sorted), 0); } - void add_update_window_dims(flatbuffers::Offset> update_window_dims) { + void add_update_window_dims(::flatbuffers::Offset<::flatbuffers::Vector> update_window_dims) { fbb_.AddOffset(StablehloScatterOptions::VT_UPDATE_WINDOW_DIMS, update_window_dims); } - void add_inserted_window_dims(flatbuffers::Offset> inserted_window_dims) { + void add_inserted_window_dims(::flatbuffers::Offset<::flatbuffers::Vector> inserted_window_dims) { fbb_.AddOffset(StablehloScatterOptions::VT_INSERTED_WINDOW_DIMS, inserted_window_dims); } - void add_scatter_dims_to_operand_dims(flatbuffers::Offset> scatter_dims_to_operand_dims) { + void add_scatter_dims_to_operand_dims(::flatbuffers::Offset<::flatbuffers::Vector> scatter_dims_to_operand_dims) { fbb_.AddOffset(StablehloScatterOptions::VT_SCATTER_DIMS_TO_OPERAND_DIMS, scatter_dims_to_operand_dims); } void add_index_vector_dim(int64_t index_vector_dim) { @@ -7573,23 +7573,23 @@ struct StablehloScatterOptionsBuilder { void add_update_computation_subgraph_index(int32_t update_computation_subgraph_index) { fbb_.AddElement(StablehloScatterOptions::VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX, update_computation_subgraph_index, 0); } - explicit StablehloScatterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloScatterOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloScatterOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloScatterOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool indices_are_sorted = false, - flatbuffers::Offset> update_window_dims = 0, - flatbuffers::Offset> inserted_window_dims = 0, - flatbuffers::Offset> scatter_dims_to_operand_dims = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> update_window_dims = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> inserted_window_dims = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> scatter_dims_to_operand_dims = 0, int64_t index_vector_dim = 0, bool unique_indices = false, int32_t update_computation_subgraph_index = 0) { @@ -7604,8 +7604,8 @@ inline flatbuffers::Offset CreateStablehloScatterOption return builder_.Finish(); } -inline flatbuffers::Offset CreateStablehloScatterOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloScatterOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, bool indices_are_sorted = false, const std::vector *update_window_dims = nullptr, const std::vector *inserted_window_dims = nullptr, @@ -7627,14 +7627,14 @@ inline flatbuffers::Offset CreateStablehloScatterOption update_computation_subgraph_index); } -flatbuffers::Offset CreateStablehloScatterOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloScatterOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StablehloRngBitGeneratorOptionsT : public flatbuffers::NativeTable { +struct StablehloRngBitGeneratorOptionsT : public ::flatbuffers::NativeTable { typedef StablehloRngBitGeneratorOptions TableType; tflite::RngAlgorithm algorithm = tflite::RngAlgorithm_DEFAULT; }; -struct StablehloRngBitGeneratorOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StablehloRngBitGeneratorOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StablehloRngBitGeneratorOptionsT NativeTableType; typedef StablehloRngBitGeneratorOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -7643,45 +7643,45 @@ struct StablehloRngBitGeneratorOptions FLATBUFFERS_FINAL_CLASS : private flatbuf tflite::RngAlgorithm algorithm() const { return static_cast(GetField(VT_ALGORITHM, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_ALGORITHM, 1) && verifier.EndTable(); } - StablehloRngBitGeneratorOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StablehloRngBitGeneratorOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StablehloRngBitGeneratorOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StablehloRngBitGeneratorOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StablehloRngBitGeneratorOptionsBuilder { typedef StablehloRngBitGeneratorOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_algorithm(tflite::RngAlgorithm algorithm) { fbb_.AddElement(StablehloRngBitGeneratorOptions::VT_ALGORITHM, static_cast(algorithm), 0); } - explicit StablehloRngBitGeneratorOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StablehloRngBitGeneratorOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStablehloRngBitGeneratorOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStablehloRngBitGeneratorOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::RngAlgorithm algorithm = tflite::RngAlgorithm_DEFAULT) { StablehloRngBitGeneratorOptionsBuilder builder_(_fbb); builder_.add_algorithm(algorithm); return builder_.Finish(); } -flatbuffers::Offset CreateStablehloRngBitGeneratorOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStablehloRngBitGeneratorOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct Conv2DOptionsT : public flatbuffers::NativeTable { +struct Conv2DOptionsT : public ::flatbuffers::NativeTable { typedef Conv2DOptions TableType; tflite::Padding padding = tflite::Padding_SAME; int32_t stride_w = 0; @@ -7692,7 +7692,7 @@ struct Conv2DOptionsT : public flatbuffers::NativeTable { tflite::TensorType quantized_bias_type = tflite::TensorType_FLOAT32; }; -struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef Conv2DOptionsT NativeTableType; typedef Conv2DOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -7725,7 +7725,7 @@ struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::TensorType quantized_bias_type() const { return static_cast(GetField(VT_QUANTIZED_BIAS_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_PADDING, 1) && VerifyField(verifier, VT_STRIDE_W, 4) && @@ -7736,15 +7736,15 @@ struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_QUANTIZED_BIAS_TYPE, 1) && verifier.EndTable(); } - Conv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + Conv2DOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Conv2DOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct Conv2DOptionsBuilder { typedef Conv2DOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_padding(tflite::Padding padding) { fbb_.AddElement(Conv2DOptions::VT_PADDING, static_cast(padding), 0); } @@ -7766,19 +7766,19 @@ struct Conv2DOptionsBuilder { void add_quantized_bias_type(tflite::TensorType quantized_bias_type) { fbb_.AddElement(Conv2DOptions::VT_QUANTIZED_BIAS_TYPE, static_cast(quantized_bias_type), 0); } - explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit Conv2DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateConv2DOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateConv2DOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding = tflite::Padding_SAME, int32_t stride_w = 0, int32_t stride_h = 0, @@ -7797,9 +7797,9 @@ inline flatbuffers::Offset CreateConv2DOptions( return builder_.Finish(); } -flatbuffers::Offset CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateConv2DOptions(::flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct Conv3DOptionsT : public flatbuffers::NativeTable { +struct Conv3DOptionsT : public ::flatbuffers::NativeTable { typedef Conv3DOptions TableType; tflite::Padding padding = tflite::Padding_SAME; int32_t stride_d = 0; @@ -7811,7 +7811,7 @@ struct Conv3DOptionsT : public flatbuffers::NativeTable { int32_t dilation_h_factor = 1; }; -struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef Conv3DOptionsT NativeTableType; typedef Conv3DOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -7848,7 +7848,7 @@ struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t dilation_h_factor() const { return GetField(VT_DILATION_H_FACTOR, 1); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_PADDING, 1) && VerifyField(verifier, VT_STRIDE_D, 4) && @@ -7860,15 +7860,15 @@ struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_DILATION_H_FACTOR, 4) && verifier.EndTable(); } - Conv3DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(Conv3DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + Conv3DOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Conv3DOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct Conv3DOptionsBuilder { typedef Conv3DOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_padding(tflite::Padding padding) { fbb_.AddElement(Conv3DOptions::VT_PADDING, static_cast(padding), 0); } @@ -7893,19 +7893,19 @@ struct Conv3DOptionsBuilder { void add_dilation_h_factor(int32_t dilation_h_factor) { fbb_.AddElement(Conv3DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1); } - explicit Conv3DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit Conv3DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateConv3DOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateConv3DOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding = tflite::Padding_SAME, int32_t stride_d = 0, int32_t stride_w = 0, @@ -7926,9 +7926,9 @@ inline flatbuffers::Offset CreateConv3DOptions( return builder_.Finish(); } -flatbuffers::Offset CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateConv3DOptions(::flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct Pool2DOptionsT : public flatbuffers::NativeTable { +struct Pool2DOptionsT : public ::flatbuffers::NativeTable { typedef Pool2DOptions TableType; tflite::Padding padding = tflite::Padding_SAME; int32_t stride_w = 0; @@ -7938,7 +7938,7 @@ struct Pool2DOptionsT : public flatbuffers::NativeTable { tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; }; -struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef Pool2DOptionsT NativeTableType; typedef Pool2DOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -7967,7 +7967,7 @@ struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::ActivationFunctionType fused_activation_function() const { return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_PADDING, 1) && VerifyField(verifier, VT_STRIDE_W, 4) && @@ -7977,15 +7977,15 @@ struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && verifier.EndTable(); } - Pool2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + Pool2DOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Pool2DOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct Pool2DOptionsBuilder { typedef Pool2DOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_padding(tflite::Padding padding) { fbb_.AddElement(Pool2DOptions::VT_PADDING, static_cast(padding), 0); } @@ -8004,19 +8004,19 @@ struct Pool2DOptionsBuilder { void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } - explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit Pool2DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreatePool2DOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreatePool2DOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding = tflite::Padding_SAME, int32_t stride_w = 0, int32_t stride_h = 0, @@ -8033,9 +8033,9 @@ inline flatbuffers::Offset CreatePool2DOptions( return builder_.Finish(); } -flatbuffers::Offset CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreatePool2DOptions(::flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable { +struct DepthwiseConv2DOptionsT : public ::flatbuffers::NativeTable { typedef DepthwiseConv2DOptions TableType; tflite::Padding padding = tflite::Padding_SAME; int32_t stride_w = 0; @@ -8046,7 +8046,7 @@ struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable { int32_t dilation_h_factor = 1; }; -struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DepthwiseConv2DOptionsT NativeTableType; typedef DepthwiseConv2DOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8079,7 +8079,7 @@ struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab int32_t dilation_h_factor() const { return GetField(VT_DILATION_H_FACTOR, 1); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_PADDING, 1) && VerifyField(verifier, VT_STRIDE_W, 4) && @@ -8090,15 +8090,15 @@ struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab VerifyField(verifier, VT_DILATION_H_FACTOR, 4) && verifier.EndTable(); } - DepthwiseConv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DepthwiseConv2DOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DepthwiseConv2DOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct DepthwiseConv2DOptionsBuilder { typedef DepthwiseConv2DOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_padding(tflite::Padding padding) { fbb_.AddElement(DepthwiseConv2DOptions::VT_PADDING, static_cast(padding), 0); } @@ -8120,19 +8120,19 @@ struct DepthwiseConv2DOptionsBuilder { void add_dilation_h_factor(int32_t dilation_h_factor) { fbb_.AddElement(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1); } - explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit DepthwiseConv2DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDepthwiseConv2DOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateDepthwiseConv2DOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding = tflite::Padding_SAME, int32_t stride_w = 0, int32_t stride_h = 0, @@ -8151,16 +8151,16 @@ inline flatbuffers::Offset CreateDepthwiseConv2DOptions( return builder_.Finish(); } -flatbuffers::Offset CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateDepthwiseConv2DOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable { +struct ConcatEmbeddingsOptionsT : public ::flatbuffers::NativeTable { typedef ConcatEmbeddingsOptions TableType; int32_t num_channels = 0; std::vector num_columns_per_channel{}; std::vector embedding_dim_per_channel{}; }; -struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ConcatEmbeddingsOptionsT NativeTableType; typedef ConcatEmbeddingsOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8171,13 +8171,13 @@ struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta int32_t num_channels() const { return GetField(VT_NUM_CHANNELS, 0); } - const flatbuffers::Vector *num_columns_per_channel() const { - return GetPointer *>(VT_NUM_COLUMNS_PER_CHANNEL); + const ::flatbuffers::Vector *num_columns_per_channel() const { + return GetPointer *>(VT_NUM_COLUMNS_PER_CHANNEL); } - const flatbuffers::Vector *embedding_dim_per_channel() const { - return GetPointer *>(VT_EMBEDDING_DIM_PER_CHANNEL); + const ::flatbuffers::Vector *embedding_dim_per_channel() const { + return GetPointer *>(VT_EMBEDDING_DIM_PER_CHANNEL); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_NUM_CHANNELS, 4) && VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) && @@ -8186,40 +8186,40 @@ struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta verifier.VerifyVector(embedding_dim_per_channel()) && verifier.EndTable(); } - ConcatEmbeddingsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ConcatEmbeddingsOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ConcatEmbeddingsOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ConcatEmbeddingsOptionsBuilder { typedef ConcatEmbeddingsOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_num_channels(int32_t num_channels) { fbb_.AddElement(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0); } - void add_num_columns_per_channel(flatbuffers::Offset> num_columns_per_channel) { + void add_num_columns_per_channel(::flatbuffers::Offset<::flatbuffers::Vector> num_columns_per_channel) { fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel); } - void add_embedding_dim_per_channel(flatbuffers::Offset> embedding_dim_per_channel) { + void add_embedding_dim_per_channel(::flatbuffers::Offset<::flatbuffers::Vector> embedding_dim_per_channel) { fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel); } - explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ConcatEmbeddingsOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateConcatEmbeddingsOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateConcatEmbeddingsOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0, - flatbuffers::Offset> num_columns_per_channel = 0, - flatbuffers::Offset> embedding_dim_per_channel = 0) { + ::flatbuffers::Offset<::flatbuffers::Vector> num_columns_per_channel = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> embedding_dim_per_channel = 0) { ConcatEmbeddingsOptionsBuilder builder_(_fbb); builder_.add_embedding_dim_per_channel(embedding_dim_per_channel); builder_.add_num_columns_per_channel(num_columns_per_channel); @@ -8227,8 +8227,8 @@ inline flatbuffers::Offset CreateConcatEmbeddingsOption return builder_.Finish(); } -inline flatbuffers::Offset CreateConcatEmbeddingsOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateConcatEmbeddingsOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0, const std::vector *num_columns_per_channel = nullptr, const std::vector *embedding_dim_per_channel = nullptr) { @@ -8241,14 +8241,14 @@ inline flatbuffers::Offset CreateConcatEmbeddingsOption embedding_dim_per_channel__); } -flatbuffers::Offset CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateConcatEmbeddingsOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LSHProjectionOptionsT : public flatbuffers::NativeTable { +struct LSHProjectionOptionsT : public ::flatbuffers::NativeTable { typedef LSHProjectionOptions TableType; tflite::LSHProjectionType type = tflite::LSHProjectionType_UNKNOWN; }; -struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LSHProjectionOptionsT NativeTableType; typedef LSHProjectionOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8257,52 +8257,52 @@ struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table tflite::LSHProjectionType type() const { return static_cast(GetField(VT_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TYPE, 1) && verifier.EndTable(); } - LSHProjectionOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LSHProjectionOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LSHProjectionOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LSHProjectionOptionsBuilder { typedef LSHProjectionOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_type(tflite::LSHProjectionType type) { fbb_.AddElement(LSHProjectionOptions::VT_TYPE, static_cast(type), 0); } - explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit LSHProjectionOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLSHProjectionOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateLSHProjectionOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::LSHProjectionType type = tflite::LSHProjectionType_UNKNOWN) { LSHProjectionOptionsBuilder builder_(_fbb); builder_.add_type(type); return builder_.Finish(); } -flatbuffers::Offset CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLSHProjectionOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SVDFOptionsT : public flatbuffers::NativeTable { +struct SVDFOptionsT : public ::flatbuffers::NativeTable { typedef SVDFOptions TableType; int32_t rank = 0; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; bool asymmetric_quantize_inputs = false; }; -struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SVDFOptionsT NativeTableType; typedef SVDFOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8319,22 +8319,22 @@ struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool asymmetric_quantize_inputs() const { return GetField(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_RANK, 4) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) && verifier.EndTable(); } - SVDFOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SVDFOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SVDFOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SVDFOptionsBuilder { typedef SVDFOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_rank(int32_t rank) { fbb_.AddElement(SVDFOptions::VT_RANK, rank, 0); } @@ -8344,19 +8344,19 @@ struct SVDFOptionsBuilder { void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) { fbb_.AddElement(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast(asymmetric_quantize_inputs), 0); } - explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SVDFOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSVDFOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSVDFOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t rank = 0, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, bool asymmetric_quantize_inputs = false) { @@ -8367,15 +8367,15 @@ inline flatbuffers::Offset CreateSVDFOptions( return builder_.Finish(); } -flatbuffers::Offset CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSVDFOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct RNNOptionsT : public flatbuffers::NativeTable { +struct RNNOptionsT : public ::flatbuffers::NativeTable { typedef RNNOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; bool asymmetric_quantize_inputs = false; }; -struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct RNNOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef RNNOptionsT NativeTableType; typedef RNNOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8388,40 +8388,40 @@ struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool asymmetric_quantize_inputs() const { return GetField(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) && verifier.EndTable(); } - RNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + RNNOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(RNNOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct RNNOptionsBuilder { typedef RNNOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) { fbb_.AddElement(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast(asymmetric_quantize_inputs), 0); } - explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit RNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRNNOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateRNNOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, bool asymmetric_quantize_inputs = false) { RNNOptionsBuilder builder_(_fbb); @@ -8430,16 +8430,16 @@ inline flatbuffers::Offset CreateRNNOptions( return builder_.Finish(); } -flatbuffers::Offset CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateRNNOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SequenceRNNOptionsT : public flatbuffers::NativeTable { +struct SequenceRNNOptionsT : public ::flatbuffers::NativeTable { typedef SequenceRNNOptions TableType; bool time_major = false; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; bool asymmetric_quantize_inputs = false; }; -struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SequenceRNNOptionsT NativeTableType; typedef SequenceRNNOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8456,22 +8456,22 @@ struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool asymmetric_quantize_inputs() const { return GetField(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME_MAJOR, 1) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) && verifier.EndTable(); } - SequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SequenceRNNOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SequenceRNNOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SequenceRNNOptionsBuilder { typedef SequenceRNNOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_time_major(bool time_major) { fbb_.AddElement(SequenceRNNOptions::VT_TIME_MAJOR, static_cast(time_major), 0); } @@ -8481,19 +8481,19 @@ struct SequenceRNNOptionsBuilder { void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) { fbb_.AddElement(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast(asymmetric_quantize_inputs), 0); } - explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SequenceRNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSequenceRNNOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSequenceRNNOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, bool asymmetric_quantize_inputs = false) { @@ -8504,9 +8504,9 @@ inline flatbuffers::Offset CreateSequenceRNNOptions( return builder_.Finish(); } -flatbuffers::Offset CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSequenceRNNOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable { +struct BidirectionalSequenceRNNOptionsT : public ::flatbuffers::NativeTable { typedef BidirectionalSequenceRNNOptions TableType; bool time_major = false; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; @@ -8514,7 +8514,7 @@ struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable { bool asymmetric_quantize_inputs = false; }; -struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BidirectionalSequenceRNNOptionsT NativeTableType; typedef BidirectionalSequenceRNNOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8535,7 +8535,7 @@ struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuf bool asymmetric_quantize_inputs() const { return GetField(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME_MAJOR, 1) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && @@ -8543,15 +8543,15 @@ struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuf VerifyField(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) && verifier.EndTable(); } - BidirectionalSequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BidirectionalSequenceRNNOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BidirectionalSequenceRNNOptionsBuilder { typedef BidirectionalSequenceRNNOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_time_major(bool time_major) { fbb_.AddElement(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast(time_major), 0); } @@ -8564,19 +8564,19 @@ struct BidirectionalSequenceRNNOptionsBuilder { void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) { fbb_.AddElement(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast(asymmetric_quantize_inputs), 0); } - explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit BidirectionalSequenceRNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBidirectionalSequenceRNNOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateBidirectionalSequenceRNNOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, bool merge_outputs = false, @@ -8589,9 +8589,9 @@ inline flatbuffers::Offset CreateBidirectionalS return builder_.Finish(); } -flatbuffers::Offset CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBidirectionalSequenceRNNOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct FullyConnectedOptionsT : public flatbuffers::NativeTable { +struct FullyConnectedOptionsT : public ::flatbuffers::NativeTable { typedef FullyConnectedOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; tflite::FullyConnectedOptionsWeightsFormat weights_format = tflite::FullyConnectedOptionsWeightsFormat_DEFAULT; @@ -8600,7 +8600,7 @@ struct FullyConnectedOptionsT : public flatbuffers::NativeTable { tflite::TensorType quantized_bias_type = tflite::TensorType_FLOAT32; }; -struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef FullyConnectedOptionsT NativeTableType; typedef FullyConnectedOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8625,7 +8625,7 @@ struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tabl tflite::TensorType quantized_bias_type() const { return static_cast(GetField(VT_QUANTIZED_BIAS_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_WEIGHTS_FORMAT, 1) && @@ -8634,15 +8634,15 @@ struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tabl VerifyField(verifier, VT_QUANTIZED_BIAS_TYPE, 1) && verifier.EndTable(); } - FullyConnectedOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + FullyConnectedOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(FullyConnectedOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct FullyConnectedOptionsBuilder { typedef FullyConnectedOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } @@ -8658,19 +8658,19 @@ struct FullyConnectedOptionsBuilder { void add_quantized_bias_type(tflite::TensorType quantized_bias_type) { fbb_.AddElement(FullyConnectedOptions::VT_QUANTIZED_BIAS_TYPE, static_cast(quantized_bias_type), 0); } - explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit FullyConnectedOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFullyConnectedOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateFullyConnectedOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, tflite::FullyConnectedOptionsWeightsFormat weights_format = tflite::FullyConnectedOptionsWeightsFormat_DEFAULT, bool keep_num_dims = false, @@ -8685,14 +8685,14 @@ inline flatbuffers::Offset CreateFullyConnectedOptions( return builder_.Finish(); } -flatbuffers::Offset CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateFullyConnectedOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SoftmaxOptionsT : public flatbuffers::NativeTable { +struct SoftmaxOptionsT : public ::flatbuffers::NativeTable { typedef SoftmaxOptions TableType; float beta = 0.0f; }; -struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SoftmaxOptionsT NativeTableType; typedef SoftmaxOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8701,51 +8701,51 @@ struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { float beta() const { return GetField(VT_BETA, 0.0f); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_BETA, 4) && verifier.EndTable(); } - SoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SoftmaxOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SoftmaxOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SoftmaxOptionsBuilder { typedef SoftmaxOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_beta(float beta) { fbb_.AddElement(SoftmaxOptions::VT_BETA, beta, 0.0f); } - explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SoftmaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSoftmaxOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSoftmaxOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, float beta = 0.0f) { SoftmaxOptionsBuilder builder_(_fbb); builder_.add_beta(beta); return builder_.Finish(); } -flatbuffers::Offset CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSoftmaxOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ConcatenationOptionsT : public flatbuffers::NativeTable { +struct ConcatenationOptionsT : public ::flatbuffers::NativeTable { typedef ConcatenationOptions TableType; int32_t axis = 0; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; }; -struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ConcatenationOptionsT NativeTableType; typedef ConcatenationOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8758,40 +8758,40 @@ struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table tflite::ActivationFunctionType fused_activation_function() const { return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_AXIS, 4) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && verifier.EndTable(); } - ConcatenationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ConcatenationOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ConcatenationOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ConcatenationOptionsBuilder { typedef ConcatenationOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_axis(int32_t axis) { fbb_.AddElement(ConcatenationOptions::VT_AXIS, axis, 0); } void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } - explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ConcatenationOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateConcatenationOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateConcatenationOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) { ConcatenationOptionsBuilder builder_(_fbb); @@ -8800,15 +8800,15 @@ inline flatbuffers::Offset CreateConcatenationOptions( return builder_.Finish(); } -flatbuffers::Offset CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateConcatenationOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct AddOptionsT : public flatbuffers::NativeTable { +struct AddOptionsT : public ::flatbuffers::NativeTable { typedef AddOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; bool pot_scale_int16 = true; }; -struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct AddOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef AddOptionsT NativeTableType; typedef AddOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8821,40 +8821,40 @@ struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool pot_scale_int16() const { return GetField(VT_POT_SCALE_INT16, 1) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_POT_SCALE_INT16, 1) && verifier.EndTable(); } - AddOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + AddOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(AddOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct AddOptionsBuilder { typedef AddOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } void add_pot_scale_int16(bool pot_scale_int16) { fbb_.AddElement(AddOptions::VT_POT_SCALE_INT16, static_cast(pot_scale_int16), 1); } - explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit AddOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateAddOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateAddOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, bool pot_scale_int16 = true) { AddOptionsBuilder builder_(_fbb); @@ -8863,14 +8863,14 @@ inline flatbuffers::Offset CreateAddOptions( return builder_.Finish(); } -flatbuffers::Offset CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateAddOptions(::flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct MulOptionsT : public flatbuffers::NativeTable { +struct MulOptionsT : public ::flatbuffers::NativeTable { typedef MulOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; }; -struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct MulOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MulOptionsT NativeTableType; typedef MulOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8879,50 +8879,50 @@ struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::ActivationFunctionType fused_activation_function() const { return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && verifier.EndTable(); } - MulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + MulOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MulOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct MulOptionsBuilder { typedef MulOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } - explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit MulOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMulOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateMulOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) { MulOptionsBuilder builder_(_fbb); builder_.add_fused_activation_function(fused_activation_function); return builder_.Finish(); } -flatbuffers::Offset CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateMulOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct L2NormOptionsT : public flatbuffers::NativeTable { +struct L2NormOptionsT : public ::flatbuffers::NativeTable { typedef L2NormOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; }; -struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef L2NormOptionsT NativeTableType; typedef L2NormOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8931,45 +8931,45 @@ struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::ActivationFunctionType fused_activation_function() const { return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && verifier.EndTable(); } - L2NormOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + L2NormOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(L2NormOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct L2NormOptionsBuilder { typedef L2NormOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } - explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit L2NormOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateL2NormOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateL2NormOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) { L2NormOptionsBuilder builder_(_fbb); builder_.add_fused_activation_function(fused_activation_function); return builder_.Finish(); } -flatbuffers::Offset CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateL2NormOptions(::flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable { +struct LocalResponseNormalizationOptionsT : public ::flatbuffers::NativeTable { typedef LocalResponseNormalizationOptions TableType; int32_t radius = 0; float bias = 0.0f; @@ -8977,7 +8977,7 @@ struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable { float beta = 0.0f; }; -struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LocalResponseNormalizationOptionsT NativeTableType; typedef LocalResponseNormalizationOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -8998,7 +8998,7 @@ struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatb float beta() const { return GetField(VT_BETA, 0.0f); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_RADIUS, 4) && VerifyField(verifier, VT_BIAS, 4) && @@ -9006,15 +9006,15 @@ struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatb VerifyField(verifier, VT_BETA, 4) && verifier.EndTable(); } - LocalResponseNormalizationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LocalResponseNormalizationOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LocalResponseNormalizationOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LocalResponseNormalizationOptionsBuilder { typedef LocalResponseNormalizationOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_radius(int32_t radius) { fbb_.AddElement(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0); } @@ -9027,19 +9027,19 @@ struct LocalResponseNormalizationOptionsBuilder { void add_beta(float beta) { fbb_.AddElement(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f); } - explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit LocalResponseNormalizationOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLocalResponseNormalizationOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateLocalResponseNormalizationOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t radius = 0, float bias = 0.0f, float alpha = 0.0f, @@ -9052,9 +9052,9 @@ inline flatbuffers::Offset CreateLocalRespons return builder_.Finish(); } -flatbuffers::Offset CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLocalResponseNormalizationOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LSTMOptionsT : public flatbuffers::NativeTable { +struct LSTMOptionsT : public ::flatbuffers::NativeTable { typedef LSTMOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; float cell_clip = 0.0f; @@ -9063,7 +9063,7 @@ struct LSTMOptionsT : public flatbuffers::NativeTable { bool asymmetric_quantize_inputs = false; }; -struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LSTMOptionsT NativeTableType; typedef LSTMOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9088,7 +9088,7 @@ struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool asymmetric_quantize_inputs() const { return GetField(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_CELL_CLIP, 4) && @@ -9097,15 +9097,15 @@ struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) && verifier.EndTable(); } - LSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LSTMOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LSTMOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LSTMOptionsBuilder { typedef LSTMOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } @@ -9121,19 +9121,19 @@ struct LSTMOptionsBuilder { void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) { fbb_.AddElement(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast(asymmetric_quantize_inputs), 0); } - explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit LSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLSTMOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateLSTMOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, float cell_clip = 0.0f, float proj_clip = 0.0f, @@ -9148,9 +9148,9 @@ inline flatbuffers::Offset CreateLSTMOptions( return builder_.Finish(); } -flatbuffers::Offset CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLSTMOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable { +struct UnidirectionalSequenceLSTMOptionsT : public ::flatbuffers::NativeTable { typedef UnidirectionalSequenceLSTMOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; float cell_clip = 0.0f; @@ -9160,7 +9160,7 @@ struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable { bool diagonal_recurrent_tensors = false; }; -struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef UnidirectionalSequenceLSTMOptionsT NativeTableType; typedef UnidirectionalSequenceLSTMOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9189,7 +9189,7 @@ struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatb bool diagonal_recurrent_tensors() const { return GetField(VT_DIAGONAL_RECURRENT_TENSORS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_CELL_CLIP, 4) && @@ -9199,15 +9199,15 @@ struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatb VerifyField(verifier, VT_DIAGONAL_RECURRENT_TENSORS, 1) && verifier.EndTable(); } - UnidirectionalSequenceLSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + UnidirectionalSequenceLSTMOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct UnidirectionalSequenceLSTMOptionsBuilder { typedef UnidirectionalSequenceLSTMOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } @@ -9226,19 +9226,19 @@ struct UnidirectionalSequenceLSTMOptionsBuilder { void add_diagonal_recurrent_tensors(bool diagonal_recurrent_tensors) { fbb_.AddElement(UnidirectionalSequenceLSTMOptions::VT_DIAGONAL_RECURRENT_TENSORS, static_cast(diagonal_recurrent_tensors), 0); } - explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit UnidirectionalSequenceLSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUnidirectionalSequenceLSTMOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateUnidirectionalSequenceLSTMOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, float cell_clip = 0.0f, float proj_clip = 0.0f, @@ -9255,9 +9255,9 @@ inline flatbuffers::Offset CreateUnidirection return builder_.Finish(); } -flatbuffers::Offset CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUnidirectionalSequenceLSTMOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable { +struct BidirectionalSequenceLSTMOptionsT : public ::flatbuffers::NativeTable { typedef BidirectionalSequenceLSTMOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; float cell_clip = 0.0f; @@ -9267,7 +9267,7 @@ struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable { bool asymmetric_quantize_inputs = false; }; -struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BidirectionalSequenceLSTMOptionsT NativeTableType; typedef BidirectionalSequenceLSTMOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9296,7 +9296,7 @@ struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbu bool asymmetric_quantize_inputs() const { return GetField(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_CELL_CLIP, 4) && @@ -9306,15 +9306,15 @@ struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbu VerifyField(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) && verifier.EndTable(); } - BidirectionalSequenceLSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BidirectionalSequenceLSTMOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BidirectionalSequenceLSTMOptionsBuilder { typedef BidirectionalSequenceLSTMOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } @@ -9333,19 +9333,19 @@ struct BidirectionalSequenceLSTMOptionsBuilder { void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) { fbb_.AddElement(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast(asymmetric_quantize_inputs), 0); } - explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit BidirectionalSequenceLSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBidirectionalSequenceLSTMOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateBidirectionalSequenceLSTMOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, float cell_clip = 0.0f, float proj_clip = 0.0f, @@ -9362,15 +9362,15 @@ inline flatbuffers::Offset CreateBidirectional return builder_.Finish(); } -flatbuffers::Offset CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBidirectionalSequenceLSTMOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ResizeBilinearOptionsT : public flatbuffers::NativeTable { +struct ResizeBilinearOptionsT : public ::flatbuffers::NativeTable { typedef ResizeBilinearOptions TableType; bool align_corners = false; bool half_pixel_centers = false; }; -struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ResizeBilinearOptionsT NativeTableType; typedef ResizeBilinearOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9383,40 +9383,40 @@ struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tabl bool half_pixel_centers() const { return GetField(VT_HALF_PIXEL_CENTERS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_ALIGN_CORNERS, 1) && VerifyField(verifier, VT_HALF_PIXEL_CENTERS, 1) && verifier.EndTable(); } - ResizeBilinearOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ResizeBilinearOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ResizeBilinearOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ResizeBilinearOptionsBuilder { typedef ResizeBilinearOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_align_corners(bool align_corners) { fbb_.AddElement(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast(align_corners), 0); } void add_half_pixel_centers(bool half_pixel_centers) { fbb_.AddElement(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS, static_cast(half_pixel_centers), 0); } - explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ResizeBilinearOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateResizeBilinearOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateResizeBilinearOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false, bool half_pixel_centers = false) { ResizeBilinearOptionsBuilder builder_(_fbb); @@ -9425,15 +9425,15 @@ inline flatbuffers::Offset CreateResizeBilinearOptions( return builder_.Finish(); } -flatbuffers::Offset CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateResizeBilinearOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ResizeNearestNeighborOptionsT : public flatbuffers::NativeTable { +struct ResizeNearestNeighborOptionsT : public ::flatbuffers::NativeTable { typedef ResizeNearestNeighborOptions TableType; bool align_corners = false; bool half_pixel_centers = false; }; -struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ResizeNearestNeighborOptionsT NativeTableType; typedef ResizeNearestNeighborOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9446,40 +9446,40 @@ struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffer bool half_pixel_centers() const { return GetField(VT_HALF_PIXEL_CENTERS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_ALIGN_CORNERS, 1) && VerifyField(verifier, VT_HALF_PIXEL_CENTERS, 1) && verifier.EndTable(); } - ResizeNearestNeighborOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ResizeNearestNeighborOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ResizeNearestNeighborOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ResizeNearestNeighborOptionsBuilder { typedef ResizeNearestNeighborOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_align_corners(bool align_corners) { fbb_.AddElement(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast(align_corners), 0); } void add_half_pixel_centers(bool half_pixel_centers) { fbb_.AddElement(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS, static_cast(half_pixel_centers), 0); } - explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ResizeNearestNeighborOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateResizeNearestNeighborOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateResizeNearestNeighborOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false, bool half_pixel_centers = false) { ResizeNearestNeighborOptionsBuilder builder_(_fbb); @@ -9488,14 +9488,14 @@ inline flatbuffers::Offset CreateResizeNearestNeig return builder_.Finish(); } -flatbuffers::Offset CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateResizeNearestNeighborOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct CallOptionsT : public flatbuffers::NativeTable { +struct CallOptionsT : public ::flatbuffers::NativeTable { typedef CallOptions TableType; uint32_t subgraph = 0; }; -struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct CallOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef CallOptionsT NativeTableType; typedef CallOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9504,175 +9504,175 @@ struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { uint32_t subgraph() const { return GetField(VT_SUBGRAPH, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_SUBGRAPH, 4) && verifier.EndTable(); } - CallOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + CallOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CallOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct CallOptionsBuilder { typedef CallOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_subgraph(uint32_t subgraph) { fbb_.AddElement(CallOptions::VT_SUBGRAPH, subgraph, 0); } - explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit CallOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateCallOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateCallOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, uint32_t subgraph = 0) { CallOptionsBuilder builder_(_fbb); builder_.add_subgraph(subgraph); return builder_.Finish(); } -flatbuffers::Offset CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateCallOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct PadOptionsT : public flatbuffers::NativeTable { +struct PadOptionsT : public ::flatbuffers::NativeTable { typedef PadOptions TableType; }; -struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct PadOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef PadOptionsT NativeTableType; typedef PadOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - PadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + PadOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(PadOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct PadOptionsBuilder { typedef PadOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit PadOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreatePadOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreatePadOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { PadOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreatePadOptions(::flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct PadV2OptionsT : public flatbuffers::NativeTable { +struct PadV2OptionsT : public ::flatbuffers::NativeTable { typedef PadV2Options TableType; }; -struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct PadV2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef PadV2OptionsT NativeTableType; typedef PadV2OptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - PadV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + PadV2OptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(PadV2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct PadV2OptionsBuilder { typedef PadV2Options Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit PadV2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreatePadV2Options( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreatePadV2Options( + ::flatbuffers::FlatBufferBuilder &_fbb) { PadV2OptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreatePadV2Options(::flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ReshapeOptionsT : public flatbuffers::NativeTable { +struct ReshapeOptionsT : public ::flatbuffers::NativeTable { typedef ReshapeOptions TableType; std::vector new_shape{}; }; -struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ReshapeOptionsT NativeTableType; typedef ReshapeOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_NEW_SHAPE = 4 }; - const flatbuffers::Vector *new_shape() const { - return GetPointer *>(VT_NEW_SHAPE); + const ::flatbuffers::Vector *new_shape() const { + return GetPointer *>(VT_NEW_SHAPE); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NEW_SHAPE) && verifier.VerifyVector(new_shape()) && verifier.EndTable(); } - ReshapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ReshapeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReshapeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ReshapeOptionsBuilder { typedef ReshapeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_new_shape(flatbuffers::Offset> new_shape) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_new_shape(::flatbuffers::Offset<::flatbuffers::Vector> new_shape) { fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape); } - explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ReshapeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateReshapeOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> new_shape = 0) { +inline ::flatbuffers::Offset CreateReshapeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> new_shape = 0) { ReshapeOptionsBuilder builder_(_fbb); builder_.add_new_shape(new_shape); return builder_.Finish(); } -inline flatbuffers::Offset CreateReshapeOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateReshapeOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *new_shape = nullptr) { auto new_shape__ = new_shape ? _fbb.CreateVector(*new_shape) : 0; return tflite::CreateReshapeOptions( @@ -9680,94 +9680,94 @@ inline flatbuffers::Offset CreateReshapeOptionsDirect( new_shape__); } -flatbuffers::Offset CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateReshapeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SpaceToBatchNDOptionsT : public flatbuffers::NativeTable { +struct SpaceToBatchNDOptionsT : public ::flatbuffers::NativeTable { typedef SpaceToBatchNDOptions TableType; }; -struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SpaceToBatchNDOptionsT NativeTableType; typedef SpaceToBatchNDOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - SpaceToBatchNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SpaceToBatchNDOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SpaceToBatchNDOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SpaceToBatchNDOptionsBuilder { typedef SpaceToBatchNDOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit SpaceToBatchNDOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSpaceToBatchNDOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateSpaceToBatchNDOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { SpaceToBatchNDOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSpaceToBatchNDOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BatchToSpaceNDOptionsT : public flatbuffers::NativeTable { +struct BatchToSpaceNDOptionsT : public ::flatbuffers::NativeTable { typedef BatchToSpaceNDOptions TableType; }; -struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BatchToSpaceNDOptionsT NativeTableType; typedef BatchToSpaceNDOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - BatchToSpaceNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BatchToSpaceNDOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BatchToSpaceNDOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BatchToSpaceNDOptionsBuilder { typedef BatchToSpaceNDOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit BatchToSpaceNDOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBatchToSpaceNDOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateBatchToSpaceNDOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { BatchToSpaceNDOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBatchToSpaceNDOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SkipGramOptionsT : public flatbuffers::NativeTable { +struct SkipGramOptionsT : public ::flatbuffers::NativeTable { typedef SkipGramOptions TableType; int32_t ngram_size = 0; int32_t max_skip_size = 0; bool include_all_ngrams = false; }; -struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SkipGramOptionsT NativeTableType; typedef SkipGramOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9784,22 +9784,22 @@ struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool include_all_ngrams() const { return GetField(VT_INCLUDE_ALL_NGRAMS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_NGRAM_SIZE, 4) && VerifyField(verifier, VT_MAX_SKIP_SIZE, 4) && VerifyField(verifier, VT_INCLUDE_ALL_NGRAMS, 1) && verifier.EndTable(); } - SkipGramOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SkipGramOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SkipGramOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SkipGramOptionsBuilder { typedef SkipGramOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_ngram_size(int32_t ngram_size) { fbb_.AddElement(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0); } @@ -9809,19 +9809,19 @@ struct SkipGramOptionsBuilder { void add_include_all_ngrams(bool include_all_ngrams) { fbb_.AddElement(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast(include_all_ngrams), 0); } - explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkipGramOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSkipGramOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSkipGramOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t ngram_size = 0, int32_t max_skip_size = 0, bool include_all_ngrams = false) { @@ -9832,14 +9832,14 @@ inline flatbuffers::Offset CreateSkipGramOptions( return builder_.Finish(); } -flatbuffers::Offset CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSkipGramOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SpaceToDepthOptionsT : public flatbuffers::NativeTable { +struct SpaceToDepthOptionsT : public ::flatbuffers::NativeTable { typedef SpaceToDepthOptions TableType; int32_t block_size = 0; }; -struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SpaceToDepthOptionsT NativeTableType; typedef SpaceToDepthOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9848,50 +9848,50 @@ struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table int32_t block_size() const { return GetField(VT_BLOCK_SIZE, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_BLOCK_SIZE, 4) && verifier.EndTable(); } - SpaceToDepthOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SpaceToDepthOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SpaceToDepthOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SpaceToDepthOptionsBuilder { typedef SpaceToDepthOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_block_size(int32_t block_size) { fbb_.AddElement(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0); } - explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SpaceToDepthOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSpaceToDepthOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSpaceToDepthOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0) { SpaceToDepthOptionsBuilder builder_(_fbb); builder_.add_block_size(block_size); return builder_.Finish(); } -flatbuffers::Offset CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSpaceToDepthOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct DepthToSpaceOptionsT : public flatbuffers::NativeTable { +struct DepthToSpaceOptionsT : public ::flatbuffers::NativeTable { typedef DepthToSpaceOptions TableType; int32_t block_size = 0; }; -struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DepthToSpaceOptionsT NativeTableType; typedef DepthToSpaceOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9900,51 +9900,51 @@ struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table int32_t block_size() const { return GetField(VT_BLOCK_SIZE, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_BLOCK_SIZE, 4) && verifier.EndTable(); } - DepthToSpaceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DepthToSpaceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DepthToSpaceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct DepthToSpaceOptionsBuilder { typedef DepthToSpaceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_block_size(int32_t block_size) { fbb_.AddElement(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0); } - explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit DepthToSpaceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDepthToSpaceOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateDepthToSpaceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0) { DepthToSpaceOptionsBuilder builder_(_fbb); builder_.add_block_size(block_size); return builder_.Finish(); } -flatbuffers::Offset CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateDepthToSpaceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SubOptionsT : public flatbuffers::NativeTable { +struct SubOptionsT : public ::flatbuffers::NativeTable { typedef SubOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; bool pot_scale_int16 = true; }; -struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SubOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SubOptionsT NativeTableType; typedef SubOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9957,40 +9957,40 @@ struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool pot_scale_int16() const { return GetField(VT_POT_SCALE_INT16, 1) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && VerifyField(verifier, VT_POT_SCALE_INT16, 1) && verifier.EndTable(); } - SubOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SubOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SubOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SubOptionsBuilder { typedef SubOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } void add_pot_scale_int16(bool pot_scale_int16) { fbb_.AddElement(SubOptions::VT_POT_SCALE_INT16, static_cast(pot_scale_int16), 1); } - explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SubOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSubOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSubOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE, bool pot_scale_int16 = true) { SubOptionsBuilder builder_(_fbb); @@ -9999,14 +9999,14 @@ inline flatbuffers::Offset CreateSubOptions( return builder_.Finish(); } -flatbuffers::Offset CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSubOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct DivOptionsT : public flatbuffers::NativeTable { +struct DivOptionsT : public ::flatbuffers::NativeTable { typedef DivOptions TableType; tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE; }; -struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct DivOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DivOptionsT NativeTableType; typedef DivOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10015,89 +10015,89 @@ struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::ActivationFunctionType fused_activation_function() const { return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) && verifier.EndTable(); } - DivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DivOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DivOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct DivOptionsBuilder { typedef DivOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) { fbb_.AddElement(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); } - explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit DivOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDivOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateDivOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) { DivOptionsBuilder builder_(_fbb); builder_.add_fused_activation_function(fused_activation_function); return builder_.Finish(); } -flatbuffers::Offset CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateDivOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct TopKV2OptionsT : public flatbuffers::NativeTable { +struct TopKV2OptionsT : public ::flatbuffers::NativeTable { typedef TopKV2Options TableType; }; -struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef TopKV2OptionsT NativeTableType; typedef TopKV2OptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - TopKV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + TopKV2OptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TopKV2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct TopKV2OptionsBuilder { typedef TopKV2Options Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit TopKV2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTopKV2Options( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateTopKV2Options( + ::flatbuffers::FlatBufferBuilder &_fbb) { TopKV2OptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateTopKV2Options(::flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable { +struct EmbeddingLookupSparseOptionsT : public ::flatbuffers::NativeTable { typedef EmbeddingLookupSparseOptions TableType; tflite::CombinerType combiner = tflite::CombinerType_SUM; }; -struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef EmbeddingLookupSparseOptionsT NativeTableType; typedef EmbeddingLookupSparseOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10106,51 +10106,51 @@ struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffer tflite::CombinerType combiner() const { return static_cast(GetField(VT_COMBINER, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_COMBINER, 1) && verifier.EndTable(); } - EmbeddingLookupSparseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + EmbeddingLookupSparseOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(EmbeddingLookupSparseOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct EmbeddingLookupSparseOptionsBuilder { typedef EmbeddingLookupSparseOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_combiner(tflite::CombinerType combiner) { fbb_.AddElement(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast(combiner), 0); } - explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit EmbeddingLookupSparseOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateEmbeddingLookupSparseOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateEmbeddingLookupSparseOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::CombinerType combiner = tflite::CombinerType_SUM) { EmbeddingLookupSparseOptionsBuilder builder_(_fbb); builder_.add_combiner(combiner); return builder_.Finish(); } -flatbuffers::Offset CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateEmbeddingLookupSparseOptions(::flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct GatherOptionsT : public flatbuffers::NativeTable { +struct GatherOptionsT : public ::flatbuffers::NativeTable { typedef GatherOptions TableType; int32_t axis = 0; int32_t batch_dims = 0; }; -struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct GatherOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef GatherOptionsT NativeTableType; typedef GatherOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10163,40 +10163,40 @@ struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t batch_dims() const { return GetField(VT_BATCH_DIMS, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_AXIS, 4) && VerifyField(verifier, VT_BATCH_DIMS, 4) && verifier.EndTable(); } - GatherOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + GatherOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GatherOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct GatherOptionsBuilder { typedef GatherOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_axis(int32_t axis) { fbb_.AddElement(GatherOptions::VT_AXIS, axis, 0); } void add_batch_dims(int32_t batch_dims) { fbb_.AddElement(GatherOptions::VT_BATCH_DIMS, batch_dims, 0); } - explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit GatherOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateGatherOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateGatherOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0, int32_t batch_dims = 0) { GatherOptionsBuilder builder_(_fbb); @@ -10205,131 +10205,131 @@ inline flatbuffers::Offset CreateGatherOptions( return builder_.Finish(); } -flatbuffers::Offset CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateGatherOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct TransposeOptionsT : public flatbuffers::NativeTable { +struct TransposeOptionsT : public ::flatbuffers::NativeTable { typedef TransposeOptions TableType; }; -struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef TransposeOptionsT NativeTableType; typedef TransposeOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - TransposeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + TransposeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TransposeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct TransposeOptionsBuilder { typedef TransposeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit TransposeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTransposeOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateTransposeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { TransposeOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateTransposeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ExpOptionsT : public flatbuffers::NativeTable { +struct ExpOptionsT : public ::flatbuffers::NativeTable { typedef ExpOptions TableType; }; -struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ExpOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ExpOptionsT NativeTableType; typedef ExpOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - ExpOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ExpOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ExpOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ExpOptionsBuilder { typedef ExpOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit ExpOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateExpOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateExpOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { ExpOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateExpOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct CosOptionsT : public flatbuffers::NativeTable { +struct CosOptionsT : public ::flatbuffers::NativeTable { typedef CosOptions TableType; }; -struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct CosOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef CosOptionsT NativeTableType; typedef CosOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - CosOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + CosOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CosOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct CosOptionsBuilder { typedef CosOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit CosOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateCosOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateCosOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { CosOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateCosOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ReducerOptionsT : public flatbuffers::NativeTable { +struct ReducerOptionsT : public ::flatbuffers::NativeTable { typedef ReducerOptions TableType; bool keep_dims = false; }; -struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ReducerOptionsT NativeTableType; typedef ReducerOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10338,97 +10338,97 @@ struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool keep_dims() const { return GetField(VT_KEEP_DIMS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_KEEP_DIMS, 1) && verifier.EndTable(); } - ReducerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ReducerOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReducerOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ReducerOptionsBuilder { typedef ReducerOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_keep_dims(bool keep_dims) { fbb_.AddElement(ReducerOptions::VT_KEEP_DIMS, static_cast(keep_dims), 0); } - explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ReducerOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateReducerOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateReducerOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool keep_dims = false) { ReducerOptionsBuilder builder_(_fbb); builder_.add_keep_dims(keep_dims); return builder_.Finish(); } -flatbuffers::Offset CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateReducerOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SqueezeOptionsT : public flatbuffers::NativeTable { +struct SqueezeOptionsT : public ::flatbuffers::NativeTable { typedef SqueezeOptions TableType; std::vector squeeze_dims{}; }; -struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SqueezeOptionsT NativeTableType; typedef SqueezeOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_SQUEEZE_DIMS = 4 }; - const flatbuffers::Vector *squeeze_dims() const { - return GetPointer *>(VT_SQUEEZE_DIMS); + const ::flatbuffers::Vector *squeeze_dims() const { + return GetPointer *>(VT_SQUEEZE_DIMS); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SQUEEZE_DIMS) && verifier.VerifyVector(squeeze_dims()) && verifier.EndTable(); } - SqueezeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SqueezeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SqueezeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SqueezeOptionsBuilder { typedef SqueezeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_squeeze_dims(flatbuffers::Offset> squeeze_dims) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_squeeze_dims(::flatbuffers::Offset<::flatbuffers::Vector> squeeze_dims) { fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims); } - explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SqueezeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSqueezeOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> squeeze_dims = 0) { +inline ::flatbuffers::Offset CreateSqueezeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> squeeze_dims = 0) { SqueezeOptionsBuilder builder_(_fbb); builder_.add_squeeze_dims(squeeze_dims); return builder_.Finish(); } -inline flatbuffers::Offset CreateSqueezeOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSqueezeOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *squeeze_dims = nullptr) { auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector(*squeeze_dims) : 0; return tflite::CreateSqueezeOptions( @@ -10436,14 +10436,14 @@ inline flatbuffers::Offset CreateSqueezeOptionsDirect( squeeze_dims__); } -flatbuffers::Offset CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSqueezeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SplitOptionsT : public flatbuffers::NativeTable { +struct SplitOptionsT : public ::flatbuffers::NativeTable { typedef SplitOptions TableType; int32_t num_splits = 0; }; -struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SplitOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SplitOptionsT NativeTableType; typedef SplitOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10452,50 +10452,50 @@ struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t num_splits() const { return GetField(VT_NUM_SPLITS, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_NUM_SPLITS, 4) && verifier.EndTable(); } - SplitOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SplitOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SplitOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SplitOptionsBuilder { typedef SplitOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_num_splits(int32_t num_splits) { fbb_.AddElement(SplitOptions::VT_NUM_SPLITS, num_splits, 0); } - explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SplitOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSplitOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSplitOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t num_splits = 0) { SplitOptionsBuilder builder_(_fbb); builder_.add_num_splits(num_splits); return builder_.Finish(); } -flatbuffers::Offset CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSplitOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SplitVOptionsT : public flatbuffers::NativeTable { +struct SplitVOptionsT : public ::flatbuffers::NativeTable { typedef SplitVOptions TableType; int32_t num_splits = 0; }; -struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SplitVOptionsT NativeTableType; typedef SplitVOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10504,45 +10504,45 @@ struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t num_splits() const { return GetField(VT_NUM_SPLITS, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_NUM_SPLITS, 4) && verifier.EndTable(); } - SplitVOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SplitVOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SplitVOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SplitVOptionsBuilder { typedef SplitVOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_num_splits(int32_t num_splits) { fbb_.AddElement(SplitVOptions::VT_NUM_SPLITS, num_splits, 0); } - explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SplitVOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSplitVOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSplitVOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t num_splits = 0) { SplitVOptionsBuilder builder_(_fbb); builder_.add_num_splits(num_splits); return builder_.Finish(); } -flatbuffers::Offset CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSplitVOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct StridedSliceOptionsT : public flatbuffers::NativeTable { +struct StridedSliceOptionsT : public ::flatbuffers::NativeTable { typedef StridedSliceOptions TableType; int32_t begin_mask = 0; int32_t end_mask = 0; @@ -10552,7 +10552,7 @@ struct StridedSliceOptionsT : public flatbuffers::NativeTable { bool offset = false; }; -struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef StridedSliceOptionsT NativeTableType; typedef StridedSliceOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10581,7 +10581,7 @@ struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table bool offset() const { return GetField(VT_OFFSET, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_BEGIN_MASK, 4) && VerifyField(verifier, VT_END_MASK, 4) && @@ -10591,15 +10591,15 @@ struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table VerifyField(verifier, VT_OFFSET, 1) && verifier.EndTable(); } - StridedSliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + StridedSliceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StridedSliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct StridedSliceOptionsBuilder { typedef StridedSliceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_begin_mask(int32_t begin_mask) { fbb_.AddElement(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0); } @@ -10618,19 +10618,19 @@ struct StridedSliceOptionsBuilder { void add_offset(bool offset) { fbb_.AddElement(StridedSliceOptions::VT_OFFSET, static_cast(offset), 0); } - explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StridedSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStridedSliceOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateStridedSliceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t begin_mask = 0, int32_t end_mask = 0, int32_t ellipsis_mask = 0, @@ -10647,54 +10647,54 @@ inline flatbuffers::Offset CreateStridedSliceOptions( return builder_.Finish(); } -flatbuffers::Offset CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateStridedSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LogSoftmaxOptionsT : public flatbuffers::NativeTable { +struct LogSoftmaxOptionsT : public ::flatbuffers::NativeTable { typedef LogSoftmaxOptions TableType; }; -struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LogSoftmaxOptionsT NativeTableType; typedef LogSoftmaxOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - LogSoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LogSoftmaxOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LogSoftmaxOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LogSoftmaxOptionsBuilder { typedef LogSoftmaxOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit LogSoftmaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLogSoftmaxOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateLogSoftmaxOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { LogSoftmaxOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLogSoftmaxOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct CastOptionsT : public flatbuffers::NativeTable { +struct CastOptionsT : public ::flatbuffers::NativeTable { typedef CastOptions TableType; tflite::TensorType in_data_type = tflite::TensorType_FLOAT32; tflite::TensorType out_data_type = tflite::TensorType_FLOAT32; }; -struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct CastOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef CastOptionsT NativeTableType; typedef CastOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10707,40 +10707,40 @@ struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::TensorType out_data_type() const { return static_cast(GetField(VT_OUT_DATA_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_IN_DATA_TYPE, 1) && VerifyField(verifier, VT_OUT_DATA_TYPE, 1) && verifier.EndTable(); } - CastOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + CastOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CastOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct CastOptionsBuilder { typedef CastOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_in_data_type(tflite::TensorType in_data_type) { fbb_.AddElement(CastOptions::VT_IN_DATA_TYPE, static_cast(in_data_type), 0); } void add_out_data_type(tflite::TensorType out_data_type) { fbb_.AddElement(CastOptions::VT_OUT_DATA_TYPE, static_cast(out_data_type), 0); } - explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit CastOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateCastOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateCastOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType in_data_type = tflite::TensorType_FLOAT32, tflite::TensorType out_data_type = tflite::TensorType_FLOAT32) { CastOptionsBuilder builder_(_fbb); @@ -10749,131 +10749,131 @@ inline flatbuffers::Offset CreateCastOptions( return builder_.Finish(); } -flatbuffers::Offset CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateCastOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct DequantizeOptionsT : public flatbuffers::NativeTable { +struct DequantizeOptionsT : public ::flatbuffers::NativeTable { typedef DequantizeOptions TableType; }; -struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DequantizeOptionsT NativeTableType; typedef DequantizeOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - DequantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DequantizeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DequantizeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct DequantizeOptionsBuilder { typedef DequantizeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit DequantizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDequantizeOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateDequantizeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { DequantizeOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateDequantizeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct MaximumMinimumOptionsT : public flatbuffers::NativeTable { +struct MaximumMinimumOptionsT : public ::flatbuffers::NativeTable { typedef MaximumMinimumOptions TableType; }; -struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MaximumMinimumOptionsT NativeTableType; typedef MaximumMinimumOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - MaximumMinimumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + MaximumMinimumOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MaximumMinimumOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct MaximumMinimumOptionsBuilder { typedef MaximumMinimumOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit MaximumMinimumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMaximumMinimumOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateMaximumMinimumOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { MaximumMinimumOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateMaximumMinimumOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct TileOptionsT : public flatbuffers::NativeTable { +struct TileOptionsT : public ::flatbuffers::NativeTable { typedef TileOptions TableType; }; -struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct TileOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef TileOptionsT NativeTableType; typedef TileOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - TileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + TileOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TileOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct TileOptionsBuilder { typedef TileOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit TileOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTileOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateTileOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { TileOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateTileOptions(::flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ArgMaxOptionsT : public flatbuffers::NativeTable { +struct ArgMaxOptionsT : public ::flatbuffers::NativeTable { typedef ArgMaxOptions TableType; tflite::TensorType output_type = tflite::TensorType_FLOAT32; }; -struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ArgMaxOptionsT NativeTableType; typedef ArgMaxOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10882,50 +10882,50 @@ struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::TensorType output_type() const { return static_cast(GetField(VT_OUTPUT_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_OUTPUT_TYPE, 1) && verifier.EndTable(); } - ArgMaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ArgMaxOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ArgMaxOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ArgMaxOptionsBuilder { typedef ArgMaxOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_output_type(tflite::TensorType output_type) { fbb_.AddElement(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast(output_type), 0); } - explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ArgMaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateArgMaxOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateArgMaxOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType output_type = tflite::TensorType_FLOAT32) { ArgMaxOptionsBuilder builder_(_fbb); builder_.add_output_type(output_type); return builder_.Finish(); } -flatbuffers::Offset CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateArgMaxOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ArgMinOptionsT : public flatbuffers::NativeTable { +struct ArgMinOptionsT : public ::flatbuffers::NativeTable { typedef ArgMinOptions TableType; tflite::TensorType output_type = tflite::TensorType_FLOAT32; }; -struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ArgMinOptionsT NativeTableType; typedef ArgMinOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -10934,318 +10934,318 @@ struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::TensorType output_type() const { return static_cast(GetField(VT_OUTPUT_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_OUTPUT_TYPE, 1) && verifier.EndTable(); } - ArgMinOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ArgMinOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ArgMinOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ArgMinOptionsBuilder { typedef ArgMinOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_output_type(tflite::TensorType output_type) { fbb_.AddElement(ArgMinOptions::VT_OUTPUT_TYPE, static_cast(output_type), 0); } - explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ArgMinOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateArgMinOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateArgMinOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType output_type = tflite::TensorType_FLOAT32) { ArgMinOptionsBuilder builder_(_fbb); builder_.add_output_type(output_type); return builder_.Finish(); } -flatbuffers::Offset CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateArgMinOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct GreaterOptionsT : public flatbuffers::NativeTable { +struct GreaterOptionsT : public ::flatbuffers::NativeTable { typedef GreaterOptions TableType; }; -struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef GreaterOptionsT NativeTableType; typedef GreaterOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - GreaterOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + GreaterOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GreaterOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct GreaterOptionsBuilder { typedef GreaterOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit GreaterOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateGreaterOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateGreaterOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { GreaterOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateGreaterOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct GreaterEqualOptionsT : public flatbuffers::NativeTable { +struct GreaterEqualOptionsT : public ::flatbuffers::NativeTable { typedef GreaterEqualOptions TableType; }; -struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef GreaterEqualOptionsT NativeTableType; typedef GreaterEqualOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - GreaterEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + GreaterEqualOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GreaterEqualOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct GreaterEqualOptionsBuilder { typedef GreaterEqualOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit GreaterEqualOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateGreaterEqualOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateGreaterEqualOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { GreaterEqualOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateGreaterEqualOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LessOptionsT : public flatbuffers::NativeTable { +struct LessOptionsT : public ::flatbuffers::NativeTable { typedef LessOptions TableType; }; -struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LessOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LessOptionsT NativeTableType; typedef LessOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - LessOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LessOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LessOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LessOptionsBuilder { typedef LessOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit LessOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLessOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateLessOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { LessOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLessOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LessEqualOptionsT : public flatbuffers::NativeTable { +struct LessEqualOptionsT : public ::flatbuffers::NativeTable { typedef LessEqualOptions TableType; }; -struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LessEqualOptionsT NativeTableType; typedef LessEqualOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - LessEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LessEqualOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LessEqualOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LessEqualOptionsBuilder { typedef LessEqualOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit LessEqualOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLessEqualOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateLessEqualOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { LessEqualOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLessEqualOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct NegOptionsT : public flatbuffers::NativeTable { +struct NegOptionsT : public ::flatbuffers::NativeTable { typedef NegOptions TableType; }; -struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct NegOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef NegOptionsT NativeTableType; typedef NegOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - NegOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + NegOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(NegOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct NegOptionsBuilder { typedef NegOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit NegOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateNegOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateNegOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { NegOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateNegOptions(::flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SelectOptionsT : public flatbuffers::NativeTable { +struct SelectOptionsT : public ::flatbuffers::NativeTable { typedef SelectOptions TableType; }; -struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SelectOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SelectOptionsT NativeTableType; typedef SelectOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - SelectOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SelectOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SelectOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SelectOptionsBuilder { typedef SelectOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit SelectOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSelectOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateSelectOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { SelectOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSelectOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SliceOptionsT : public flatbuffers::NativeTable { +struct SliceOptionsT : public ::flatbuffers::NativeTable { typedef SliceOptions TableType; }; -struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SliceOptionsT NativeTableType; typedef SliceOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - SliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SliceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SliceOptionsBuilder { typedef SliceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit SliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSliceOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateSliceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { SliceOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct TransposeConvOptionsT : public flatbuffers::NativeTable { +struct TransposeConvOptionsT : public ::flatbuffers::NativeTable { typedef TransposeConvOptions TableType; tflite::Padding padding = tflite::Padding_SAME; int32_t stride_w = 0; @@ -11254,7 +11254,7 @@ struct TransposeConvOptionsT : public flatbuffers::NativeTable { tflite::TensorType quantized_bias_type = tflite::TensorType_FLOAT32; }; -struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef TransposeConvOptionsT NativeTableType; typedef TransposeConvOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -11279,7 +11279,7 @@ struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table tflite::TensorType quantized_bias_type() const { return static_cast(GetField(VT_QUANTIZED_BIAS_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_PADDING, 1) && VerifyField(verifier, VT_STRIDE_W, 4) && @@ -11288,15 +11288,15 @@ struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table VerifyField(verifier, VT_QUANTIZED_BIAS_TYPE, 1) && verifier.EndTable(); } - TransposeConvOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + TransposeConvOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TransposeConvOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct TransposeConvOptionsBuilder { typedef TransposeConvOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_padding(tflite::Padding padding) { fbb_.AddElement(TransposeConvOptions::VT_PADDING, static_cast(padding), 0); } @@ -11312,19 +11312,19 @@ struct TransposeConvOptionsBuilder { void add_quantized_bias_type(tflite::TensorType quantized_bias_type) { fbb_.AddElement(TransposeConvOptions::VT_QUANTIZED_BIAS_TYPE, static_cast(quantized_bias_type), 0); } - explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TransposeConvOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTransposeConvOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateTransposeConvOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding = tflite::Padding_SAME, int32_t stride_w = 0, int32_t stride_h = 0, @@ -11339,53 +11339,53 @@ inline flatbuffers::Offset CreateTransposeConvOptions( return builder_.Finish(); } -flatbuffers::Offset CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateTransposeConvOptions(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ExpandDimsOptionsT : public flatbuffers::NativeTable { +struct ExpandDimsOptionsT : public ::flatbuffers::NativeTable { typedef ExpandDimsOptions TableType; }; -struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ExpandDimsOptionsT NativeTableType; typedef ExpandDimsOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - ExpandDimsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ExpandDimsOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ExpandDimsOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ExpandDimsOptionsBuilder { typedef ExpandDimsOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit ExpandDimsOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateExpandDimsOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateExpandDimsOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { ExpandDimsOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateExpandDimsOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SparseToDenseOptionsT : public flatbuffers::NativeTable { +struct SparseToDenseOptionsT : public ::flatbuffers::NativeTable { typedef SparseToDenseOptions TableType; bool validate_indices = false; }; -struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SparseToDenseOptionsT NativeTableType; typedef SparseToDenseOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -11394,128 +11394,128 @@ struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table bool validate_indices() const { return GetField(VT_VALIDATE_INDICES, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_VALIDATE_INDICES, 1) && verifier.EndTable(); } - SparseToDenseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SparseToDenseOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SparseToDenseOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SparseToDenseOptionsBuilder { typedef SparseToDenseOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_validate_indices(bool validate_indices) { fbb_.AddElement(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast(validate_indices), 0); } - explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SparseToDenseOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSparseToDenseOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateSparseToDenseOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool validate_indices = false) { SparseToDenseOptionsBuilder builder_(_fbb); builder_.add_validate_indices(validate_indices); return builder_.Finish(); } -flatbuffers::Offset CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSparseToDenseOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct EqualOptionsT : public flatbuffers::NativeTable { +struct EqualOptionsT : public ::flatbuffers::NativeTable { typedef EqualOptions TableType; }; -struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct EqualOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef EqualOptionsT NativeTableType; typedef EqualOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - EqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + EqualOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(EqualOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct EqualOptionsBuilder { typedef EqualOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit EqualOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateEqualOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateEqualOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { EqualOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateEqualOptions(::flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct NotEqualOptionsT : public flatbuffers::NativeTable { +struct NotEqualOptionsT : public ::flatbuffers::NativeTable { typedef NotEqualOptions TableType; }; -struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef NotEqualOptionsT NativeTableType; typedef NotEqualOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - NotEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + NotEqualOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(NotEqualOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct NotEqualOptionsBuilder { typedef NotEqualOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit NotEqualOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateNotEqualOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateNotEqualOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { NotEqualOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateNotEqualOptions(::flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ShapeOptionsT : public flatbuffers::NativeTable { +struct ShapeOptionsT : public ::flatbuffers::NativeTable { typedef ShapeOptions TableType; tflite::TensorType out_type = tflite::TensorType_FLOAT32; }; -struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ShapeOptionsT NativeTableType; typedef ShapeOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -11524,123 +11524,123 @@ struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::TensorType out_type() const { return static_cast(GetField(VT_OUT_TYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_OUT_TYPE, 1) && verifier.EndTable(); } - ShapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ShapeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ShapeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ShapeOptionsBuilder { typedef ShapeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_out_type(tflite::TensorType out_type) { fbb_.AddElement(ShapeOptions::VT_OUT_TYPE, static_cast(out_type), 0); } - explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ShapeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateShapeOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateShapeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType out_type = tflite::TensorType_FLOAT32) { ShapeOptionsBuilder builder_(_fbb); builder_.add_out_type(out_type); return builder_.Finish(); } -flatbuffers::Offset CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateShapeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct RankOptionsT : public flatbuffers::NativeTable { +struct RankOptionsT : public ::flatbuffers::NativeTable { typedef RankOptions TableType; }; -struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct RankOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef RankOptionsT NativeTableType; typedef RankOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - RankOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + RankOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(RankOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct RankOptionsBuilder { typedef RankOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit RankOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRankOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateRankOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { RankOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateRankOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct PowOptionsT : public flatbuffers::NativeTable { +struct PowOptionsT : public ::flatbuffers::NativeTable { typedef PowOptions TableType; }; -struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct PowOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef PowOptionsT NativeTableType; typedef PowOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - PowOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + PowOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(PowOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct PowOptionsBuilder { typedef PowOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit PowOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreatePowOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreatePowOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { PowOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreatePowOptions(::flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct FakeQuantOptionsT : public flatbuffers::NativeTable { +struct FakeQuantOptionsT : public ::flatbuffers::NativeTable { typedef FakeQuantOptions TableType; float min = 0.0f; float max = 0.0f; @@ -11648,7 +11648,7 @@ struct FakeQuantOptionsT : public flatbuffers::NativeTable { bool narrow_range = false; }; -struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef FakeQuantOptionsT NativeTableType; typedef FakeQuantOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -11669,7 +11669,7 @@ struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool narrow_range() const { return GetField(VT_NARROW_RANGE, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_MIN, 4) && VerifyField(verifier, VT_MAX, 4) && @@ -11677,15 +11677,15 @@ struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_NARROW_RANGE, 1) && verifier.EndTable(); } - FakeQuantOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + FakeQuantOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(FakeQuantOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct FakeQuantOptionsBuilder { typedef FakeQuantOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_min(float min) { fbb_.AddElement(FakeQuantOptions::VT_MIN, min, 0.0f); } @@ -11698,19 +11698,19 @@ struct FakeQuantOptionsBuilder { void add_narrow_range(bool narrow_range) { fbb_.AddElement(FakeQuantOptions::VT_NARROW_RANGE, static_cast(narrow_range), 0); } - explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit FakeQuantOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFakeQuantOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateFakeQuantOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, float min = 0.0f, float max = 0.0f, int32_t num_bits = 0, @@ -11723,15 +11723,15 @@ inline flatbuffers::Offset CreateFakeQuantOptions( return builder_.Finish(); } -flatbuffers::Offset CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateFakeQuantOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct PackOptionsT : public flatbuffers::NativeTable { +struct PackOptionsT : public ::flatbuffers::NativeTable { typedef PackOptions TableType; int32_t values_count = 0; int32_t axis = 0; }; -struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct PackOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef PackOptionsT NativeTableType; typedef PackOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -11744,40 +11744,40 @@ struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t axis() const { return GetField(VT_AXIS, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_VALUES_COUNT, 4) && VerifyField(verifier, VT_AXIS, 4) && verifier.EndTable(); } - PackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + PackOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(PackOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct PackOptionsBuilder { typedef PackOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_values_count(int32_t values_count) { fbb_.AddElement(PackOptions::VT_VALUES_COUNT, values_count, 0); } void add_axis(int32_t axis) { fbb_.AddElement(PackOptions::VT_AXIS, axis, 0); } - explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit PackOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreatePackOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreatePackOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t values_count = 0, int32_t axis = 0) { PackOptionsBuilder builder_(_fbb); @@ -11786,53 +11786,53 @@ inline flatbuffers::Offset CreatePackOptions( return builder_.Finish(); } -flatbuffers::Offset CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreatePackOptions(::flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LogicalOrOptionsT : public flatbuffers::NativeTable { +struct LogicalOrOptionsT : public ::flatbuffers::NativeTable { typedef LogicalOrOptions TableType; }; -struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LogicalOrOptionsT NativeTableType; typedef LogicalOrOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - LogicalOrOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LogicalOrOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LogicalOrOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LogicalOrOptionsBuilder { typedef LogicalOrOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit LogicalOrOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLogicalOrOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateLogicalOrOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { LogicalOrOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLogicalOrOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct OneHotOptionsT : public flatbuffers::NativeTable { +struct OneHotOptionsT : public ::flatbuffers::NativeTable { typedef OneHotOptions TableType; int32_t axis = 0; }; -struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef OneHotOptionsT NativeTableType; typedef OneHotOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -11841,207 +11841,207 @@ struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t axis() const { return GetField(VT_AXIS, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_AXIS, 4) && verifier.EndTable(); } - OneHotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + OneHotOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(OneHotOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct OneHotOptionsBuilder { typedef OneHotOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_axis(int32_t axis) { fbb_.AddElement(OneHotOptions::VT_AXIS, axis, 0); } - explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit OneHotOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOneHotOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateOneHotOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0) { OneHotOptionsBuilder builder_(_fbb); builder_.add_axis(axis); return builder_.Finish(); } -flatbuffers::Offset CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateOneHotOptions(::flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct AbsOptionsT : public flatbuffers::NativeTable { +struct AbsOptionsT : public ::flatbuffers::NativeTable { typedef AbsOptions TableType; }; -struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct AbsOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef AbsOptionsT NativeTableType; typedef AbsOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - AbsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + AbsOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(AbsOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct AbsOptionsBuilder { typedef AbsOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit AbsOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateAbsOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateAbsOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { AbsOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateAbsOptions(::flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct HardSwishOptionsT : public flatbuffers::NativeTable { +struct HardSwishOptionsT : public ::flatbuffers::NativeTable { typedef HardSwishOptions TableType; }; -struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef HardSwishOptionsT NativeTableType; typedef HardSwishOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - HardSwishOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + HardSwishOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(HardSwishOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct HardSwishOptionsBuilder { typedef HardSwishOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit HardSwishOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHardSwishOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateHardSwishOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { HardSwishOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateHardSwishOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LogicalAndOptionsT : public flatbuffers::NativeTable { +struct LogicalAndOptionsT : public ::flatbuffers::NativeTable { typedef LogicalAndOptions TableType; }; -struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LogicalAndOptionsT NativeTableType; typedef LogicalAndOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - LogicalAndOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LogicalAndOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LogicalAndOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LogicalAndOptionsBuilder { typedef LogicalAndOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit LogicalAndOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLogicalAndOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateLogicalAndOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { LogicalAndOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLogicalAndOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LogicalNotOptionsT : public flatbuffers::NativeTable { +struct LogicalNotOptionsT : public ::flatbuffers::NativeTable { typedef LogicalNotOptions TableType; }; -struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LogicalNotOptionsT NativeTableType; typedef LogicalNotOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - LogicalNotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LogicalNotOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LogicalNotOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LogicalNotOptionsBuilder { typedef LogicalNotOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit LogicalNotOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLogicalNotOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateLogicalNotOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { LogicalNotOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLogicalNotOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct UnpackOptionsT : public flatbuffers::NativeTable { +struct UnpackOptionsT : public ::flatbuffers::NativeTable { typedef UnpackOptions TableType; int32_t num = 0; int32_t axis = 0; }; -struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef UnpackOptionsT NativeTableType; typedef UnpackOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -12054,40 +12054,40 @@ struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t axis() const { return GetField(VT_AXIS, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_NUM, 4) && VerifyField(verifier, VT_AXIS, 4) && verifier.EndTable(); } - UnpackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + UnpackOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(UnpackOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct UnpackOptionsBuilder { typedef UnpackOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_num(int32_t num) { fbb_.AddElement(UnpackOptions::VT_NUM, num, 0); } void add_axis(int32_t axis) { fbb_.AddElement(UnpackOptions::VT_AXIS, axis, 0); } - explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit UnpackOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUnpackOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateUnpackOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t num = 0, int32_t axis = 0) { UnpackOptionsBuilder builder_(_fbb); @@ -12096,248 +12096,248 @@ inline flatbuffers::Offset CreateUnpackOptions( return builder_.Finish(); } -flatbuffers::Offset CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUnpackOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct FloorDivOptionsT : public flatbuffers::NativeTable { +struct FloorDivOptionsT : public ::flatbuffers::NativeTable { typedef FloorDivOptions TableType; }; -struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef FloorDivOptionsT NativeTableType; typedef FloorDivOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - FloorDivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + FloorDivOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(FloorDivOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct FloorDivOptionsBuilder { typedef FloorDivOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit FloorDivOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFloorDivOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateFloorDivOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { FloorDivOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateFloorDivOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SquareOptionsT : public flatbuffers::NativeTable { +struct SquareOptionsT : public ::flatbuffers::NativeTable { typedef SquareOptions TableType; }; -struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SquareOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SquareOptionsT NativeTableType; typedef SquareOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - SquareOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SquareOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SquareOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SquareOptionsBuilder { typedef SquareOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit SquareOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSquareOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateSquareOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { SquareOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSquareOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ZerosLikeOptionsT : public flatbuffers::NativeTable { +struct ZerosLikeOptionsT : public ::flatbuffers::NativeTable { typedef ZerosLikeOptions TableType; }; -struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ZerosLikeOptionsT NativeTableType; typedef ZerosLikeOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - ZerosLikeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ZerosLikeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ZerosLikeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ZerosLikeOptionsBuilder { typedef ZerosLikeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit ZerosLikeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateZerosLikeOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateZerosLikeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { ZerosLikeOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateZerosLikeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct FillOptionsT : public flatbuffers::NativeTable { +struct FillOptionsT : public ::flatbuffers::NativeTable { typedef FillOptions TableType; }; -struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct FillOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef FillOptionsT NativeTableType; typedef FillOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - FillOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + FillOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(FillOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct FillOptionsBuilder { typedef FillOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit FillOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFillOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateFillOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { FillOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateFillOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct FloorModOptionsT : public flatbuffers::NativeTable { +struct FloorModOptionsT : public ::flatbuffers::NativeTable { typedef FloorModOptions TableType; }; -struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef FloorModOptionsT NativeTableType; typedef FloorModOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - FloorModOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + FloorModOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(FloorModOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct FloorModOptionsBuilder { typedef FloorModOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit FloorModOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFloorModOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateFloorModOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { FloorModOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateFloorModOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct RangeOptionsT : public flatbuffers::NativeTable { +struct RangeOptionsT : public ::flatbuffers::NativeTable { typedef RangeOptions TableType; }; -struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct RangeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef RangeOptionsT NativeTableType; typedef RangeOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - RangeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + RangeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(RangeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct RangeOptionsBuilder { typedef RangeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit RangeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRangeOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateRangeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { RangeOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateRangeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct LeakyReluOptionsT : public flatbuffers::NativeTable { +struct LeakyReluOptionsT : public ::flatbuffers::NativeTable { typedef LeakyReluOptions TableType; float alpha = 0.0f; }; -struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef LeakyReluOptionsT NativeTableType; typedef LeakyReluOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -12346,89 +12346,89 @@ struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { float alpha() const { return GetField(VT_ALPHA, 0.0f); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_ALPHA, 4) && verifier.EndTable(); } - LeakyReluOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + LeakyReluOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LeakyReluOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct LeakyReluOptionsBuilder { typedef LeakyReluOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_alpha(float alpha) { fbb_.AddElement(LeakyReluOptions::VT_ALPHA, alpha, 0.0f); } - explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit LeakyReluOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLeakyReluOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateLeakyReluOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, float alpha = 0.0f) { LeakyReluOptionsBuilder builder_(_fbb); builder_.add_alpha(alpha); return builder_.Finish(); } -flatbuffers::Offset CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateLeakyReluOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SquaredDifferenceOptionsT : public flatbuffers::NativeTable { +struct SquaredDifferenceOptionsT : public ::flatbuffers::NativeTable { typedef SquaredDifferenceOptions TableType; }; -struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SquaredDifferenceOptionsT NativeTableType; typedef SquaredDifferenceOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - SquaredDifferenceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SquaredDifferenceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SquaredDifferenceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SquaredDifferenceOptionsBuilder { typedef SquaredDifferenceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit SquaredDifferenceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSquaredDifferenceOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateSquaredDifferenceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { SquaredDifferenceOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSquaredDifferenceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct MirrorPadOptionsT : public flatbuffers::NativeTable { +struct MirrorPadOptionsT : public ::flatbuffers::NativeTable { typedef MirrorPadOptions TableType; tflite::MirrorPadMode mode = tflite::MirrorPadMode_REFLECT; }; -struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MirrorPadOptionsT NativeTableType; typedef MirrorPadOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -12437,50 +12437,50 @@ struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::MirrorPadMode mode() const { return static_cast(GetField(VT_MODE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_MODE, 1) && verifier.EndTable(); } - MirrorPadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + MirrorPadOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MirrorPadOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct MirrorPadOptionsBuilder { typedef MirrorPadOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_mode(tflite::MirrorPadMode mode) { fbb_.AddElement(MirrorPadOptions::VT_MODE, static_cast(mode), 0); } - explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit MirrorPadOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMirrorPadOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateMirrorPadOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::MirrorPadMode mode = tflite::MirrorPadMode_REFLECT) { MirrorPadOptionsBuilder builder_(_fbb); builder_.add_mode(mode); return builder_.Finish(); } -flatbuffers::Offset CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateMirrorPadOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct UniqueOptionsT : public flatbuffers::NativeTable { +struct UniqueOptionsT : public ::flatbuffers::NativeTable { typedef UniqueOptions TableType; tflite::TensorType idx_out_type = tflite::TensorType_INT32; }; -struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef UniqueOptionsT NativeTableType; typedef UniqueOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -12489,207 +12489,207 @@ struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::TensorType idx_out_type() const { return static_cast(GetField(VT_IDX_OUT_TYPE, 2)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_IDX_OUT_TYPE, 1) && verifier.EndTable(); } - UniqueOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + UniqueOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(UniqueOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct UniqueOptionsBuilder { typedef UniqueOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_idx_out_type(tflite::TensorType idx_out_type) { fbb_.AddElement(UniqueOptions::VT_IDX_OUT_TYPE, static_cast(idx_out_type), 2); } - explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit UniqueOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUniqueOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateUniqueOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType idx_out_type = tflite::TensorType_INT32) { UniqueOptionsBuilder builder_(_fbb); builder_.add_idx_out_type(idx_out_type); return builder_.Finish(); } -flatbuffers::Offset CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUniqueOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ReverseV2OptionsT : public flatbuffers::NativeTable { +struct ReverseV2OptionsT : public ::flatbuffers::NativeTable { typedef ReverseV2Options TableType; }; -struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ReverseV2OptionsT NativeTableType; typedef ReverseV2OptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - ReverseV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ReverseV2OptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReverseV2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ReverseV2OptionsBuilder { typedef ReverseV2Options Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit ReverseV2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateReverseV2Options( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateReverseV2Options( + ::flatbuffers::FlatBufferBuilder &_fbb) { ReverseV2OptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateReverseV2Options(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct AddNOptionsT : public flatbuffers::NativeTable { +struct AddNOptionsT : public ::flatbuffers::NativeTable { typedef AddNOptions TableType; }; -struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct AddNOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef AddNOptionsT NativeTableType; typedef AddNOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - AddNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + AddNOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(AddNOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct AddNOptionsBuilder { typedef AddNOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit AddNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateAddNOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateAddNOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { AddNOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateAddNOptions(::flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct GatherNdOptionsT : public flatbuffers::NativeTable { +struct GatherNdOptionsT : public ::flatbuffers::NativeTable { typedef GatherNdOptions TableType; }; -struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef GatherNdOptionsT NativeTableType; typedef GatherNdOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - GatherNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + GatherNdOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GatherNdOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct GatherNdOptionsBuilder { typedef GatherNdOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit GatherNdOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateGatherNdOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateGatherNdOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { GatherNdOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateGatherNdOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct WhereOptionsT : public flatbuffers::NativeTable { +struct WhereOptionsT : public ::flatbuffers::NativeTable { typedef WhereOptions TableType; }; -struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct WhereOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef WhereOptionsT NativeTableType; typedef WhereOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - WhereOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + WhereOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(WhereOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct WhereOptionsBuilder { typedef WhereOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit WhereOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateWhereOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateWhereOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { WhereOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateWhereOptions(::flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ReverseSequenceOptionsT : public flatbuffers::NativeTable { +struct ReverseSequenceOptionsT : public ::flatbuffers::NativeTable { typedef ReverseSequenceOptions TableType; int32_t seq_dim = 0; int32_t batch_dim = 0; }; -struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ReverseSequenceOptionsT NativeTableType; typedef ReverseSequenceOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -12702,40 +12702,40 @@ struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tab int32_t batch_dim() const { return GetField(VT_BATCH_DIM, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_SEQ_DIM, 4) && VerifyField(verifier, VT_BATCH_DIM, 4) && verifier.EndTable(); } - ReverseSequenceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ReverseSequenceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReverseSequenceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ReverseSequenceOptionsBuilder { typedef ReverseSequenceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_seq_dim(int32_t seq_dim) { fbb_.AddElement(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0); } void add_batch_dim(int32_t batch_dim) { fbb_.AddElement(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0); } - explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ReverseSequenceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateReverseSequenceOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateReverseSequenceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t seq_dim = 0, int32_t batch_dim = 0) { ReverseSequenceOptionsBuilder builder_(_fbb); @@ -12744,132 +12744,132 @@ inline flatbuffers::Offset CreateReverseSequenceOptions( return builder_.Finish(); } -flatbuffers::Offset CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateReverseSequenceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct MatrixDiagOptionsT : public flatbuffers::NativeTable { +struct MatrixDiagOptionsT : public ::flatbuffers::NativeTable { typedef MatrixDiagOptions TableType; }; -struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MatrixDiagOptionsT NativeTableType; typedef MatrixDiagOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - MatrixDiagOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + MatrixDiagOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MatrixDiagOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct MatrixDiagOptionsBuilder { typedef MatrixDiagOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit MatrixDiagOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMatrixDiagOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateMatrixDiagOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { MatrixDiagOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateMatrixDiagOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct QuantizeOptionsT : public flatbuffers::NativeTable { +struct QuantizeOptionsT : public ::flatbuffers::NativeTable { typedef QuantizeOptions TableType; }; -struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef QuantizeOptionsT NativeTableType; typedef QuantizeOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - QuantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + QuantizeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(QuantizeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct QuantizeOptionsBuilder { typedef QuantizeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit QuantizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateQuantizeOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateQuantizeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { QuantizeOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateQuantizeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct MatrixSetDiagOptionsT : public flatbuffers::NativeTable { +struct MatrixSetDiagOptionsT : public ::flatbuffers::NativeTable { typedef MatrixSetDiagOptions TableType; }; -struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MatrixSetDiagOptionsT NativeTableType; typedef MatrixSetDiagOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - MatrixSetDiagOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + MatrixSetDiagOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MatrixSetDiagOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct MatrixSetDiagOptionsBuilder { typedef MatrixSetDiagOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit MatrixSetDiagOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMatrixSetDiagOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateMatrixSetDiagOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { MatrixSetDiagOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateMatrixSetDiagOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct IfOptionsT : public flatbuffers::NativeTable { +struct IfOptionsT : public ::flatbuffers::NativeTable { typedef IfOptions TableType; int32_t then_subgraph_index = 0; int32_t else_subgraph_index = 0; }; -struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct IfOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef IfOptionsT NativeTableType; typedef IfOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -12882,40 +12882,40 @@ struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t else_subgraph_index() const { return GetField(VT_ELSE_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_THEN_SUBGRAPH_INDEX, 4) && VerifyField(verifier, VT_ELSE_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - IfOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + IfOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(IfOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct IfOptionsBuilder { typedef IfOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_then_subgraph_index(int32_t then_subgraph_index) { fbb_.AddElement(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0); } void add_else_subgraph_index(int32_t else_subgraph_index) { fbb_.AddElement(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0); } - explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit IfOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateIfOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateIfOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t then_subgraph_index = 0, int32_t else_subgraph_index = 0) { IfOptionsBuilder builder_(_fbb); @@ -12924,14 +12924,14 @@ inline flatbuffers::Offset CreateIfOptions( return builder_.Finish(); } -flatbuffers::Offset CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateIfOptions(::flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct CallOnceOptionsT : public flatbuffers::NativeTable { +struct CallOnceOptionsT : public ::flatbuffers::NativeTable { typedef CallOnceOptions TableType; int32_t init_subgraph_index = 0; }; -struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef CallOnceOptionsT NativeTableType; typedef CallOnceOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -12940,51 +12940,51 @@ struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t init_subgraph_index() const { return GetField(VT_INIT_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INIT_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - CallOnceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(CallOnceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + CallOnceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CallOnceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct CallOnceOptionsBuilder { typedef CallOnceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_init_subgraph_index(int32_t init_subgraph_index) { fbb_.AddElement(CallOnceOptions::VT_INIT_SUBGRAPH_INDEX, init_subgraph_index, 0); } - explicit CallOnceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit CallOnceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateCallOnceOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateCallOnceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t init_subgraph_index = 0) { CallOnceOptionsBuilder builder_(_fbb); builder_.add_init_subgraph_index(init_subgraph_index); return builder_.Finish(); } -flatbuffers::Offset CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateCallOnceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct WhileOptionsT : public flatbuffers::NativeTable { +struct WhileOptionsT : public ::flatbuffers::NativeTable { typedef WhileOptions TableType; int32_t cond_subgraph_index = 0; int32_t body_subgraph_index = 0; }; -struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct WhileOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef WhileOptionsT NativeTableType; typedef WhileOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -12997,40 +12997,40 @@ struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t body_subgraph_index() const { return GetField(VT_BODY_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_COND_SUBGRAPH_INDEX, 4) && VerifyField(verifier, VT_BODY_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - WhileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + WhileOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(WhileOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct WhileOptionsBuilder { typedef WhileOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_cond_subgraph_index(int32_t cond_subgraph_index) { fbb_.AddElement(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0); } void add_body_subgraph_index(int32_t body_subgraph_index) { fbb_.AddElement(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0); } - explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit WhileOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateWhileOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateWhileOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t cond_subgraph_index = 0, int32_t body_subgraph_index = 0) { WhileOptionsBuilder builder_(_fbb); @@ -13039,250 +13039,250 @@ inline flatbuffers::Offset CreateWhileOptions( return builder_.Finish(); } -flatbuffers::Offset CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateWhileOptions(::flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct NonMaxSuppressionV4OptionsT : public flatbuffers::NativeTable { +struct NonMaxSuppressionV4OptionsT : public ::flatbuffers::NativeTable { typedef NonMaxSuppressionV4Options TableType; }; -struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef NonMaxSuppressionV4OptionsT NativeTableType; typedef NonMaxSuppressionV4OptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - NonMaxSuppressionV4OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + NonMaxSuppressionV4OptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(NonMaxSuppressionV4OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct NonMaxSuppressionV4OptionsBuilder { typedef NonMaxSuppressionV4Options Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit NonMaxSuppressionV4OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateNonMaxSuppressionV4Options( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateNonMaxSuppressionV4Options( + ::flatbuffers::FlatBufferBuilder &_fbb) { NonMaxSuppressionV4OptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateNonMaxSuppressionV4Options(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct NonMaxSuppressionV5OptionsT : public flatbuffers::NativeTable { +struct NonMaxSuppressionV5OptionsT : public ::flatbuffers::NativeTable { typedef NonMaxSuppressionV5Options TableType; }; -struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef NonMaxSuppressionV5OptionsT NativeTableType; typedef NonMaxSuppressionV5OptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - NonMaxSuppressionV5OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + NonMaxSuppressionV5OptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(NonMaxSuppressionV5OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct NonMaxSuppressionV5OptionsBuilder { typedef NonMaxSuppressionV5Options Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit NonMaxSuppressionV5OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateNonMaxSuppressionV5Options( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateNonMaxSuppressionV5Options( + ::flatbuffers::FlatBufferBuilder &_fbb) { NonMaxSuppressionV5OptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateNonMaxSuppressionV5Options(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ScatterNdOptionsT : public flatbuffers::NativeTable { +struct ScatterNdOptionsT : public ::flatbuffers::NativeTable { typedef ScatterNdOptions TableType; }; -struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ScatterNdOptionsT NativeTableType; typedef ScatterNdOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - ScatterNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ScatterNdOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ScatterNdOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ScatterNdOptionsBuilder { typedef ScatterNdOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit ScatterNdOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateScatterNdOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateScatterNdOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { ScatterNdOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateScatterNdOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SelectV2OptionsT : public flatbuffers::NativeTable { +struct SelectV2OptionsT : public ::flatbuffers::NativeTable { typedef SelectV2Options TableType; }; -struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SelectV2OptionsT NativeTableType; typedef SelectV2OptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - SelectV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SelectV2OptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SelectV2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SelectV2OptionsBuilder { typedef SelectV2Options Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit SelectV2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSelectV2Options( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateSelectV2Options( + ::flatbuffers::FlatBufferBuilder &_fbb) { SelectV2OptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSelectV2Options(::flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct DensifyOptionsT : public flatbuffers::NativeTable { +struct DensifyOptionsT : public ::flatbuffers::NativeTable { typedef DensifyOptions TableType; }; -struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DensifyOptionsT NativeTableType; typedef DensifyOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - DensifyOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DensifyOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DensifyOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DensifyOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct DensifyOptionsBuilder { typedef DensifyOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit DensifyOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDensifyOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateDensifyOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { DensifyOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateDensifyOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SegmentSumOptionsT : public flatbuffers::NativeTable { +struct SegmentSumOptionsT : public ::flatbuffers::NativeTable { typedef SegmentSumOptions TableType; }; -struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SegmentSumOptionsT NativeTableType; typedef SegmentSumOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - SegmentSumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SegmentSumOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SegmentSumOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SegmentSumOptionsBuilder { typedef SegmentSumOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit SegmentSumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSegmentSumOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateSegmentSumOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { SegmentSumOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSegmentSumOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BatchMatMulOptionsT : public flatbuffers::NativeTable { +struct BatchMatMulOptionsT : public ::flatbuffers::NativeTable { typedef BatchMatMulOptions TableType; bool adj_x = false; bool adj_y = false; bool asymmetric_quantize_inputs = false; }; -struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BatchMatMulOptionsT NativeTableType; typedef BatchMatMulOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -13299,22 +13299,22 @@ struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool asymmetric_quantize_inputs() const { return GetField(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_ADJ_X, 1) && VerifyField(verifier, VT_ADJ_Y, 1) && VerifyField(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) && verifier.EndTable(); } - BatchMatMulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BatchMatMulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BatchMatMulOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BatchMatMulOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BatchMatMulOptionsBuilder { typedef BatchMatMulOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_adj_x(bool adj_x) { fbb_.AddElement(BatchMatMulOptions::VT_ADJ_X, static_cast(adj_x), 0); } @@ -13324,19 +13324,19 @@ struct BatchMatMulOptionsBuilder { void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) { fbb_.AddElement(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast(asymmetric_quantize_inputs), 0); } - explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit BatchMatMulOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBatchMatMulOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateBatchMatMulOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool adj_x = false, bool adj_y = false, bool asymmetric_quantize_inputs = false) { @@ -13347,15 +13347,15 @@ inline flatbuffers::Offset CreateBatchMatMulOptions( return builder_.Finish(); } -flatbuffers::Offset CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBatchMatMulOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct CumsumOptionsT : public flatbuffers::NativeTable { +struct CumsumOptionsT : public ::flatbuffers::NativeTable { typedef CumsumOptions TableType; bool exclusive = false; bool reverse = false; }; -struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef CumsumOptionsT NativeTableType; typedef CumsumOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -13368,40 +13368,40 @@ struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool reverse() const { return GetField(VT_REVERSE, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_EXCLUSIVE, 1) && VerifyField(verifier, VT_REVERSE, 1) && verifier.EndTable(); } - CumsumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(CumsumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + CumsumOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CumsumOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct CumsumOptionsBuilder { typedef CumsumOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_exclusive(bool exclusive) { fbb_.AddElement(CumsumOptions::VT_EXCLUSIVE, static_cast(exclusive), 0); } void add_reverse(bool reverse) { fbb_.AddElement(CumsumOptions::VT_REVERSE, static_cast(reverse), 0); } - explicit CumsumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit CumsumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateCumsumOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateCumsumOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool exclusive = false, bool reverse = false) { CumsumOptionsBuilder builder_(_fbb); @@ -13410,94 +13410,94 @@ inline flatbuffers::Offset CreateCumsumOptions( return builder_.Finish(); } -flatbuffers::Offset CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateCumsumOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BroadcastToOptionsT : public flatbuffers::NativeTable { +struct BroadcastToOptionsT : public ::flatbuffers::NativeTable { typedef BroadcastToOptions TableType; }; -struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BroadcastToOptionsT NativeTableType; typedef BroadcastToOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - BroadcastToOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BroadcastToOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BroadcastToOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BroadcastToOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BroadcastToOptionsBuilder { typedef BroadcastToOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit BroadcastToOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit BroadcastToOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBroadcastToOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateBroadcastToOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { BroadcastToOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBroadcastToOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct Rfft2dOptionsT : public flatbuffers::NativeTable { +struct Rfft2dOptionsT : public ::flatbuffers::NativeTable { typedef Rfft2dOptions TableType; }; -struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef Rfft2dOptionsT NativeTableType; typedef Rfft2dOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - Rfft2dOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(Rfft2dOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + Rfft2dOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Rfft2dOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct Rfft2dOptionsBuilder { typedef Rfft2dOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit Rfft2dOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit Rfft2dOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRfft2dOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateRfft2dOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { Rfft2dOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateRfft2dOptions(::flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct HashtableOptionsT : public flatbuffers::NativeTable { +struct HashtableOptionsT : public ::flatbuffers::NativeTable { typedef HashtableOptions TableType; int32_t table_id = 0; tflite::TensorType key_dtype = tflite::TensorType_FLOAT32; tflite::TensorType value_dtype = tflite::TensorType_FLOAT32; }; -struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef HashtableOptionsT NativeTableType; typedef HashtableOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -13514,22 +13514,22 @@ struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::TensorType value_dtype() const { return static_cast(GetField(VT_VALUE_DTYPE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TABLE_ID, 4) && VerifyField(verifier, VT_KEY_DTYPE, 1) && VerifyField(verifier, VT_VALUE_DTYPE, 1) && verifier.EndTable(); } - HashtableOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(HashtableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + HashtableOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(HashtableOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct HashtableOptionsBuilder { typedef HashtableOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_table_id(int32_t table_id) { fbb_.AddElement(HashtableOptions::VT_TABLE_ID, table_id, 0); } @@ -13539,19 +13539,19 @@ struct HashtableOptionsBuilder { void add_value_dtype(tflite::TensorType value_dtype) { fbb_.AddElement(HashtableOptions::VT_VALUE_DTYPE, static_cast(value_dtype), 0); } - explicit HashtableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit HashtableOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHashtableOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateHashtableOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int32_t table_id = 0, tflite::TensorType key_dtype = tflite::TensorType_FLOAT32, tflite::TensorType value_dtype = tflite::TensorType_FLOAT32) { @@ -13562,145 +13562,145 @@ inline flatbuffers::Offset CreateHashtableOptions( return builder_.Finish(); } -flatbuffers::Offset CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateHashtableOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct HashtableFindOptionsT : public flatbuffers::NativeTable { +struct HashtableFindOptionsT : public ::flatbuffers::NativeTable { typedef HashtableFindOptions TableType; }; -struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef HashtableFindOptionsT NativeTableType; typedef HashtableFindOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - HashtableFindOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(HashtableFindOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + HashtableFindOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(HashtableFindOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct HashtableFindOptionsBuilder { typedef HashtableFindOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit HashtableFindOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit HashtableFindOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHashtableFindOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateHashtableFindOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { HashtableFindOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateHashtableFindOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct HashtableImportOptionsT : public flatbuffers::NativeTable { +struct HashtableImportOptionsT : public ::flatbuffers::NativeTable { typedef HashtableImportOptions TableType; }; -struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef HashtableImportOptionsT NativeTableType; typedef HashtableImportOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - HashtableImportOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(HashtableImportOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + HashtableImportOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(HashtableImportOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct HashtableImportOptionsBuilder { typedef HashtableImportOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit HashtableImportOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit HashtableImportOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHashtableImportOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateHashtableImportOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { HashtableImportOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateHashtableImportOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct HashtableSizeOptionsT : public flatbuffers::NativeTable { +struct HashtableSizeOptionsT : public ::flatbuffers::NativeTable { typedef HashtableSizeOptions TableType; }; -struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef HashtableSizeOptionsT NativeTableType; typedef HashtableSizeOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - HashtableSizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(HashtableSizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + HashtableSizeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(HashtableSizeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct HashtableSizeOptionsBuilder { typedef HashtableSizeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit HashtableSizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit HashtableSizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHashtableSizeOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateHashtableSizeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { HashtableSizeOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateHashtableSizeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct VarHandleOptionsT : public flatbuffers::NativeTable { +struct VarHandleOptionsT : public ::flatbuffers::NativeTable { typedef VarHandleOptions TableType; std::string container{}; std::string shared_name{}; }; -struct VarHandleOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct VarHandleOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef VarHandleOptionsT NativeTableType; typedef VarHandleOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_CONTAINER = 4, VT_SHARED_NAME = 6 }; - const flatbuffers::String *container() const { - return GetPointer(VT_CONTAINER); + const ::flatbuffers::String *container() const { + return GetPointer(VT_CONTAINER); } - const flatbuffers::String *shared_name() const { - return GetPointer(VT_SHARED_NAME); + const ::flatbuffers::String *shared_name() const { + return GetPointer(VT_SHARED_NAME); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CONTAINER) && verifier.VerifyString(container()) && @@ -13708,44 +13708,44 @@ struct VarHandleOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyString(shared_name()) && verifier.EndTable(); } - VarHandleOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(VarHandleOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + VarHandleOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(VarHandleOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct VarHandleOptionsBuilder { typedef VarHandleOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_container(flatbuffers::Offset container) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_container(::flatbuffers::Offset<::flatbuffers::String> container) { fbb_.AddOffset(VarHandleOptions::VT_CONTAINER, container); } - void add_shared_name(flatbuffers::Offset shared_name) { + void add_shared_name(::flatbuffers::Offset<::flatbuffers::String> shared_name) { fbb_.AddOffset(VarHandleOptions::VT_SHARED_NAME, shared_name); } - explicit VarHandleOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VarHandleOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateVarHandleOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset container = 0, - flatbuffers::Offset shared_name = 0) { +inline ::flatbuffers::Offset CreateVarHandleOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::String> container = 0, + ::flatbuffers::Offset<::flatbuffers::String> shared_name = 0) { VarHandleOptionsBuilder builder_(_fbb); builder_.add_shared_name(shared_name); builder_.add_container(container); return builder_.Finish(); } -inline flatbuffers::Offset CreateVarHandleOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateVarHandleOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const char *container = nullptr, const char *shared_name = nullptr) { auto container__ = container ? _fbb.CreateString(container) : 0; @@ -13756,93 +13756,93 @@ inline flatbuffers::Offset CreateVarHandleOptionsDirect( shared_name__); } -flatbuffers::Offset CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateVarHandleOptions(::flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ReadVariableOptionsT : public flatbuffers::NativeTable { +struct ReadVariableOptionsT : public ::flatbuffers::NativeTable { typedef ReadVariableOptions TableType; }; -struct ReadVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ReadVariableOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ReadVariableOptionsT NativeTableType; typedef ReadVariableOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - ReadVariableOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ReadVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ReadVariableOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReadVariableOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ReadVariableOptionsBuilder { typedef ReadVariableOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit ReadVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit ReadVariableOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateReadVariableOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateReadVariableOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { ReadVariableOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateReadVariableOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct AssignVariableOptionsT : public flatbuffers::NativeTable { +struct AssignVariableOptionsT : public ::flatbuffers::NativeTable { typedef AssignVariableOptions TableType; }; -struct AssignVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct AssignVariableOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef AssignVariableOptionsT NativeTableType; typedef AssignVariableOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - AssignVariableOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(AssignVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + AssignVariableOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(AssignVariableOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct AssignVariableOptionsBuilder { typedef AssignVariableOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit AssignVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit AssignVariableOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateAssignVariableOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateAssignVariableOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { AssignVariableOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateAssignVariableOptions(::flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct RandomOptionsT : public flatbuffers::NativeTable { +struct RandomOptionsT : public ::flatbuffers::NativeTable { typedef RandomOptions TableType; int64_t seed = 0; int64_t seed2 = 0; }; -struct RandomOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct RandomOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef RandomOptionsT NativeTableType; typedef RandomOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -13855,40 +13855,40 @@ struct RandomOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int64_t seed2() const { return GetField(VT_SEED2, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_SEED, 8) && VerifyField(verifier, VT_SEED2, 8) && verifier.EndTable(); } - RandomOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RandomOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + RandomOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(RandomOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct RandomOptionsBuilder { typedef RandomOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_seed(int64_t seed) { fbb_.AddElement(RandomOptions::VT_SEED, seed, 0); } void add_seed2(int64_t seed2) { fbb_.AddElement(RandomOptions::VT_SEED2, seed2, 0); } - explicit RandomOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit RandomOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRandomOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateRandomOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, int64_t seed = 0, int64_t seed2 = 0) { RandomOptionsBuilder builder_(_fbb); @@ -13897,61 +13897,61 @@ inline flatbuffers::Offset CreateRandomOptions( return builder_.Finish(); } -flatbuffers::Offset CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateRandomOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BucketizeOptionsT : public flatbuffers::NativeTable { +struct BucketizeOptionsT : public ::flatbuffers::NativeTable { typedef BucketizeOptions TableType; std::vector boundaries{}; }; -struct BucketizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct BucketizeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BucketizeOptionsT NativeTableType; typedef BucketizeOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BOUNDARIES = 4 }; - const flatbuffers::Vector *boundaries() const { - return GetPointer *>(VT_BOUNDARIES); + const ::flatbuffers::Vector *boundaries() const { + return GetPointer *>(VT_BOUNDARIES); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BOUNDARIES) && verifier.VerifyVector(boundaries()) && verifier.EndTable(); } - BucketizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BucketizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BucketizeOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BucketizeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BucketizeOptionsBuilder { typedef BucketizeOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_boundaries(flatbuffers::Offset> boundaries) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_boundaries(::flatbuffers::Offset<::flatbuffers::Vector> boundaries) { fbb_.AddOffset(BucketizeOptions::VT_BOUNDARIES, boundaries); } - explicit BucketizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit BucketizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBucketizeOptions( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> boundaries = 0) { +inline ::flatbuffers::Offset CreateBucketizeOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> boundaries = 0) { BucketizeOptionsBuilder builder_(_fbb); builder_.add_boundaries(boundaries); return builder_.Finish(); } -inline flatbuffers::Offset CreateBucketizeOptionsDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateBucketizeOptionsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *boundaries = nullptr) { auto boundaries__ = boundaries ? _fbb.CreateVector(*boundaries) : 0; return tflite::CreateBucketizeOptions( @@ -13959,14 +13959,14 @@ inline flatbuffers::Offset CreateBucketizeOptionsDirect( boundaries__); } -flatbuffers::Offset CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBucketizeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct GeluOptionsT : public flatbuffers::NativeTable { +struct GeluOptionsT : public ::flatbuffers::NativeTable { typedef GeluOptions TableType; bool approximate = false; }; -struct GeluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct GeluOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef GeluOptionsT NativeTableType; typedef GeluOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -13975,479 +13975,479 @@ struct GeluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool approximate() const { return GetField(VT_APPROXIMATE, 0) != 0; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_APPROXIMATE, 1) && verifier.EndTable(); } - GeluOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(GeluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + GeluOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GeluOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct GeluOptionsBuilder { typedef GeluOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_approximate(bool approximate) { fbb_.AddElement(GeluOptions::VT_APPROXIMATE, static_cast(approximate), 0); } - explicit GeluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit GeluOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateGeluOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateGeluOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, bool approximate = false) { GeluOptionsBuilder builder_(_fbb); builder_.add_approximate(approximate); return builder_.Finish(); } -flatbuffers::Offset CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateGeluOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct DynamicUpdateSliceOptionsT : public flatbuffers::NativeTable { +struct DynamicUpdateSliceOptionsT : public ::flatbuffers::NativeTable { typedef DynamicUpdateSliceOptions TableType; }; -struct DynamicUpdateSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct DynamicUpdateSliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DynamicUpdateSliceOptionsT NativeTableType; typedef DynamicUpdateSliceOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - DynamicUpdateSliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DynamicUpdateSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DynamicUpdateSliceOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DynamicUpdateSliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct DynamicUpdateSliceOptionsBuilder { typedef DynamicUpdateSliceOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit DynamicUpdateSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit DynamicUpdateSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDynamicUpdateSliceOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateDynamicUpdateSliceOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { DynamicUpdateSliceOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateDynamicUpdateSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct UnsortedSegmentProdOptionsT : public flatbuffers::NativeTable { +struct UnsortedSegmentProdOptionsT : public ::flatbuffers::NativeTable { typedef UnsortedSegmentProdOptions TableType; }; -struct UnsortedSegmentProdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct UnsortedSegmentProdOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef UnsortedSegmentProdOptionsT NativeTableType; typedef UnsortedSegmentProdOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - UnsortedSegmentProdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(UnsortedSegmentProdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + UnsortedSegmentProdOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(UnsortedSegmentProdOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct UnsortedSegmentProdOptionsBuilder { typedef UnsortedSegmentProdOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit UnsortedSegmentProdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit UnsortedSegmentProdOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUnsortedSegmentProdOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateUnsortedSegmentProdOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { UnsortedSegmentProdOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUnsortedSegmentProdOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct UnsortedSegmentMaxOptionsT : public flatbuffers::NativeTable { +struct UnsortedSegmentMaxOptionsT : public ::flatbuffers::NativeTable { typedef UnsortedSegmentMaxOptions TableType; }; -struct UnsortedSegmentMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct UnsortedSegmentMaxOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef UnsortedSegmentMaxOptionsT NativeTableType; typedef UnsortedSegmentMaxOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - UnsortedSegmentMaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(UnsortedSegmentMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + UnsortedSegmentMaxOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(UnsortedSegmentMaxOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct UnsortedSegmentMaxOptionsBuilder { typedef UnsortedSegmentMaxOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit UnsortedSegmentMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit UnsortedSegmentMaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUnsortedSegmentMaxOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateUnsortedSegmentMaxOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { UnsortedSegmentMaxOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUnsortedSegmentMaxOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct UnsortedSegmentSumOptionsT : public flatbuffers::NativeTable { +struct UnsortedSegmentSumOptionsT : public ::flatbuffers::NativeTable { typedef UnsortedSegmentSumOptions TableType; }; -struct UnsortedSegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct UnsortedSegmentSumOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef UnsortedSegmentSumOptionsT NativeTableType; typedef UnsortedSegmentSumOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - UnsortedSegmentSumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(UnsortedSegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + UnsortedSegmentSumOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(UnsortedSegmentSumOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct UnsortedSegmentSumOptionsBuilder { typedef UnsortedSegmentSumOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit UnsortedSegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit UnsortedSegmentSumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUnsortedSegmentSumOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateUnsortedSegmentSumOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { UnsortedSegmentSumOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUnsortedSegmentSumOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ATan2OptionsT : public flatbuffers::NativeTable { +struct ATan2OptionsT : public ::flatbuffers::NativeTable { typedef ATan2Options TableType; }; -struct ATan2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ATan2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ATan2OptionsT NativeTableType; typedef ATan2OptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - ATan2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ATan2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ATan2OptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ATan2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ATan2OptionsBuilder { typedef ATan2Options Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit ATan2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit ATan2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateATan2Options( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateATan2Options( + ::flatbuffers::FlatBufferBuilder &_fbb) { ATan2OptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateATan2Options(::flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct UnsortedSegmentMinOptionsT : public flatbuffers::NativeTable { +struct UnsortedSegmentMinOptionsT : public ::flatbuffers::NativeTable { typedef UnsortedSegmentMinOptions TableType; }; -struct UnsortedSegmentMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct UnsortedSegmentMinOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef UnsortedSegmentMinOptionsT NativeTableType; typedef UnsortedSegmentMinOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - UnsortedSegmentMinOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(UnsortedSegmentMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + UnsortedSegmentMinOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(UnsortedSegmentMinOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct UnsortedSegmentMinOptionsBuilder { typedef UnsortedSegmentMinOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit UnsortedSegmentMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit UnsortedSegmentMinOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUnsortedSegmentMinOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateUnsortedSegmentMinOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { UnsortedSegmentMinOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateUnsortedSegmentMinOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SignOptionsT : public flatbuffers::NativeTable { +struct SignOptionsT : public ::flatbuffers::NativeTable { typedef SignOptions TableType; }; -struct SignOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SignOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SignOptionsT NativeTableType; typedef SignOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - SignOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SignOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SignOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SignOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SignOptionsBuilder { typedef SignOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit SignOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit SignOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSignOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateSignOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { SignOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSignOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BitcastOptionsT : public flatbuffers::NativeTable { +struct BitcastOptionsT : public ::flatbuffers::NativeTable { typedef BitcastOptions TableType; }; -struct BitcastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct BitcastOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BitcastOptionsT NativeTableType; typedef BitcastOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - BitcastOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BitcastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BitcastOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BitcastOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BitcastOptionsBuilder { typedef BitcastOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit BitcastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit BitcastOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBitcastOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateBitcastOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { BitcastOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateBitcastOptions(flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBitcastOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BitwiseXorOptionsT : public flatbuffers::NativeTable { +struct BitwiseXorOptionsT : public ::flatbuffers::NativeTable { typedef BitwiseXorOptions TableType; }; -struct BitwiseXorOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct BitwiseXorOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BitwiseXorOptionsT NativeTableType; typedef BitwiseXorOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - BitwiseXorOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BitwiseXorOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BitwiseXorOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BitwiseXorOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BitwiseXorOptionsBuilder { typedef BitwiseXorOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit BitwiseXorOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit BitwiseXorOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBitwiseXorOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateBitwiseXorOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { BitwiseXorOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateBitwiseXorOptions(flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBitwiseXorOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct RightShiftOptionsT : public flatbuffers::NativeTable { +struct RightShiftOptionsT : public ::flatbuffers::NativeTable { typedef RightShiftOptions TableType; }; -struct RightShiftOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct RightShiftOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef RightShiftOptionsT NativeTableType; typedef RightShiftOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - RightShiftOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RightShiftOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + RightShiftOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(RightShiftOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct RightShiftOptionsBuilder { typedef RightShiftOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit RightShiftOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit RightShiftOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRightShiftOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateRightShiftOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { RightShiftOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateRightShiftOptions(flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateRightShiftOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct DilateOptionsT : public flatbuffers::NativeTable { +struct DilateOptionsT : public ::flatbuffers::NativeTable { typedef DilateOptions TableType; }; -struct DilateOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct DilateOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DilateOptionsT NativeTableType; typedef DilateOptionsBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - DilateOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(DilateOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + DilateOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DilateOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct DilateOptionsBuilder { typedef DilateOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit DilateOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit DilateOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDilateOptions( - flatbuffers::FlatBufferBuilder &_fbb) { +inline ::flatbuffers::Offset CreateDilateOptions( + ::flatbuffers::FlatBufferBuilder &_fbb) { DilateOptionsBuilder builder_(_fbb); return builder_.Finish(); } -flatbuffers::Offset CreateDilateOptions(flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateDilateOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ReduceWindowOptionsT : public flatbuffers::NativeTable { +struct ReduceWindowOptionsT : public ::flatbuffers::NativeTable { typedef ReduceWindowOptions TableType; tflite::ReduceWindowFunction reduce_function = tflite::ReduceWindowFunction_UNSUPPORTED; }; -struct ReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct ReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ReduceWindowOptionsT NativeTableType; typedef ReduceWindowOptionsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -14456,45 +14456,45 @@ struct ReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table tflite::ReduceWindowFunction reduce_function() const { return static_cast(GetField(VT_REDUCE_FUNCTION, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_REDUCE_FUNCTION, 4) && verifier.EndTable(); } - ReduceWindowOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ReduceWindowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ReduceWindowOptionsT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReduceWindowOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ReduceWindowOptionsBuilder { typedef ReduceWindowOptions Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_reduce_function(tflite::ReduceWindowFunction reduce_function) { fbb_.AddElement(ReduceWindowOptions::VT_REDUCE_FUNCTION, static_cast(reduce_function), 0); } - explicit ReduceWindowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ReduceWindowOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateReduceWindowOptions( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateReduceWindowOptions( + ::flatbuffers::FlatBufferBuilder &_fbb, tflite::ReduceWindowFunction reduce_function = tflite::ReduceWindowFunction_UNSUPPORTED) { ReduceWindowOptionsBuilder builder_(_fbb); builder_.add_reduce_function(reduce_function); return builder_.Finish(); } -flatbuffers::Offset CreateReduceWindowOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateReduceWindowOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct OperatorCodeT : public flatbuffers::NativeTable { +struct OperatorCodeT : public ::flatbuffers::NativeTable { typedef OperatorCode TableType; int8_t deprecated_builtin_code = 0; std::string custom_code{}; @@ -14502,7 +14502,7 @@ struct OperatorCodeT : public flatbuffers::NativeTable { tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD; }; -struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct OperatorCode FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef OperatorCodeT NativeTableType; typedef OperatorCodeBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -14514,8 +14514,8 @@ struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int8_t deprecated_builtin_code() const { return GetField(VT_DEPRECATED_BUILTIN_CODE, 0); } - const flatbuffers::String *custom_code() const { - return GetPointer(VT_CUSTOM_CODE); + const ::flatbuffers::String *custom_code() const { + return GetPointer(VT_CUSTOM_CODE); } int32_t version() const { return GetField(VT_VERSION, 1); @@ -14523,7 +14523,7 @@ struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { tflite::BuiltinOperator builtin_code() const { return static_cast(GetField(VT_BUILTIN_CODE, 0)); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_DEPRECATED_BUILTIN_CODE, 1) && VerifyOffset(verifier, VT_CUSTOM_CODE) && @@ -14532,19 +14532,19 @@ struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_BUILTIN_CODE, 4) && verifier.EndTable(); } - OperatorCodeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + OperatorCodeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(OperatorCodeT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct OperatorCodeBuilder { typedef OperatorCode Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_deprecated_builtin_code(int8_t deprecated_builtin_code) { fbb_.AddElement(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, 0); } - void add_custom_code(flatbuffers::Offset custom_code) { + void add_custom_code(::flatbuffers::Offset<::flatbuffers::String> custom_code) { fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code); } void add_version(int32_t version) { @@ -14553,21 +14553,21 @@ struct OperatorCodeBuilder { void add_builtin_code(tflite::BuiltinOperator builtin_code) { fbb_.AddElement(OperatorCode::VT_BUILTIN_CODE, static_cast(builtin_code), 0); } - explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit OperatorCodeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOperatorCode( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateOperatorCode( + ::flatbuffers::FlatBufferBuilder &_fbb, int8_t deprecated_builtin_code = 0, - flatbuffers::Offset custom_code = 0, + ::flatbuffers::Offset<::flatbuffers::String> custom_code = 0, int32_t version = 1, tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD) { OperatorCodeBuilder builder_(_fbb); @@ -14578,8 +14578,8 @@ inline flatbuffers::Offset CreateOperatorCode( return builder_.Finish(); } -inline flatbuffers::Offset CreateOperatorCodeDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateOperatorCodeDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, int8_t deprecated_builtin_code = 0, const char *custom_code = nullptr, int32_t version = 1, @@ -14593,9 +14593,9 @@ inline flatbuffers::Offset CreateOperatorCodeDirect( builtin_code); } -flatbuffers::Offset CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateOperatorCode(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct OperatorT : public flatbuffers::NativeTable { +struct OperatorT : public ::flatbuffers::NativeTable { typedef Operator TableType; uint32_t opcode_index = 0; std::vector inputs{}; @@ -14610,7 +14610,7 @@ struct OperatorT : public flatbuffers::NativeTable { tflite::BuiltinOptions2Union builtin_options_2{}; }; -struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Operator FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef OperatorT NativeTableType; typedef OperatorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -14631,11 +14631,11 @@ struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { uint32_t opcode_index() const { return GetField(VT_OPCODE_INDEX, 0); } - const flatbuffers::Vector *inputs() const { - return GetPointer *>(VT_INPUTS); + const ::flatbuffers::Vector *inputs() const { + return GetPointer *>(VT_INPUTS); } - const flatbuffers::Vector *outputs() const { - return GetPointer *>(VT_OUTPUTS); + const ::flatbuffers::Vector *outputs() const { + return GetPointer *>(VT_OUTPUTS); } tflite::BuiltinOptions builtin_options_type() const { return static_cast(GetField(VT_BUILTIN_OPTIONS_TYPE, 0)); @@ -15022,17 +15022,17 @@ struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const tflite::RightShiftOptions *builtin_options_as_RightShiftOptions() const { return builtin_options_type() == tflite::BuiltinOptions_RightShiftOptions ? static_cast(builtin_options()) : nullptr; } - const flatbuffers::Vector *custom_options() const { - return GetPointer *>(VT_CUSTOM_OPTIONS); + const ::flatbuffers::Vector *custom_options() const { + return GetPointer *>(VT_CUSTOM_OPTIONS); } tflite::CustomOptionsFormat custom_options_format() const { return static_cast(GetField(VT_CUSTOM_OPTIONS_FORMAT, 0)); } - const flatbuffers::Vector *mutating_variable_inputs() const { - return GetPointer *>(VT_MUTATING_VARIABLE_INPUTS); + const ::flatbuffers::Vector *mutating_variable_inputs() const { + return GetPointer *>(VT_MUTATING_VARIABLE_INPUTS); } - const flatbuffers::Vector *intermediates() const { - return GetPointer *>(VT_INTERMEDIATES); + const ::flatbuffers::Vector *intermediates() const { + return GetPointer *>(VT_INTERMEDIATES); } uint64_t large_custom_options_offset() const { return GetField(VT_LARGE_CUSTOM_OPTIONS_OFFSET, 0); @@ -15107,7 +15107,7 @@ struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const tflite::ReduceWindowOptions *builtin_options_2_as_ReduceWindowOptions() const { return builtin_options_2_type() == tflite::BuiltinOptions2_ReduceWindowOptions ? static_cast(builtin_options_2()) : nullptr; } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_OPCODE_INDEX, 4) && VerifyOffset(verifier, VT_INPUTS) && @@ -15131,9 +15131,9 @@ struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyBuiltinOptions2(verifier, builtin_options_2(), builtin_options_2_type()) && verifier.EndTable(); } - OperatorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + OperatorT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(OperatorT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; template<> inline const tflite::Conv2DOptions *Operator::builtin_options_as() const { @@ -15722,33 +15722,33 @@ template<> inline const tflite::ReduceWindowOptions *Operator::builtin_options_2 struct OperatorBuilder { typedef Operator Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_opcode_index(uint32_t opcode_index) { fbb_.AddElement(Operator::VT_OPCODE_INDEX, opcode_index, 0); } - void add_inputs(flatbuffers::Offset> inputs) { + void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector> inputs) { fbb_.AddOffset(Operator::VT_INPUTS, inputs); } - void add_outputs(flatbuffers::Offset> outputs) { + void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector> outputs) { fbb_.AddOffset(Operator::VT_OUTPUTS, outputs); } void add_builtin_options_type(tflite::BuiltinOptions builtin_options_type) { fbb_.AddElement(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast(builtin_options_type), 0); } - void add_builtin_options(flatbuffers::Offset builtin_options) { + void add_builtin_options(::flatbuffers::Offset builtin_options) { fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options); } - void add_custom_options(flatbuffers::Offset> custom_options) { + void add_custom_options(::flatbuffers::Offset<::flatbuffers::Vector> custom_options) { fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options); } void add_custom_options_format(tflite::CustomOptionsFormat custom_options_format) { fbb_.AddElement(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast(custom_options_format), 0); } - void add_mutating_variable_inputs(flatbuffers::Offset> mutating_variable_inputs) { + void add_mutating_variable_inputs(::flatbuffers::Offset<::flatbuffers::Vector> mutating_variable_inputs) { fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs); } - void add_intermediates(flatbuffers::Offset> intermediates) { + void add_intermediates(::flatbuffers::Offset<::flatbuffers::Vector> intermediates) { fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates); } void add_large_custom_options_offset(uint64_t large_custom_options_offset) { @@ -15760,35 +15760,35 @@ struct OperatorBuilder { void add_builtin_options_2_type(tflite::BuiltinOptions2 builtin_options_2_type) { fbb_.AddElement(Operator::VT_BUILTIN_OPTIONS_2_TYPE, static_cast(builtin_options_2_type), 0); } - void add_builtin_options_2(flatbuffers::Offset builtin_options_2) { + void add_builtin_options_2(::flatbuffers::Offset builtin_options_2) { fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS_2, builtin_options_2); } - explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit OperatorBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOperator( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateOperator( + ::flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0, - flatbuffers::Offset> inputs = 0, - flatbuffers::Offset> outputs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> inputs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> outputs = 0, tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE, - flatbuffers::Offset builtin_options = 0, - flatbuffers::Offset> custom_options = 0, + ::flatbuffers::Offset builtin_options = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> custom_options = 0, tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS, - flatbuffers::Offset> mutating_variable_inputs = 0, - flatbuffers::Offset> intermediates = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> mutating_variable_inputs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> intermediates = 0, uint64_t large_custom_options_offset = 0, uint64_t large_custom_options_size = 0, tflite::BuiltinOptions2 builtin_options_2_type = tflite::BuiltinOptions2_NONE, - flatbuffers::Offset builtin_options_2 = 0) { + ::flatbuffers::Offset builtin_options_2 = 0) { OperatorBuilder builder_(_fbb); builder_.add_large_custom_options_size(large_custom_options_size); builder_.add_large_custom_options_offset(large_custom_options_offset); @@ -15806,13 +15806,13 @@ inline flatbuffers::Offset CreateOperator( return builder_.Finish(); } -inline flatbuffers::Offset CreateOperatorDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateOperatorDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0, const std::vector *inputs = nullptr, const std::vector *outputs = nullptr, tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE, - flatbuffers::Offset builtin_options = 0, + ::flatbuffers::Offset builtin_options = 0, const std::vector *custom_options = nullptr, tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS, const std::vector *mutating_variable_inputs = nullptr, @@ -15820,7 +15820,7 @@ inline flatbuffers::Offset CreateOperatorDirect( uint64_t large_custom_options_offset = 0, uint64_t large_custom_options_size = 0, tflite::BuiltinOptions2 builtin_options_2_type = tflite::BuiltinOptions2_NONE, - flatbuffers::Offset builtin_options_2 = 0) { + ::flatbuffers::Offset builtin_options_2 = 0) { auto inputs__ = inputs ? _fbb.CreateVector(*inputs) : 0; auto outputs__ = outputs ? _fbb.CreateVector(*outputs) : 0; auto custom_options__ = custom_options ? _fbb.CreateVector(*custom_options) : 0; @@ -15843,9 +15843,9 @@ inline flatbuffers::Offset CreateOperatorDirect( builtin_options_2); } -flatbuffers::Offset CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateOperator(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SubGraphT : public flatbuffers::NativeTable { +struct SubGraphT : public ::flatbuffers::NativeTable { typedef SubGraph TableType; std::vector> tensors{}; std::vector inputs{}; @@ -15858,7 +15858,7 @@ struct SubGraphT : public flatbuffers::NativeTable { SubGraphT &operator=(SubGraphT o) FLATBUFFERS_NOEXCEPT; }; -struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SubGraph FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SubGraphT NativeTableType; typedef SubGraphBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -15868,22 +15868,22 @@ struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_OPERATORS = 10, VT_NAME = 12 }; - const flatbuffers::Vector> *tensors() const { - return GetPointer> *>(VT_TENSORS); + const ::flatbuffers::Vector<::flatbuffers::Offset> *tensors() const { + return GetPointer> *>(VT_TENSORS); } - const flatbuffers::Vector *inputs() const { - return GetPointer *>(VT_INPUTS); + const ::flatbuffers::Vector *inputs() const { + return GetPointer *>(VT_INPUTS); } - const flatbuffers::Vector *outputs() const { - return GetPointer *>(VT_OUTPUTS); + const ::flatbuffers::Vector *outputs() const { + return GetPointer *>(VT_OUTPUTS); } - const flatbuffers::Vector> *operators() const { - return GetPointer> *>(VT_OPERATORS); + const ::flatbuffers::Vector<::flatbuffers::Offset> *operators() const { + return GetPointer> *>(VT_OPERATORS); } - const flatbuffers::String *name() const { - return GetPointer(VT_NAME); + const ::flatbuffers::String *name() const { + return GetPointer(VT_NAME); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TENSORS) && verifier.VerifyVector(tensors()) && @@ -15899,48 +15899,48 @@ struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyString(name()) && verifier.EndTable(); } - SubGraphT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SubGraphT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SubGraphT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SubGraphBuilder { typedef SubGraph Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_tensors(flatbuffers::Offset>> tensors) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_tensors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> tensors) { fbb_.AddOffset(SubGraph::VT_TENSORS, tensors); } - void add_inputs(flatbuffers::Offset> inputs) { + void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector> inputs) { fbb_.AddOffset(SubGraph::VT_INPUTS, inputs); } - void add_outputs(flatbuffers::Offset> outputs) { + void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector> outputs) { fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs); } - void add_operators(flatbuffers::Offset>> operators) { + void add_operators(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> operators) { fbb_.AddOffset(SubGraph::VT_OPERATORS, operators); } - void add_name(flatbuffers::Offset name) { + void add_name(::flatbuffers::Offset<::flatbuffers::String> name) { fbb_.AddOffset(SubGraph::VT_NAME, name); } - explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SubGraphBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSubGraph( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> tensors = 0, - flatbuffers::Offset> inputs = 0, - flatbuffers::Offset> outputs = 0, - flatbuffers::Offset>> operators = 0, - flatbuffers::Offset name = 0) { +inline ::flatbuffers::Offset CreateSubGraph( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> tensors = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> inputs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> outputs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> operators = 0, + ::flatbuffers::Offset<::flatbuffers::String> name = 0) { SubGraphBuilder builder_(_fbb); builder_.add_name(name); builder_.add_operators(operators); @@ -15950,17 +15950,17 @@ inline flatbuffers::Offset CreateSubGraph( return builder_.Finish(); } -inline flatbuffers::Offset CreateSubGraphDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *tensors = nullptr, +inline ::flatbuffers::Offset CreateSubGraphDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *tensors = nullptr, const std::vector *inputs = nullptr, const std::vector *outputs = nullptr, - const std::vector> *operators = nullptr, + const std::vector<::flatbuffers::Offset> *operators = nullptr, const char *name = nullptr) { - auto tensors__ = tensors ? _fbb.CreateVector>(*tensors) : 0; + auto tensors__ = tensors ? _fbb.CreateVector<::flatbuffers::Offset>(*tensors) : 0; auto inputs__ = inputs ? _fbb.CreateVector(*inputs) : 0; auto outputs__ = outputs ? _fbb.CreateVector(*outputs) : 0; - auto operators__ = operators ? _fbb.CreateVector>(*operators) : 0; + auto operators__ = operators ? _fbb.CreateVector<::flatbuffers::Offset>(*operators) : 0; auto name__ = name ? _fbb.CreateString(name) : 0; return tflite::CreateSubGraph( _fbb, @@ -15971,16 +15971,16 @@ inline flatbuffers::Offset CreateSubGraphDirect( name__); } -flatbuffers::Offset CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSubGraph(::flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct BufferT : public flatbuffers::NativeTable { +struct BufferT : public ::flatbuffers::NativeTable { typedef Buffer TableType; std::vector data{}; uint64_t offset = 0; uint64_t size = 0; }; -struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Buffer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BufferT NativeTableType; typedef BufferBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -15988,8 +15988,8 @@ struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_OFFSET = 6, VT_SIZE = 8 }; - const flatbuffers::Vector *data() const { - return GetPointer *>(VT_DATA); + const ::flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); } uint64_t offset() const { return GetField(VT_OFFSET, 0); @@ -15997,7 +15997,7 @@ struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { uint64_t size() const { return GetField(VT_SIZE, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DATA) && verifier.VerifyVector(data()) && @@ -16005,16 +16005,16 @@ struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_SIZE, 8) && verifier.EndTable(); } - BufferT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + BufferT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BufferT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct BufferBuilder { typedef Buffer Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_data(flatbuffers::Offset> data) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_data(::flatbuffers::Offset<::flatbuffers::Vector> data) { fbb_.AddOffset(Buffer::VT_DATA, data); } void add_offset(uint64_t offset) { @@ -16023,20 +16023,20 @@ struct BufferBuilder { void add_size(uint64_t size) { fbb_.AddElement(Buffer::VT_SIZE, size, 0); } - explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit BufferBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateBuffer( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> data = 0, +inline ::flatbuffers::Offset CreateBuffer( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> data = 0, uint64_t offset = 0, uint64_t size = 0) { BufferBuilder builder_(_fbb); @@ -16046,8 +16046,8 @@ inline flatbuffers::Offset CreateBuffer( return builder_.Finish(); } -inline flatbuffers::Offset CreateBufferDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateBufferDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *data = nullptr, uint64_t offset = 0, uint64_t size = 0) { @@ -16060,63 +16060,63 @@ inline flatbuffers::Offset CreateBufferDirect( size); } -flatbuffers::Offset CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateBuffer(::flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct MetadataT : public flatbuffers::NativeTable { +struct MetadataT : public ::flatbuffers::NativeTable { typedef Metadata TableType; std::string name{}; uint32_t buffer = 0; }; -struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Metadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MetadataT NativeTableType; typedef MetadataBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_NAME = 4, VT_BUFFER = 6 }; - const flatbuffers::String *name() const { - return GetPointer(VT_NAME); + const ::flatbuffers::String *name() const { + return GetPointer(VT_NAME); } uint32_t buffer() const { return GetField(VT_BUFFER, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) && verifier.VerifyString(name()) && VerifyField(verifier, VT_BUFFER, 4) && verifier.EndTable(); } - MetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + MetadataT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MetadataT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct MetadataBuilder { typedef Metadata Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_name(flatbuffers::Offset name) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_name(::flatbuffers::Offset<::flatbuffers::String> name) { fbb_.AddOffset(Metadata::VT_NAME, name); } void add_buffer(uint32_t buffer) { fbb_.AddElement(Metadata::VT_BUFFER, buffer, 0); } - explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit MetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMetadata( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset name = 0, +inline ::flatbuffers::Offset CreateMetadata( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::String> name = 0, uint32_t buffer = 0) { MetadataBuilder builder_(_fbb); builder_.add_buffer(buffer); @@ -16124,8 +16124,8 @@ inline flatbuffers::Offset CreateMetadata( return builder_.Finish(); } -inline flatbuffers::Offset CreateMetadataDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateMetadataDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr, uint32_t buffer = 0) { auto name__ = name ? _fbb.CreateString(name) : 0; @@ -16135,63 +16135,63 @@ inline flatbuffers::Offset CreateMetadataDirect( buffer); } -flatbuffers::Offset CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateMetadata(::flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct TensorMapT : public flatbuffers::NativeTable { +struct TensorMapT : public ::flatbuffers::NativeTable { typedef TensorMap TableType; std::string name{}; uint32_t tensor_index = 0; }; -struct TensorMap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct TensorMap FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef TensorMapT NativeTableType; typedef TensorMapBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_NAME = 4, VT_TENSOR_INDEX = 6 }; - const flatbuffers::String *name() const { - return GetPointer(VT_NAME); + const ::flatbuffers::String *name() const { + return GetPointer(VT_NAME); } uint32_t tensor_index() const { return GetField(VT_TENSOR_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) && verifier.VerifyString(name()) && VerifyField(verifier, VT_TENSOR_INDEX, 4) && verifier.EndTable(); } - TensorMapT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(TensorMapT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + TensorMapT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TensorMapT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct TensorMapBuilder { typedef TensorMap Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_name(flatbuffers::Offset name) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_name(::flatbuffers::Offset<::flatbuffers::String> name) { fbb_.AddOffset(TensorMap::VT_NAME, name); } void add_tensor_index(uint32_t tensor_index) { fbb_.AddElement(TensorMap::VT_TENSOR_INDEX, tensor_index, 0); } - explicit TensorMapBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TensorMapBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTensorMap( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset name = 0, +inline ::flatbuffers::Offset CreateTensorMap( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::String> name = 0, uint32_t tensor_index = 0) { TensorMapBuilder builder_(_fbb); builder_.add_tensor_index(tensor_index); @@ -16199,8 +16199,8 @@ inline flatbuffers::Offset CreateTensorMap( return builder_.Finish(); } -inline flatbuffers::Offset CreateTensorMapDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateTensorMapDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const char *name = nullptr, uint32_t tensor_index = 0) { auto name__ = name ? _fbb.CreateString(name) : 0; @@ -16210,9 +16210,9 @@ inline flatbuffers::Offset CreateTensorMapDirect( tensor_index); } -flatbuffers::Offset CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateTensorMap(::flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct SignatureDefT : public flatbuffers::NativeTable { +struct SignatureDefT : public ::flatbuffers::NativeTable { typedef SignatureDef TableType; std::vector> inputs{}; std::vector> outputs{}; @@ -16224,7 +16224,7 @@ struct SignatureDefT : public flatbuffers::NativeTable { SignatureDefT &operator=(SignatureDefT o) FLATBUFFERS_NOEXCEPT; }; -struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct SignatureDef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef SignatureDefT NativeTableType; typedef SignatureDefBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -16233,19 +16233,19 @@ struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_SIGNATURE_KEY = 8, VT_SUBGRAPH_INDEX = 12 }; - const flatbuffers::Vector> *inputs() const { - return GetPointer> *>(VT_INPUTS); + const ::flatbuffers::Vector<::flatbuffers::Offset> *inputs() const { + return GetPointer> *>(VT_INPUTS); } - const flatbuffers::Vector> *outputs() const { - return GetPointer> *>(VT_OUTPUTS); + const ::flatbuffers::Vector<::flatbuffers::Offset> *outputs() const { + return GetPointer> *>(VT_OUTPUTS); } - const flatbuffers::String *signature_key() const { - return GetPointer(VT_SIGNATURE_KEY); + const ::flatbuffers::String *signature_key() const { + return GetPointer(VT_SIGNATURE_KEY); } uint32_t subgraph_index() const { return GetField(VT_SUBGRAPH_INDEX, 0); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) && @@ -16258,43 +16258,43 @@ struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_SUBGRAPH_INDEX, 4) && verifier.EndTable(); } - SignatureDefT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(SignatureDefT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + SignatureDefT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SignatureDefT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct SignatureDefBuilder { typedef SignatureDef Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_inputs(flatbuffers::Offset>> inputs) { + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> inputs) { fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs); } - void add_outputs(flatbuffers::Offset>> outputs) { + void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> outputs) { fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs); } - void add_signature_key(flatbuffers::Offset signature_key) { + void add_signature_key(::flatbuffers::Offset<::flatbuffers::String> signature_key) { fbb_.AddOffset(SignatureDef::VT_SIGNATURE_KEY, signature_key); } void add_subgraph_index(uint32_t subgraph_index) { fbb_.AddElement(SignatureDef::VT_SUBGRAPH_INDEX, subgraph_index, 0); } - explicit SignatureDefBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SignatureDefBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSignatureDef( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> inputs = 0, - flatbuffers::Offset>> outputs = 0, - flatbuffers::Offset signature_key = 0, +inline ::flatbuffers::Offset CreateSignatureDef( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> inputs = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> outputs = 0, + ::flatbuffers::Offset<::flatbuffers::String> signature_key = 0, uint32_t subgraph_index = 0) { SignatureDefBuilder builder_(_fbb); builder_.add_subgraph_index(subgraph_index); @@ -16304,14 +16304,14 @@ inline flatbuffers::Offset CreateSignatureDef( return builder_.Finish(); } -inline flatbuffers::Offset CreateSignatureDefDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *inputs = nullptr, - const std::vector> *outputs = nullptr, +inline ::flatbuffers::Offset CreateSignatureDefDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *inputs = nullptr, + const std::vector<::flatbuffers::Offset> *outputs = nullptr, const char *signature_key = nullptr, uint32_t subgraph_index = 0) { - auto inputs__ = inputs ? _fbb.CreateVector>(*inputs) : 0; - auto outputs__ = outputs ? _fbb.CreateVector>(*outputs) : 0; + auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset>(*inputs) : 0; + auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset>(*outputs) : 0; auto signature_key__ = signature_key ? _fbb.CreateString(signature_key) : 0; return tflite::CreateSignatureDef( _fbb, @@ -16321,9 +16321,9 @@ inline flatbuffers::Offset CreateSignatureDefDirect( subgraph_index); } -flatbuffers::Offset CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateSignatureDef(::flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct ModelT : public flatbuffers::NativeTable { +struct ModelT : public ::flatbuffers::NativeTable { typedef Model TableType; uint32_t version = 0; std::vector> operator_codes{}; @@ -16339,7 +16339,7 @@ struct ModelT : public flatbuffers::NativeTable { ModelT &operator=(ModelT o) FLATBUFFERS_NOEXCEPT; }; -struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { +struct Model FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef ModelT NativeTableType; typedef ModelBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -16355,28 +16355,28 @@ struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { uint32_t version() const { return GetField(VT_VERSION, 0); } - const flatbuffers::Vector> *operator_codes() const { - return GetPointer> *>(VT_OPERATOR_CODES); + const ::flatbuffers::Vector<::flatbuffers::Offset> *operator_codes() const { + return GetPointer> *>(VT_OPERATOR_CODES); } - const flatbuffers::Vector> *subgraphs() const { - return GetPointer> *>(VT_SUBGRAPHS); + const ::flatbuffers::Vector<::flatbuffers::Offset> *subgraphs() const { + return GetPointer> *>(VT_SUBGRAPHS); } - const flatbuffers::String *description() const { - return GetPointer(VT_DESCRIPTION); + const ::flatbuffers::String *description() const { + return GetPointer(VT_DESCRIPTION); } - const flatbuffers::Vector> *buffers() const { - return GetPointer> *>(VT_BUFFERS); + const ::flatbuffers::Vector<::flatbuffers::Offset> *buffers() const { + return GetPointer> *>(VT_BUFFERS); } - const flatbuffers::Vector *metadata_buffer() const { - return GetPointer *>(VT_METADATA_BUFFER); + const ::flatbuffers::Vector *metadata_buffer() const { + return GetPointer *>(VT_METADATA_BUFFER); } - const flatbuffers::Vector> *metadata() const { - return GetPointer> *>(VT_METADATA); + const ::flatbuffers::Vector<::flatbuffers::Offset> *metadata() const { + return GetPointer> *>(VT_METADATA); } - const flatbuffers::Vector> *signature_defs() const { - return GetPointer> *>(VT_SIGNATURE_DEFS); + const ::flatbuffers::Vector<::flatbuffers::Offset> *signature_defs() const { + return GetPointer> *>(VT_SIGNATURE_DEFS); } - bool Verify(flatbuffers::Verifier &verifier) const { + bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_VERSION, 4) && VerifyOffset(verifier, VT_OPERATOR_CODES) && @@ -16400,60 +16400,60 @@ struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyVectorOfTables(signature_defs()) && verifier.EndTable(); } - ModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; - static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + ModelT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ModelT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; struct ModelBuilder { typedef Model Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; void add_version(uint32_t version) { fbb_.AddElement(Model::VT_VERSION, version, 0); } - void add_operator_codes(flatbuffers::Offset>> operator_codes) { + void add_operator_codes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> operator_codes) { fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes); } - void add_subgraphs(flatbuffers::Offset>> subgraphs) { + void add_subgraphs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> subgraphs) { fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs); } - void add_description(flatbuffers::Offset description) { + void add_description(::flatbuffers::Offset<::flatbuffers::String> description) { fbb_.AddOffset(Model::VT_DESCRIPTION, description); } - void add_buffers(flatbuffers::Offset>> buffers) { + void add_buffers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> buffers) { fbb_.AddOffset(Model::VT_BUFFERS, buffers); } - void add_metadata_buffer(flatbuffers::Offset> metadata_buffer) { + void add_metadata_buffer(::flatbuffers::Offset<::flatbuffers::Vector> metadata_buffer) { fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer); } - void add_metadata(flatbuffers::Offset>> metadata) { + void add_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> metadata) { fbb_.AddOffset(Model::VT_METADATA, metadata); } - void add_signature_defs(flatbuffers::Offset>> signature_defs) { + void add_signature_defs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> signature_defs) { fbb_.AddOffset(Model::VT_SIGNATURE_DEFS, signature_defs); } - explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ModelBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateModel( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateModel( + ::flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0, - flatbuffers::Offset>> operator_codes = 0, - flatbuffers::Offset>> subgraphs = 0, - flatbuffers::Offset description = 0, - flatbuffers::Offset>> buffers = 0, - flatbuffers::Offset> metadata_buffer = 0, - flatbuffers::Offset>> metadata = 0, - flatbuffers::Offset>> signature_defs = 0) { + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> operator_codes = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> subgraphs = 0, + ::flatbuffers::Offset<::flatbuffers::String> description = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> buffers = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> metadata_buffer = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> metadata = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> signature_defs = 0) { ModelBuilder builder_(_fbb); builder_.add_signature_defs(signature_defs); builder_.add_metadata(metadata); @@ -16466,23 +16466,23 @@ inline flatbuffers::Offset CreateModel( return builder_.Finish(); } -inline flatbuffers::Offset CreateModelDirect( - flatbuffers::FlatBufferBuilder &_fbb, +inline ::flatbuffers::Offset CreateModelDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0, - const std::vector> *operator_codes = nullptr, - const std::vector> *subgraphs = nullptr, + const std::vector<::flatbuffers::Offset> *operator_codes = nullptr, + const std::vector<::flatbuffers::Offset> *subgraphs = nullptr, const char *description = nullptr, - const std::vector> *buffers = nullptr, + const std::vector<::flatbuffers::Offset> *buffers = nullptr, const std::vector *metadata_buffer = nullptr, - const std::vector> *metadata = nullptr, - const std::vector> *signature_defs = nullptr) { - auto operator_codes__ = operator_codes ? _fbb.CreateVector>(*operator_codes) : 0; - auto subgraphs__ = subgraphs ? _fbb.CreateVector>(*subgraphs) : 0; + const std::vector<::flatbuffers::Offset> *metadata = nullptr, + const std::vector<::flatbuffers::Offset> *signature_defs = nullptr) { + auto operator_codes__ = operator_codes ? _fbb.CreateVector<::flatbuffers::Offset>(*operator_codes) : 0; + auto subgraphs__ = subgraphs ? _fbb.CreateVector<::flatbuffers::Offset>(*subgraphs) : 0; auto description__ = description ? _fbb.CreateString(description) : 0; - auto buffers__ = buffers ? _fbb.CreateVector>(*buffers) : 0; + auto buffers__ = buffers ? _fbb.CreateVector<::flatbuffers::Offset>(*buffers) : 0; auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector(*metadata_buffer) : 0; - auto metadata__ = metadata ? _fbb.CreateVector>(*metadata) : 0; - auto signature_defs__ = signature_defs ? _fbb.CreateVector>(*signature_defs) : 0; + auto metadata__ = metadata ? _fbb.CreateVector<::flatbuffers::Offset>(*metadata) : 0; + auto signature_defs__ = signature_defs ? _fbb.CreateVector<::flatbuffers::Offset>(*signature_defs) : 0; return tflite::CreateModel( _fbb, version, @@ -16495,28 +16495,28 @@ inline flatbuffers::Offset CreateModelDirect( signature_defs__); } -flatbuffers::Offset CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateModel(::flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -inline CustomQuantizationT *CustomQuantization::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline CustomQuantizationT *CustomQuantization::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new CustomQuantizationT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void CustomQuantization::UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void CustomQuantization::UnPackTo(CustomQuantizationT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = custom(); if (_e) { _o->custom.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom.begin()); } } } -inline flatbuffers::Offset CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CustomQuantization::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateCustomQuantization(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateCustomQuantization(::flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CustomQuantizationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CustomQuantizationT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; _fbb.ForceVectorAlignment(_o->custom.size(), sizeof(uint8_t), 16); auto _custom = _o->custom.size() ? _fbb.CreateVector(_o->custom) : 0; return tflite::CreateCustomQuantization( @@ -16524,32 +16524,32 @@ inline flatbuffers::Offset CreateCustomQuantization(flatbuff _custom); } -inline QuantizationParametersT *QuantizationParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline QuantizationParametersT *QuantizationParameters::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new QuantizationParametersT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void QuantizationParameters::UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void QuantizationParameters::UnPackTo(QuantizationParametersT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { 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); } } } - { 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); } } } - { auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scale[_i] = _e->Get(_i); } } } - { auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } } + { 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); } } else { _o->min.resize(0); } } + { 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); } } else { _o->max.resize(0); } } + { auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scale[_i] = _e->Get(_i); } } else { _o->scale.resize(0); } } + { auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } else { _o->zero_point.resize(0); } } { auto _e = details_type(); _o->details.type = _e; } { auto _e = details(); if (_e) _o->details.value = tflite::QuantizationDetailsUnion::UnPack(_e, details_type(), _resolver); } { auto _e = quantized_dimension(); _o->quantized_dimension = _e; } } -inline flatbuffers::Offset QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset QuantizationParameters::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateQuantizationParameters(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateQuantizationParameters(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizationParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const QuantizationParametersT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : 0; auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : 0; auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : 0; @@ -16568,52 +16568,52 @@ inline flatbuffers::Offset CreateQuantizationParameters( _quantized_dimension); } -inline Int32VectorT *Int32Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline Int32VectorT *Int32Vector::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new Int32VectorT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Int32Vector::UnPackTo(Int32VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Int32Vector::UnPackTo(Int32VectorT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } } + { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } else { _o->values.resize(0); } } } -inline flatbuffers::Offset Int32Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Int32Vector::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateInt32Vector(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateInt32Vector(::flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Int32VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const Int32VectorT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0; return tflite::CreateInt32Vector( _fbb, _values); } -inline Uint16VectorT *Uint16Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline Uint16VectorT *Uint16Vector::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new Uint16VectorT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Uint16Vector::UnPackTo(Uint16VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Uint16Vector::UnPackTo(Uint16VectorT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } } + { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } else { _o->values.resize(0); } } } -inline flatbuffers::Offset Uint16Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Uint16Vector::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUint16Vector(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUint16Vector(::flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Uint16VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const Uint16VectorT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; _fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint16_t), 4); auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0; return tflite::CreateUint16Vector( @@ -16621,26 +16621,26 @@ inline flatbuffers::Offset CreateUint16Vector(flatbuffers::FlatBuf _values); } -inline Uint8VectorT *Uint8Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline Uint8VectorT *Uint8Vector::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new Uint8VectorT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Uint8Vector::UnPackTo(Uint8VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Uint8Vector::UnPackTo(Uint8VectorT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = values(); if (_e) { _o->values.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->values.begin()); } } } -inline flatbuffers::Offset Uint8Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Uint8Vector::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUint8Vector(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUint8Vector(::flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Uint8VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const Uint8VectorT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; _fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint8_t), 4); auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0; return tflite::CreateUint8Vector( @@ -16648,13 +16648,13 @@ inline flatbuffers::Offset CreateUint8Vector(flatbuffers::FlatBuffe _values); } -inline DimensionMetadataT *DimensionMetadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DimensionMetadataT *DimensionMetadata::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DimensionMetadataT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void DimensionMetadata::UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void DimensionMetadata::UnPackTo(DimensionMetadataT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = format(); _o->format = _e; } @@ -16665,14 +16665,14 @@ inline void DimensionMetadata::UnPackTo(DimensionMetadataT *_o, const flatbuffer { auto _e = array_indices(); if (_e) _o->array_indices.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_indices_type(), _resolver); } } -inline flatbuffers::Offset DimensionMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset DimensionMetadata::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateDimensionMetadata(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateDimensionMetadata(::flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DimensionMetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DimensionMetadataT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _format = _o->format; auto _dense_size = _o->dense_size; auto _array_segments_type = _o->array_segments.type; @@ -16703,31 +16703,31 @@ inline SparsityParametersT &SparsityParametersT::operator=(SparsityParametersT o return *this; } -inline SparsityParametersT *SparsityParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SparsityParametersT *SparsityParameters::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SparsityParametersT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SparsityParameters::UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SparsityParameters::UnPackTo(SparsityParametersT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = traversal_order(); if (_e) { _o->traversal_order.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->traversal_order[_i] = _e->Get(_i); } } } - { auto _e = block_map(); if (_e) { _o->block_map.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->block_map[_i] = _e->Get(_i); } } } - { auto _e = dim_metadata(); if (_e) { _o->dim_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->dim_metadata[_i]) { _e->Get(_i)->UnPackTo(_o->dim_metadata[_i].get(), _resolver); } else { _o->dim_metadata[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = traversal_order(); if (_e) { _o->traversal_order.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->traversal_order[_i] = _e->Get(_i); } } else { _o->traversal_order.resize(0); } } + { auto _e = block_map(); if (_e) { _o->block_map.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->block_map[_i] = _e->Get(_i); } } else { _o->block_map.resize(0); } } + { auto _e = dim_metadata(); if (_e) { _o->dim_metadata.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->dim_metadata[_i]) { _e->Get(_i)->UnPackTo(_o->dim_metadata[_i].get(), _resolver); } else { _o->dim_metadata[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->dim_metadata.resize(0); } } } -inline flatbuffers::Offset SparsityParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SparsityParameters::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSparsityParameters(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSparsityParameters(::flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparsityParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SparsityParametersT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _traversal_order = _o->traversal_order.size() ? _fbb.CreateVector(_o->traversal_order) : 0; auto _block_map = _o->block_map.size() ? _fbb.CreateVector(_o->block_map) : 0; - auto _dim_metadata = _o->dim_metadata.size() ? _fbb.CreateVector> (_o->dim_metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateDimensionMetadata(*__va->__fbb, __va->__o->dim_metadata[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _dim_metadata = _o->dim_metadata.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->dim_metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateDimensionMetadata(*__va->__fbb, __va->__o->dim_metadata[i].get(), __va->__rehasher); }, &_va ) : 0; return tflite::CreateSparsityParameters( _fbb, _traversal_order, @@ -16735,28 +16735,28 @@ inline flatbuffers::Offset CreateSparsityParameters(flatbuff _dim_metadata); } -inline VariantSubTypeT *VariantSubType::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline VariantSubTypeT *VariantSubType::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new VariantSubTypeT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void VariantSubType::UnPackTo(VariantSubTypeT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void VariantSubType::UnPackTo(VariantSubTypeT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } } + { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } else { _o->shape.resize(0); } } { auto _e = type(); _o->type = _e; } { auto _e = has_rank(); _o->has_rank = _e; } } -inline flatbuffers::Offset VariantSubType::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset VariantSubType::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateVariantSubType(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateVariantSubType(::flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const VariantSubTypeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const VariantSubTypeT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0; auto _type = _o->type; auto _has_rank = _o->has_rank; @@ -16795,35 +16795,35 @@ inline TensorT &TensorT::operator=(TensorT o) FLATBUFFERS_NOEXCEPT { return *this; } -inline TensorT *Tensor::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline TensorT *Tensor::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new TensorT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Tensor::UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Tensor::UnPackTo(TensorT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } } + { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } else { _o->shape.resize(0); } } { auto _e = type(); _o->type = _e; } { auto _e = buffer(); _o->buffer = _e; } { auto _e = name(); if (_e) _o->name = _e->str(); } - { auto _e = quantization(); if (_e) { if(_o->quantization) { _e->UnPackTo(_o->quantization.get(), _resolver); } else { _o->quantization = std::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = quantization(); if (_e) { if(_o->quantization) { _e->UnPackTo(_o->quantization.get(), _resolver); } else { _o->quantization = std::unique_ptr(_e->UnPack(_resolver)); } } else if (_o->quantization) { _o->quantization.reset(); } } { auto _e = is_variable(); _o->is_variable = _e; } - { auto _e = sparsity(); if (_e) { if(_o->sparsity) { _e->UnPackTo(_o->sparsity.get(), _resolver); } else { _o->sparsity = std::unique_ptr(_e->UnPack(_resolver)); } } } - { auto _e = shape_signature(); if (_e) { _o->shape_signature.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape_signature[_i] = _e->Get(_i); } } } + { auto _e = sparsity(); if (_e) { if(_o->sparsity) { _e->UnPackTo(_o->sparsity.get(), _resolver); } else { _o->sparsity = std::unique_ptr(_e->UnPack(_resolver)); } } else if (_o->sparsity) { _o->sparsity.reset(); } } + { auto _e = shape_signature(); if (_e) { _o->shape_signature.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape_signature[_i] = _e->Get(_i); } } else { _o->shape_signature.resize(0); } } { auto _e = has_rank(); _o->has_rank = _e; } - { auto _e = variant_tensors(); if (_e) { _o->variant_tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->variant_tensors[_i]) { _e->Get(_i)->UnPackTo(_o->variant_tensors[_i].get(), _resolver); } else { _o->variant_tensors[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = variant_tensors(); if (_e) { _o->variant_tensors.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->variant_tensors[_i]) { _e->Get(_i)->UnPackTo(_o->variant_tensors[_i].get(), _resolver); } else { _o->variant_tensors[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->variant_tensors.resize(0); } } } -inline flatbuffers::Offset Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Tensor::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateTensor(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateTensor(::flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TensorT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0; auto _type = _o->type; auto _buffer = _o->buffer; @@ -16833,7 +16833,7 @@ inline flatbuffers::Offset CreateTensor(flatbuffers::FlatBufferBuilder & auto _sparsity = _o->sparsity ? CreateSparsityParameters(_fbb, _o->sparsity.get(), _rehasher) : 0; auto _shape_signature = _o->shape_signature.size() ? _fbb.CreateVector(_o->shape_signature) : 0; auto _has_rank = _o->has_rank; - auto _variant_tensors = _o->variant_tensors.size() ? _fbb.CreateVector> (_o->variant_tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateVariantSubType(*__va->__fbb, __va->__o->variant_tensors[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _variant_tensors = _o->variant_tensors.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->variant_tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateVariantSubType(*__va->__fbb, __va->__o->variant_tensors[i].get(), __va->__rehasher); }, &_va ) : 0; return tflite::CreateTensor( _fbb, _shape, @@ -16848,31 +16848,31 @@ inline flatbuffers::Offset CreateTensor(flatbuffers::FlatBufferBuilder & _variant_tensors); } -inline StablehloGatherOptionsT *StablehloGatherOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloGatherOptionsT *StablehloGatherOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloGatherOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloGatherOptions::UnPackTo(StablehloGatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloGatherOptions::UnPackTo(StablehloGatherOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = offset_dims(); if (_e) { _o->offset_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->offset_dims[_i] = _e->Get(_i); } } } - { auto _e = collapsed_slice_dims(); if (_e) { _o->collapsed_slice_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->collapsed_slice_dims[_i] = _e->Get(_i); } } } - { auto _e = start_index_map(); if (_e) { _o->start_index_map.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->start_index_map[_i] = _e->Get(_i); } } } + { auto _e = offset_dims(); if (_e) { _o->offset_dims.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->offset_dims[_i] = _e->Get(_i); } } else { _o->offset_dims.resize(0); } } + { auto _e = collapsed_slice_dims(); if (_e) { _o->collapsed_slice_dims.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->collapsed_slice_dims[_i] = _e->Get(_i); } } else { _o->collapsed_slice_dims.resize(0); } } + { auto _e = start_index_map(); if (_e) { _o->start_index_map.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->start_index_map[_i] = _e->Get(_i); } } else { _o->start_index_map.resize(0); } } { auto _e = index_vector_dim(); _o->index_vector_dim = _e; } - { auto _e = slice_sizes(); if (_e) { _o->slice_sizes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->slice_sizes[_i] = _e->Get(_i); } } } + { auto _e = slice_sizes(); if (_e) { _o->slice_sizes.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->slice_sizes[_i] = _e->Get(_i); } } else { _o->slice_sizes.resize(0); } } { auto _e = indices_are_sorted(); _o->indices_are_sorted = _e; } } -inline flatbuffers::Offset StablehloGatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloGatherOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloGatherOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloGatherOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloGatherOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloGatherOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _offset_dims = _o->offset_dims.size() ? _fbb.CreateVector(_o->offset_dims) : 0; auto _collapsed_slice_dims = _o->collapsed_slice_dims.size() ? _fbb.CreateVector(_o->collapsed_slice_dims) : 0; auto _start_index_map = _o->start_index_map.size() ? _fbb.CreateVector(_o->start_index_map) : 0; @@ -16889,61 +16889,61 @@ inline flatbuffers::Offset CreateStablehloGatherOptions( _indices_are_sorted); } -inline StablehloTransposeOptionsT *StablehloTransposeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloTransposeOptionsT *StablehloTransposeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloTransposeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloTransposeOptions::UnPackTo(StablehloTransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloTransposeOptions::UnPackTo(StablehloTransposeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = permutation(); if (_e) { _o->permutation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->permutation[_i] = _e->Get(_i); } } } + { auto _e = permutation(); if (_e) { _o->permutation.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->permutation[_i] = _e->Get(_i); } } else { _o->permutation.resize(0); } } } -inline flatbuffers::Offset StablehloTransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloTransposeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloTransposeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloTransposeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloTransposeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloTransposeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _permutation = _o->permutation.size() ? _fbb.CreateVector(_o->permutation) : 0; return tflite::CreateStablehloTransposeOptions( _fbb, _permutation); } -inline StablehloDotGeneralOptionsT *StablehloDotGeneralOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloDotGeneralOptionsT *StablehloDotGeneralOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloDotGeneralOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloDotGeneralOptions::UnPackTo(StablehloDotGeneralOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloDotGeneralOptions::UnPackTo(StablehloDotGeneralOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = lhs_batching_dimensions(); if (_e) { _o->lhs_batching_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lhs_batching_dimensions[_i] = _e->Get(_i); } } } - { auto _e = rhs_batching_dimensions(); if (_e) { _o->rhs_batching_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->rhs_batching_dimensions[_i] = _e->Get(_i); } } } - { auto _e = lhs_contracting_dimensions(); if (_e) { _o->lhs_contracting_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lhs_contracting_dimensions[_i] = _e->Get(_i); } } } - { auto _e = rhs_contracting_dimensions(); if (_e) { _o->rhs_contracting_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->rhs_contracting_dimensions[_i] = _e->Get(_i); } } } - { auto _e = precision_config(); if (_e) { _o->precision_config.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->precision_config[_i] = static_cast(_e->Get(_i)); } } } + { auto _e = lhs_batching_dimensions(); if (_e) { _o->lhs_batching_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lhs_batching_dimensions[_i] = _e->Get(_i); } } else { _o->lhs_batching_dimensions.resize(0); } } + { auto _e = rhs_batching_dimensions(); if (_e) { _o->rhs_batching_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->rhs_batching_dimensions[_i] = _e->Get(_i); } } else { _o->rhs_batching_dimensions.resize(0); } } + { auto _e = lhs_contracting_dimensions(); if (_e) { _o->lhs_contracting_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lhs_contracting_dimensions[_i] = _e->Get(_i); } } else { _o->lhs_contracting_dimensions.resize(0); } } + { auto _e = rhs_contracting_dimensions(); if (_e) { _o->rhs_contracting_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->rhs_contracting_dimensions[_i] = _e->Get(_i); } } else { _o->rhs_contracting_dimensions.resize(0); } } + { auto _e = precision_config(); if (_e) { _o->precision_config.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->precision_config[_i] = static_cast(_e->Get(_i)); } } else { _o->precision_config.resize(0); } } } -inline flatbuffers::Offset StablehloDotGeneralOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloDotGeneralOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloDotGeneralOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloDotGeneralOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloDotGeneralOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloDotGeneralOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloDotGeneralOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _lhs_batching_dimensions = _o->lhs_batching_dimensions.size() ? _fbb.CreateVector(_o->lhs_batching_dimensions) : 0; auto _rhs_batching_dimensions = _o->rhs_batching_dimensions.size() ? _fbb.CreateVector(_o->rhs_batching_dimensions) : 0; auto _lhs_contracting_dimensions = _o->lhs_contracting_dimensions.size() ? _fbb.CreateVector(_o->lhs_contracting_dimensions) : 0; auto _rhs_contracting_dimensions = _o->rhs_contracting_dimensions.size() ? _fbb.CreateVector(_o->rhs_contracting_dimensions) : 0; - auto _precision_config = _o->precision_config.size() ? _fbb.CreateVectorScalarCast(flatbuffers::data(_o->precision_config), _o->precision_config.size()) : 0; + auto _precision_config = _o->precision_config.size() ? _fbb.CreateVectorScalarCast(::flatbuffers::data(_o->precision_config), _o->precision_config.size()) : 0; return tflite::CreateStablehloDotGeneralOptions( _fbb, _lhs_batching_dimensions, @@ -16953,31 +16953,31 @@ inline flatbuffers::Offset CreateStablehloDotGeneral _precision_config); } -inline StablehloReduceWindowOptionsT *StablehloReduceWindowOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloReduceWindowOptionsT *StablehloReduceWindowOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloReduceWindowOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloReduceWindowOptions::UnPackTo(StablehloReduceWindowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloReduceWindowOptions::UnPackTo(StablehloReduceWindowOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = window_dimensions(); if (_e) { _o->window_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_dimensions[_i] = _e->Get(_i); } } } - { auto _e = window_strides(); if (_e) { _o->window_strides.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_strides[_i] = _e->Get(_i); } } } - { auto _e = base_dilations(); if (_e) { _o->base_dilations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->base_dilations[_i] = _e->Get(_i); } } } - { auto _e = window_dilations(); if (_e) { _o->window_dilations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_dilations[_i] = _e->Get(_i); } } } - { auto _e = padding(); if (_e) { _o->padding.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->padding[_i] = _e->Get(_i); } } } + { auto _e = window_dimensions(); if (_e) { _o->window_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_dimensions[_i] = _e->Get(_i); } } else { _o->window_dimensions.resize(0); } } + { auto _e = window_strides(); if (_e) { _o->window_strides.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_strides[_i] = _e->Get(_i); } } else { _o->window_strides.resize(0); } } + { auto _e = base_dilations(); if (_e) { _o->base_dilations.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->base_dilations[_i] = _e->Get(_i); } } else { _o->base_dilations.resize(0); } } + { auto _e = window_dilations(); if (_e) { _o->window_dilations.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_dilations[_i] = _e->Get(_i); } } else { _o->window_dilations.resize(0); } } + { auto _e = padding(); if (_e) { _o->padding.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->padding[_i] = _e->Get(_i); } } else { _o->padding.resize(0); } } { auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; } } -inline flatbuffers::Offset StablehloReduceWindowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloReduceWindowOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloReduceWindowOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloReduceWindowOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloReduceWindowOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloReduceWindowOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloReduceWindowOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _window_dimensions = _o->window_dimensions.size() ? _fbb.CreateVector(_o->window_dimensions) : 0; auto _window_strides = _o->window_strides.size() ? _fbb.CreateVector(_o->window_strides) : 0; auto _base_dilations = _o->base_dilations.size() ? _fbb.CreateVector(_o->base_dilations) : 0; @@ -16994,27 +16994,27 @@ inline flatbuffers::Offset CreateStablehloReduceWi _body_subgraph_index); } -inline StablehloWhileOptionsT *StablehloWhileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloWhileOptionsT *StablehloWhileOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloWhileOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloWhileOptions::UnPackTo(StablehloWhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloWhileOptions::UnPackTo(StablehloWhileOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = cond_subgraph_index(); _o->cond_subgraph_index = _e; } { auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; } } -inline flatbuffers::Offset StablehloWhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloWhileOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloWhileOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloWhileOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloWhileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloWhileOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _cond_subgraph_index = _o->cond_subgraph_index; auto _body_subgraph_index = _o->body_subgraph_index; return tflite::CreateStablehloWhileOptions( @@ -17023,13 +17023,13 @@ inline flatbuffers::Offset CreateStablehloWhileOptions(fl _body_subgraph_index); } -inline StablehloSortOptionsT *StablehloSortOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloSortOptionsT *StablehloSortOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloSortOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloSortOptions::UnPackTo(StablehloSortOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloSortOptions::UnPackTo(StablehloSortOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = dimension(); _o->dimension = _e; } @@ -17037,14 +17037,14 @@ inline void StablehloSortOptions::UnPackTo(StablehloSortOptionsT *_o, const flat { auto _e = comparator_subgraph_index(); _o->comparator_subgraph_index = _e; } } -inline flatbuffers::Offset StablehloSortOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloSortOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloSortOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloSortOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloSortOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloSortOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloSortOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _dimension = _o->dimension; auto _is_stable = _o->is_stable; auto _comparator_subgraph_index = _o->comparator_subgraph_index; @@ -17055,79 +17055,79 @@ inline flatbuffers::Offset CreateStablehloSortOptions(flat _comparator_subgraph_index); } -inline StablehloConcatenateOptionsT *StablehloConcatenateOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloConcatenateOptionsT *StablehloConcatenateOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloConcatenateOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloConcatenateOptions::UnPackTo(StablehloConcatenateOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloConcatenateOptions::UnPackTo(StablehloConcatenateOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = dimension(); _o->dimension = _e; } } -inline flatbuffers::Offset StablehloConcatenateOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloConcatenateOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloConcatenateOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloConcatenateOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloConcatenateOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloConcatenateOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloConcatenateOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _dimension = _o->dimension; return tflite::CreateStablehloConcatenateOptions( _fbb, _dimension); } -inline StablehloBroadcastInDimOptionsT *StablehloBroadcastInDimOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloBroadcastInDimOptionsT *StablehloBroadcastInDimOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloBroadcastInDimOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloBroadcastInDimOptions::UnPackTo(StablehloBroadcastInDimOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloBroadcastInDimOptions::UnPackTo(StablehloBroadcastInDimOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = broadcast_dimensions(); if (_e) { _o->broadcast_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->broadcast_dimensions[_i] = _e->Get(_i); } } } + { auto _e = broadcast_dimensions(); if (_e) { _o->broadcast_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->broadcast_dimensions[_i] = _e->Get(_i); } } else { _o->broadcast_dimensions.resize(0); } } } -inline flatbuffers::Offset StablehloBroadcastInDimOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloBroadcastInDimOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloBroadcastInDimOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloBroadcastInDimOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloBroadcastInDimOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloBroadcastInDimOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloBroadcastInDimOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _broadcast_dimensions = _o->broadcast_dimensions.size() ? _fbb.CreateVector(_o->broadcast_dimensions) : 0; return tflite::CreateStablehloBroadcastInDimOptions( _fbb, _broadcast_dimensions); } -inline StablehloCompareOptionsT *StablehloCompareOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloCompareOptionsT *StablehloCompareOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloCompareOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloCompareOptions::UnPackTo(StablehloCompareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloCompareOptions::UnPackTo(StablehloCompareOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = comparison_direction(); _o->comparison_direction = _e; } { auto _e = compare_type(); _o->compare_type = _e; } } -inline flatbuffers::Offset StablehloCompareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloCompareOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloCompareOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloCompareOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloCompareOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloCompareOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloCompareOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _comparison_direction = _o->comparison_direction; auto _compare_type = _o->compare_type; return tflite::CreateStablehloCompareOptions( @@ -17136,54 +17136,54 @@ inline flatbuffers::Offset CreateStablehloCompareOption _compare_type); } -inline StablehloDynamicSliceOptionsT *StablehloDynamicSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloDynamicSliceOptionsT *StablehloDynamicSliceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloDynamicSliceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloDynamicSliceOptions::UnPackTo(StablehloDynamicSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloDynamicSliceOptions::UnPackTo(StablehloDynamicSliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = slice_sizes(); if (_e) { _o->slice_sizes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->slice_sizes[_i] = _e->Get(_i); } } } + { auto _e = slice_sizes(); if (_e) { _o->slice_sizes.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->slice_sizes[_i] = _e->Get(_i); } } else { _o->slice_sizes.resize(0); } } } -inline flatbuffers::Offset StablehloDynamicSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloDynamicSliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloDynamicSliceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloDynamicSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloDynamicSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloDynamicSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloDynamicSliceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _slice_sizes = _o->slice_sizes.size() ? _fbb.CreateVector(_o->slice_sizes) : 0; return tflite::CreateStablehloDynamicSliceOptions( _fbb, _slice_sizes); } -inline StablehloPadOptionsT *StablehloPadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloPadOptionsT *StablehloPadOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloPadOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloPadOptions::UnPackTo(StablehloPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloPadOptions::UnPackTo(StablehloPadOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = edge_padding_low(); if (_e) { _o->edge_padding_low.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->edge_padding_low[_i] = _e->Get(_i); } } } - { auto _e = edge_padding_high(); if (_e) { _o->edge_padding_high.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->edge_padding_high[_i] = _e->Get(_i); } } } - { auto _e = interior_padding(); if (_e) { _o->interior_padding.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->interior_padding[_i] = _e->Get(_i); } } } + { auto _e = edge_padding_low(); if (_e) { _o->edge_padding_low.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->edge_padding_low[_i] = _e->Get(_i); } } else { _o->edge_padding_low.resize(0); } } + { auto _e = edge_padding_high(); if (_e) { _o->edge_padding_high.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->edge_padding_high[_i] = _e->Get(_i); } } else { _o->edge_padding_high.resize(0); } } + { auto _e = interior_padding(); if (_e) { _o->interior_padding.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->interior_padding[_i] = _e->Get(_i); } } else { _o->interior_padding.resize(0); } } } -inline flatbuffers::Offset StablehloPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloPadOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloPadOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloPadOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloPadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloPadOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _edge_padding_low = _o->edge_padding_low.size() ? _fbb.CreateVector(_o->edge_padding_low) : 0; auto _edge_padding_high = _o->edge_padding_high.size() ? _fbb.CreateVector(_o->edge_padding_high) : 0; auto _interior_padding = _o->interior_padding.size() ? _fbb.CreateVector(_o->interior_padding) : 0; @@ -17194,57 +17194,57 @@ inline flatbuffers::Offset CreateStablehloPadOptions(flatbu _interior_padding); } -inline StablehloIotaOptionsT *StablehloIotaOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloIotaOptionsT *StablehloIotaOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloIotaOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloIotaOptions::UnPackTo(StablehloIotaOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloIotaOptions::UnPackTo(StablehloIotaOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = iota_dimension(); _o->iota_dimension = _e; } } -inline flatbuffers::Offset StablehloIotaOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloIotaOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloIotaOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloIotaOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloIotaOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloIotaOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloIotaOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _iota_dimension = _o->iota_dimension; return tflite::CreateStablehloIotaOptions( _fbb, _iota_dimension); } -inline StablehloCustomCallOptionsT *StablehloCustomCallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloCustomCallOptionsT *StablehloCustomCallOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloCustomCallOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloCustomCallOptions::UnPackTo(StablehloCustomCallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloCustomCallOptions::UnPackTo(StablehloCustomCallOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = call_target_name(); if (_e) _o->call_target_name = _e->str(); } { auto _e = has_side_effect(); _o->has_side_effect = _e; } { auto _e = backend_config(); if (_e) _o->backend_config = _e->str(); } { auto _e = api_version(); _o->api_version = _e; } - { auto _e = called_computations(); if (_e) { _o->called_computations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->called_computations[_i] = _e->Get(_i); } } } + { auto _e = called_computations(); if (_e) { _o->called_computations.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->called_computations[_i] = _e->Get(_i); } } else { _o->called_computations.resize(0); } } { auto _e = custom_attributes(); if (_e) { _o->custom_attributes.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom_attributes.begin()); } } } -inline flatbuffers::Offset StablehloCustomCallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloCustomCallOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloCustomCallOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloCustomCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloCustomCallOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloCustomCallOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloCustomCallOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _call_target_name = _o->call_target_name.empty() ? 0 : _fbb.CreateString(_o->call_target_name); auto _has_side_effect = _o->has_side_effect; auto _backend_config = _o->backend_config.empty() ? 0 : _fbb.CreateString(_o->backend_config); @@ -17261,27 +17261,27 @@ inline flatbuffers::Offset CreateStablehloCustomCall _custom_attributes); } -inline StablehloReduceOptionsT *StablehloReduceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloReduceOptionsT *StablehloReduceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloReduceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloReduceOptions::UnPackTo(StablehloReduceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloReduceOptions::UnPackTo(StablehloReduceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = dimensions(); if (_e) { _o->dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dimensions[_i] = _e->Get(_i); } } } + { auto _e = dimensions(); if (_e) { _o->dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dimensions[_i] = _e->Get(_i); } } else { _o->dimensions.resize(0); } } { auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; } } -inline flatbuffers::Offset StablehloReduceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloReduceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloReduceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloReduceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloReduceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloReduceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloReduceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _dimensions = _o->dimensions.size() ? _fbb.CreateVector(_o->dimensions) : 0; auto _body_subgraph_index = _o->body_subgraph_index; return tflite::CreateStablehloReduceOptions( @@ -17290,28 +17290,28 @@ inline flatbuffers::Offset CreateStablehloReduceOptions( _body_subgraph_index); } -inline StablehloSliceOptionsT *StablehloSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloSliceOptionsT *StablehloSliceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloSliceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloSliceOptions::UnPackTo(StablehloSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloSliceOptions::UnPackTo(StablehloSliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = start_indices(); if (_e) { _o->start_indices.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->start_indices[_i] = _e->Get(_i); } } } - { auto _e = limit_indices(); if (_e) { _o->limit_indices.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->limit_indices[_i] = _e->Get(_i); } } } - { auto _e = strides(); if (_e) { _o->strides.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->strides[_i] = _e->Get(_i); } } } + { auto _e = start_indices(); if (_e) { _o->start_indices.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->start_indices[_i] = _e->Get(_i); } } else { _o->start_indices.resize(0); } } + { auto _e = limit_indices(); if (_e) { _o->limit_indices.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->limit_indices[_i] = _e->Get(_i); } } else { _o->limit_indices.resize(0); } } + { auto _e = strides(); if (_e) { _o->strides.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->strides[_i] = _e->Get(_i); } } else { _o->strides.resize(0); } } } -inline flatbuffers::Offset StablehloSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloSliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloSliceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloSliceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _start_indices = _o->start_indices.size() ? _fbb.CreateVector(_o->start_indices) : 0; auto _limit_indices = _o->limit_indices.size() ? _fbb.CreateVector(_o->limit_indices) : 0; auto _strides = _o->strides.size() ? _fbb.CreateVector(_o->strides) : 0; @@ -17322,42 +17322,42 @@ inline flatbuffers::Offset CreateStablehloSliceOptions(fl _strides); } -inline StablehloConvolutionOptionsT *StablehloConvolutionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloConvolutionOptionsT *StablehloConvolutionOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloConvolutionOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloConvolutionOptions::UnPackTo(StablehloConvolutionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloConvolutionOptions::UnPackTo(StablehloConvolutionOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = window_strides(); if (_e) { _o->window_strides.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_strides[_i] = _e->Get(_i); } } } - { auto _e = padding(); if (_e) { _o->padding.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->padding[_i] = _e->Get(_i); } } } - { auto _e = lhs_dilation(); if (_e) { _o->lhs_dilation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lhs_dilation[_i] = _e->Get(_i); } } } - { auto _e = rhs_dilation(); if (_e) { _o->rhs_dilation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->rhs_dilation[_i] = _e->Get(_i); } } } - { auto _e = window_reversal(); if (_e) { _o->window_reversal.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_reversal[_i] = _e->Get(_i) != 0; } } } + { auto _e = window_strides(); if (_e) { _o->window_strides.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_strides[_i] = _e->Get(_i); } } else { _o->window_strides.resize(0); } } + { auto _e = padding(); if (_e) { _o->padding.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->padding[_i] = _e->Get(_i); } } else { _o->padding.resize(0); } } + { auto _e = lhs_dilation(); if (_e) { _o->lhs_dilation.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lhs_dilation[_i] = _e->Get(_i); } } else { _o->lhs_dilation.resize(0); } } + { auto _e = rhs_dilation(); if (_e) { _o->rhs_dilation.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->rhs_dilation[_i] = _e->Get(_i); } } else { _o->rhs_dilation.resize(0); } } + { auto _e = window_reversal(); if (_e) { _o->window_reversal.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->window_reversal[_i] = _e->Get(_i) != 0; } } else { _o->window_reversal.resize(0); } } { auto _e = input_batch_dimension(); _o->input_batch_dimension = _e; } { auto _e = input_feature_dimension(); _o->input_feature_dimension = _e; } - { auto _e = input_spatial_dimensions(); if (_e) { _o->input_spatial_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->input_spatial_dimensions[_i] = _e->Get(_i); } } } + { auto _e = input_spatial_dimensions(); if (_e) { _o->input_spatial_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->input_spatial_dimensions[_i] = _e->Get(_i); } } else { _o->input_spatial_dimensions.resize(0); } } { auto _e = kernel_input_feature_dimension(); _o->kernel_input_feature_dimension = _e; } { auto _e = kernel_output_feature_dimension(); _o->kernel_output_feature_dimension = _e; } - { auto _e = kernel_spatial_dimensions(); if (_e) { _o->kernel_spatial_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->kernel_spatial_dimensions[_i] = _e->Get(_i); } } } + { auto _e = kernel_spatial_dimensions(); if (_e) { _o->kernel_spatial_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->kernel_spatial_dimensions[_i] = _e->Get(_i); } } else { _o->kernel_spatial_dimensions.resize(0); } } { auto _e = output_batch_dimension(); _o->output_batch_dimension = _e; } { auto _e = output_feature_dimension(); _o->output_feature_dimension = _e; } - { auto _e = output_spatial_dimensions(); if (_e) { _o->output_spatial_dimensions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->output_spatial_dimensions[_i] = _e->Get(_i); } } } + { auto _e = output_spatial_dimensions(); if (_e) { _o->output_spatial_dimensions.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->output_spatial_dimensions[_i] = _e->Get(_i); } } else { _o->output_spatial_dimensions.resize(0); } } { auto _e = feature_group_count(); _o->feature_group_count = _e; } { auto _e = batch_group_count(); _o->batch_group_count = _e; } - { auto _e = precision_config(); if (_e) { _o->precision_config.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->precision_config[_i] = static_cast(_e->Get(_i)); } } } + { auto _e = precision_config(); if (_e) { _o->precision_config.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->precision_config[_i] = static_cast(_e->Get(_i)); } } else { _o->precision_config.resize(0); } } } -inline flatbuffers::Offset StablehloConvolutionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloConvolutionOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloConvolutionOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloConvolutionOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloConvolutionOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloConvolutionOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloConvolutionOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _window_strides = _o->window_strides.size() ? _fbb.CreateVector(_o->window_strides) : 0; auto _padding = _o->padding.size() ? _fbb.CreateVector(_o->padding) : 0; auto _lhs_dilation = _o->lhs_dilation.size() ? _fbb.CreateVector(_o->lhs_dilation) : 0; @@ -17374,7 +17374,7 @@ inline flatbuffers::Offset CreateStablehloConvoluti auto _output_spatial_dimensions = _o->output_spatial_dimensions.size() ? _fbb.CreateVector(_o->output_spatial_dimensions) : 0; auto _feature_group_count = _o->feature_group_count; auto _batch_group_count = _o->batch_group_count; - auto _precision_config = _o->precision_config.size() ? _fbb.CreateVectorScalarCast(flatbuffers::data(_o->precision_config), _o->precision_config.size()) : 0; + auto _precision_config = _o->precision_config.size() ? _fbb.CreateVectorScalarCast(::flatbuffers::data(_o->precision_config), _o->precision_config.size()) : 0; return tflite::CreateStablehloConvolutionOptions( _fbb, _window_strides, @@ -17396,32 +17396,32 @@ inline flatbuffers::Offset CreateStablehloConvoluti _precision_config); } -inline StablehloScatterOptionsT *StablehloScatterOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloScatterOptionsT *StablehloScatterOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloScatterOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloScatterOptions::UnPackTo(StablehloScatterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloScatterOptions::UnPackTo(StablehloScatterOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = indices_are_sorted(); _o->indices_are_sorted = _e; } - { auto _e = update_window_dims(); if (_e) { _o->update_window_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->update_window_dims[_i] = _e->Get(_i); } } } - { auto _e = inserted_window_dims(); if (_e) { _o->inserted_window_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inserted_window_dims[_i] = _e->Get(_i); } } } - { auto _e = scatter_dims_to_operand_dims(); if (_e) { _o->scatter_dims_to_operand_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scatter_dims_to_operand_dims[_i] = _e->Get(_i); } } } + { auto _e = update_window_dims(); if (_e) { _o->update_window_dims.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->update_window_dims[_i] = _e->Get(_i); } } else { _o->update_window_dims.resize(0); } } + { auto _e = inserted_window_dims(); if (_e) { _o->inserted_window_dims.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inserted_window_dims[_i] = _e->Get(_i); } } else { _o->inserted_window_dims.resize(0); } } + { auto _e = scatter_dims_to_operand_dims(); if (_e) { _o->scatter_dims_to_operand_dims.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scatter_dims_to_operand_dims[_i] = _e->Get(_i); } } else { _o->scatter_dims_to_operand_dims.resize(0); } } { auto _e = index_vector_dim(); _o->index_vector_dim = _e; } { auto _e = unique_indices(); _o->unique_indices = _e; } { auto _e = update_computation_subgraph_index(); _o->update_computation_subgraph_index = _e; } } -inline flatbuffers::Offset StablehloScatterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloScatterOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloScatterOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloScatterOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloScatterOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloScatterOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloScatterOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _indices_are_sorted = _o->indices_are_sorted; auto _update_window_dims = _o->update_window_dims.size() ? _fbb.CreateVector(_o->update_window_dims) : 0; auto _inserted_window_dims = _o->inserted_window_dims.size() ? _fbb.CreateVector(_o->inserted_window_dims) : 0; @@ -17440,39 +17440,39 @@ inline flatbuffers::Offset CreateStablehloScatterOption _update_computation_subgraph_index); } -inline StablehloRngBitGeneratorOptionsT *StablehloRngBitGeneratorOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StablehloRngBitGeneratorOptionsT *StablehloRngBitGeneratorOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StablehloRngBitGeneratorOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StablehloRngBitGeneratorOptions::UnPackTo(StablehloRngBitGeneratorOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StablehloRngBitGeneratorOptions::UnPackTo(StablehloRngBitGeneratorOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = algorithm(); _o->algorithm = _e; } } -inline flatbuffers::Offset StablehloRngBitGeneratorOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StablehloRngBitGeneratorOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStablehloRngBitGeneratorOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStablehloRngBitGeneratorOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStablehloRngBitGeneratorOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StablehloRngBitGeneratorOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StablehloRngBitGeneratorOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _algorithm = _o->algorithm; return tflite::CreateStablehloRngBitGeneratorOptions( _fbb, _algorithm); } -inline Conv2DOptionsT *Conv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline Conv2DOptionsT *Conv2DOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new Conv2DOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = padding(); _o->padding = _e; } @@ -17484,14 +17484,14 @@ inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resol { auto _e = quantized_bias_type(); _o->quantized_bias_type = _e; } } -inline flatbuffers::Offset Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Conv2DOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateConv2DOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateConv2DOptions(::flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const Conv2DOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _padding = _o->padding; auto _stride_w = _o->stride_w; auto _stride_h = _o->stride_h; @@ -17510,13 +17510,13 @@ inline flatbuffers::Offset CreateConv2DOptions(flatbuffers::FlatB _quantized_bias_type); } -inline Conv3DOptionsT *Conv3DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline Conv3DOptionsT *Conv3DOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new Conv3DOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Conv3DOptions::UnPackTo(Conv3DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Conv3DOptions::UnPackTo(Conv3DOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = padding(); _o->padding = _e; } @@ -17529,14 +17529,14 @@ inline void Conv3DOptions::UnPackTo(Conv3DOptionsT *_o, const flatbuffers::resol { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; } } -inline flatbuffers::Offset Conv3DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Conv3DOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateConv3DOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateConv3DOptions(::flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv3DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const Conv3DOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _padding = _o->padding; auto _stride_d = _o->stride_d; auto _stride_w = _o->stride_w; @@ -17557,13 +17557,13 @@ inline flatbuffers::Offset CreateConv3DOptions(flatbuffers::FlatB _dilation_h_factor); } -inline Pool2DOptionsT *Pool2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline Pool2DOptionsT *Pool2DOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new Pool2DOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = padding(); _o->padding = _e; } @@ -17574,14 +17574,14 @@ inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resol { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } } -inline flatbuffers::Offset Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Pool2DOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreatePool2DOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreatePool2DOptions(::flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Pool2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const Pool2DOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _padding = _o->padding; auto _stride_w = _o->stride_w; auto _stride_h = _o->stride_h; @@ -17598,13 +17598,13 @@ inline flatbuffers::Offset CreatePool2DOptions(flatbuffers::FlatB _fused_activation_function); } -inline DepthwiseConv2DOptionsT *DepthwiseConv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DepthwiseConv2DOptionsT *DepthwiseConv2DOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DepthwiseConv2DOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = padding(); _o->padding = _e; } @@ -17616,14 +17616,14 @@ inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o, const { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; } } -inline flatbuffers::Offset DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset DepthwiseConv2DOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateDepthwiseConv2DOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthwiseConv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DepthwiseConv2DOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _padding = _o->padding; auto _stride_w = _o->stride_w; auto _stride_h = _o->stride_h; @@ -17642,28 +17642,28 @@ inline flatbuffers::Offset CreateDepthwiseConv2DOptions( _dilation_h_factor); } -inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ConcatEmbeddingsOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = num_channels(); _o->num_channels = _e; } - { auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->num_columns_per_channel[_i] = _e->Get(_i); } } } - { auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->embedding_dim_per_channel[_i] = _e->Get(_i); } } } + { auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->num_columns_per_channel[_i] = _e->Get(_i); } } else { _o->num_columns_per_channel.resize(0); } } + { auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->embedding_dim_per_channel[_i] = _e->Get(_i); } } else { _o->embedding_dim_per_channel.resize(0); } } } -inline flatbuffers::Offset ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ConcatEmbeddingsOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateConcatEmbeddingsOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatEmbeddingsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ConcatEmbeddingsOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _num_channels = _o->num_channels; auto _num_columns_per_channel = _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : 0; auto _embedding_dim_per_channel = _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : 0; @@ -17674,39 +17674,39 @@ inline flatbuffers::Offset CreateConcatEmbeddingsOption _embedding_dim_per_channel); } -inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LSHProjectionOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = type(); _o->type = _e; } } -inline flatbuffers::Offset LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LSHProjectionOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLSHProjectionOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLSHProjectionOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSHProjectionOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LSHProjectionOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _type = _o->type; return tflite::CreateLSHProjectionOptions( _fbb, _type); } -inline SVDFOptionsT *SVDFOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SVDFOptionsT *SVDFOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SVDFOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = rank(); _o->rank = _e; } @@ -17714,14 +17714,14 @@ inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_ { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; } } -inline flatbuffers::Offset SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SVDFOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSVDFOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSVDFOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SVDFOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SVDFOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _rank = _o->rank; auto _fused_activation_function = _o->fused_activation_function; auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs; @@ -17732,27 +17732,27 @@ inline flatbuffers::Offset CreateSVDFOptions(flatbuffers::FlatBuffe _asymmetric_quantize_inputs); } -inline RNNOptionsT *RNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline RNNOptionsT *RNNOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new RNNOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void RNNOptions::UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void RNNOptions::UnPackTo(RNNOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; } } -inline flatbuffers::Offset RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset RNNOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateRNNOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateRNNOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RNNOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs; return tflite::CreateRNNOptions( @@ -17761,13 +17761,13 @@ inline flatbuffers::Offset CreateRNNOptions(flatbuffers::FlatBufferB _asymmetric_quantize_inputs); } -inline SequenceRNNOptionsT *SequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SequenceRNNOptionsT *SequenceRNNOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SequenceRNNOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = time_major(); _o->time_major = _e; } @@ -17775,14 +17775,14 @@ inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT *_o, const flatbuff { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; } } -inline flatbuffers::Offset SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SequenceRNNOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSequenceRNNOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSequenceRNNOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SequenceRNNOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _time_major = _o->time_major; auto _fused_activation_function = _o->fused_activation_function; auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs; @@ -17793,13 +17793,13 @@ inline flatbuffers::Offset CreateSequenceRNNOptions(flatbuff _asymmetric_quantize_inputs); } -inline BidirectionalSequenceRNNOptionsT *BidirectionalSequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BidirectionalSequenceRNNOptionsT *BidirectionalSequenceRNNOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BidirectionalSequenceRNNOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = time_major(); _o->time_major = _e; } @@ -17808,14 +17808,14 @@ inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOp { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; } } -inline flatbuffers::Offset BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset BidirectionalSequenceRNNOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBidirectionalSequenceRNNOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceRNNOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _time_major = _o->time_major; auto _fused_activation_function = _o->fused_activation_function; auto _merge_outputs = _o->merge_outputs; @@ -17828,13 +17828,13 @@ inline flatbuffers::Offset CreateBidirectionalS _asymmetric_quantize_inputs); } -inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new FullyConnectedOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } @@ -17844,14 +17844,14 @@ inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o, const fl { auto _e = quantized_bias_type(); _o->quantized_bias_type = _e; } } -inline flatbuffers::Offset FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset FullyConnectedOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateFullyConnectedOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateFullyConnectedOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FullyConnectedOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FullyConnectedOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; auto _weights_format = _o->weights_format; auto _keep_num_dims = _o->keep_num_dims; @@ -17866,53 +17866,53 @@ inline flatbuffers::Offset CreateFullyConnectedOptions(fl _quantized_bias_type); } -inline SoftmaxOptionsT *SoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SoftmaxOptionsT *SoftmaxOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SoftmaxOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = beta(); _o->beta = _e; } } -inline flatbuffers::Offset SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SoftmaxOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSoftmaxOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSoftmaxOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SoftmaxOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _beta = _o->beta; return tflite::CreateSoftmaxOptions( _fbb, _beta); } -inline ConcatenationOptionsT *ConcatenationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ConcatenationOptionsT *ConcatenationOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ConcatenationOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = axis(); _o->axis = _e; } { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } } -inline flatbuffers::Offset ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ConcatenationOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateConcatenationOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateConcatenationOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatenationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ConcatenationOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _axis = _o->axis; auto _fused_activation_function = _o->fused_activation_function; return tflite::CreateConcatenationOptions( @@ -17921,27 +17921,27 @@ inline flatbuffers::Offset CreateConcatenationOptions(flat _fused_activation_function); } -inline AddOptionsT *AddOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline AddOptionsT *AddOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new AddOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void AddOptions::UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void AddOptions::UnPackTo(AddOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } { auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; } } -inline flatbuffers::Offset AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset AddOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateAddOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateAddOptions(::flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AddOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; auto _pot_scale_int16 = _o->pot_scale_int16; return tflite::CreateAddOptions( @@ -17950,65 +17950,65 @@ inline flatbuffers::Offset CreateAddOptions(flatbuffers::FlatBufferB _pot_scale_int16); } -inline MulOptionsT *MulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline MulOptionsT *MulOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new MulOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void MulOptions::UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void MulOptions::UnPackTo(MulOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } } -inline flatbuffers::Offset MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset MulOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateMulOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateMulOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MulOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; return tflite::CreateMulOptions( _fbb, _fused_activation_function); } -inline L2NormOptionsT *L2NormOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline L2NormOptionsT *L2NormOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new L2NormOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void L2NormOptions::UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void L2NormOptions::UnPackTo(L2NormOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } } -inline flatbuffers::Offset L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset L2NormOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateL2NormOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateL2NormOptions(::flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const L2NormOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const L2NormOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; return tflite::CreateL2NormOptions( _fbb, _fused_activation_function); } -inline LocalResponseNormalizationOptionsT *LocalResponseNormalizationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LocalResponseNormalizationOptionsT *LocalResponseNormalizationOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LocalResponseNormalizationOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = radius(); _o->radius = _e; } @@ -18017,14 +18017,14 @@ inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizati { auto _e = beta(); _o->beta = _e; } } -inline flatbuffers::Offset LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LocalResponseNormalizationOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLocalResponseNormalizationOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LocalResponseNormalizationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LocalResponseNormalizationOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _radius = _o->radius; auto _bias = _o->bias; auto _alpha = _o->alpha; @@ -18037,13 +18037,13 @@ inline flatbuffers::Offset CreateLocalRespons _beta); } -inline LSTMOptionsT *LSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LSTMOptionsT *LSTMOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LSTMOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } @@ -18053,14 +18053,14 @@ inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_ { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; } } -inline flatbuffers::Offset LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LSTMOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLSTMOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLSTMOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LSTMOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; auto _cell_clip = _o->cell_clip; auto _proj_clip = _o->proj_clip; @@ -18075,13 +18075,13 @@ inline flatbuffers::Offset CreateLSTMOptions(flatbuffers::FlatBuffe _asymmetric_quantize_inputs); } -inline UnidirectionalSequenceLSTMOptionsT *UnidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline UnidirectionalSequenceLSTMOptionsT *UnidirectionalSequenceLSTMOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new UnidirectionalSequenceLSTMOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } @@ -18092,14 +18092,14 @@ inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLS { auto _e = diagonal_recurrent_tensors(); _o->diagonal_recurrent_tensors = _e; } } -inline flatbuffers::Offset UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset UnidirectionalSequenceLSTMOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUnidirectionalSequenceLSTMOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const UnidirectionalSequenceLSTMOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; auto _cell_clip = _o->cell_clip; auto _proj_clip = _o->proj_clip; @@ -18116,13 +18116,13 @@ inline flatbuffers::Offset CreateUnidirection _diagonal_recurrent_tensors); } -inline BidirectionalSequenceLSTMOptionsT *BidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BidirectionalSequenceLSTMOptionsT *BidirectionalSequenceLSTMOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BidirectionalSequenceLSTMOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } @@ -18133,14 +18133,14 @@ inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTM { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; } } -inline flatbuffers::Offset BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset BidirectionalSequenceLSTMOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBidirectionalSequenceLSTMOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceLSTMOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; auto _cell_clip = _o->cell_clip; auto _proj_clip = _o->proj_clip; @@ -18157,27 +18157,27 @@ inline flatbuffers::Offset CreateBidirectional _asymmetric_quantize_inputs); } -inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ResizeBilinearOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = align_corners(); _o->align_corners = _e; } { auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; } } -inline flatbuffers::Offset ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ResizeBilinearOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateResizeBilinearOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateResizeBilinearOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeBilinearOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ResizeBilinearOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _align_corners = _o->align_corners; auto _half_pixel_centers = _o->half_pixel_centers; return tflite::CreateResizeBilinearOptions( @@ -18186,27 +18186,27 @@ inline flatbuffers::Offset CreateResizeBilinearOptions(fl _half_pixel_centers); } -inline ResizeNearestNeighborOptionsT *ResizeNearestNeighborOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ResizeNearestNeighborOptionsT *ResizeNearestNeighborOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ResizeNearestNeighborOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = align_corners(); _o->align_corners = _e; } { auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; } } -inline flatbuffers::Offset ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ResizeNearestNeighborOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateResizeNearestNeighborOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeNearestNeighborOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ResizeNearestNeighborOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _align_corners = _o->align_corners; auto _half_pixel_centers = _o->half_pixel_centers; return tflite::CreateResizeNearestNeighborOptions( @@ -18215,157 +18215,157 @@ inline flatbuffers::Offset CreateResizeNearestNeig _half_pixel_centers); } -inline CallOptionsT *CallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline CallOptionsT *CallOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new CallOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void CallOptions::UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void CallOptions::UnPackTo(CallOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = subgraph(); _o->subgraph = _e; } } -inline flatbuffers::Offset CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CallOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateCallOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateCallOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CallOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _subgraph = _o->subgraph; return tflite::CreateCallOptions( _fbb, _subgraph); } -inline PadOptionsT *PadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline PadOptionsT *PadOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new PadOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void PadOptions::UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void PadOptions::UnPackTo(PadOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset PadOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreatePadOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreatePadOptions(::flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const PadOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreatePadOptions( _fbb); } -inline PadV2OptionsT *PadV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline PadV2OptionsT *PadV2Options::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new PadV2OptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void PadV2Options::UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void PadV2Options::UnPackTo(PadV2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset PadV2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreatePadV2Options(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreatePadV2Options(::flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const PadV2OptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreatePadV2Options( _fbb); } -inline ReshapeOptionsT *ReshapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ReshapeOptionsT *ReshapeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ReshapeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ReshapeOptions::UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ReshapeOptions::UnPackTo(ReshapeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_shape[_i] = _e->Get(_i); } } } + { auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_shape[_i] = _e->Get(_i); } } else { _o->new_shape.resize(0); } } } -inline flatbuffers::Offset ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ReshapeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateReshapeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateReshapeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReshapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReshapeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : 0; return tflite::CreateReshapeOptions( _fbb, _new_shape); } -inline SpaceToBatchNDOptionsT *SpaceToBatchNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SpaceToBatchNDOptionsT *SpaceToBatchNDOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SpaceToBatchNDOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SpaceToBatchNDOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSpaceToBatchNDOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToBatchNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SpaceToBatchNDOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateSpaceToBatchNDOptions( _fbb); } -inline BatchToSpaceNDOptionsT *BatchToSpaceNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BatchToSpaceNDOptionsT *BatchToSpaceNDOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BatchToSpaceNDOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset BatchToSpaceNDOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBatchToSpaceNDOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchToSpaceNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BatchToSpaceNDOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateBatchToSpaceNDOptions( _fbb); } -inline SkipGramOptionsT *SkipGramOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SkipGramOptionsT *SkipGramOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SkipGramOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = ngram_size(); _o->ngram_size = _e; } @@ -18373,14 +18373,14 @@ inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o, const flatbuffers::r { auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; } } -inline flatbuffers::Offset SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SkipGramOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSkipGramOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSkipGramOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SkipGramOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SkipGramOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _ngram_size = _o->ngram_size; auto _max_skip_size = _o->max_skip_size; auto _include_all_ngrams = _o->include_all_ngrams; @@ -18391,79 +18391,79 @@ inline flatbuffers::Offset CreateSkipGramOptions(flatbuffers::F _include_all_ngrams); } -inline SpaceToDepthOptionsT *SpaceToDepthOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SpaceToDepthOptionsT *SpaceToDepthOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SpaceToDepthOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = block_size(); _o->block_size = _e; } } -inline flatbuffers::Offset SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SpaceToDepthOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSpaceToDepthOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSpaceToDepthOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToDepthOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SpaceToDepthOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _block_size = _o->block_size; return tflite::CreateSpaceToDepthOptions( _fbb, _block_size); } -inline DepthToSpaceOptionsT *DepthToSpaceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DepthToSpaceOptionsT *DepthToSpaceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DepthToSpaceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void DepthToSpaceOptions::UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void DepthToSpaceOptions::UnPackTo(DepthToSpaceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = block_size(); _o->block_size = _e; } } -inline flatbuffers::Offset DepthToSpaceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset DepthToSpaceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateDepthToSpaceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateDepthToSpaceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthToSpaceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DepthToSpaceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _block_size = _o->block_size; return tflite::CreateDepthToSpaceOptions( _fbb, _block_size); } -inline SubOptionsT *SubOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SubOptionsT *SubOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SubOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SubOptions::UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SubOptions::UnPackTo(SubOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } { auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; } } -inline flatbuffers::Offset SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SubOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSubOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSubOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SubOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; auto _pot_scale_int16 = _o->pot_scale_int16; return tflite::CreateSubOptions( @@ -18472,102 +18472,102 @@ inline flatbuffers::Offset CreateSubOptions(flatbuffers::FlatBufferB _pot_scale_int16); } -inline DivOptionsT *DivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DivOptionsT *DivOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DivOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void DivOptions::UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void DivOptions::UnPackTo(DivOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = fused_activation_function(); _o->fused_activation_function = _e; } } -inline flatbuffers::Offset DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset DivOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateDivOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateDivOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DivOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _fused_activation_function = _o->fused_activation_function; return tflite::CreateDivOptions( _fbb, _fused_activation_function); } -inline TopKV2OptionsT *TopKV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline TopKV2OptionsT *TopKV2Options::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new TopKV2OptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void TopKV2Options::UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void TopKV2Options::UnPackTo(TopKV2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset TopKV2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateTopKV2Options(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateTopKV2Options(::flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TopKV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TopKV2OptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateTopKV2Options( _fbb); } -inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new EmbeddingLookupSparseOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = combiner(); _o->combiner = _e; } } -inline flatbuffers::Offset EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset EmbeddingLookupSparseOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateEmbeddingLookupSparseOptions(::flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EmbeddingLookupSparseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const EmbeddingLookupSparseOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _combiner = _o->combiner; return tflite::CreateEmbeddingLookupSparseOptions( _fbb, _combiner); } -inline GatherOptionsT *GatherOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline GatherOptionsT *GatherOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new GatherOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void GatherOptions::UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void GatherOptions::UnPackTo(GatherOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = axis(); _o->axis = _e; } { auto _e = batch_dims(); _o->batch_dims = _e; } } -inline flatbuffers::Offset GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset GatherOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateGatherOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateGatherOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GatherOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _axis = _o->axis; auto _batch_dims = _o->batch_dims; return tflite::CreateGatherOptions( @@ -18576,186 +18576,186 @@ inline flatbuffers::Offset CreateGatherOptions(flatbuffers::FlatB _batch_dims); } -inline TransposeOptionsT *TransposeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline TransposeOptionsT *TransposeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new TransposeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void TransposeOptions::UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void TransposeOptions::UnPackTo(TransposeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset TransposeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateTransposeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateTransposeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TransposeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateTransposeOptions( _fbb); } -inline ExpOptionsT *ExpOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ExpOptionsT *ExpOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ExpOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ExpOptions::UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ExpOptions::UnPackTo(ExpOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ExpOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateExpOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateExpOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ExpOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateExpOptions( _fbb); } -inline CosOptionsT *CosOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline CosOptionsT *CosOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new CosOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void CosOptions::UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void CosOptions::UnPackTo(CosOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CosOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateCosOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateCosOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CosOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CosOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateCosOptions( _fbb); } -inline ReducerOptionsT *ReducerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ReducerOptionsT *ReducerOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ReducerOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ReducerOptions::UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ReducerOptions::UnPackTo(ReducerOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = keep_dims(); _o->keep_dims = _e; } } -inline flatbuffers::Offset ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ReducerOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateReducerOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateReducerOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReducerOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReducerOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _keep_dims = _o->keep_dims; return tflite::CreateReducerOptions( _fbb, _keep_dims); } -inline SqueezeOptionsT *SqueezeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SqueezeOptionsT *SqueezeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SqueezeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SqueezeOptions::UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SqueezeOptions::UnPackTo(SqueezeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = squeeze_dims(); if (_e) { _o->squeeze_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->squeeze_dims[_i] = _e->Get(_i); } } } + { auto _e = squeeze_dims(); if (_e) { _o->squeeze_dims.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->squeeze_dims[_i] = _e->Get(_i); } } else { _o->squeeze_dims.resize(0); } } } -inline flatbuffers::Offset SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SqueezeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSqueezeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSqueezeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SqueezeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SqueezeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _squeeze_dims = _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : 0; return tflite::CreateSqueezeOptions( _fbb, _squeeze_dims); } -inline SplitOptionsT *SplitOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SplitOptionsT *SplitOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SplitOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SplitOptions::UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SplitOptions::UnPackTo(SplitOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = num_splits(); _o->num_splits = _e; } } -inline flatbuffers::Offset SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SplitOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSplitOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSplitOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SplitOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _num_splits = _o->num_splits; return tflite::CreateSplitOptions( _fbb, _num_splits); } -inline SplitVOptionsT *SplitVOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SplitVOptionsT *SplitVOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SplitVOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SplitVOptions::UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SplitVOptions::UnPackTo(SplitVOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = num_splits(); _o->num_splits = _e; } } -inline flatbuffers::Offset SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SplitVOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSplitVOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSplitVOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitVOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SplitVOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _num_splits = _o->num_splits; return tflite::CreateSplitVOptions( _fbb, _num_splits); } -inline StridedSliceOptionsT *StridedSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline StridedSliceOptionsT *StridedSliceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new StridedSliceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = begin_mask(); _o->begin_mask = _e; } @@ -18766,14 +18766,14 @@ inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT *_o, const flatbu { auto _e = offset(); _o->offset = _e; } } -inline flatbuffers::Offset StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset StridedSliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateStridedSliceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateStridedSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StridedSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StridedSliceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _begin_mask = _o->begin_mask; auto _end_mask = _o->end_mask; auto _ellipsis_mask = _o->ellipsis_mask; @@ -18790,50 +18790,50 @@ inline flatbuffers::Offset CreateStridedSliceOptions(flatbu _offset); } -inline LogSoftmaxOptionsT *LogSoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LogSoftmaxOptionsT *LogSoftmaxOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LogSoftmaxOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LogSoftmaxOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLogSoftmaxOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLogSoftmaxOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogSoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LogSoftmaxOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateLogSoftmaxOptions( _fbb); } -inline CastOptionsT *CastOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline CastOptionsT *CastOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new CastOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void CastOptions::UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void CastOptions::UnPackTo(CastOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = in_data_type(); _o->in_data_type = _e; } { auto _e = out_data_type(); _o->out_data_type = _e; } } -inline flatbuffers::Offset CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CastOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateCastOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateCastOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CastOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CastOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _in_data_type = _o->in_data_type; auto _out_data_type = _o->out_data_type; return tflite::CreateCastOptions( @@ -18842,295 +18842,295 @@ inline flatbuffers::Offset CreateCastOptions(flatbuffers::FlatBuffe _out_data_type); } -inline DequantizeOptionsT *DequantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DequantizeOptionsT *DequantizeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DequantizeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void DequantizeOptions::UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void DequantizeOptions::UnPackTo(DequantizeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset DequantizeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateDequantizeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateDequantizeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DequantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DequantizeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateDequantizeOptions( _fbb); } -inline MaximumMinimumOptionsT *MaximumMinimumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline MaximumMinimumOptionsT *MaximumMinimumOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new MaximumMinimumOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset MaximumMinimumOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateMaximumMinimumOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateMaximumMinimumOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MaximumMinimumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MaximumMinimumOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateMaximumMinimumOptions( _fbb); } -inline TileOptionsT *TileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline TileOptionsT *TileOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new TileOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void TileOptions::UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void TileOptions::UnPackTo(TileOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset TileOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateTileOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateTileOptions(::flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TileOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateTileOptions( _fbb); } -inline ArgMaxOptionsT *ArgMaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ArgMaxOptionsT *ArgMaxOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ArgMaxOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = output_type(); _o->output_type = _e; } } -inline flatbuffers::Offset ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ArgMaxOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateArgMaxOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateArgMaxOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ArgMaxOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _output_type = _o->output_type; return tflite::CreateArgMaxOptions( _fbb, _output_type); } -inline ArgMinOptionsT *ArgMinOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ArgMinOptionsT *ArgMinOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ArgMinOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ArgMinOptions::UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ArgMinOptions::UnPackTo(ArgMinOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = output_type(); _o->output_type = _e; } } -inline flatbuffers::Offset ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ArgMinOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateArgMinOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateArgMinOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMinOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ArgMinOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _output_type = _o->output_type; return tflite::CreateArgMinOptions( _fbb, _output_type); } -inline GreaterOptionsT *GreaterOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline GreaterOptionsT *GreaterOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new GreaterOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void GreaterOptions::UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void GreaterOptions::UnPackTo(GreaterOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset GreaterOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateGreaterOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateGreaterOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GreaterOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateGreaterOptions( _fbb); } -inline GreaterEqualOptionsT *GreaterEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline GreaterEqualOptionsT *GreaterEqualOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new GreaterEqualOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset GreaterEqualOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateGreaterEqualOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateGreaterEqualOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GreaterEqualOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateGreaterEqualOptions( _fbb); } -inline LessOptionsT *LessOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LessOptionsT *LessOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LessOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LessOptions::UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LessOptions::UnPackTo(LessOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LessOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLessOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLessOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LessOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateLessOptions( _fbb); } -inline LessEqualOptionsT *LessEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LessEqualOptionsT *LessEqualOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LessEqualOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LessEqualOptions::UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LessEqualOptions::UnPackTo(LessEqualOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LessEqualOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLessEqualOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLessEqualOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LessEqualOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateLessEqualOptions( _fbb); } -inline NegOptionsT *NegOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline NegOptionsT *NegOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new NegOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void NegOptions::UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void NegOptions::UnPackTo(NegOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset NegOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateNegOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateNegOptions(::flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NegOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const NegOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateNegOptions( _fbb); } -inline SelectOptionsT *SelectOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SelectOptionsT *SelectOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SelectOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SelectOptions::UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SelectOptions::UnPackTo(SelectOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SelectOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSelectOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSelectOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SelectOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateSelectOptions( _fbb); } -inline SliceOptionsT *SliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SliceOptionsT *SliceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SliceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SliceOptions::UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SliceOptions::UnPackTo(SliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSliceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SliceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateSliceOptions( _fbb); } -inline TransposeConvOptionsT *TransposeConvOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline TransposeConvOptionsT *TransposeConvOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new TransposeConvOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = padding(); _o->padding = _e; } @@ -19140,14 +19140,14 @@ inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT *_o, const flat { auto _e = quantized_bias_type(); _o->quantized_bias_type = _e; } } -inline flatbuffers::Offset TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset TransposeConvOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateTransposeConvOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateTransposeConvOptions(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeConvOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TransposeConvOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _padding = _o->padding; auto _stride_w = _o->stride_w; auto _stride_h = _o->stride_h; @@ -19162,180 +19162,180 @@ inline flatbuffers::Offset CreateTransposeConvOptions(flat _quantized_bias_type); } -inline ExpandDimsOptionsT *ExpandDimsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ExpandDimsOptionsT *ExpandDimsOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ExpandDimsOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ExpandDimsOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateExpandDimsOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateExpandDimsOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpandDimsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ExpandDimsOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateExpandDimsOptions( _fbb); } -inline SparseToDenseOptionsT *SparseToDenseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SparseToDenseOptionsT *SparseToDenseOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SparseToDenseOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = validate_indices(); _o->validate_indices = _e; } } -inline flatbuffers::Offset SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SparseToDenseOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSparseToDenseOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSparseToDenseOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparseToDenseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SparseToDenseOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _validate_indices = _o->validate_indices; return tflite::CreateSparseToDenseOptions( _fbb, _validate_indices); } -inline EqualOptionsT *EqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline EqualOptionsT *EqualOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new EqualOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void EqualOptions::UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void EqualOptions::UnPackTo(EqualOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset EqualOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateEqualOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateEqualOptions(::flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const EqualOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateEqualOptions( _fbb); } -inline NotEqualOptionsT *NotEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline NotEqualOptionsT *NotEqualOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new NotEqualOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void NotEqualOptions::UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void NotEqualOptions::UnPackTo(NotEqualOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset NotEqualOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateNotEqualOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateNotEqualOptions(::flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NotEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const NotEqualOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateNotEqualOptions( _fbb); } -inline ShapeOptionsT *ShapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ShapeOptionsT *ShapeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ShapeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ShapeOptions::UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ShapeOptions::UnPackTo(ShapeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = out_type(); _o->out_type = _e; } } -inline flatbuffers::Offset ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ShapeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateShapeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateShapeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ShapeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _out_type = _o->out_type; return tflite::CreateShapeOptions( _fbb, _out_type); } -inline RankOptionsT *RankOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline RankOptionsT *RankOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new RankOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void RankOptions::UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void RankOptions::UnPackTo(RankOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset RankOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateRankOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateRankOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RankOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RankOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateRankOptions( _fbb); } -inline PowOptionsT *PowOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline PowOptionsT *PowOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new PowOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void PowOptions::UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void PowOptions::UnPackTo(PowOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset PowOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreatePowOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreatePowOptions(::flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PowOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const PowOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreatePowOptions( _fbb); } -inline FakeQuantOptionsT *FakeQuantOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline FakeQuantOptionsT *FakeQuantOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new FakeQuantOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = min(); _o->min = _e; } @@ -19344,14 +19344,14 @@ inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT *_o, const flatbuffers: { auto _e = narrow_range(); _o->narrow_range = _e; } } -inline flatbuffers::Offset FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset FakeQuantOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateFakeQuantOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateFakeQuantOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FakeQuantOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FakeQuantOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _min = _o->min; auto _max = _o->max; auto _num_bits = _o->num_bits; @@ -19364,27 +19364,27 @@ inline flatbuffers::Offset CreateFakeQuantOptions(flatbuffers: _narrow_range); } -inline PackOptionsT *PackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline PackOptionsT *PackOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new PackOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void PackOptions::UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void PackOptions::UnPackTo(PackOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = values_count(); _o->values_count = _e; } { auto _e = axis(); _o->axis = _e; } } -inline flatbuffers::Offset PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset PackOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreatePackOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreatePackOptions(::flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const PackOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _values_count = _o->values_count; auto _axis = _o->axis; return tflite::CreatePackOptions( @@ -19393,168 +19393,168 @@ inline flatbuffers::Offset CreatePackOptions(flatbuffers::FlatBuffe _axis); } -inline LogicalOrOptionsT *LogicalOrOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LogicalOrOptionsT *LogicalOrOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LogicalOrOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LogicalOrOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLogicalOrOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLogicalOrOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalOrOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LogicalOrOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateLogicalOrOptions( _fbb); } -inline OneHotOptionsT *OneHotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline OneHotOptionsT *OneHotOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new OneHotOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void OneHotOptions::UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void OneHotOptions::UnPackTo(OneHotOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = axis(); _o->axis = _e; } } -inline flatbuffers::Offset OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset OneHotOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateOneHotOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateOneHotOptions(::flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OneHotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const OneHotOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _axis = _o->axis; return tflite::CreateOneHotOptions( _fbb, _axis); } -inline AbsOptionsT *AbsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline AbsOptionsT *AbsOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new AbsOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void AbsOptions::UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void AbsOptions::UnPackTo(AbsOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset AbsOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateAbsOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateAbsOptions(::flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AbsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AbsOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateAbsOptions( _fbb); } -inline HardSwishOptionsT *HardSwishOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline HardSwishOptionsT *HardSwishOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new HardSwishOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void HardSwishOptions::UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void HardSwishOptions::UnPackTo(HardSwishOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset HardSwishOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset HardSwishOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateHardSwishOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateHardSwishOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HardSwishOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HardSwishOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateHardSwishOptions( _fbb); } -inline LogicalAndOptionsT *LogicalAndOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LogicalAndOptionsT *LogicalAndOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LogicalAndOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LogicalAndOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLogicalAndOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLogicalAndOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalAndOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LogicalAndOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateLogicalAndOptions( _fbb); } -inline LogicalNotOptionsT *LogicalNotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LogicalNotOptionsT *LogicalNotOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LogicalNotOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LogicalNotOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLogicalNotOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLogicalNotOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalNotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LogicalNotOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateLogicalNotOptions( _fbb); } -inline UnpackOptionsT *UnpackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline UnpackOptionsT *UnpackOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new UnpackOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void UnpackOptions::UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void UnpackOptions::UnPackTo(UnpackOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = num(); _o->num = _e; } { auto _e = axis(); _o->axis = _e; } } -inline flatbuffers::Offset UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset UnpackOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUnpackOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUnpackOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnpackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const UnpackOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _num = _o->num; auto _axis = _o->axis; return tflite::CreateUnpackOptions( @@ -19563,358 +19563,358 @@ inline flatbuffers::Offset CreateUnpackOptions(flatbuffers::FlatB _axis); } -inline FloorDivOptionsT *FloorDivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline FloorDivOptionsT *FloorDivOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new FloorDivOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void FloorDivOptions::UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void FloorDivOptions::UnPackTo(FloorDivOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset FloorDivOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateFloorDivOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateFloorDivOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorDivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FloorDivOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateFloorDivOptions( _fbb); } -inline SquareOptionsT *SquareOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SquareOptionsT *SquareOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SquareOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SquareOptions::UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SquareOptions::UnPackTo(SquareOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SquareOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSquareOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSquareOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquareOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SquareOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateSquareOptions( _fbb); } -inline ZerosLikeOptionsT *ZerosLikeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ZerosLikeOptionsT *ZerosLikeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ZerosLikeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ZerosLikeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateZerosLikeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateZerosLikeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ZerosLikeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ZerosLikeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateZerosLikeOptions( _fbb); } -inline FillOptionsT *FillOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline FillOptionsT *FillOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new FillOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void FillOptions::UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void FillOptions::UnPackTo(FillOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset FillOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateFillOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateFillOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FillOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FillOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateFillOptions( _fbb); } -inline FloorModOptionsT *FloorModOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline FloorModOptionsT *FloorModOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new FloorModOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void FloorModOptions::UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void FloorModOptions::UnPackTo(FloorModOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset FloorModOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateFloorModOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateFloorModOptions(::flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorModOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FloorModOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateFloorModOptions( _fbb); } -inline RangeOptionsT *RangeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline RangeOptionsT *RangeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new RangeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void RangeOptions::UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void RangeOptions::UnPackTo(RangeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset RangeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateRangeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateRangeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RangeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RangeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateRangeOptions( _fbb); } -inline LeakyReluOptionsT *LeakyReluOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline LeakyReluOptionsT *LeakyReluOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new LeakyReluOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = alpha(); _o->alpha = _e; } } -inline flatbuffers::Offset LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset LeakyReluOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateLeakyReluOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateLeakyReluOptions(::flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LeakyReluOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const LeakyReluOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _alpha = _o->alpha; return tflite::CreateLeakyReluOptions( _fbb, _alpha); } -inline SquaredDifferenceOptionsT *SquaredDifferenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SquaredDifferenceOptionsT *SquaredDifferenceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SquaredDifferenceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SquaredDifferenceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSquaredDifferenceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquaredDifferenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SquaredDifferenceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateSquaredDifferenceOptions( _fbb); } -inline MirrorPadOptionsT *MirrorPadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline MirrorPadOptionsT *MirrorPadOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new MirrorPadOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = mode(); _o->mode = _e; } } -inline flatbuffers::Offset MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset MirrorPadOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateMirrorPadOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateMirrorPadOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MirrorPadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MirrorPadOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _mode = _o->mode; return tflite::CreateMirrorPadOptions( _fbb, _mode); } -inline UniqueOptionsT *UniqueOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline UniqueOptionsT *UniqueOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new UniqueOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void UniqueOptions::UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void UniqueOptions::UnPackTo(UniqueOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = idx_out_type(); _o->idx_out_type = _e; } } -inline flatbuffers::Offset UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset UniqueOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUniqueOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUniqueOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UniqueOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const UniqueOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _idx_out_type = _o->idx_out_type; return tflite::CreateUniqueOptions( _fbb, _idx_out_type); } -inline ReverseV2OptionsT *ReverseV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ReverseV2OptionsT *ReverseV2Options::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ReverseV2OptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ReverseV2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateReverseV2Options(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateReverseV2Options(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReverseV2OptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateReverseV2Options( _fbb); } -inline AddNOptionsT *AddNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline AddNOptionsT *AddNOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new AddNOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void AddNOptions::UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void AddNOptions::UnPackTo(AddNOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset AddNOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateAddNOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateAddNOptions(::flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AddNOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateAddNOptions( _fbb); } -inline GatherNdOptionsT *GatherNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline GatherNdOptionsT *GatherNdOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new GatherNdOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void GatherNdOptions::UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void GatherNdOptions::UnPackTo(GatherNdOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset GatherNdOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateGatherNdOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateGatherNdOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GatherNdOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateGatherNdOptions( _fbb); } -inline WhereOptionsT *WhereOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline WhereOptionsT *WhereOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new WhereOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void WhereOptions::UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void WhereOptions::UnPackTo(WhereOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset WhereOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateWhereOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateWhereOptions(::flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhereOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WhereOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateWhereOptions( _fbb); } -inline ReverseSequenceOptionsT *ReverseSequenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ReverseSequenceOptionsT *ReverseSequenceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ReverseSequenceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = seq_dim(); _o->seq_dim = _e; } { auto _e = batch_dim(); _o->batch_dim = _e; } } -inline flatbuffers::Offset ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ReverseSequenceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateReverseSequenceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateReverseSequenceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseSequenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReverseSequenceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _seq_dim = _o->seq_dim; auto _batch_dim = _o->batch_dim; return tflite::CreateReverseSequenceOptions( @@ -19923,96 +19923,96 @@ inline flatbuffers::Offset CreateReverseSequenceOptions( _batch_dim); } -inline MatrixDiagOptionsT *MatrixDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline MatrixDiagOptionsT *MatrixDiagOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new MatrixDiagOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void MatrixDiagOptions::UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void MatrixDiagOptions::UnPackTo(MatrixDiagOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset MatrixDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset MatrixDiagOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateMatrixDiagOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateMatrixDiagOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixDiagOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MatrixDiagOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateMatrixDiagOptions( _fbb); } -inline QuantizeOptionsT *QuantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline QuantizeOptionsT *QuantizeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new QuantizeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void QuantizeOptions::UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void QuantizeOptions::UnPackTo(QuantizeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset QuantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset QuantizeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateQuantizeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateQuantizeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const QuantizeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateQuantizeOptions( _fbb); } -inline MatrixSetDiagOptionsT *MatrixSetDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline MatrixSetDiagOptionsT *MatrixSetDiagOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new MatrixSetDiagOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void MatrixSetDiagOptions::UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void MatrixSetDiagOptions::UnPackTo(MatrixSetDiagOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset MatrixSetDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset MatrixSetDiagOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateMatrixSetDiagOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateMatrixSetDiagOptions(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixSetDiagOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MatrixSetDiagOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateMatrixSetDiagOptions( _fbb); } -inline IfOptionsT *IfOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline IfOptionsT *IfOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new IfOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void IfOptions::UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void IfOptions::UnPackTo(IfOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = then_subgraph_index(); _o->then_subgraph_index = _e; } { auto _e = else_subgraph_index(); _o->else_subgraph_index = _e; } } -inline flatbuffers::Offset IfOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset IfOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateIfOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateIfOptions(::flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IfOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const IfOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _then_subgraph_index = _o->then_subgraph_index; auto _else_subgraph_index = _o->else_subgraph_index; return tflite::CreateIfOptions( @@ -20021,53 +20021,53 @@ inline flatbuffers::Offset CreateIfOptions(flatbuffers::FlatBufferBui _else_subgraph_index); } -inline CallOnceOptionsT *CallOnceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline CallOnceOptionsT *CallOnceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new CallOnceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void CallOnceOptions::UnPackTo(CallOnceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void CallOnceOptions::UnPackTo(CallOnceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = init_subgraph_index(); _o->init_subgraph_index = _e; } } -inline flatbuffers::Offset CallOnceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CallOnceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateCallOnceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateCallOnceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOnceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CallOnceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _init_subgraph_index = _o->init_subgraph_index; return tflite::CreateCallOnceOptions( _fbb, _init_subgraph_index); } -inline WhileOptionsT *WhileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline WhileOptionsT *WhileOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new WhileOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void WhileOptions::UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void WhileOptions::UnPackTo(WhileOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = cond_subgraph_index(); _o->cond_subgraph_index = _e; } { auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; } } -inline flatbuffers::Offset WhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset WhileOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateWhileOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateWhileOptions(::flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WhileOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _cond_subgraph_index = _o->cond_subgraph_index; auto _body_subgraph_index = _o->body_subgraph_index; return tflite::CreateWhileOptions( @@ -20076,151 +20076,151 @@ inline flatbuffers::Offset CreateWhileOptions(flatbuffers::FlatBuf _body_subgraph_index); } -inline NonMaxSuppressionV4OptionsT *NonMaxSuppressionV4Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline NonMaxSuppressionV4OptionsT *NonMaxSuppressionV4Options::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new NonMaxSuppressionV4OptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void NonMaxSuppressionV4Options::UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void NonMaxSuppressionV4Options::UnPackTo(NonMaxSuppressionV4OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset NonMaxSuppressionV4Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset NonMaxSuppressionV4Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateNonMaxSuppressionV4Options(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateNonMaxSuppressionV4Options(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV4OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV4OptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateNonMaxSuppressionV4Options( _fbb); } -inline NonMaxSuppressionV5OptionsT *NonMaxSuppressionV5Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline NonMaxSuppressionV5OptionsT *NonMaxSuppressionV5Options::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new NonMaxSuppressionV5OptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void NonMaxSuppressionV5Options::UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void NonMaxSuppressionV5Options::UnPackTo(NonMaxSuppressionV5OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset NonMaxSuppressionV5Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset NonMaxSuppressionV5Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateNonMaxSuppressionV5Options(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateNonMaxSuppressionV5Options(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV5OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV5OptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateNonMaxSuppressionV5Options( _fbb); } -inline ScatterNdOptionsT *ScatterNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ScatterNdOptionsT *ScatterNdOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ScatterNdOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ScatterNdOptions::UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ScatterNdOptions::UnPackTo(ScatterNdOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset ScatterNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ScatterNdOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateScatterNdOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateScatterNdOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScatterNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ScatterNdOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateScatterNdOptions( _fbb); } -inline SelectV2OptionsT *SelectV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SelectV2OptionsT *SelectV2Options::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SelectV2OptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SelectV2Options::UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SelectV2Options::UnPackTo(SelectV2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset SelectV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SelectV2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSelectV2Options(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSelectV2Options(::flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SelectV2OptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateSelectV2Options( _fbb); } -inline DensifyOptionsT *DensifyOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DensifyOptionsT *DensifyOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DensifyOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void DensifyOptions::UnPackTo(DensifyOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void DensifyOptions::UnPackTo(DensifyOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset DensifyOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset DensifyOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateDensifyOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateDensifyOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DensifyOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DensifyOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateDensifyOptions( _fbb); } -inline SegmentSumOptionsT *SegmentSumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SegmentSumOptionsT *SegmentSumOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SegmentSumOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SegmentSumOptions::UnPackTo(SegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SegmentSumOptions::UnPackTo(SegmentSumOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset SegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SegmentSumOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSegmentSumOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSegmentSumOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SegmentSumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SegmentSumOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateSegmentSumOptions( _fbb); } -inline BatchMatMulOptionsT *BatchMatMulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BatchMatMulOptionsT *BatchMatMulOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BatchMatMulOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void BatchMatMulOptions::UnPackTo(BatchMatMulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void BatchMatMulOptions::UnPackTo(BatchMatMulOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = adj_x(); _o->adj_x = _e; } @@ -20228,14 +20228,14 @@ inline void BatchMatMulOptions::UnPackTo(BatchMatMulOptionsT *_o, const flatbuff { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; } } -inline flatbuffers::Offset BatchMatMulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset BatchMatMulOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBatchMatMulOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBatchMatMulOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchMatMulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BatchMatMulOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _adj_x = _o->adj_x; auto _adj_y = _o->adj_y; auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs; @@ -20246,27 +20246,27 @@ inline flatbuffers::Offset CreateBatchMatMulOptions(flatbuff _asymmetric_quantize_inputs); } -inline CumsumOptionsT *CumsumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline CumsumOptionsT *CumsumOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new CumsumOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void CumsumOptions::UnPackTo(CumsumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void CumsumOptions::UnPackTo(CumsumOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = exclusive(); _o->exclusive = _e; } { auto _e = reverse(); _o->reverse = _e; } } -inline flatbuffers::Offset CumsumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CumsumOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateCumsumOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateCumsumOptions(::flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CumsumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CumsumOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _exclusive = _o->exclusive; auto _reverse = _o->reverse; return tflite::CreateCumsumOptions( @@ -20275,59 +20275,59 @@ inline flatbuffers::Offset CreateCumsumOptions(flatbuffers::FlatB _reverse); } -inline BroadcastToOptionsT *BroadcastToOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BroadcastToOptionsT *BroadcastToOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BroadcastToOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void BroadcastToOptions::UnPackTo(BroadcastToOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void BroadcastToOptions::UnPackTo(BroadcastToOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset BroadcastToOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset BroadcastToOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBroadcastToOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBroadcastToOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BroadcastToOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BroadcastToOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateBroadcastToOptions( _fbb); } -inline Rfft2dOptionsT *Rfft2dOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline Rfft2dOptionsT *Rfft2dOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new Rfft2dOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Rfft2dOptions::UnPackTo(Rfft2dOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Rfft2dOptions::UnPackTo(Rfft2dOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset Rfft2dOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Rfft2dOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateRfft2dOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateRfft2dOptions(::flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Rfft2dOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const Rfft2dOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateRfft2dOptions( _fbb); } -inline HashtableOptionsT *HashtableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline HashtableOptionsT *HashtableOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new HashtableOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void HashtableOptions::UnPackTo(HashtableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void HashtableOptions::UnPackTo(HashtableOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = table_id(); _o->table_id = _e; } @@ -20335,14 +20335,14 @@ inline void HashtableOptions::UnPackTo(HashtableOptionsT *_o, const flatbuffers: { auto _e = value_dtype(); _o->value_dtype = _e; } } -inline flatbuffers::Offset HashtableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset HashtableOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateHashtableOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateHashtableOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HashtableOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _table_id = _o->table_id; auto _key_dtype = _o->key_dtype; auto _value_dtype = _o->value_dtype; @@ -20353,96 +20353,96 @@ inline flatbuffers::Offset CreateHashtableOptions(flatbuffers: _value_dtype); } -inline HashtableFindOptionsT *HashtableFindOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline HashtableFindOptionsT *HashtableFindOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new HashtableFindOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void HashtableFindOptions::UnPackTo(HashtableFindOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void HashtableFindOptions::UnPackTo(HashtableFindOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset HashtableFindOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset HashtableFindOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateHashtableFindOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateHashtableFindOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableFindOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HashtableFindOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateHashtableFindOptions( _fbb); } -inline HashtableImportOptionsT *HashtableImportOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline HashtableImportOptionsT *HashtableImportOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new HashtableImportOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void HashtableImportOptions::UnPackTo(HashtableImportOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void HashtableImportOptions::UnPackTo(HashtableImportOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset HashtableImportOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset HashtableImportOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateHashtableImportOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateHashtableImportOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableImportOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HashtableImportOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateHashtableImportOptions( _fbb); } -inline HashtableSizeOptionsT *HashtableSizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline HashtableSizeOptionsT *HashtableSizeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new HashtableSizeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void HashtableSizeOptions::UnPackTo(HashtableSizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void HashtableSizeOptions::UnPackTo(HashtableSizeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset HashtableSizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset HashtableSizeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateHashtableSizeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateHashtableSizeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableSizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HashtableSizeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateHashtableSizeOptions( _fbb); } -inline VarHandleOptionsT *VarHandleOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline VarHandleOptionsT *VarHandleOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new VarHandleOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void VarHandleOptions::UnPackTo(VarHandleOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void VarHandleOptions::UnPackTo(VarHandleOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = container(); if (_e) _o->container = _e->str(); } { auto _e = shared_name(); if (_e) _o->shared_name = _e->str(); } } -inline flatbuffers::Offset VarHandleOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset VarHandleOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateVarHandleOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateVarHandleOptions(::flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const VarHandleOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const VarHandleOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _container = _o->container.empty() ? 0 : _fbb.CreateString(_o->container); auto _shared_name = _o->shared_name.empty() ? 0 : _fbb.CreateString(_o->shared_name); return tflite::CreateVarHandleOptions( @@ -20451,73 +20451,73 @@ inline flatbuffers::Offset CreateVarHandleOptions(flatbuffers: _shared_name); } -inline ReadVariableOptionsT *ReadVariableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ReadVariableOptionsT *ReadVariableOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ReadVariableOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ReadVariableOptions::UnPackTo(ReadVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ReadVariableOptions::UnPackTo(ReadVariableOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset ReadVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ReadVariableOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateReadVariableOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateReadVariableOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReadVariableOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReadVariableOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateReadVariableOptions( _fbb); } -inline AssignVariableOptionsT *AssignVariableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline AssignVariableOptionsT *AssignVariableOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new AssignVariableOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void AssignVariableOptions::UnPackTo(AssignVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void AssignVariableOptions::UnPackTo(AssignVariableOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset AssignVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset AssignVariableOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateAssignVariableOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateAssignVariableOptions(::flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AssignVariableOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssignVariableOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateAssignVariableOptions( _fbb); } -inline RandomOptionsT *RandomOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline RandomOptionsT *RandomOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new RandomOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void RandomOptions::UnPackTo(RandomOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void RandomOptions::UnPackTo(RandomOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = seed(); _o->seed = _e; } { auto _e = seed2(); _o->seed2 = _e; } } -inline flatbuffers::Offset RandomOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset RandomOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateRandomOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateRandomOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RandomOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RandomOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _seed = _o->seed; auto _seed2 = _o->seed2; return tflite::CreateRandomOptions( @@ -20526,344 +20526,344 @@ inline flatbuffers::Offset CreateRandomOptions(flatbuffers::FlatB _seed2); } -inline BucketizeOptionsT *BucketizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BucketizeOptionsT *BucketizeOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BucketizeOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void BucketizeOptions::UnPackTo(BucketizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void BucketizeOptions::UnPackTo(BucketizeOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = boundaries(); if (_e) { _o->boundaries.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->boundaries[_i] = _e->Get(_i); } } } + { auto _e = boundaries(); if (_e) { _o->boundaries.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->boundaries[_i] = _e->Get(_i); } } else { _o->boundaries.resize(0); } } } -inline flatbuffers::Offset BucketizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset BucketizeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBucketizeOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBucketizeOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BucketizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BucketizeOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _boundaries = _o->boundaries.size() ? _fbb.CreateVector(_o->boundaries) : 0; return tflite::CreateBucketizeOptions( _fbb, _boundaries); } -inline GeluOptionsT *GeluOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline GeluOptionsT *GeluOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new GeluOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void GeluOptions::UnPackTo(GeluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void GeluOptions::UnPackTo(GeluOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = approximate(); _o->approximate = _e; } } -inline flatbuffers::Offset GeluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset GeluOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateGeluOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateGeluOptions(::flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GeluOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GeluOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _approximate = _o->approximate; return tflite::CreateGeluOptions( _fbb, _approximate); } -inline DynamicUpdateSliceOptionsT *DynamicUpdateSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DynamicUpdateSliceOptionsT *DynamicUpdateSliceOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DynamicUpdateSliceOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void DynamicUpdateSliceOptions::UnPackTo(DynamicUpdateSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void DynamicUpdateSliceOptions::UnPackTo(DynamicUpdateSliceOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset DynamicUpdateSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset DynamicUpdateSliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateDynamicUpdateSliceOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateDynamicUpdateSliceOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DynamicUpdateSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DynamicUpdateSliceOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateDynamicUpdateSliceOptions( _fbb); } -inline UnsortedSegmentProdOptionsT *UnsortedSegmentProdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline UnsortedSegmentProdOptionsT *UnsortedSegmentProdOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new UnsortedSegmentProdOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void UnsortedSegmentProdOptions::UnPackTo(UnsortedSegmentProdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void UnsortedSegmentProdOptions::UnPackTo(UnsortedSegmentProdOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset UnsortedSegmentProdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset UnsortedSegmentProdOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUnsortedSegmentProdOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUnsortedSegmentProdOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentProdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentProdOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateUnsortedSegmentProdOptions( _fbb); } -inline UnsortedSegmentMaxOptionsT *UnsortedSegmentMaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline UnsortedSegmentMaxOptionsT *UnsortedSegmentMaxOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new UnsortedSegmentMaxOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void UnsortedSegmentMaxOptions::UnPackTo(UnsortedSegmentMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void UnsortedSegmentMaxOptions::UnPackTo(UnsortedSegmentMaxOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset UnsortedSegmentMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset UnsortedSegmentMaxOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUnsortedSegmentMaxOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUnsortedSegmentMaxOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentMaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentMaxOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateUnsortedSegmentMaxOptions( _fbb); } -inline UnsortedSegmentSumOptionsT *UnsortedSegmentSumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline UnsortedSegmentSumOptionsT *UnsortedSegmentSumOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new UnsortedSegmentSumOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void UnsortedSegmentSumOptions::UnPackTo(UnsortedSegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void UnsortedSegmentSumOptions::UnPackTo(UnsortedSegmentSumOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset UnsortedSegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset UnsortedSegmentSumOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUnsortedSegmentSumOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUnsortedSegmentSumOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentSumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentSumOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateUnsortedSegmentSumOptions( _fbb); } -inline ATan2OptionsT *ATan2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ATan2OptionsT *ATan2Options::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ATan2OptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ATan2Options::UnPackTo(ATan2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ATan2Options::UnPackTo(ATan2OptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset ATan2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ATan2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateATan2Options(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateATan2Options(::flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ATan2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ATan2OptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateATan2Options( _fbb); } -inline UnsortedSegmentMinOptionsT *UnsortedSegmentMinOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline UnsortedSegmentMinOptionsT *UnsortedSegmentMinOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new UnsortedSegmentMinOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void UnsortedSegmentMinOptions::UnPackTo(UnsortedSegmentMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void UnsortedSegmentMinOptions::UnPackTo(UnsortedSegmentMinOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset UnsortedSegmentMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset UnsortedSegmentMinOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateUnsortedSegmentMinOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateUnsortedSegmentMinOptions(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentMinOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentMinOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateUnsortedSegmentMinOptions( _fbb); } -inline SignOptionsT *SignOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SignOptionsT *SignOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SignOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SignOptions::UnPackTo(SignOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SignOptions::UnPackTo(SignOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset SignOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SignOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSignOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSignOptions(::flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SignOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SignOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateSignOptions( _fbb); } -inline BitcastOptionsT *BitcastOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BitcastOptionsT *BitcastOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BitcastOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void BitcastOptions::UnPackTo(BitcastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void BitcastOptions::UnPackTo(BitcastOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset BitcastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset BitcastOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBitcastOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBitcastOptions(flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBitcastOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BitcastOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BitcastOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateBitcastOptions( _fbb); } -inline BitwiseXorOptionsT *BitwiseXorOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BitwiseXorOptionsT *BitwiseXorOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BitwiseXorOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void BitwiseXorOptions::UnPackTo(BitwiseXorOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void BitwiseXorOptions::UnPackTo(BitwiseXorOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset BitwiseXorOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset BitwiseXorOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBitwiseXorOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBitwiseXorOptions(flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBitwiseXorOptions(::flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BitwiseXorOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BitwiseXorOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateBitwiseXorOptions( _fbb); } -inline RightShiftOptionsT *RightShiftOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline RightShiftOptionsT *RightShiftOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new RightShiftOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void RightShiftOptions::UnPackTo(RightShiftOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void RightShiftOptions::UnPackTo(RightShiftOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset RightShiftOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset RightShiftOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateRightShiftOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateRightShiftOptions(flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateRightShiftOptions(::flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RightShiftOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RightShiftOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateRightShiftOptions( _fbb); } -inline DilateOptionsT *DilateOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline DilateOptionsT *DilateOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DilateOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void DilateOptions::UnPackTo(DilateOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void DilateOptions::UnPackTo(DilateOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline flatbuffers::Offset DilateOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset DilateOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateDilateOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateDilateOptions(flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateDilateOptions(::flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DilateOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DilateOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; return tflite::CreateDilateOptions( _fbb); } -inline ReduceWindowOptionsT *ReduceWindowOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ReduceWindowOptionsT *ReduceWindowOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ReduceWindowOptionsT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void ReduceWindowOptions::UnPackTo(ReduceWindowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void ReduceWindowOptions::UnPackTo(ReduceWindowOptionsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = reduce_function(); _o->reduce_function = _e; } } -inline flatbuffers::Offset ReduceWindowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset ReduceWindowOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateReduceWindowOptions(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateReduceWindowOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateReduceWindowOptions(::flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReduceWindowOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReduceWindowOptionsT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _reduce_function = _o->reduce_function; return tflite::CreateReduceWindowOptions( _fbb, _reduce_function); } -inline OperatorCodeT *OperatorCode::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline OperatorCodeT *OperatorCode::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new OperatorCodeT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void OperatorCode::UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void OperatorCode::UnPackTo(OperatorCodeT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = deprecated_builtin_code(); _o->deprecated_builtin_code = _e; } @@ -20872,14 +20872,14 @@ inline void OperatorCode::UnPackTo(OperatorCodeT *_o, const flatbuffers::resolve { auto _e = builtin_code(); _o->builtin_code = _e; } } -inline flatbuffers::Offset OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset OperatorCode::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateOperatorCode(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateOperatorCode(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorCodeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const OperatorCodeT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _deprecated_builtin_code = _o->deprecated_builtin_code; auto _custom_code = _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code); auto _version = _o->version; @@ -20892,38 +20892,38 @@ inline flatbuffers::Offset CreateOperatorCode(flatbuffers::FlatBuf _builtin_code); } -inline OperatorT *Operator::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline OperatorT *Operator::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new OperatorT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Operator::UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Operator::UnPackTo(OperatorT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = opcode_index(); _o->opcode_index = _e; } - { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } } - { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } } + { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } else { _o->inputs.resize(0); } } + { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } else { _o->outputs.resize(0); } } { auto _e = builtin_options_type(); _o->builtin_options.type = _e; } { auto _e = builtin_options(); if (_e) _o->builtin_options.value = tflite::BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); } { auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom_options.begin()); } } { auto _e = custom_options_format(); _o->custom_options_format = _e; } - { auto _e = mutating_variable_inputs(); if (_e) { _o->mutating_variable_inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mutating_variable_inputs[_i] = _e->Get(_i) != 0; } } } - { auto _e = intermediates(); if (_e) { _o->intermediates.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->intermediates[_i] = _e->Get(_i); } } } + { auto _e = mutating_variable_inputs(); if (_e) { _o->mutating_variable_inputs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mutating_variable_inputs[_i] = _e->Get(_i) != 0; } } else { _o->mutating_variable_inputs.resize(0); } } + { auto _e = intermediates(); if (_e) { _o->intermediates.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->intermediates[_i] = _e->Get(_i); } } else { _o->intermediates.resize(0); } } { auto _e = large_custom_options_offset(); _o->large_custom_options_offset = _e; } { auto _e = large_custom_options_size(); _o->large_custom_options_size = _e; } { auto _e = builtin_options_2_type(); _o->builtin_options_2.type = _e; } { auto _e = builtin_options_2(); if (_e) _o->builtin_options_2.value = tflite::BuiltinOptions2Union::UnPack(_e, builtin_options_2_type(), _resolver); } } -inline flatbuffers::Offset Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Operator::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateOperator(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateOperator(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const OperatorT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _opcode_index = _o->opcode_index; auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0; auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0; @@ -20973,34 +20973,34 @@ inline SubGraphT &SubGraphT::operator=(SubGraphT o) FLATBUFFERS_NOEXCEPT { return *this; } -inline SubGraphT *SubGraph::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SubGraphT *SubGraph::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SubGraphT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SubGraph::UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SubGraph::UnPackTo(SubGraphT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->tensors[_i]) { _e->Get(_i)->UnPackTo(_o->tensors[_i].get(), _resolver); } else { _o->tensors[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } - { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } } - { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } } - { auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->operators[_i]) { _e->Get(_i)->UnPackTo(_o->operators[_i].get(), _resolver); } else { _o->operators[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->tensors[_i]) { _e->Get(_i)->UnPackTo(_o->tensors[_i].get(), _resolver); } else { _o->tensors[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->tensors.resize(0); } } + { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } else { _o->inputs.resize(0); } } + { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } else { _o->outputs.resize(0); } } + { auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->operators[_i]) { _e->Get(_i)->UnPackTo(_o->operators[_i].get(), _resolver); } else { _o->operators[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->operators.resize(0); } } { auto _e = name(); if (_e) _o->name = _e->str(); } } -inline flatbuffers::Offset SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SubGraph::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSubGraph(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSubGraph(::flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubGraphT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _tensors = _o->tensors.size() ? _fbb.CreateVector> (_o->tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher); }, &_va ) : 0; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SubGraphT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _tensors = _o->tensors.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher); }, &_va ) : 0; auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0; auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0; - auto _operators = _o->operators.size() ? _fbb.CreateVector> (_o->operators.size(), [](size_t i, _VectorArgs *__va) { return CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _operators = _o->operators.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->operators.size(), [](size_t i, _VectorArgs *__va) { return CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher); }, &_va ) : 0; auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); return tflite::CreateSubGraph( _fbb, @@ -21011,13 +21011,13 @@ inline flatbuffers::Offset CreateSubGraph(flatbuffers::FlatBufferBuild _name); } -inline BufferT *Buffer::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline BufferT *Buffer::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new BufferT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Buffer::UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Buffer::UnPackTo(BufferT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } @@ -21025,14 +21025,14 @@ inline void Buffer::UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t { auto _e = size(); _o->size = _e; } } -inline flatbuffers::Offset Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Buffer::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateBuffer(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateBuffer(::flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BufferT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BufferT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; _fbb.ForceVectorAlignment(_o->data.size(), sizeof(uint8_t), 16); auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; auto _offset = _o->offset; @@ -21044,27 +21044,27 @@ inline flatbuffers::Offset CreateBuffer(flatbuffers::FlatBufferBuilder & _size); } -inline MetadataT *Metadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline MetadataT *Metadata::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new MetadataT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Metadata::UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Metadata::UnPackTo(MetadataT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = name(); if (_e) _o->name = _e->str(); } { auto _e = buffer(); _o->buffer = _e; } } -inline flatbuffers::Offset Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Metadata::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateMetadata(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateMetadata(::flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MetadataT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); auto _buffer = _o->buffer; return tflite::CreateMetadata( @@ -21073,27 +21073,27 @@ inline flatbuffers::Offset CreateMetadata(flatbuffers::FlatBufferBuild _buffer); } -inline TensorMapT *TensorMap::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline TensorMapT *TensorMap::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new TensorMapT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void TensorMap::UnPackTo(TensorMapT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void TensorMap::UnPackTo(TensorMapT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = name(); if (_e) _o->name = _e->str(); } { auto _e = tensor_index(); _o->tensor_index = _e; } } -inline flatbuffers::Offset TensorMap::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset TensorMap::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateTensorMap(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateTensorMap(::flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorMapT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TensorMapT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); auto _tensor_index = _o->tensor_index; return tflite::CreateTensorMap( @@ -21119,31 +21119,31 @@ inline SignatureDefT &SignatureDefT::operator=(SignatureDefT o) FLATBUFFERS_NOEX return *this; } -inline SignatureDefT *SignatureDef::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline SignatureDefT *SignatureDef::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new SignatureDefT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void SignatureDef::UnPackTo(SignatureDefT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void SignatureDef::UnPackTo(SignatureDefT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->inputs[_i]) { _e->Get(_i)->UnPackTo(_o->inputs[_i].get(), _resolver); } else { _o->inputs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } - { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->outputs[_i]) { _e->Get(_i)->UnPackTo(_o->outputs[_i].get(), _resolver); } else { _o->outputs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->inputs[_i]) { _e->Get(_i)->UnPackTo(_o->inputs[_i].get(), _resolver); } else { _o->inputs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->inputs.resize(0); } } + { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->outputs[_i]) { _e->Get(_i)->UnPackTo(_o->outputs[_i].get(), _resolver); } else { _o->outputs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->outputs.resize(0); } } { auto _e = signature_key(); if (_e) _o->signature_key = _e->str(); } { auto _e = subgraph_index(); _o->subgraph_index = _e; } } -inline flatbuffers::Offset SignatureDef::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset SignatureDef::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateSignatureDef(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateSignatureDef(::flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SignatureDefT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - auto _inputs = _o->inputs.size() ? _fbb.CreateVector> (_o->inputs.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMap(*__va->__fbb, __va->__o->inputs[i].get(), __va->__rehasher); }, &_va ) : 0; - auto _outputs = _o->outputs.size() ? _fbb.CreateVector> (_o->outputs.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMap(*__va->__fbb, __va->__o->outputs[i].get(), __va->__rehasher); }, &_va ) : 0; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SignatureDefT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _inputs = _o->inputs.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->inputs.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMap(*__va->__fbb, __va->__o->inputs[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _outputs = _o->outputs.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->outputs.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMap(*__va->__fbb, __va->__o->outputs[i].get(), __va->__rehasher); }, &_va ) : 0; auto _signature_key = _o->signature_key.empty() ? 0 : _fbb.CreateString(_o->signature_key); auto _subgraph_index = _o->subgraph_index; return tflite::CreateSignatureDef( @@ -21182,41 +21182,41 @@ inline ModelT &ModelT::operator=(ModelT o) FLATBUFFERS_NOEXCEPT { return *this; } -inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const { +inline ModelT *Model::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new ModelT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void Model::UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver) const { +inline void Model::UnPackTo(ModelT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = version(); _o->version = _e; } - { auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->operator_codes[_i]) { _e->Get(_i)->UnPackTo(_o->operator_codes[_i].get(), _resolver); } else { _o->operator_codes[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } - { auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->subgraphs[_i]) { _e->Get(_i)->UnPackTo(_o->subgraphs[_i].get(), _resolver); } else { _o->subgraphs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->operator_codes[_i]) { _e->Get(_i)->UnPackTo(_o->operator_codes[_i].get(), _resolver); } else { _o->operator_codes[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->operator_codes.resize(0); } } + { auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->subgraphs[_i]) { _e->Get(_i)->UnPackTo(_o->subgraphs[_i].get(), _resolver); } else { _o->subgraphs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->subgraphs.resize(0); } } { auto _e = description(); if (_e) _o->description = _e->str(); } - { auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->buffers[_i]) { _e->Get(_i)->UnPackTo(_o->buffers[_i].get(), _resolver); } else { _o->buffers[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } - { auto _e = metadata_buffer(); if (_e) { _o->metadata_buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata_buffer[_i] = _e->Get(_i); } } } - { auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->metadata[_i]) { _e->Get(_i)->UnPackTo(_o->metadata[_i].get(), _resolver); } else { _o->metadata[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } - { auto _e = signature_defs(); if (_e) { _o->signature_defs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->signature_defs[_i]) { _e->Get(_i)->UnPackTo(_o->signature_defs[_i].get(), _resolver); } else { _o->signature_defs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->buffers[_i]) { _e->Get(_i)->UnPackTo(_o->buffers[_i].get(), _resolver); } else { _o->buffers[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->buffers.resize(0); } } + { auto _e = metadata_buffer(); if (_e) { _o->metadata_buffer.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata_buffer[_i] = _e->Get(_i); } } else { _o->metadata_buffer.resize(0); } } + { auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->metadata[_i]) { _e->Get(_i)->UnPackTo(_o->metadata[_i].get(), _resolver); } else { _o->metadata[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->metadata.resize(0); } } + { auto _e = signature_defs(); if (_e) { _o->signature_defs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->signature_defs[_i]) { _e->Get(_i)->UnPackTo(_o->signature_defs[_i].get(), _resolver); } else { _o->signature_defs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->signature_defs.resize(0); } } } -inline flatbuffers::Offset Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset Model::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { return CreateModel(_fbb, _o, _rehasher); } -inline flatbuffers::Offset CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateModel(::flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ModelT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _version = _o->version; - auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector> (_o->operator_codes.size(), [](size_t i, _VectorArgs *__va) { return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : 0; - auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector> (_o->subgraphs.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->operator_codes.size(), [](size_t i, _VectorArgs *__va) { return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->subgraphs.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : 0; auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description); - auto _buffers = _o->buffers.size() ? _fbb.CreateVector> (_o->buffers.size(), [](size_t i, _VectorArgs *__va) { return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _buffers = _o->buffers.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->buffers.size(), [](size_t i, _VectorArgs *__va) { return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : 0; auto _metadata_buffer = _o->metadata_buffer.size() ? _fbb.CreateVector(_o->metadata_buffer) : 0; - auto _metadata = _o->metadata.size() ? _fbb.CreateVector> (_o->metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateMetadata(*__va->__fbb, __va->__o->metadata[i].get(), __va->__rehasher); }, &_va ) : 0; - auto _signature_defs = _o->signature_defs.size() ? _fbb.CreateVector> (_o->signature_defs.size(), [](size_t i, _VectorArgs *__va) { return CreateSignatureDef(*__va->__fbb, __va->__o->signature_defs[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _metadata = _o->metadata.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateMetadata(*__va->__fbb, __va->__o->metadata[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _signature_defs = _o->signature_defs.size() ? _fbb.CreateVector<::flatbuffers::Offset> (_o->signature_defs.size(), [](size_t i, _VectorArgs *__va) { return CreateSignatureDef(*__va->__fbb, __va->__o->signature_defs[i].get(), __va->__rehasher); }, &_va ) : 0; return tflite::CreateModel( _fbb, _version, @@ -21229,7 +21229,7 @@ inline flatbuffers::Offset CreateModel(flatbuffers::FlatBufferBuilder &_f _signature_defs); } -inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) { +inline bool VerifyQuantizationDetails(::flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) { switch (type) { case QuantizationDetails_NONE: { return true; @@ -21242,10 +21242,10 @@ inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const voi } } -inline bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { +inline bool VerifyQuantizationDetailsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types) { if (!values || !types) return !values && !types; if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { if (!VerifyQuantizationDetails( verifier, values->Get(i), types->GetEnum(i))) { return false; @@ -21254,7 +21254,7 @@ inline bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, con return true; } -inline void *QuantizationDetailsUnion::UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver) { +inline void *QuantizationDetailsUnion::UnPack(const void *obj, QuantizationDetails type, const ::flatbuffers::resolver_function_t *resolver) { (void)resolver; switch (type) { case QuantizationDetails_CustomQuantization: { @@ -21265,7 +21265,7 @@ inline void *QuantizationDetailsUnion::UnPack(const void *obj, QuantizationDetai } } -inline flatbuffers::Offset QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { +inline ::flatbuffers::Offset QuantizationDetailsUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { (void)_rehasher; switch (type) { case QuantizationDetails_CustomQuantization: { @@ -21300,7 +21300,7 @@ inline void QuantizationDetailsUnion::Reset() { type = QuantizationDetails_NONE; } -inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type) { +inline bool VerifySparseIndexVector(::flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type) { switch (type) { case SparseIndexVector_NONE: { return true; @@ -21321,10 +21321,10 @@ inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void } } -inline bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { +inline bool VerifySparseIndexVectorVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types) { if (!values || !types) return !values && !types; if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { if (!VerifySparseIndexVector( verifier, values->Get(i), types->GetEnum(i))) { return false; @@ -21333,7 +21333,7 @@ inline bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const return true; } -inline void *SparseIndexVectorUnion::UnPack(const void *obj, SparseIndexVector type, const flatbuffers::resolver_function_t *resolver) { +inline void *SparseIndexVectorUnion::UnPack(const void *obj, SparseIndexVector type, const ::flatbuffers::resolver_function_t *resolver) { (void)resolver; switch (type) { case SparseIndexVector_Int32Vector: { @@ -21352,7 +21352,7 @@ inline void *SparseIndexVectorUnion::UnPack(const void *obj, SparseIndexVector t } } -inline flatbuffers::Offset SparseIndexVectorUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { +inline ::flatbuffers::Offset SparseIndexVectorUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { (void)_rehasher; switch (type) { case SparseIndexVector_Int32Vector: { @@ -21413,7 +21413,7 @@ inline void SparseIndexVectorUnion::Reset() { type = SparseIndexVector_NONE; } -inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) { +inline bool VerifyBuiltinOptions(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) { switch (type) { case BuiltinOptions_NONE: { return true; @@ -21926,10 +21926,10 @@ inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *ob } } -inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { +inline bool VerifyBuiltinOptionsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types) { if (!values || !types) return !values && !types; if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { if (!VerifyBuiltinOptions( verifier, values->Get(i), types->GetEnum(i))) { return false; @@ -21938,7 +21938,7 @@ inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const fl return true; } -inline void *BuiltinOptionsUnion::UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver) { +inline void *BuiltinOptionsUnion::UnPack(const void *obj, BuiltinOptions type, const ::flatbuffers::resolver_function_t *resolver) { (void)resolver; switch (type) { case BuiltinOptions_Conv2DOptions: { @@ -22449,7 +22449,7 @@ inline void *BuiltinOptionsUnion::UnPack(const void *obj, BuiltinOptions type, c } } -inline flatbuffers::Offset BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { +inline ::flatbuffers::Offset BuiltinOptionsUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { (void)_rehasher; switch (type) { case BuiltinOptions_Conv2DOptions: { @@ -24109,7 +24109,7 @@ inline void BuiltinOptionsUnion::Reset() { type = BuiltinOptions_NONE; } -inline bool VerifyBuiltinOptions2(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions2 type) { +inline bool VerifyBuiltinOptions2(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions2 type) { switch (type) { case BuiltinOptions2_NONE: { return true; @@ -24198,10 +24198,10 @@ inline bool VerifyBuiltinOptions2(flatbuffers::Verifier &verifier, const void *o } } -inline bool VerifyBuiltinOptions2Vector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { +inline bool VerifyBuiltinOptions2Vector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types) { if (!values || !types) return !values && !types; if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { if (!VerifyBuiltinOptions2( verifier, values->Get(i), types->GetEnum(i))) { return false; @@ -24210,7 +24210,7 @@ inline bool VerifyBuiltinOptions2Vector(flatbuffers::Verifier &verifier, const f return true; } -inline void *BuiltinOptions2Union::UnPack(const void *obj, BuiltinOptions2 type, const flatbuffers::resolver_function_t *resolver) { +inline void *BuiltinOptions2Union::UnPack(const void *obj, BuiltinOptions2 type, const ::flatbuffers::resolver_function_t *resolver) { (void)resolver; switch (type) { case BuiltinOptions2_StablehloConcatenateOptions: { @@ -24297,7 +24297,7 @@ inline void *BuiltinOptions2Union::UnPack(const void *obj, BuiltinOptions2 type, } } -inline flatbuffers::Offset BuiltinOptions2Union::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { +inline ::flatbuffers::Offset BuiltinOptions2Union::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { (void)_rehasher; switch (type) { case BuiltinOptions2_StablehloConcatenateOptions: { @@ -24580,11 +24580,11 @@ inline void BuiltinOptions2Union::Reset() { } inline const tflite::Model *GetModel(const void *buf) { - return flatbuffers::GetRoot(buf); + return ::flatbuffers::GetRoot(buf); } inline const tflite::Model *GetSizePrefixedModel(const void *buf) { - return flatbuffers::GetSizePrefixedRoot(buf); + return ::flatbuffers::GetSizePrefixedRoot(buf); } inline const char *ModelIdentifier() { @@ -24592,22 +24592,22 @@ inline const char *ModelIdentifier() { } inline bool ModelBufferHasIdentifier(const void *buf) { - return flatbuffers::BufferHasIdentifier( + return ::flatbuffers::BufferHasIdentifier( buf, ModelIdentifier()); } inline bool SizePrefixedModelBufferHasIdentifier(const void *buf) { - return flatbuffers::BufferHasIdentifier( + return ::flatbuffers::BufferHasIdentifier( buf, ModelIdentifier(), true); } inline bool VerifyModelBuffer( - flatbuffers::Verifier &verifier) { + ::flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer(ModelIdentifier()); } inline bool VerifySizePrefixedModelBuffer( - flatbuffers::Verifier &verifier) { + ::flatbuffers::Verifier &verifier) { return verifier.VerifySizePrefixedBuffer(ModelIdentifier()); } @@ -24616,26 +24616,26 @@ inline const char *ModelExtension() { } inline void FinishModelBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + ::flatbuffers::FlatBufferBuilder &fbb, + ::flatbuffers::Offset root) { fbb.Finish(root, ModelIdentifier()); } inline void FinishSizePrefixedModelBuffer( - flatbuffers::FlatBufferBuilder &fbb, - flatbuffers::Offset root) { + ::flatbuffers::FlatBufferBuilder &fbb, + ::flatbuffers::Offset root) { fbb.FinishSizePrefixed(root, ModelIdentifier()); } inline std::unique_ptr UnPackModel( const void *buf, - const flatbuffers::resolver_function_t *res = nullptr) { + const ::flatbuffers::resolver_function_t *res = nullptr) { return std::unique_ptr(GetModel(buf)->UnPack(res)); } inline std::unique_ptr UnPackSizePrefixedModel( const void *buf, - const flatbuffers::resolver_function_t *res = nullptr) { + const ::flatbuffers::resolver_function_t *res = nullptr) { return std::unique_ptr(GetSizePrefixedModel(buf)->UnPack(res)); } diff --git a/third_party/flatbuffers/BUILD.external b/third_party/flatbuffers/BUILD.external index dfd3a16966e..8f9d4ebe346 100644 --- a/third_party/flatbuffers/BUILD.external +++ b/third_party/flatbuffers/BUILD.external @@ -2,30 +2,23 @@ load(":build_defs.bzl", "flatbuffer_py_strip_prefix_srcs") package(default_visibility = ["//visibility:public"]) -licenses(["notice"]) +licenses(["notice"]) # Apache 2.0 -exports_files(["LICENSE.txt"]) - -licenses(["notice"]) +exports_files(["LICENSE"]) config_setting( - name = "freebsd", + name = "platform_freebsd", values = {"cpu": "freebsd"}, ) -config_setting( - name = "windows", - values = {"cpu": "x64_windows"}, -) - config_setting( name = "platform_openbsd", values = {"cpu": "openbsd"}, ) config_setting( - name = "platform_freebsd", - values = {"cpu": "freebsd"}, + name = "windows", + values = {"cpu": "x64_windows"}, ) load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library") @@ -47,12 +40,13 @@ filegroup( "include/flatbuffers/allocator.h", "include/flatbuffers/array.h", "include/flatbuffers/base.h", - "include/flatbuffers/bfbs_generator.h", "include/flatbuffers/buffer.h", "include/flatbuffers/buffer_ref.h", + "include/flatbuffers/code_generator.h", "include/flatbuffers/code_generators.h", "include/flatbuffers/default_allocator.h", "include/flatbuffers/detached_buffer.h", + "include/flatbuffers/file_manager.h", "include/flatbuffers/flatbuffer_builder.h", "include/flatbuffers/flatbuffers.h", "include/flatbuffers/flex_flat_util.h", @@ -73,7 +67,7 @@ filegroup( "include/flatbuffers/vector_downward.h", "include/flatbuffers/verifier.h", ], - visibility = ["//:__subpackages__"], + visibility = ["//visibility:public"], ) # Public flatc compiler library. @@ -90,9 +84,11 @@ cc_library( cc_binary( name = "flatc", linkopts = select({ - ":freebsd": [ + ":platform_freebsd": [ "-lm", ], + # If Visual Studio 2022 developers facing linking errors, + # change the line below as ":windows": ["/DEFAULTLIB:msvcrt.lib"], ":windows": [], "//conditions:default": [ "-lm", @@ -110,7 +106,7 @@ filegroup( srcs = [ "include/flatbuffers/flatc.h", ], - visibility = ["//:__subpackages__"], + visibility = ["//visibility:public"], ) # Library used by flatbuffer_cc_library rules. @@ -120,22 +116,13 @@ cc_library( "include/flatbuffers/allocator.h", "include/flatbuffers/array.h", "include/flatbuffers/base.h", - "include/flatbuffers/bfbs_generator.h", "include/flatbuffers/buffer.h", "include/flatbuffers/buffer_ref.h", - "include/flatbuffers/code_generators.h", "include/flatbuffers/default_allocator.h", "include/flatbuffers/detached_buffer.h", "include/flatbuffers/flatbuffer_builder.h", "include/flatbuffers/flatbuffers.h", "include/flatbuffers/flexbuffers.h", - "include/flatbuffers/grpc.h", - "include/flatbuffers/hash.h", - "include/flatbuffers/idl.h", - "include/flatbuffers/minireflect.h", - "include/flatbuffers/reflection.h", - "include/flatbuffers/reflection_generated.h", - "include/flatbuffers/registry.h", "include/flatbuffers/stl_emulation.h", "include/flatbuffers/string.h", "include/flatbuffers/struct.h", @@ -187,4 +174,4 @@ py_library( name = "runtime_py", srcs = [":runtime_py_srcs"], visibility = ["//visibility:public"], -) \ No newline at end of file +) diff --git a/third_party/flatbuffers/build_defs.bzl b/third_party/flatbuffers/build_defs.bzl index 1a84928cd4f..f746b67c7b1 100644 --- a/third_party/flatbuffers/build_defs.bzl +++ b/third_party/flatbuffers/build_defs.bzl @@ -279,6 +279,11 @@ def _gen_flatbuffer_srcs_impl(ctx): else: no_includes_statement = [] + if ctx.attr.language_flag == "--python": + onefile_statement = ["--gen-onefile"] + else: + onefile_statement = [] + # Need to generate all files in a directory. if not outputs: outputs = [ctx.actions.declare_directory("{}_all".format(ctx.attr.name))] @@ -314,6 +319,7 @@ def _gen_flatbuffer_srcs_impl(ctx): "-I", ctx.bin_dir.path, ] + no_includes_statement + + onefile_statement + include_paths_cmd_line + [ "--no-union-value-namespacing", "--gen-object-api", @@ -394,6 +400,7 @@ def _concat_flatbuffer_py_srcs_impl(ctx): ctx.attr.deps[0].files.to_list()[0].path, ctx.outputs.out.path, ), + use_default_shell_env = True, ) _concat_flatbuffer_py_srcs = rule( @@ -432,6 +439,8 @@ def flatbuffer_py_library( deps = deps, include_paths = include_paths, ) + + # TODO(b/235550563): Remove the concatnation rule with 2.0.6 update. all_srcs_no_include = "{}_srcs_no_include".format(name) _gen_flatbuffer_srcs( name = all_srcs_no_include, diff --git a/third_party/flatbuffers/workspace.bzl b/third_party/flatbuffers/workspace.bzl index e799a708945..c22ca37b2bd 100644 --- a/third_party/flatbuffers/workspace.bzl +++ b/third_party/flatbuffers/workspace.bzl @@ -5,10 +5,10 @@ load("//third_party:repo.bzl", "tf_http_archive") def repo(): tf_http_archive( name = "flatbuffers", - strip_prefix = "flatbuffers-a66de58af9565586832c276fbb4251fc416bf07f", - sha256 = "da06ac2fc6fed8e38b6392f5a20fa24a4290cecaadd87aef16b6b84960408680", + strip_prefix = "flatbuffers-23.5.26", + sha256 = "1cce06b17cddd896b6d73cc047e36a254fb8df4d7ea18a46acf16c4c0cd3f3f3", urls = [ - "https://github.com/google/flatbuffers/archive/a66de58af9565586832c276fbb4251fc416bf07f.tar.gz", + "https://github.com/google/flatbuffers/archive/v23.5.26.tar.gz", ], build_file = "//third_party/flatbuffers:BUILD.external", system_build_file = "//third_party/flatbuffers:BUILD.system",