build: update flatbuffers dependency to v23.5.26 (#2274)
Update the third_party flatbuffers library to v23.5.26, the
current version in upstream TF. Synchronize the override BUILD
and build_defs.bzl files with those from upstream TF at
e4485c98eae.
Also update the Makefile build, which downloads flatbuffers
separately. Rebase the patch applied to the download.
Regenerate the generated-and-checked-in schemas (see
ci/sync_from_upstream_tf.sh and codegen/preprocessor/
update_schema.sh), because they are stamped with the version of
the flatbuffers library, and fail a static_assert if they are
built with a different version of flatbuffers than they were
generated with.
BUG=unsuccessful attempt to fix warning in #2183
diff --git a/codegen/preprocessor/preprocessor_schema_generated.h b/codegen/preprocessor/preprocessor_schema_generated.h
index e59ea90..c483dd5 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 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<const flatbuffers::String *>(VT_INPUT_MODEL_PATH);
+ const ::flatbuffers::String *input_model_path() const {
+ return GetPointer<const ::flatbuffers::String *>(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<Data> 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<Data> 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<flatbuffers::String> 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<Data> Finish() {
+ ::flatbuffers::Offset<Data> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Data>(end);
+ auto o = ::flatbuffers::Offset<Data>(end);
return o;
}
};
-inline flatbuffers::Offset<Data> CreateData(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::String> input_model_path = 0) {
+inline ::flatbuffers::Offset<Data> 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<Data> CreateDataDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Data> 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 @@
input_model_path__);
}
-flatbuffers::Offset<Data> CreateData(flatbuffers::FlatBufferBuilder &_fbb, const DataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Data> 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<DataT>(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> Data::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Data> Data::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateData(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Data> CreateData(flatbuffers::FlatBufferBuilder &_fbb, const DataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Data> 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 const tflm::codegen::preprocessor::Data *GetData(const void *buf) {
- return flatbuffers::GetRoot<tflm::codegen::preprocessor::Data>(buf);
+ return ::flatbuffers::GetRoot<tflm::codegen::preprocessor::Data>(buf);
}
inline const tflm::codegen::preprocessor::Data *GetSizePrefixedData(const void *buf) {
- return flatbuffers::GetSizePrefixedRoot<tflm::codegen::preprocessor::Data>(buf);
+ return ::flatbuffers::GetSizePrefixedRoot<tflm::codegen::preprocessor::Data>(buf);
}
inline bool VerifyDataBuffer(
- flatbuffers::Verifier &verifier) {
+ ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<tflm::codegen::preprocessor::Data>(nullptr);
}
inline bool VerifySizePrefixedDataBuffer(
- flatbuffers::Verifier &verifier) {
+ ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<tflm::codegen::preprocessor::Data>(nullptr);
}
inline void FinishDataBuffer(
- flatbuffers::FlatBufferBuilder &fbb,
- flatbuffers::Offset<tflm::codegen::preprocessor::Data> root) {
+ ::flatbuffers::FlatBufferBuilder &fbb,
+ ::flatbuffers::Offset<tflm::codegen::preprocessor::Data> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedDataBuffer(
- flatbuffers::FlatBufferBuilder &fbb,
- flatbuffers::Offset<tflm::codegen::preprocessor::Data> root) {
+ ::flatbuffers::FlatBufferBuilder &fbb,
+ ::flatbuffers::Offset<tflm::codegen::preprocessor::Data> root) {
fbb.FinishSizePrefixed(root);
}
inline std::unique_ptr<tflm::codegen::preprocessor::DataT> UnPackData(
const void *buf,
- const flatbuffers::resolver_function_t *res = nullptr) {
+ const ::flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<tflm::codegen::preprocessor::DataT>(GetData(buf)->UnPack(res));
}
inline std::unique_ptr<tflm::codegen::preprocessor::DataT> UnPackSizePrefixedData(
const void *buf,
- const flatbuffers::resolver_function_t *res = nullptr) {
+ const ::flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<tflm::codegen::preprocessor::DataT>(GetSizePrefixedData(buf)->UnPack(res));
}
diff --git a/codegen/preprocessor/preprocessor_schema_py_generated.py b/codegen/preprocessor/preprocessor_schema_py_generated.py
index e484f26..2394bbf 100644
--- a/codegen/preprocessor/preprocessor_schema_py_generated.py
+++ b/codegen/preprocessor/preprocessor_schema_py_generated.py
@@ -32,15 +32,16 @@
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):
@@ -55,6 +56,11 @@
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()
x._UnPack(data)
@@ -75,3 +81,5 @@
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 beffcec..6fb4fd0 100644
--- a/tensorflow/lite/micro/tools/make/Makefile
+++ b/tensorflow/lite/micro/tools/make/Makefile
@@ -522,20 +522,31 @@
$(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 cb22cf0..2017775 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 @@
// 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 @@
}
} // 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<double>(ReadUInt64(Indirect(), byte_width_));
case FBT_NULL: return 0.0;
case FBT_STRING: {
@@ -86,10 +82,10 @@
case FBT_VECTOR: return static_cast<double>(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 @@
#ifndef FLATBUFFERS_PREFER_PRINTF
# include <iomanip>
# include <sstream>
-
\ 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 af5e80f..52acccc 100755
--- a/tensorflow/lite/micro/tools/make/flatbuffers_download.sh
+++ b/tensorflow/lite/micro/tools/make/flatbuffers_download.sh
@@ -54,9 +54,9 @@
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 @@
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 87d2b87..994ab39 100755
--- a/tensorflow/lite/python/schema_py_generated.py
+++ b/tensorflow/lite/python/schema_py_generated.py
@@ -7,1386 +7,63 @@
from flatbuffers.compat import import_numpy
np = import_numpy()
-class ATan2Options(object):
- __slots__ = ['_tab']
+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
- @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
-
-# 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
+ CustomQuantization = 1
-# namespace: tflite
+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
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-class AddNOptions(object):
- __slots__ = ['_tab']
+class DimensionType(object):
+ DENSE = 0
+ SPARSE_CSR = 1
- @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)
+class SparseIndexVector(object):
+ NONE = 0
+ Int32Vector = 1
+ Uint16Vector = 2
+ Uint8Vector = 3
- # 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
-
- @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)
-
- # 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
-
- # 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 AddOptionsT(object):
-
- # 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
-
- @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
+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
-# namespace: tflite
class BuiltinOperator(object):
ADD = 0
@@ -1595,9 +272,7 @@
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
@@ -1985,9 +660,7 @@
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
@@ -2057,1012 +730,91 @@
if unionType == BuiltinOptions2().ReduceWindowOptions:
return ReduceWindowOptionsT.InitFromBuf(table.Bytes, table.Pos)
return None
-# automatically generated by the FlatBuffers compiler, do not modify
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
+class StablehloPrecisionConfig(object):
+ DEFAULT = 0
+ HIGH = 1
+ HIGHEST = 2
-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
+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
- @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)
+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
- # 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
-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)
+class RngAlgorithm(object):
+ DEFAULT = 0
+ PHILOX = 1
+ THREEFRY = 2
-class CallOnceOptionsT(object):
- # CallOnceOptionsT
- def __init__(self):
- self.initSubgraphIndex = 0 # type: int
+class Padding(object):
+ SAME = 0
+ VALID = 1
- @classmethod
- def InitFromBuf(cls, buf, pos):
- callOnceOptions = CallOnceOptions()
- callOnceOptions.Init(buf, pos)
- return cls.InitFromObj(callOnceOptions)
- @classmethod
- def InitFromObj(cls, callOnceOptions):
- x = CallOnceOptionsT()
- x._UnPack(callOnceOptions)
- return x
+class ActivationFunctionType(object):
+ NONE = 0
+ RELU = 1
+ RELU_N1_TO_1 = 2
+ RELU6 = 3
+ TANH = 4
+ SIGN_BIT = 5
- # 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
-# automatically generated by the FlatBuffers compiler, do not modify
+class LSHProjectionType(object):
+ UNKNOWN = 0
+ SPARSE = 1
+ DENSE = 2
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
+class FullyConnectedOptionsWeightsFormat(object):
+ DEFAULT = 0
+ SHUFFLED4x16INT8 = 1
-class CallOptions(object):
- __slots__ = ['_tab']
- @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
+class LSTMKernelType(object):
+ FULL = 0
+ BASIC = 1
- @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)
-
- # CallOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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 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):
-
- # CallOptionsT
- def __init__(self):
- self.subgraph = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- callOptions = CallOptions()
- callOptions.Init(buf, pos)
- return cls.InitFromObj(callOptions)
-
- @classmethod
- def InitFromObj(cls, callOptions):
- x = CallOptionsT()
- x._UnPack(callOptions)
- return x
-
- # CallOptionsT
- def _UnPack(self, callOptions):
- if callOptions is None:
- return
- self.subgraph = callOptions.Subgraph()
-
- # CallOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class CastOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = CastOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsCastOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # CastOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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.Int8Flags, o + self._tab.Pos)
- return 0
-
- # 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.Int8Flags, 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)
-
-class CastOptionsT(object):
-
- # CastOptionsT
- def __init__(self):
- self.inDataType = 0 # type: int
- self.outDataType = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- castOptions = CastOptions()
- castOptions.Init(buf, pos)
- return cls.InitFromObj(castOptions)
-
- @classmethod
- def InitFromObj(cls, castOptions):
- x = CastOptionsT()
- x._UnPack(castOptions)
- return x
-
- # CastOptionsT
- def _UnPack(self, castOptions):
- if castOptions is None:
- return
- self.inDataType = castOptions.InDataType()
- self.outDataType = castOptions.OutDataType()
-
- # CastOptionsT
- 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
-from flatbuffers.compat import import_numpy
-np = import_numpy()
+class MirrorPadMode(object):
+ REFLECT = 0
+ SYMMETRIC = 1
-class ConcatEmbeddingsOptions(object):
- __slots__ = ['_tab']
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ConcatEmbeddingsOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsConcatEmbeddingsOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ConcatEmbeddingsOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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
-
- # 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
-
- # 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
-
- # 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
-
- # ConcatEmbeddingsOptions
- def EmbeddingDimPerChannelIsNone(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)
-try:
- from typing import List
-except:
- pass
-
-class ConcatEmbeddingsOptionsT(object):
-
- # ConcatEmbeddingsOptionsT
- def __init__(self):
- self.numChannels = 0 # type: int
- self.numColumnsPerChannel = None # type: List[int]
- self.embeddingDimPerChannel = None # type: List[int]
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- concatEmbeddingsOptions = ConcatEmbeddingsOptions()
- concatEmbeddingsOptions.Init(buf, pos)
- return cls.InitFromObj(concatEmbeddingsOptions)
-
- @classmethod
- def InitFromObj(cls, concatEmbeddingsOptions):
- x = ConcatEmbeddingsOptionsT()
- x._UnPack(concatEmbeddingsOptions)
- return x
-
- # 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()
-
- # ConcatEmbeddingsOptionsT
- 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)
- 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ConcatenationOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # ConcatenationOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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)
-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)
-
-class ConcatenationOptionsT(object):
-
- # ConcatenationOptionsT
- def __init__(self):
- self.axis = 0 # type: int
- self.fusedActivationFunction = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- concatenationOptions = ConcatenationOptions()
- concatenationOptions.Init(buf, pos)
- return cls.InitFromObj(concatenationOptions)
-
- @classmethod
- def InitFromObj(cls, concatenationOptions):
- x = ConcatenationOptionsT()
- x._UnPack(concatenationOptions)
- return x
-
- # ConcatenationOptionsT
- def _UnPack(self, concatenationOptions):
- if concatenationOptions is None:
- return
- self.axis = concatenationOptions.Axis()
- self.fusedActivationFunction = concatenationOptions.FusedActivationFunction()
-
- # 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
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class Conv2DOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # Conv2DOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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
-
- # 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
-
- # Conv2DOptions
- 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
-
- # Conv2DOptions
- def DilationWFactor(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 1
-
- # Conv2DOptions
- def DilationHFactor(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
-
- # 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
-
-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)
-
- # 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
-
- # 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
-
- # 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.Int32Flags, o + self._tab.Pos)
- return 0
-
- # Conv3DOptions
- def StrideH(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
-
- # 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.Int8Flags, o + self._tab.Pos)
- 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
-
- # 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 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)
-
-class Conv3DOptionsT(object):
-
- # 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
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- conv3doptions = Conv3DOptions()
- conv3doptions.Init(buf, pos)
- return cls.InitFromObj(conv3doptions)
-
- @classmethod
- def InitFromObj(cls, conv3doptions):
- x = Conv3DOptionsT()
- x._UnPack(conv3doptions)
- return x
-
- # 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()
-
- # 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
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class CosOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # CosOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
-def CosOptionsStart(builder): builder.StartObject(0)
-def Start(builder):
- return CosOptionsStart(builder)
-def CosOptionsEnd(builder): return builder.EndObject()
-def End(builder):
- return CosOptionsEnd(builder)
-
-class CosOptionsT(object):
-
- # CosOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- cosOptions = CosOptions()
- cosOptions.Init(buf, pos)
- return cls.InitFromObj(cosOptions)
-
- @classmethod
- def InitFromObj(cls, cosOptions):
- x = CosOptionsT()
- x._UnPack(cosOptions)
- return x
-
- # CosOptionsT
- def _UnPack(self, cosOptions):
- if cosOptions is None:
- return
-
- # CosOptionsT
- def Pack(self, builder):
- CosOptionsStart(builder)
- cosOptions = CosOptionsEnd(builder)
- return cosOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class CumsumOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # CumsumOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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)
-
-class CumsumOptionsT(object):
-
- # CumsumOptionsT
- def __init__(self):
- self.exclusive = False # type: bool
- self.reverse = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- cumsumOptions = CumsumOptions()
- cumsumOptions.Init(buf, pos)
- return cls.InitFromObj(cumsumOptions)
-
- @classmethod
- def InitFromObj(cls, cumsumOptions):
- x = CumsumOptionsT()
- x._UnPack(cumsumOptions)
- return x
-
- # CumsumOptionsT
- def _UnPack(self, cumsumOptions):
- if cumsumOptions is None:
- return
- self.exclusive = cumsumOptions.Exclusive()
- self.reverse = cumsumOptions.Reverse()
-
- # CumsumOptionsT
- 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
+class ReduceWindowFunction(object):
+ UNSUPPORTED = 0
+ ADD = 1
+ MUL = 2
+ MINIMUM = 3
+ MAXIMUM = 4
+ ALL = 5
+ ANY = 6
-# namespace: tflite
class CustomOptionsFormat(object):
FLEXBUFFERS = 0
-# automatically generated by the FlatBuffers compiler, do not modify
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
class CustomQuantization(object):
__slots__ = ['_tab']
@@ -3113,18 +865,19 @@
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
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)
+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:
@@ -3143,6 +896,11 @@
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)
@@ -3175,5407 +933,7 @@
CustomQuantizationAddCustom(builder, custom)
customQuantization = CustomQuantizationEnd(builder)
return customQuantization
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class DensifyOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # DensifyOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
-def DensifyOptionsStart(builder): builder.StartObject(0)
-def Start(builder):
- return DensifyOptionsStart(builder)
-def DensifyOptionsEnd(builder): return builder.EndObject()
-def End(builder):
- return DensifyOptionsEnd(builder)
-
-class DensifyOptionsT(object):
-
- # DensifyOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- densifyOptions = DensifyOptions()
- densifyOptions.Init(buf, pos)
- return cls.InitFromObj(densifyOptions)
-
- @classmethod
- def InitFromObj(cls, densifyOptions):
- x = DensifyOptionsT()
- x._UnPack(densifyOptions)
- return x
-
- # DensifyOptionsT
- def _UnPack(self, densifyOptions):
- if densifyOptions is None:
- return
-
- # DensifyOptionsT
- def Pack(self, builder):
- DensifyOptionsStart(builder)
- densifyOptions = DensifyOptionsEnd(builder)
- return densifyOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class DepthToSpaceOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = DepthToSpaceOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsDepthToSpaceOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # DepthToSpaceOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
-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)
-
-class DepthToSpaceOptionsT(object):
-
- # DepthToSpaceOptionsT
- def __init__(self):
- self.blockSize = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- depthToSpaceOptions = DepthToSpaceOptions()
- depthToSpaceOptions.Init(buf, pos)
- return cls.InitFromObj(depthToSpaceOptions)
-
- @classmethod
- def InitFromObj(cls, depthToSpaceOptions):
- x = DepthToSpaceOptionsT()
- x._UnPack(depthToSpaceOptions)
- return x
-
- # DepthToSpaceOptionsT
- def _UnPack(self, depthToSpaceOptions):
- if depthToSpaceOptions is None:
- return
- self.blockSize = depthToSpaceOptions.BlockSize()
-
- # DepthToSpaceOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class DepthwiseConv2DOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = DepthwiseConv2DOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsDepthwiseConv2DOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # DepthwiseConv2DOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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
-
- # 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
-
- # 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
- 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
-
- # 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
-
- # 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
-
-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
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- dequantizeOptions = DequantizeOptions()
- dequantizeOptions.Init(buf, pos)
- return cls.InitFromObj(dequantizeOptions)
-
- @classmethod
- def InitFromObj(cls, dequantizeOptions):
- x = DequantizeOptionsT()
- x._UnPack(dequantizeOptions)
- return x
-
- # DequantizeOptionsT
- def _UnPack(self, dequantizeOptions):
- if dequantizeOptions is None:
- return
-
- # DequantizeOptionsT
- def Pack(self, builder):
- DequantizeOptionsStart(builder)
- dequantizeOptions = DequantizeOptionsEnd(builder)
- return dequantizeOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class DilateOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # 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):
-
- # DilateOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- dilateOptions = DilateOptions()
- dilateOptions.Init(buf, pos)
- return cls.InitFromObj(dilateOptions)
-
- @classmethod
- def InitFromObj(cls, dilateOptions):
- x = DilateOptionsT()
- x._UnPack(dilateOptions)
- return x
-
- # DilateOptionsT
- def _UnPack(self, dilateOptions):
- if dilateOptions is None:
- return
-
- # DilateOptionsT
- def Pack(self, builder):
- DilateOptionsStart(builder)
- dilateOptions = DilateOptionsEnd(builder)
- return dilateOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 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
-
-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 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
-# 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class DivOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = DivOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsDivOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # DivOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
-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)
-
-class DivOptionsT(object):
-
- # DivOptionsT
- def __init__(self):
- self.fusedActivationFunction = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- divOptions = DivOptions()
- divOptions.Init(buf, pos)
- return cls.InitFromObj(divOptions)
-
- @classmethod
- def InitFromObj(cls, divOptions):
- x = DivOptionsT()
- x._UnPack(divOptions)
- return x
-
- # DivOptionsT
- def _UnPack(self, divOptions):
- if divOptions is None:
- return
- self.fusedActivationFunction = divOptions.FusedActivationFunction()
-
- # DivOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class DynamicUpdateSliceOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = DynamicUpdateSliceOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsDynamicUpdateSliceOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # DynamicUpdateSliceOptions
- 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)
-
-class DynamicUpdateSliceOptionsT(object):
-
- # DynamicUpdateSliceOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- dynamicUpdateSliceOptions = DynamicUpdateSliceOptions()
- dynamicUpdateSliceOptions.Init(buf, pos)
- return cls.InitFromObj(dynamicUpdateSliceOptions)
-
- @classmethod
- def InitFromObj(cls, dynamicUpdateSliceOptions):
- x = DynamicUpdateSliceOptionsT()
- x._UnPack(dynamicUpdateSliceOptions)
- return x
-
- # DynamicUpdateSliceOptionsT
- def _UnPack(self, dynamicUpdateSliceOptions):
- if dynamicUpdateSliceOptions is None:
- return
-
- # DynamicUpdateSliceOptionsT
- def Pack(self, builder):
- DynamicUpdateSliceOptionsStart(builder)
- dynamicUpdateSliceOptions = DynamicUpdateSliceOptionsEnd(builder)
- return dynamicUpdateSliceOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class EmbeddingLookupSparseOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # EmbeddingLookupSparseOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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 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)
-
-class EmbeddingLookupSparseOptionsT(object):
-
- # EmbeddingLookupSparseOptionsT
- def __init__(self):
- self.combiner = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- embeddingLookupSparseOptions = EmbeddingLookupSparseOptions()
- embeddingLookupSparseOptions.Init(buf, pos)
- return cls.InitFromObj(embeddingLookupSparseOptions)
-
- @classmethod
- def InitFromObj(cls, embeddingLookupSparseOptions):
- x = EmbeddingLookupSparseOptionsT()
- x._UnPack(embeddingLookupSparseOptions)
- return x
-
- # EmbeddingLookupSparseOptionsT
- def _UnPack(self, embeddingLookupSparseOptions):
- if embeddingLookupSparseOptions is None:
- return
- self.combiner = embeddingLookupSparseOptions.Combiner()
-
- # EmbeddingLookupSparseOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class EqualOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = EqualOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsEqualOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # EqualOptions
- 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)
-
-class EqualOptionsT(object):
-
- # EqualOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- equalOptions = EqualOptions()
- equalOptions.Init(buf, pos)
- return cls.InitFromObj(equalOptions)
-
- @classmethod
- def InitFromObj(cls, equalOptions):
- x = EqualOptionsT()
- x._UnPack(equalOptions)
- return x
-
- # EqualOptionsT
- def _UnPack(self, equalOptions):
- if equalOptions is None:
- return
-
- # EqualOptionsT
- def Pack(self, builder):
- EqualOptionsStart(builder)
- equalOptions = EqualOptionsEnd(builder)
- return equalOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ExpOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # ExpOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
-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):
-
- # ExpOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- expOptions = ExpOptions()
- expOptions.Init(buf, pos)
- return cls.InitFromObj(expOptions)
-
- @classmethod
- def InitFromObj(cls, expOptions):
- x = ExpOptionsT()
- x._UnPack(expOptions)
- return x
-
- # ExpOptionsT
- def _UnPack(self, expOptions):
- if expOptions is None:
- return
-
- # ExpOptionsT
- def Pack(self, builder):
- ExpOptionsStart(builder)
- expOptions = ExpOptionsEnd(builder)
- return expOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ExpandDimsOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ExpandDimsOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsExpandDimsOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ExpandDimsOptions
- 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)
-
-class ExpandDimsOptionsT(object):
-
- # ExpandDimsOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- expandDimsOptions = ExpandDimsOptions()
- expandDimsOptions.Init(buf, pos)
- return cls.InitFromObj(expandDimsOptions)
-
- @classmethod
- def InitFromObj(cls, expandDimsOptions):
- x = ExpandDimsOptionsT()
- x._UnPack(expandDimsOptions)
- return x
-
- # ExpandDimsOptionsT
- def _UnPack(self, expandDimsOptions):
- if expandDimsOptions is None:
- return
-
- # ExpandDimsOptionsT
- def Pack(self, builder):
- ExpandDimsOptionsStart(builder)
- expandDimsOptions = ExpandDimsOptionsEnd(builder)
- return expandDimsOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class FakeQuantOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = FakeQuantOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsFakeQuantOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # FakeQuantOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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
-
- # 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 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)
-
-class FakeQuantOptionsT(object):
-
- # FakeQuantOptionsT
- 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
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- fakeQuantOptions = FakeQuantOptions()
- fakeQuantOptions.Init(buf, pos)
- return cls.InitFromObj(fakeQuantOptions)
-
- @classmethod
- def InitFromObj(cls, fakeQuantOptions):
- x = FakeQuantOptionsT()
- x._UnPack(fakeQuantOptions)
- return x
-
- # 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()
-
- # FakeQuantOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class FillOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = FillOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsFillOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # FillOptions
- 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)
-
-class FillOptionsT(object):
-
- # FillOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- fillOptions = FillOptions()
- fillOptions.Init(buf, pos)
- return cls.InitFromObj(fillOptions)
-
- @classmethod
- def InitFromObj(cls, fillOptions):
- x = FillOptionsT()
- x._UnPack(fillOptions)
- return x
-
- # FillOptionsT
- def _UnPack(self, fillOptions):
- if fillOptions is None:
- return
-
- # FillOptionsT
- def Pack(self, builder):
- FillOptionsStart(builder)
- fillOptions = FillOptionsEnd(builder)
- return fillOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class FloorDivOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = FloorDivOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsFloorDivOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # FloorDivOptions
- 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)
-
-class FloorDivOptionsT(object):
-
- # FloorDivOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- floorDivOptions = FloorDivOptions()
- floorDivOptions.Init(buf, pos)
- return cls.InitFromObj(floorDivOptions)
-
- @classmethod
- def InitFromObj(cls, floorDivOptions):
- x = FloorDivOptionsT()
- x._UnPack(floorDivOptions)
- return x
-
- # FloorDivOptionsT
- def _UnPack(self, floorDivOptions):
- if floorDivOptions is None:
- return
-
- # FloorDivOptionsT
- def Pack(self, builder):
- FloorDivOptionsStart(builder)
- floorDivOptions = FloorDivOptionsEnd(builder)
- return floorDivOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class FloorModOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = FloorModOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsFloorModOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # FloorModOptions
- 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)
-
-class FloorModOptionsT(object):
-
- # FloorModOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- floorModOptions = FloorModOptions()
- floorModOptions.Init(buf, pos)
- return cls.InitFromObj(floorModOptions)
-
- @classmethod
- def InitFromObj(cls, floorModOptions):
- x = FloorModOptionsT()
- x._UnPack(floorModOptions)
- return x
-
- # FloorModOptionsT
- def _UnPack(self, floorModOptions):
- if floorModOptions is None:
- return
-
- # FloorModOptionsT
- def Pack(self, builder):
- FloorModOptionsStart(builder)
- floorModOptions = FloorModOptionsEnd(builder)
- return floorModOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class FullyConnectedOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = FullyConnectedOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsFullyConnectedOptions(cls, buf, offset=0):
- """This method is deprecated. Please switch to GetRootAs."""
- return cls.GetRootAs(buf, offset)
- @classmethod
- def FullyConnectedOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # FullyConnectedOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # FullyConnectedOptions
- 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
-
- # FullyConnectedOptions
- def WeightsFormat(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
-
- # FullyConnectedOptions
- def KeepNumDims(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
-
- # FullyConnectedOptions
- 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
-
- # FullyConnectedOptions
- 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 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)
-
-class FullyConnectedOptionsT(object):
-
- # FullyConnectedOptionsT
- def __init__(self):
- self.fusedActivationFunction = 0 # type: int
- self.weightsFormat = 0 # type: int
- self.keepNumDims = False # type: bool
- self.asymmetricQuantizeInputs = False # type: bool
- self.quantizedBiasType = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- fullyConnectedOptions = FullyConnectedOptions()
- fullyConnectedOptions.Init(buf, pos)
- return cls.InitFromObj(fullyConnectedOptions)
-
- @classmethod
- def InitFromObj(cls, fullyConnectedOptions):
- x = FullyConnectedOptionsT()
- x._UnPack(fullyConnectedOptions)
- return x
-
- # FullyConnectedOptionsT
- def _UnPack(self, fullyConnectedOptions):
- if fullyConnectedOptions is None:
- return
- self.fusedActivationFunction = fullyConnectedOptions.FusedActivationFunction()
- self.weightsFormat = fullyConnectedOptions.WeightsFormat()
- self.keepNumDims = fullyConnectedOptions.KeepNumDims()
- self.asymmetricQuantizeInputs = fullyConnectedOptions.AsymmetricQuantizeInputs()
- self.quantizedBiasType = fullyConnectedOptions.QuantizedBiasType()
-
- # FullyConnectedOptionsT
- def Pack(self, builder):
- FullyConnectedOptionsStart(builder)
- FullyConnectedOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
- FullyConnectedOptionsAddWeightsFormat(builder, self.weightsFormat)
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class GreaterEqualOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = GreaterEqualOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsGreaterEqualOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # GreaterEqualOptions
- 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)
-
-class GreaterEqualOptionsT(object):
-
- # GreaterEqualOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- greaterEqualOptions = GreaterEqualOptions()
- greaterEqualOptions.Init(buf, pos)
- return cls.InitFromObj(greaterEqualOptions)
-
- @classmethod
- def InitFromObj(cls, greaterEqualOptions):
- x = GreaterEqualOptionsT()
- x._UnPack(greaterEqualOptions)
- return x
-
- # GreaterEqualOptionsT
- def _UnPack(self, greaterEqualOptions):
- if greaterEqualOptions is None:
- return
-
- # GreaterEqualOptionsT
- def Pack(self, builder):
- GreaterEqualOptionsStart(builder)
- greaterEqualOptions = GreaterEqualOptionsEnd(builder)
- return greaterEqualOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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)
-
- # GreaterOptions
- 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)
-
-class GreaterOptionsT(object):
-
- # GreaterOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- greaterOptions = GreaterOptions()
- greaterOptions.Init(buf, pos)
- return cls.InitFromObj(greaterOptions)
-
- @classmethod
- def InitFromObj(cls, greaterOptions):
- x = GreaterOptionsT()
- x._UnPack(greaterOptions)
- return x
-
- # GreaterOptionsT
- def _UnPack(self, greaterOptions):
- if greaterOptions is None:
- return
-
- # GreaterOptionsT
- def Pack(self, builder):
- GreaterOptionsStart(builder)
- greaterOptions = GreaterOptionsEnd(builder)
- return greaterOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class HardSwishOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = HardSwishOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsHardSwishOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # HardSwishOptions
- 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)
-
-class HardSwishOptionsT(object):
-
- # HardSwishOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- hardSwishOptions = HardSwishOptions()
- hardSwishOptions.Init(buf, pos)
- return cls.InitFromObj(hardSwishOptions)
-
- @classmethod
- def InitFromObj(cls, hardSwishOptions):
- x = HardSwishOptionsT()
- x._UnPack(hardSwishOptions)
- return x
-
- # HardSwishOptionsT
- def _UnPack(self, hardSwishOptions):
- if hardSwishOptions is None:
- return
-
- # HardSwishOptionsT
- def Pack(self, builder):
- HardSwishOptionsStart(builder)
- hardSwishOptions = HardSwishOptionsEnd(builder)
- return hardSwishOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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)
-
-def HashtableFindOptionsStart(builder): builder.StartObject(0)
-def Start(builder):
- return HashtableFindOptionsStart(builder)
-def HashtableFindOptionsEnd(builder): return builder.EndObject()
-def End(builder):
- return HashtableFindOptionsEnd(builder)
-
-class HashtableFindOptionsT(object):
-
- # HashtableFindOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- hashtableFindOptions = HashtableFindOptions()
- hashtableFindOptions.Init(buf, pos)
- return cls.InitFromObj(hashtableFindOptions)
-
- @classmethod
- def InitFromObj(cls, hashtableFindOptions):
- x = HashtableFindOptionsT()
- x._UnPack(hashtableFindOptions)
- return x
-
- # HashtableFindOptionsT
- def _UnPack(self, hashtableFindOptions):
- if hashtableFindOptions is None:
- return
-
- # HashtableFindOptionsT
- def Pack(self, builder):
- HashtableFindOptionsStart(builder)
- hashtableFindOptions = HashtableFindOptionsEnd(builder)
- return hashtableFindOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class HashtableImportOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # HashtableImportOptions
- 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)
-
-class HashtableImportOptionsT(object):
-
- # HashtableImportOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- hashtableImportOptions = HashtableImportOptions()
- hashtableImportOptions.Init(buf, pos)
- return cls.InitFromObj(hashtableImportOptions)
-
- @classmethod
- def InitFromObj(cls, hashtableImportOptions):
- x = HashtableImportOptionsT()
- x._UnPack(hashtableImportOptions)
- return x
-
- # HashtableImportOptionsT
- def _UnPack(self, hashtableImportOptions):
- if hashtableImportOptions is None:
- return
-
- # HashtableImportOptionsT
- def Pack(self, builder):
- HashtableImportOptionsStart(builder)
- hashtableImportOptions = HashtableImportOptionsEnd(builder)
- return hashtableImportOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class HashtableOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = HashtableOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsHashtableOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # HashtableOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # HashtableOptions
- def TableId(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):
- 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
-
- # HashtableOptions
- def ValueDtype(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
-
-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)
-
-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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class HashtableSizeOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = HashtableSizeOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsHashtableSizeOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # HashtableSizeOptions
- 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)
-
-class HashtableSizeOptionsT(object):
-
- # HashtableSizeOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- hashtableSizeOptions = HashtableSizeOptions()
- hashtableSizeOptions.Init(buf, pos)
- return cls.InitFromObj(hashtableSizeOptions)
-
- @classmethod
- def InitFromObj(cls, hashtableSizeOptions):
- x = HashtableSizeOptionsT()
- x._UnPack(hashtableSizeOptions)
- return x
-
- # HashtableSizeOptionsT
- def _UnPack(self, hashtableSizeOptions):
- if hashtableSizeOptions is None:
- return
-
- # HashtableSizeOptionsT
- def Pack(self, builder):
- HashtableSizeOptionsStart(builder)
- hashtableSizeOptions = HashtableSizeOptionsEnd(builder)
- return hashtableSizeOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class IfOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # IfOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # IfOptions
- def ThenSubgraphIndex(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
-
- # IfOptions
- def ElseSubgraphIndex(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 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)
-
-class IfOptionsT(object):
-
- # IfOptionsT
- def __init__(self):
- self.thenSubgraphIndex = 0 # type: int
- self.elseSubgraphIndex = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- ifOptions = IfOptions()
- ifOptions.Init(buf, pos)
- return cls.InitFromObj(ifOptions)
-
- @classmethod
- def InitFromObj(cls, ifOptions):
- x = IfOptionsT()
- x._UnPack(ifOptions)
- return x
-
- # IfOptionsT
- def _UnPack(self, ifOptions):
- if ifOptions is None:
- return
- self.thenSubgraphIndex = ifOptions.ThenSubgraphIndex()
- self.elseSubgraphIndex = ifOptions.ElseSubgraphIndex()
-
- # IfOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 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
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class L2NormOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # L2NormOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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)
-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)
-
-class L2NormOptionsT(object):
-
- # L2NormOptionsT
- def __init__(self):
- self.fusedActivationFunction = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- l2normOptions = L2NormOptions()
- l2normOptions.Init(buf, pos)
- return cls.InitFromObj(l2normOptions)
-
- @classmethod
- def InitFromObj(cls, l2normOptions):
- x = L2NormOptionsT()
- x._UnPack(l2normOptions)
- return x
-
- # L2NormOptionsT
- def _UnPack(self, l2normOptions):
- if l2normOptions is None:
- return
- self.fusedActivationFunction = l2normOptions.FusedActivationFunction()
-
- # L2NormOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LSHProjectionOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LSHProjectionOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLSHProjectionOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LSHProjectionOptions
- 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))
- if o != 0:
- return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
- return 0
-
-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)
-
-class LSHProjectionOptionsT(object):
-
- # LSHProjectionOptionsT
- def __init__(self):
- self.type = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- lshprojectionOptions = LSHProjectionOptions()
- lshprojectionOptions.Init(buf, pos)
- return cls.InitFromObj(lshprojectionOptions)
-
- @classmethod
- def InitFromObj(cls, lshprojectionOptions):
- x = LSHProjectionOptionsT()
- x._UnPack(lshprojectionOptions)
- return x
-
- # LSHProjectionOptionsT
- def _UnPack(self, lshprojectionOptions):
- if lshprojectionOptions is None:
- return
- self.type = lshprojectionOptions.Type()
-
- # LSHProjectionOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LSTMOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LSTMOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLSTMOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LSTMOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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
-
- # 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 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)
-
-class LSTMOptionsT(object):
-
- # LSTMOptionsT
- 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
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- lstmoptions = LSTMOptions()
- lstmoptions.Init(buf, pos)
- return cls.InitFromObj(lstmoptions)
-
- @classmethod
- def InitFromObj(cls, lstmoptions):
- x = LSTMOptionsT()
- x._UnPack(lstmoptions)
- return x
-
- # 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()
-
- # 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
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LeakyReluOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LeakyReluOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLeakyReluOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LeakyReluOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # LeakyReluOptions
- def Alpha(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 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)
-
-class LeakyReluOptionsT(object):
-
- # LeakyReluOptionsT
- def __init__(self):
- self.alpha = 0.0 # type: float
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- leakyReluOptions = LeakyReluOptions()
- leakyReluOptions.Init(buf, pos)
- return cls.InitFromObj(leakyReluOptions)
-
- @classmethod
- def InitFromObj(cls, leakyReluOptions):
- x = LeakyReluOptionsT()
- x._UnPack(leakyReluOptions)
- return x
-
- # LeakyReluOptionsT
- def _UnPack(self, leakyReluOptions):
- if leakyReluOptions is None:
- return
- self.alpha = leakyReluOptions.Alpha()
-
- # LeakyReluOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LessEqualOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LessEqualOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLessEqualOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LessEqualOptions
- 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)
-
-class LessEqualOptionsT(object):
-
- # LessEqualOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- lessEqualOptions = LessEqualOptions()
- lessEqualOptions.Init(buf, pos)
- return cls.InitFromObj(lessEqualOptions)
-
- @classmethod
- def InitFromObj(cls, lessEqualOptions):
- x = LessEqualOptionsT()
- x._UnPack(lessEqualOptions)
- return x
-
- # LessEqualOptionsT
- def _UnPack(self, lessEqualOptions):
- if lessEqualOptions is None:
- return
-
- # LessEqualOptionsT
- def Pack(self, builder):
- LessEqualOptionsStart(builder)
- lessEqualOptions = LessEqualOptionsEnd(builder)
- return lessEqualOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LessOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LessOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLessOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LessOptions
- 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)
-
-class LessOptionsT(object):
-
- # LessOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- lessOptions = LessOptions()
- lessOptions.Init(buf, pos)
- return cls.InitFromObj(lessOptions)
-
- @classmethod
- def InitFromObj(cls, lessOptions):
- x = LessOptionsT()
- x._UnPack(lessOptions)
- return x
-
- # LessOptionsT
- def _UnPack(self, lessOptions):
- if lessOptions is None:
- return
-
- # LessOptionsT
- def Pack(self, builder):
- LessOptionsStart(builder)
- lessOptions = LessOptionsEnd(builder)
- return lessOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LocalResponseNormalizationOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LocalResponseNormalizationOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLocalResponseNormalizationOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LocalResponseNormalizationOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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.Float32Flags, o + self._tab.Pos)
- return 0.0
-
- # 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.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 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)
-
-class LocalResponseNormalizationOptionsT(object):
-
- # LocalResponseNormalizationOptionsT
- 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
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- localResponseNormalizationOptions = LocalResponseNormalizationOptions()
- localResponseNormalizationOptions.Init(buf, pos)
- return cls.InitFromObj(localResponseNormalizationOptions)
-
- @classmethod
- def InitFromObj(cls, localResponseNormalizationOptions):
- x = LocalResponseNormalizationOptionsT()
- x._UnPack(localResponseNormalizationOptions)
- return x
-
- # LocalResponseNormalizationOptionsT
- def _UnPack(self, localResponseNormalizationOptions):
- if localResponseNormalizationOptions is None:
- return
- self.radius = localResponseNormalizationOptions.Radius()
- self.bias = localResponseNormalizationOptions.Bias()
- self.alpha = localResponseNormalizationOptions.Alpha()
- self.beta = localResponseNormalizationOptions.Beta()
-
- # LocalResponseNormalizationOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LogSoftmaxOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LogSoftmaxOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLogSoftmaxOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LogSoftmaxOptions
- 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)
-
-class LogSoftmaxOptionsT(object):
-
- # LogSoftmaxOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- logSoftmaxOptions = LogSoftmaxOptions()
- logSoftmaxOptions.Init(buf, pos)
- return cls.InitFromObj(logSoftmaxOptions)
-
- @classmethod
- def InitFromObj(cls, logSoftmaxOptions):
- x = LogSoftmaxOptionsT()
- x._UnPack(logSoftmaxOptions)
- return x
-
- # LogSoftmaxOptionsT
- def _UnPack(self, logSoftmaxOptions):
- if logSoftmaxOptions is None:
- return
-
- # LogSoftmaxOptionsT
- def Pack(self, builder):
- LogSoftmaxOptionsStart(builder)
- logSoftmaxOptions = LogSoftmaxOptionsEnd(builder)
- return logSoftmaxOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LogicalAndOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LogicalAndOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLogicalAndOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LogicalAndOptions
- 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)
-
-class LogicalAndOptionsT(object):
-
- # LogicalAndOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- logicalAndOptions = LogicalAndOptions()
- logicalAndOptions.Init(buf, pos)
- return cls.InitFromObj(logicalAndOptions)
-
- @classmethod
- def InitFromObj(cls, logicalAndOptions):
- x = LogicalAndOptionsT()
- x._UnPack(logicalAndOptions)
- return x
-
- # LogicalAndOptionsT
- def _UnPack(self, logicalAndOptions):
- if logicalAndOptions is None:
- return
-
- # LogicalAndOptionsT
- def Pack(self, builder):
- LogicalAndOptionsStart(builder)
- logicalAndOptions = LogicalAndOptionsEnd(builder)
- return logicalAndOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LogicalNotOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LogicalNotOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLogicalNotOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LogicalNotOptions
- 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)
-
-class LogicalNotOptionsT(object):
-
- # LogicalNotOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- logicalNotOptions = LogicalNotOptions()
- logicalNotOptions.Init(buf, pos)
- return cls.InitFromObj(logicalNotOptions)
-
- @classmethod
- def InitFromObj(cls, logicalNotOptions):
- x = LogicalNotOptionsT()
- x._UnPack(logicalNotOptions)
- return x
-
- # LogicalNotOptionsT
- def _UnPack(self, logicalNotOptions):
- if logicalNotOptions is None:
- return
-
- # LogicalNotOptionsT
- def Pack(self, builder):
- LogicalNotOptionsStart(builder)
- logicalNotOptions = LogicalNotOptionsEnd(builder)
- return logicalNotOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class LogicalOrOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = LogicalOrOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsLogicalOrOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # LogicalOrOptions
- 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)
-
-class LogicalOrOptionsT(object):
-
- # LogicalOrOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- logicalOrOptions = LogicalOrOptions()
- logicalOrOptions.Init(buf, pos)
- return cls.InitFromObj(logicalOrOptions)
-
- @classmethod
- def InitFromObj(cls, logicalOrOptions):
- x = LogicalOrOptionsT()
- x._UnPack(logicalOrOptions)
- return x
-
- # LogicalOrOptionsT
- def _UnPack(self, logicalOrOptions):
- if logicalOrOptions is None:
- return
-
- # LogicalOrOptionsT
- def Pack(self, builder):
- LogicalOrOptionsStart(builder)
- logicalOrOptions = LogicalOrOptionsEnd(builder)
- return logicalOrOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class MatrixDiagOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = MatrixDiagOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsMatrixDiagOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # MatrixDiagOptions
- 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)
-
-class MatrixDiagOptionsT(object):
-
- # MatrixDiagOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- matrixDiagOptions = MatrixDiagOptions()
- matrixDiagOptions.Init(buf, pos)
- return cls.InitFromObj(matrixDiagOptions)
-
- @classmethod
- def InitFromObj(cls, matrixDiagOptions):
- x = MatrixDiagOptionsT()
- x._UnPack(matrixDiagOptions)
- return x
-
- # MatrixDiagOptionsT
- def _UnPack(self, matrixDiagOptions):
- if matrixDiagOptions is None:
- return
-
- # MatrixDiagOptionsT
- def Pack(self, builder):
- MatrixDiagOptionsStart(builder)
- matrixDiagOptions = MatrixDiagOptionsEnd(builder)
- return matrixDiagOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class MatrixSetDiagOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # MatrixSetDiagOptions
- 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)
-
-class MatrixSetDiagOptionsT(object):
-
- # MatrixSetDiagOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- matrixSetDiagOptions = MatrixSetDiagOptions()
- matrixSetDiagOptions.Init(buf, pos)
- return cls.InitFromObj(matrixSetDiagOptions)
-
- @classmethod
- def InitFromObj(cls, matrixSetDiagOptions):
- x = MatrixSetDiagOptionsT()
- x._UnPack(matrixSetDiagOptions)
- return x
-
- # MatrixSetDiagOptionsT
- def _UnPack(self, matrixSetDiagOptions):
- if matrixSetDiagOptions is None:
- return
-
- # MatrixSetDiagOptionsT
- def Pack(self, builder):
- MatrixSetDiagOptionsStart(builder)
- matrixSetDiagOptions = MatrixSetDiagOptionsEnd(builder)
- return matrixSetDiagOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class MaximumMinimumOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = MaximumMinimumOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsMaximumMinimumOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # MaximumMinimumOptions
- 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)
-
-class MaximumMinimumOptionsT(object):
-
- # MaximumMinimumOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- maximumMinimumOptions = MaximumMinimumOptions()
- maximumMinimumOptions.Init(buf, pos)
- return cls.InitFromObj(maximumMinimumOptions)
-
- @classmethod
- def InitFromObj(cls, maximumMinimumOptions):
- x = MaximumMinimumOptionsT()
- x._UnPack(maximumMinimumOptions)
- return x
-
- # MaximumMinimumOptionsT
- def _UnPack(self, maximumMinimumOptions):
- if maximumMinimumOptions is None:
- return
-
- # MaximumMinimumOptionsT
- def Pack(self, builder):
- MaximumMinimumOptionsStart(builder)
- maximumMinimumOptions = MaximumMinimumOptionsEnd(builder)
- return maximumMinimumOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class Metadata(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = Metadata()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsMetadata(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # Metadata
- 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
-
- # 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 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
- def __init__(self):
- self.name = None # type: str
- self.buffer = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- metadata = Metadata()
- metadata.Init(buf, pos)
- return cls.InitFromObj(metadata)
-
- @classmethod
- def InitFromObj(cls, metadata):
- x = MetadataT()
- x._UnPack(metadata)
- return x
-
- # MetadataT
- def _UnPack(self, metadata):
- if metadata is None:
- return
- self.name = metadata.Name()
- self.buffer = metadata.Buffer()
-
- # MetadataT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class MirrorPadOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = MirrorPadOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsMirrorPadOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # MirrorPadOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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.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)
-
-class MirrorPadOptionsT(object):
-
- # MirrorPadOptionsT
- def __init__(self):
- self.mode = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- mirrorPadOptions = MirrorPadOptions()
- mirrorPadOptions.Init(buf, pos)
- return cls.InitFromObj(mirrorPadOptions)
-
- @classmethod
- def InitFromObj(cls, mirrorPadOptions):
- x = MirrorPadOptionsT()
- x._UnPack(mirrorPadOptions)
- return x
-
- # MirrorPadOptionsT
- def _UnPack(self, mirrorPadOptions):
- if mirrorPadOptions is None:
- return
- self.mode = mirrorPadOptions.Mode()
-
- # MirrorPadOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class Model(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = Model()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsModel(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # Model
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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.VectorLen(o)
- return 0
-
- # 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:
- 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
-
- # Model
- def SignatureDefsIsNone(self):
- o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
- return o == 0
-
-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
- 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]
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- model = Model()
- model.Init(buf, pos)
- return cls.InitFromObj(model)
-
- @classmethod
- def InitFromObj(cls, model):
- x = ModelT()
- x._UnPack(model)
- return x
-
- # 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_)
-
- # ModelT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class MulOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = MulOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsMulOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # MulOptions
- 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 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)
-
-class MulOptionsT(object):
-
- # MulOptionsT
- def __init__(self):
- self.fusedActivationFunction = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- mulOptions = MulOptions()
- mulOptions.Init(buf, pos)
- return cls.InitFromObj(mulOptions)
-
- @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()
-
- # MulOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class NegOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = NegOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsNegOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # NegOptions
- 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)
-
-class NegOptionsT(object):
-
- # NegOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- negOptions = NegOptions()
- negOptions.Init(buf, pos)
- return cls.InitFromObj(negOptions)
-
- @classmethod
- def InitFromObj(cls, negOptions):
- x = NegOptionsT()
- x._UnPack(negOptions)
- return x
-
- # NegOptionsT
- def _UnPack(self, negOptions):
- if negOptions is None:
- return
-
- # NegOptionsT
- def Pack(self, builder):
- NegOptionsStart(builder)
- negOptions = NegOptionsEnd(builder)
- return negOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 Start(builder):
- return NonMaxSuppressionV4OptionsStart(builder)
-def NonMaxSuppressionV4OptionsEnd(builder): return builder.EndObject()
-def End(builder):
- return NonMaxSuppressionV4OptionsEnd(builder)
-
-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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 Start(builder):
- return NonMaxSuppressionV5OptionsStart(builder)
-def NonMaxSuppressionV5OptionsEnd(builder): return builder.EndObject()
-def End(builder):
- return NonMaxSuppressionV5OptionsEnd(builder)
-
-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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class NotEqualOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = NotEqualOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsNotEqualOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # NotEqualOptions
- 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)
-
-class NotEqualOptionsT(object):
-
- # NotEqualOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- notEqualOptions = NotEqualOptions()
- notEqualOptions.Init(buf, pos)
- return cls.InitFromObj(notEqualOptions)
-
- @classmethod
- def InitFromObj(cls, notEqualOptions):
- x = NotEqualOptionsT()
- x._UnPack(notEqualOptions)
- return x
-
- # NotEqualOptionsT
- def _UnPack(self, notEqualOptions):
- if notEqualOptions is None:
- return
-
- # NotEqualOptionsT
- def Pack(self, builder):
- NotEqualOptionsStart(builder)
- notEqualOptions = NotEqualOptionsEnd(builder)
- return notEqualOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class OneHotOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = OneHotOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsOneHotOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # OneHotOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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)
-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)
-
-class OneHotOptionsT(object):
-
- # OneHotOptionsT
- def __init__(self):
- self.axis = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- oneHotOptions = OneHotOptions()
- oneHotOptions.Init(buf, pos)
- return cls.InitFromObj(oneHotOptions)
-
- @classmethod
- def InitFromObj(cls, oneHotOptions):
- x = OneHotOptionsT()
- x._UnPack(oneHotOptions)
- return x
-
- # OneHotOptionsT
- def _UnPack(self, oneHotOptions):
- if oneHotOptions is None:
- return
- self.axis = oneHotOptions.Axis()
-
- # OneHotOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class Operator(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = Operator()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsOperator(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # Operator
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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.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 0
-
- # Operator
- def InputsIsNone(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 0
-
- # Operator
- def OutputsIsNone(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 0
-
- # 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.Uint64Flags, o + self._tab.Pos)
- return 0
-
- # 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.Uint8Flags, o + self._tab.Pos)
- return 0
-
- # Operator
- def BuiltinOptions2(self):
- o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
- if o != 0:
- from flatbuffers.table import Table
- obj = Table(bytearray(), 0)
- self._tab.Union(obj, o)
- return obj
- return None
-
-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
-
-class OperatorT(object):
-
- # OperatorT
- 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]
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- operator = Operator()
- operator.Init(buf, pos)
- return cls.InitFromObj(operator)
-
- @classmethod
- def InitFromObj(cls, operator):
- x = OperatorT()
- x._UnPack(operator)
- return x
-
- # OperatorT
- def _UnPack(self, operator):
- if operator 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())
-
- # OperatorT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class OperatorCode(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = OperatorCode()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsOperatorCode(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # OperatorCode
- 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
-
- # 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
-
- # 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):
-
- # OperatorCodeT
- def __init__(self):
- 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):
- operatorCode = OperatorCode()
- operatorCode.Init(buf, pos)
- return cls.InitFromObj(operatorCode)
-
- @classmethod
- def InitFromObj(cls, operatorCode):
- x = OperatorCodeT()
- x._UnPack(operatorCode)
- return x
-
- # 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()
-
- # OperatorCodeT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class PackOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = PackOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsPackOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # PackOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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.Int32Flags, 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)
-
-class PackOptionsT(object):
-
- # PackOptionsT
- def __init__(self):
- self.valuesCount = 0 # type: int
- self.axis = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- packOptions = PackOptions()
- packOptions.Init(buf, pos)
- return cls.InitFromObj(packOptions)
-
- @classmethod
- def InitFromObj(cls, packOptions):
- x = PackOptionsT()
- x._UnPack(packOptions)
- return x
-
- # PackOptionsT
- def _UnPack(self, packOptions):
- if packOptions is None:
- return
- self.valuesCount = packOptions.ValuesCount()
- self.axis = packOptions.Axis()
-
- # PackOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class PadOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = PadOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsPadOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # PadOptions
- 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)
-
-class PadOptionsT(object):
-
- # PadOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- padOptions = PadOptions()
- padOptions.Init(buf, pos)
- return cls.InitFromObj(padOptions)
-
- @classmethod
- def InitFromObj(cls, padOptions):
- x = PadOptionsT()
- x._UnPack(padOptions)
- return x
-
- # PadOptionsT
- def _UnPack(self, padOptions):
- if padOptions is None:
- return
-
- # PadOptionsT
- def Pack(self, builder):
- PadOptionsStart(builder)
- padOptions = PadOptionsEnd(builder)
- return padOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class PadV2Options(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = PadV2Options()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsPadV2Options(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # PadV2Options
- 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)
-
-class PadV2OptionsT(object):
-
- # PadV2OptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- padV2options = PadV2Options()
- padV2options.Init(buf, pos)
- return cls.InitFromObj(padV2options)
-
- @classmethod
- def InitFromObj(cls, padV2options):
- x = PadV2OptionsT()
- x._UnPack(padV2options)
- return x
-
- # PadV2OptionsT
- def _UnPack(self, padV2options):
- if padV2options is None:
- return
-
- # PadV2OptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class Pool2DOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = Pool2DOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsPool2DOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # Pool2DOptions
- 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
-
- # 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 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):
-
- # 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):
- pool2doptions = Pool2DOptions()
- pool2doptions.Init(buf, pos)
- return cls.InitFromObj(pool2doptions)
-
- @classmethod
- def InitFromObj(cls, pool2doptions):
- x = Pool2DOptionsT()
- x._UnPack(pool2doptions)
- return x
-
- # Pool2DOptionsT
- def _UnPack(self, pool2doptions):
- if pool2doptions 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
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class PowOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = PowOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsPowOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # PowOptions
- 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)
-
-class PowOptionsT(object):
-
- # PowOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- powOptions = PowOptions()
- powOptions.Init(buf, pos)
- return cls.InitFromObj(powOptions)
-
- @classmethod
- def InitFromObj(cls, powOptions):
- x = PowOptionsT()
- x._UnPack(powOptions)
- return x
-
- # PowOptionsT
- def _UnPack(self, powOptions):
- if powOptions is None:
- return
-
- # PowOptionsT
- 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
-from flatbuffers.compat import import_numpy
-np = import_numpy()
class QuantizationParameters(object):
__slots__ = ['_tab']
@@ -8731,45 +1089,46 @@
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)
+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:
@@ -8794,6 +1153,11 @@
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)
@@ -8886,2468 +1250,522 @@
QuantizationParametersAddQuantizedDimension(builder, self.quantizedDimension)
quantizationParameters = QuantizationParametersEnd(builder)
return quantizationParameters
-# automatically generated by the FlatBuffers compiler, do not modify
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class QuantizeOptions(object):
+class Int32Vector(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = QuantizeOptions()
+ x = Int32Vector()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsQuantizeOptions(cls, buf, offset=0):
+ def GetRootAsInt32Vector(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 Int32VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
- # QuantizeOptions
+ # Int32Vector
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)
-
-class QuantizeOptionsT(object):
-
- # QuantizeOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- quantizeOptions = QuantizeOptions()
- quantizeOptions.Init(buf, pos)
- return cls.InitFromObj(quantizeOptions)
-
- @classmethod
- def InitFromObj(cls, quantizeOptions):
- x = QuantizeOptionsT()
- x._UnPack(quantizeOptions)
- return x
-
- # QuantizeOptionsT
- def _UnPack(self, quantizeOptions):
- if quantizeOptions is None:
- return
-
- # QuantizeOptionsT
- def Pack(self, builder):
- QuantizeOptionsStart(builder)
- quantizeOptions = QuantizeOptionsEnd(builder)
- return quantizeOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class RNNOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = RNNOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsRNNOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # RNNOptions
- 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
-
- # 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)
-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
- def __init__(self):
- self.fusedActivationFunction = 0 # type: int
- self.asymmetricQuantizeInputs = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- rnnoptions = RNNOptions()
- rnnoptions.Init(buf, pos)
- return cls.InitFromObj(rnnoptions)
-
- @classmethod
- def InitFromObj(cls, rnnoptions):
- x = RNNOptionsT()
- x._UnPack(rnnoptions)
- return x
-
- # RNNOptionsT
- def _UnPack(self, rnnoptions):
- if rnnoptions is None:
- return
- self.fusedActivationFunction = rnnoptions.FusedActivationFunction()
- self.asymmetricQuantizeInputs = rnnoptions.AsymmetricQuantizeInputs()
-
- # RNNOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class RandomOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = RandomOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsRandomOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # RandomOptions
- 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
-
- # 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 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
- def __init__(self):
- self.seed = 0 # type: int
- self.seed2 = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- randomOptions = RandomOptions()
- randomOptions.Init(buf, pos)
- return cls.InitFromObj(randomOptions)
-
- @classmethod
- def InitFromObj(cls, randomOptions):
- x = RandomOptionsT()
- x._UnPack(randomOptions)
- return x
-
- # RandomOptionsT
- def _UnPack(self, randomOptions):
- if randomOptions is None:
- return
- self.seed = randomOptions.Seed()
- self.seed2 = randomOptions.Seed2()
-
- # RandomOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class RangeOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = RangeOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsRangeOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # RangeOptions
- 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)
-
-class RangeOptionsT(object):
-
- # RangeOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- rangeOptions = RangeOptions()
- rangeOptions.Init(buf, pos)
- return cls.InitFromObj(rangeOptions)
-
- @classmethod
- def InitFromObj(cls, rangeOptions):
- x = RangeOptionsT()
- x._UnPack(rangeOptions)
- return x
-
- # RangeOptionsT
- def _UnPack(self, rangeOptions):
- if rangeOptions is None:
- return
-
- # RangeOptionsT
- def Pack(self, builder):
- RangeOptionsStart(builder)
- rangeOptions = RangeOptionsEnd(builder)
- return rangeOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class RankOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = RankOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsRankOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # RankOptions
- 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)
-
-class RankOptionsT(object):
-
- # RankOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- rankOptions = RankOptions()
- rankOptions.Init(buf, pos)
- return cls.InitFromObj(rankOptions)
-
- @classmethod
- def InitFromObj(cls, rankOptions):
- x = RankOptionsT()
- x._UnPack(rankOptions)
- return x
-
- # RankOptionsT
- def _UnPack(self, rankOptions):
- if rankOptions is None:
- return
-
- # RankOptionsT
- def Pack(self, builder):
- RankOptionsStart(builder)
- rankOptions = RankOptionsEnd(builder)
- return rankOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ReadVariableOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ReadVariableOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsReadVariableOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ReadVariableOptions
- 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)
-
-class ReadVariableOptionsT(object):
-
- # ReadVariableOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- readVariableOptions = ReadVariableOptions()
- readVariableOptions.Init(buf, pos)
- return cls.InitFromObj(readVariableOptions)
-
- @classmethod
- def InitFromObj(cls, readVariableOptions):
- x = ReadVariableOptionsT()
- x._UnPack(readVariableOptions)
- return x
-
- # ReadVariableOptionsT
- def _UnPack(self, readVariableOptions):
- if readVariableOptions is None:
- return
-
- # ReadVariableOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ReduceWindowOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ReduceWindowOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsReduceWindowOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ReduceWindowOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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)
-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)
-
-class ReduceWindowOptionsT(object):
-
- # ReduceWindowOptionsT
- def __init__(self):
- self.reduceFunction = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- reduceWindowOptions = ReduceWindowOptions()
- reduceWindowOptions.Init(buf, pos)
- return cls.InitFromObj(reduceWindowOptions)
-
- @classmethod
- def InitFromObj(cls, reduceWindowOptions):
- x = ReduceWindowOptionsT()
- x._UnPack(reduceWindowOptions)
- return x
-
- # ReduceWindowOptionsT
- def _UnPack(self, reduceWindowOptions):
- if reduceWindowOptions is None:
- return
- self.reduceFunction = reduceWindowOptions.ReduceFunction()
-
- # ReduceWindowOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ReducerOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ReducerOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsReducerOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ReducerOptions
- 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 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)
-
-class ReducerOptionsT(object):
-
- # ReducerOptionsT
- def __init__(self):
- self.keepDims = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- reducerOptions = ReducerOptions()
- reducerOptions.Init(buf, pos)
- return cls.InitFromObj(reducerOptions)
-
- @classmethod
- def InitFromObj(cls, reducerOptions):
- x = ReducerOptionsT()
- x._UnPack(reducerOptions)
- return x
-
- # ReducerOptionsT
- def _UnPack(self, reducerOptions):
- if reducerOptions is None:
- return
- self.keepDims = reducerOptions.KeepDims()
-
- # ReducerOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ReshapeOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ReshapeOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsReshapeOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ReshapeOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # ReshapeOptions
- def NewShape(self, j):
+ # 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
- # ReshapeOptions
- def NewShapeAsNumpy(self):
+ # 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
- # ReshapeOptions
- def NewShapeLength(self):
+ # 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
- # ReshapeOptions
- def NewShapeIsNone(self):
+ # Int32Vector
+ def ValuesIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
return o == 0
-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)
+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 ReshapeOptionsT(object):
+class Int32VectorT(object):
- # ReshapeOptionsT
+ # Int32VectorT
def __init__(self):
- self.newShape = None # type: List[int]
+ self.values = None # type: List[int]
@classmethod
def InitFromBuf(cls, buf, pos):
- reshapeOptions = ReshapeOptions()
- reshapeOptions.Init(buf, pos)
- return cls.InitFromObj(reshapeOptions)
+ int32Vector = Int32Vector()
+ int32Vector.Init(buf, pos)
+ return cls.InitFromObj(int32Vector)
@classmethod
- def InitFromObj(cls, reshapeOptions):
- x = ReshapeOptionsT()
- x._UnPack(reshapeOptions)
+ 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
- # ReshapeOptionsT
- def _UnPack(self, reshapeOptions):
- if reshapeOptions is None:
+ # Int32VectorT
+ def _UnPack(self, int32Vector):
+ if int32Vector is None:
return
- if not reshapeOptions.NewShapeIsNone():
+ if not int32Vector.ValuesIsNone():
if np is None:
- self.newShape = []
- for i in range(reshapeOptions.NewShapeLength()):
- self.newShape.append(reshapeOptions.NewShape(i))
+ self.values = []
+ for i in range(int32Vector.ValuesLength()):
+ self.values.append(int32Vector.Values(i))
else:
- self.newShape = reshapeOptions.NewShapeAsNumpy()
+ self.values = int32Vector.ValuesAsNumpy()
- # ReshapeOptionsT
+ # Int32VectorT
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)
+ if self.values is not None:
+ if np is not None and type(self.values) is np.ndarray:
+ values = builder.CreateNumpyVector(self.values)
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
+ 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
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ResizeBilinearOptions(object):
+class Uint16Vector(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ResizeBilinearOptions()
+ x = Uint16Vector()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsResizeBilinearOptions(cls, buf, offset=0):
+ def GetRootAsUint16Vector(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 Uint16VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
- # ResizeBilinearOptions
+ # Uint16Vector
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
- # ResizeBilinearOptions
- def AlignCorners(self):
+ # 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 bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
- return False
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+ return 0
- # ResizeBilinearOptions
- def HalfPixelCenters(self):
+ # DimensionMetadata
+ def ArraySegments(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 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
- def __init__(self):
- self.alignCorners = False # type: bool
- self.halfPixelCenters = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- resizeBilinearOptions = ResizeBilinearOptions()
- resizeBilinearOptions.Init(buf, pos)
- return cls.InitFromObj(resizeBilinearOptions)
-
- @classmethod
- def InitFromObj(cls, resizeBilinearOptions):
- x = ResizeBilinearOptionsT()
- x._UnPack(resizeBilinearOptions)
- return x
-
- # ResizeBilinearOptionsT
- def _UnPack(self, resizeBilinearOptions):
- if resizeBilinearOptions is None:
- return
- self.alignCorners = resizeBilinearOptions.AlignCorners()
- self.halfPixelCenters = resizeBilinearOptions.HalfPixelCenters()
-
- # ResizeBilinearOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ResizeNearestNeighborOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ResizeNearestNeighborOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsResizeNearestNeighborOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ResizeNearestNeighborOptions
- 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
-
- # 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 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
- def __init__(self):
- self.alignCorners = False # type: bool
- self.halfPixelCenters = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- resizeNearestNeighborOptions = ResizeNearestNeighborOptions()
- resizeNearestNeighborOptions.Init(buf, pos)
- return cls.InitFromObj(resizeNearestNeighborOptions)
-
- @classmethod
- def InitFromObj(cls, resizeNearestNeighborOptions):
- x = ResizeNearestNeighborOptionsT()
- x._UnPack(resizeNearestNeighborOptions)
- return x
-
- # ResizeNearestNeighborOptionsT
- def _UnPack(self, resizeNearestNeighborOptions):
- if resizeNearestNeighborOptions is None:
- return
- self.alignCorners = resizeNearestNeighborOptions.AlignCorners()
- self.halfPixelCenters = resizeNearestNeighborOptions.HalfPixelCenters()
-
- # ResizeNearestNeighborOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ReverseSequenceOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ReverseSequenceOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsReverseSequenceOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ReverseSequenceOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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.Int32Flags, 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 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)
-
-class ReverseSequenceOptionsT(object):
-
- # ReverseSequenceOptionsT
- def __init__(self):
- self.seqDim = 0 # type: int
- self.batchDim = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- reverseSequenceOptions = ReverseSequenceOptions()
- reverseSequenceOptions.Init(buf, pos)
- return cls.InitFromObj(reverseSequenceOptions)
-
- @classmethod
- def InitFromObj(cls, reverseSequenceOptions):
- x = ReverseSequenceOptionsT()
- x._UnPack(reverseSequenceOptions)
- return x
-
- # ReverseSequenceOptionsT
- def _UnPack(self, reverseSequenceOptions):
- if reverseSequenceOptions is None:
- return
- self.seqDim = reverseSequenceOptions.SeqDim()
- self.batchDim = reverseSequenceOptions.BatchDim()
-
- # ReverseSequenceOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ReverseV2Options(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ReverseV2Options()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsReverseV2Options(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ReverseV2Options
- 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)
-
-class ReverseV2OptionsT(object):
-
- # ReverseV2OptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- reverseV2options = ReverseV2Options()
- reverseV2options.Init(buf, pos)
- return cls.InitFromObj(reverseV2options)
-
- @classmethod
- def InitFromObj(cls, reverseV2options):
- x = ReverseV2OptionsT()
- x._UnPack(reverseV2options)
- return x
-
- # ReverseV2OptionsT
- def _UnPack(self, reverseV2options):
- if reverseV2options is None:
- return
-
- # ReverseV2OptionsT
- def Pack(self, builder):
- ReverseV2OptionsStart(builder)
- reverseV2options = ReverseV2OptionsEnd(builder)
- return reverseV2options
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class Rfft2dOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = Rfft2dOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsRfft2dOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # Rfft2dOptions
- 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)
-
-class Rfft2dOptionsT(object):
-
- # Rfft2dOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- rfft2dOptions = Rfft2dOptions()
- rfft2dOptions.Init(buf, pos)
- return cls.InitFromObj(rfft2dOptions)
-
- @classmethod
- def InitFromObj(cls, rfft2dOptions):
- x = Rfft2dOptionsT()
- x._UnPack(rfft2dOptions)
- return x
-
- # Rfft2dOptionsT
- def _UnPack(self, rfft2dOptions):
- if rfft2dOptions is None:
- return
-
- # Rfft2dOptionsT
- def Pack(self, builder):
- Rfft2dOptionsStart(builder)
- rfft2dOptions = Rfft2dOptionsEnd(builder)
- return rfft2dOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class RightShiftOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = RightShiftOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsRightShiftOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # RightShiftOptions
- 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)
-
-class RightShiftOptionsT(object):
-
- # RightShiftOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- rightShiftOptions = RightShiftOptions()
- rightShiftOptions.Init(buf, pos)
- return cls.InitFromObj(rightShiftOptions)
-
- @classmethod
- def InitFromObj(cls, rightShiftOptions):
- x = RightShiftOptionsT()
- x._UnPack(rightShiftOptions)
- return x
-
- # RightShiftOptionsT
- def _UnPack(self, rightShiftOptions):
- if rightShiftOptions is None:
- return
-
- # RightShiftOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SVDFOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SVDFOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSVDFOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SVDFOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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.Int32Flags, o + self._tab.Pos)
- return 0
-
- # 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.Int8Flags, 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 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)
-
-class SVDFOptionsT(object):
-
- # SVDFOptionsT
- def __init__(self):
- self.rank = 0 # type: int
- self.fusedActivationFunction = 0 # type: int
- self.asymmetricQuantizeInputs = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- svdfoptions = SVDFOptions()
- svdfoptions.Init(buf, pos)
- return cls.InitFromObj(svdfoptions)
-
- @classmethod
- def InitFromObj(cls, svdfoptions):
- x = SVDFOptionsT()
- x._UnPack(svdfoptions)
- return x
-
- # SVDFOptionsT
- def _UnPack(self, svdfoptions):
- if svdfoptions is None:
- return
- self.rank = svdfoptions.Rank()
- self.fusedActivationFunction = svdfoptions.FusedActivationFunction()
- self.asymmetricQuantizeInputs = svdfoptions.AsymmetricQuantizeInputs()
-
- # SVDFOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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)
-
- # ScatterNdOptions
- 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)
-
-class ScatterNdOptionsT(object):
-
- # ScatterNdOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- scatterNdOptions = ScatterNdOptions()
- scatterNdOptions.Init(buf, pos)
- return cls.InitFromObj(scatterNdOptions)
-
- @classmethod
- def InitFromObj(cls, scatterNdOptions):
- x = ScatterNdOptionsT()
- x._UnPack(scatterNdOptions)
- return x
-
- # ScatterNdOptionsT
- def _UnPack(self, scatterNdOptions):
- if scatterNdOptions is None:
- return
-
- # ScatterNdOptionsT
- def Pack(self, builder):
- ScatterNdOptionsStart(builder)
- scatterNdOptions = ScatterNdOptionsEnd(builder)
- return scatterNdOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SegmentSumOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SegmentSumOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSegmentSumOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SegmentSumOptions
- 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)
-
-class SegmentSumOptionsT(object):
-
- # SegmentSumOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- segmentSumOptions = SegmentSumOptions()
- segmentSumOptions.Init(buf, pos)
- return cls.InitFromObj(segmentSumOptions)
-
- @classmethod
- def InitFromObj(cls, segmentSumOptions):
- x = SegmentSumOptionsT()
- x._UnPack(segmentSumOptions)
- return x
-
- # SegmentSumOptionsT
- def _UnPack(self, segmentSumOptions):
- if segmentSumOptions is None:
- return
-
- # SegmentSumOptionsT
- def Pack(self, builder):
- SegmentSumOptionsStart(builder)
- segmentSumOptions = SegmentSumOptionsEnd(builder)
- return segmentSumOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SelectOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SelectOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSelectOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SelectOptions
- 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)
-
-class SelectOptionsT(object):
-
- # SelectOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- selectOptions = SelectOptions()
- selectOptions.Init(buf, pos)
- return cls.InitFromObj(selectOptions)
-
- @classmethod
- def InitFromObj(cls, selectOptions):
- x = SelectOptionsT()
- x._UnPack(selectOptions)
- return x
-
- # SelectOptionsT
- def _UnPack(self, selectOptions):
- if selectOptions is None:
- return
-
- # SelectOptionsT
- def Pack(self, builder):
- SelectOptionsStart(builder)
- selectOptions = SelectOptionsEnd(builder)
- return selectOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SelectV2Options(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SelectV2Options()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSelectV2Options(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SelectV2Options
- 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)
-
-class SelectV2OptionsT(object):
-
- # SelectV2OptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- selectV2options = SelectV2Options()
- selectV2options.Init(buf, pos)
- return cls.InitFromObj(selectV2options)
-
- @classmethod
- def InitFromObj(cls, selectV2options):
- x = SelectV2OptionsT()
- x._UnPack(selectV2options)
- return x
-
- # SelectV2OptionsT
- def _UnPack(self, selectV2options):
- if selectV2options is None:
- return
-
- # SelectV2OptionsT
- def Pack(self, builder):
- SelectV2OptionsStart(builder)
- selectV2options = SelectV2OptionsEnd(builder)
- return selectV2options
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SequenceRNNOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SequenceRNNOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSequenceRNNOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SequenceRNNOptions
- 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
-
- # 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
-
- # 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):
-
- # SequenceRNNOptionsT
- def __init__(self):
- self.timeMajor = False # type: bool
- self.fusedActivationFunction = 0 # type: int
- self.asymmetricQuantizeInputs = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- sequenceRnnoptions = SequenceRNNOptions()
- sequenceRnnoptions.Init(buf, pos)
- return cls.InitFromObj(sequenceRnnoptions)
-
- @classmethod
- def InitFromObj(cls, sequenceRnnoptions):
- x = SequenceRNNOptionsT()
- x._UnPack(sequenceRnnoptions)
- return x
-
- # SequenceRNNOptionsT
- def _UnPack(self, sequenceRnnoptions):
- if sequenceRnnoptions 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ShapeOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = ShapeOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsShapeOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # ShapeOptions
- 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 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)
-
-class ShapeOptionsT(object):
-
- # ShapeOptionsT
- def __init__(self):
- self.outType = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- shapeOptions = ShapeOptions()
- shapeOptions.Init(buf, pos)
- return cls.InitFromObj(shapeOptions)
-
- @classmethod
- def InitFromObj(cls, shapeOptions):
- x = ShapeOptionsT()
- x._UnPack(shapeOptions)
- return x
-
- # ShapeOptionsT
- def _UnPack(self, shapeOptions):
- if shapeOptions is None:
- return
- self.outType = shapeOptions.OutType()
-
- # ShapeOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SignOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SignOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSignOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SignOptions
- 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)
-
-class SignOptionsT(object):
-
- # SignOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- signOptions = SignOptions()
- signOptions.Init(buf, pos)
- return cls.InitFromObj(signOptions)
-
- @classmethod
- def InitFromObj(cls, signOptions):
- x = SignOptionsT()
- x._UnPack(signOptions)
- return x
-
- # SignOptionsT
- def _UnPack(self, signOptions):
- if signOptions is None:
- return
-
- # SignOptionsT
- def Pack(self, builder):
- SignOptionsStart(builder)
- signOptions = SignOptionsEnd(builder)
- return signOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SignatureDef(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SignatureDef()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSignatureDef(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SignatureDef
- 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)
+ from flatbuffers.table import Table
+ obj = Table(bytearray(), 0)
+ self._tab.Union(obj, o)
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
-
- # 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
-
- # SignatureDef
- def SubgraphIndex(self):
+ # 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.Uint32Flags, o + self._tab.Pos)
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, 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)
+ # 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 List
+ from typing import Union
except:
pass
-class SignatureDefT(object):
+class DimensionMetadataT(object):
- # SignatureDefT
+ # DimensionMetadataT
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
+ 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):
- signatureDef = SignatureDef()
- signatureDef.Init(buf, pos)
- return cls.InitFromObj(signatureDef)
+ dimensionMetadata = DimensionMetadata()
+ dimensionMetadata.Init(buf, pos)
+ return cls.InitFromObj(dimensionMetadata)
@classmethod
- def InitFromObj(cls, signatureDef):
- x = SignatureDefT()
- x._UnPack(signatureDef)
+ 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
- # SignatureDefT
- def _UnPack(self, signatureDef):
- if signatureDef is None:
+ # DimensionMetadataT
+ def _UnPack(self, dimensionMetadata):
+ if dimensionMetadata 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()
+ 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())
- # SignatureDefT
+ # DimensionMetadataT
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
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SkipGramOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SkipGramOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSkipGramOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SkipGramOptions
- 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
-
- # 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
-
- # 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):
-
- # SkipGramOptionsT
- def __init__(self):
- self.ngramSize = 0 # type: int
- self.maxSkipSize = 0 # type: int
- self.includeAllNgrams = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- skipGramOptions = SkipGramOptions()
- skipGramOptions.Init(buf, pos)
- return cls.InitFromObj(skipGramOptions)
-
- @classmethod
- def InitFromObj(cls, skipGramOptions):
- x = SkipGramOptionsT()
- x._UnPack(skipGramOptions)
- return x
-
- # SkipGramOptionsT
- def _UnPack(self, skipGramOptions):
- if skipGramOptions is None:
- return
- self.ngramSize = skipGramOptions.NgramSize()
- self.maxSkipSize = skipGramOptions.MaxSkipSize()
- self.includeAllNgrams = skipGramOptions.IncludeAllNgrams()
-
- # SkipGramOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SliceOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SliceOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSliceOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SliceOptions
- 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)
-
-class SliceOptionsT(object):
-
- # SliceOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- sliceOptions = SliceOptions()
- sliceOptions.Init(buf, pos)
- return cls.InitFromObj(sliceOptions)
-
- @classmethod
- def InitFromObj(cls, sliceOptions):
- x = SliceOptionsT()
- x._UnPack(sliceOptions)
- return x
-
- # SliceOptionsT
- def _UnPack(self, sliceOptions):
- if sliceOptions is None:
- return
-
- # SliceOptionsT
- def Pack(self, builder):
- SliceOptionsStart(builder)
- sliceOptions = SliceOptionsEnd(builder)
- return sliceOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SoftmaxOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SoftmaxOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSoftmaxOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SoftmaxOptions
- 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 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)
-
-class SoftmaxOptionsT(object):
-
- # SoftmaxOptionsT
- def __init__(self):
- self.beta = 0.0 # type: float
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- softmaxOptions = SoftmaxOptions()
- softmaxOptions.Init(buf, pos)
- return cls.InitFromObj(softmaxOptions)
-
- @classmethod
- def InitFromObj(cls, softmaxOptions):
- x = SoftmaxOptionsT()
- x._UnPack(softmaxOptions)
- return x
-
- # SoftmaxOptionsT
- def _UnPack(self, softmaxOptions):
- if softmaxOptions is None:
- return
- self.beta = softmaxOptions.Beta()
-
- # SoftmaxOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SpaceToBatchNDOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SpaceToBatchNDOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSpaceToBatchNDOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SpaceToBatchNDOptions
- 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)
-
-class SpaceToBatchNDOptionsT(object):
-
- # SpaceToBatchNDOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- spaceToBatchNdoptions = SpaceToBatchNDOptions()
- spaceToBatchNdoptions.Init(buf, pos)
- return cls.InitFromObj(spaceToBatchNdoptions)
-
- @classmethod
- def InitFromObj(cls, spaceToBatchNdoptions):
- x = SpaceToBatchNDOptionsT()
- x._UnPack(spaceToBatchNdoptions)
- return x
-
- # SpaceToBatchNDOptionsT
- def _UnPack(self, spaceToBatchNdoptions):
- if spaceToBatchNdoptions is None:
- return
-
- # SpaceToBatchNDOptionsT
- def Pack(self, builder):
- SpaceToBatchNDOptionsStart(builder)
- spaceToBatchNdoptions = SpaceToBatchNDOptionsEnd(builder)
- return spaceToBatchNdoptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SpaceToDepthOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SpaceToDepthOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSpaceToDepthOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SpaceToDepthOptions
- 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 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)
-
-class SpaceToDepthOptionsT(object):
-
- # SpaceToDepthOptionsT
- def __init__(self):
- self.blockSize = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- spaceToDepthOptions = SpaceToDepthOptions()
- spaceToDepthOptions.Init(buf, pos)
- return cls.InitFromObj(spaceToDepthOptions)
-
- @classmethod
- def InitFromObj(cls, spaceToDepthOptions):
- x = SpaceToDepthOptionsT()
- x._UnPack(spaceToDepthOptions)
- return x
-
- # SpaceToDepthOptionsT
- def _UnPack(self, spaceToDepthOptions):
- if spaceToDepthOptions is None:
- return
- self.blockSize = spaceToDepthOptions.BlockSize()
-
- # SpaceToDepthOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SparseToDenseOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SparseToDenseOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSparseToDenseOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SparseToDenseOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # SparseToDenseOptions
- def ValidateIndices(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 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)
-
-class SparseToDenseOptionsT(object):
-
- # SparseToDenseOptionsT
- def __init__(self):
- self.validateIndices = False # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- sparseToDenseOptions = SparseToDenseOptions()
- sparseToDenseOptions.Init(buf, pos)
- return cls.InitFromObj(sparseToDenseOptions)
-
- @classmethod
- def InitFromObj(cls, sparseToDenseOptions):
- x = SparseToDenseOptionsT()
- x._UnPack(sparseToDenseOptions)
- return x
-
- # SparseToDenseOptionsT
- def _UnPack(self, sparseToDenseOptions):
- if sparseToDenseOptions is None:
- return
- self.validateIndices = sparseToDenseOptions.ValidateIndices()
-
- # SparseToDenseOptionsT
- 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
+ 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
-from flatbuffers.compat import import_numpy
-np = import_numpy()
class SparsityParameters(object):
__slots__ = ['_tab']
@@ -11449,30 +1867,31 @@
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
return o == 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)
+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:
@@ -11493,6 +1912,11 @@
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)
@@ -11560,410 +1984,1825 @@
SparsityParametersAddDimMetadata(builder, dimMetadata)
sparsityParameters = SparsityParametersEnd(builder)
return sparsityParameters
-# automatically generated by the FlatBuffers compiler, do not modify
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SplitOptions(object):
+class VariantSubType(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SplitOptions()
+ x = VariantSubType()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsSplitOptions(cls, buf, offset=0):
+ def GetRootAsVariantSubType(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 VariantSubTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
- # SplitOptions
+ # VariantSubType
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
- # 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)
-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)
-
-class SplitOptionsT(object):
-
- # SplitOptionsT
- def __init__(self):
- self.numSplits = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- splitOptions = SplitOptions()
- splitOptions.Init(buf, pos)
- return cls.InitFromObj(splitOptions)
-
- @classmethod
- def InitFromObj(cls, splitOptions):
- x = SplitOptionsT()
- x._UnPack(splitOptions)
- return x
-
- # SplitOptionsT
- def _UnPack(self, splitOptions):
- if splitOptions is None:
- return
- self.numSplits = splitOptions.NumSplits()
-
- # SplitOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SplitVOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SplitVOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSplitVOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SplitVOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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 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)
-
-class SplitVOptionsT(object):
-
- # SplitVOptionsT
- def __init__(self):
- self.numSplits = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- splitVoptions = SplitVOptions()
- splitVoptions.Init(buf, pos)
- return cls.InitFromObj(splitVoptions)
-
- @classmethod
- def InitFromObj(cls, splitVoptions):
- x = SplitVOptionsT()
- x._UnPack(splitVoptions)
- return x
-
- # SplitVOptionsT
- def _UnPack(self, splitVoptions):
- if splitVoptions is None:
- return
- self.numSplits = splitVoptions.NumSplits()
-
- # SplitVOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SquareOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SquareOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSquareOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SquareOptions
- 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)
-
-class SquareOptionsT(object):
-
- # SquareOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- squareOptions = SquareOptions()
- squareOptions.Init(buf, pos)
- return cls.InitFromObj(squareOptions)
-
- @classmethod
- def InitFromObj(cls, squareOptions):
- x = SquareOptionsT()
- x._UnPack(squareOptions)
- return x
-
- # SquareOptionsT
- def _UnPack(self, squareOptions):
- if squareOptions is None:
- return
-
- # SquareOptionsT
- def Pack(self, builder):
- SquareOptionsStart(builder)
- squareOptions = SquareOptionsEnd(builder)
- return squareOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SquaredDifferenceOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SquaredDifferenceOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSquaredDifferenceOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SquaredDifferenceOptions
- 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)
-
-class SquaredDifferenceOptionsT(object):
-
- # SquaredDifferenceOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- squaredDifferenceOptions = SquaredDifferenceOptions()
- squaredDifferenceOptions.Init(buf, pos)
- return cls.InitFromObj(squaredDifferenceOptions)
-
- @classmethod
- def InitFromObj(cls, squaredDifferenceOptions):
- x = SquaredDifferenceOptionsT()
- x._UnPack(squaredDifferenceOptions)
- return x
-
- # SquaredDifferenceOptionsT
- def _UnPack(self, squaredDifferenceOptions):
- if squaredDifferenceOptions is None:
- return
-
- # SquaredDifferenceOptionsT
- def Pack(self, builder):
- SquaredDifferenceOptionsStart(builder)
- squaredDifferenceOptions = SquaredDifferenceOptionsEnd(builder)
- return squaredDifferenceOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SqueezeOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SqueezeOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsSqueezeOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # SqueezeOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # SqueezeOptions
- def SqueezeDims(self, j):
+ # 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
- # SqueezeOptions
- def SqueezeDimsAsNumpy(self):
+ # 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
- # SqueezeOptions
- def SqueezeDimsLength(self):
+ # 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
- # SqueezeOptions
- def SqueezeDimsIsNone(self):
+ # VariantSubType
+ def ShapeIsNone(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)
+ # 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 SqueezeOptionsT(object):
+class VariantSubTypeT(object):
- # SqueezeOptionsT
+ # VariantSubTypeT
def __init__(self):
- self.squeezeDims = None # type: List[int]
+ self.shape = None # type: List[int]
+ self.type = 0 # type: int
+ self.hasRank = False # type: bool
@classmethod
def InitFromBuf(cls, buf, pos):
- squeezeOptions = SqueezeOptions()
- squeezeOptions.Init(buf, pos)
- return cls.InitFromObj(squeezeOptions)
+ variantSubType = VariantSubType()
+ variantSubType.Init(buf, pos)
+ return cls.InitFromObj(variantSubType)
@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, variantSubType):
+ x = VariantSubTypeT()
+ x._UnPack(variantSubType)
return x
- # SqueezeOptionsT
- def _UnPack(self, squeezeOptions):
- if squeezeOptions is None:
+ # VariantSubTypeT
+ def _UnPack(self, variantSubType):
+ if variantSubType is None:
return
- if not squeezeOptions.SqueezeDimsIsNone():
+ if not variantSubType.ShapeIsNone():
if np is None:
- self.squeezeDims = []
- for i in range(squeezeOptions.SqueezeDimsLength()):
- self.squeezeDims.append(squeezeOptions.SqueezeDims(i))
+ self.shape = []
+ for i in range(variantSubType.ShapeLength()):
+ self.shape.append(variantSubType.Shape(i))
else:
- self.squeezeDims = squeezeOptions.SqueezeDimsAsNumpy()
+ self.shape = variantSubType.ShapeAsNumpy()
+ self.type = variantSubType.Type()
+ self.hasRank = variantSubType.HasRank()
- # SqueezeOptionsT
+ # VariantSubTypeT
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)
+ if self.shape is not None:
+ if np is not None and type(self.shape) is np.ndarray:
+ shape = builder.CreateNumpyVector(self.shape)
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
+ 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
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
+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']
@@ -12014,18 +3853,19 @@
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)
+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:
@@ -12044,6 +3884,11 @@
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)
@@ -12076,12 +3921,7 @@
StablehloBroadcastInDimOptionsAddBroadcastDimensions(builder, broadcastDimensions)
stablehloBroadcastInDimOptions = StablehloBroadcastInDimOptionsEnd(builder)
return stablehloBroadcastInDimOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
class StablehloCompareOptions(object):
__slots__ = ['_tab']
@@ -12119,18 +3959,19 @@
return self._tab.Get(flatbuffers.number_types.Uint32Flags, 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 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):
@@ -12146,6 +3987,11 @@
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)
@@ -12165,109 +4011,1005 @@
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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloConcatenateOptions(object):
+class StablehloDynamicSliceOptions(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = StablehloConcatenateOptions()
+ x = StablehloDynamicSliceOptions()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsStablehloConcatenateOptions(cls, buf, offset=0):
+ def GetRootAsStablehloDynamicSliceOptions(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 StablehloDynamicSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
- # StablehloConcatenateOptions
+ # StablehloDynamicSliceOptions
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
- # StablehloConcatenateOptions
- def Dimension(self):
+ # 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']
+
+ @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
+
+ @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)
+
+ # StablehloIotaOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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 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 StablehloIotaOptionsStart(builder):
+ builder.StartObject(1)
-class StablehloConcatenateOptionsT(object):
+def StablehloIotaOptionsAddIotaDimension(builder, iotaDimension):
+ builder.PrependInt64Slot(0, iotaDimension, 0)
- # StablehloConcatenateOptionsT
+def StablehloIotaOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class StablehloIotaOptionsT(object):
+
+ # StablehloIotaOptionsT
def __init__(self):
- self.dimension = 0 # type: int
+ self.iotaDimension = 0 # type: int
@classmethod
def InitFromBuf(cls, buf, pos):
- stablehloConcatenateOptions = StablehloConcatenateOptions()
- stablehloConcatenateOptions.Init(buf, pos)
- return cls.InitFromObj(stablehloConcatenateOptions)
+ stablehloIotaOptions = StablehloIotaOptions()
+ stablehloIotaOptions.Init(buf, pos)
+ return cls.InitFromObj(stablehloIotaOptions)
@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, stablehloIotaOptions):
+ x = StablehloIotaOptionsT()
+ x._UnPack(stablehloIotaOptions)
return x
- # StablehloConcatenateOptionsT
- def _UnPack(self, stablehloConcatenateOptions):
- if stablehloConcatenateOptions is None:
+ # StablehloIotaOptionsT
+ def _UnPack(self, stablehloIotaOptions):
+ if stablehloIotaOptions is None:
return
- self.dimension = stablehloConcatenateOptions.Dimension()
+ self.iotaDimension = stablehloIotaOptions.IotaDimension()
- # StablehloConcatenateOptionsT
+ # StablehloIotaOptionsT
def Pack(self, builder):
- StablehloConcatenateOptionsStart(builder)
- StablehloConcatenateOptionsAddDimension(builder, self.dimension)
- stablehloConcatenateOptions = StablehloConcatenateOptionsEnd(builder)
- return stablehloConcatenateOptions
-# automatically generated by the FlatBuffers compiler, do not modify
+ StablehloIotaOptionsStart(builder)
+ StablehloIotaOptionsAddIotaDimension(builder, self.iotaDimension)
+ stablehloIotaOptions = StablehloIotaOptionsEnd(builder)
+ return stablehloIotaOptions
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
+class StablehloCustomCallOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = StablehloCustomCallOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsStablehloCustomCallOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # StablehloCustomCallOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+ # 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
+
+ # 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
+
+ # 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
+
+ # 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
+
+def StablehloCustomCallOptionsStart(builder):
+ builder.StartObject(6)
+
+def StablehloCustomCallOptionsAddCallTargetName(builder, callTargetName):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(callTargetName), 0)
+
+def StablehloCustomCallOptionsAddHasSideEffect(builder, hasSideEffect):
+ builder.PrependBoolSlot(1, hasSideEffect, 0)
+
+def StablehloCustomCallOptionsAddBackendConfig(builder, backendConfig):
+ builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(backendConfig), 0)
+
+def StablehloCustomCallOptionsAddApiVersion(builder, apiVersion):
+ builder.PrependInt32Slot(3, apiVersion, 0)
+
+def StablehloCustomCallOptionsAddCalledComputations(builder, calledComputations):
+ builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(calledComputations), 0)
+
+def StablehloCustomCallOptionsStartCalledComputationsVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def StablehloCustomCallOptionsAddCustomAttributes(builder, customAttributes):
+ builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customAttributes), 0)
+
+def StablehloCustomCallOptionsStartCustomAttributesVector(builder, numElems):
+ return builder.StartVector(1, numElems, 1)
+
+def StablehloCustomCallOptionsEnd(builder):
+ return builder.EndObject()
+
+
+try:
+ from typing import List
+except:
+ pass
+
+class StablehloCustomCallOptionsT(object):
+
+ # StablehloCustomCallOptionsT
+ 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]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ stablehloCustomCallOptions = StablehloCustomCallOptions()
+ stablehloCustomCallOptions.Init(buf, pos)
+ return cls.InitFromObj(stablehloCustomCallOptions)
+
+ @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, stablehloCustomCallOptions):
+ x = StablehloCustomCallOptionsT()
+ x._UnPack(stablehloCustomCallOptions)
+ return x
+
+ # StablehloCustomCallOptionsT
+ def _UnPack(self, stablehloCustomCallOptions):
+ if stablehloCustomCallOptions 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
+ 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
+
+
+class StablehloReduceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = StablehloReduceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsStablehloReduceOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # StablehloReduceOptions
+ 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
+
+ # 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.Int32Flags, o + self._tab.Pos)
+ return 0
+
+def StablehloReduceOptionsStart(builder):
+ builder.StartObject(2)
+
+def StablehloReduceOptionsAddDimensions(builder, dimensions):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(dimensions), 0)
+
+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.dimensions = None # type: List[int]
+ self.bodySubgraphIndex = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ stablehloReduceOptions = StablehloReduceOptions()
+ stablehloReduceOptions.Init(buf, pos)
+ return cls.InitFromObj(stablehloReduceOptions)
+
+ @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, stablehloReduceOptions):
+ x = StablehloReduceOptionsT()
+ x._UnPack(stablehloReduceOptions)
+ return x
+
+ # StablehloReduceOptionsT
+ def _UnPack(self, stablehloReduceOptions):
+ if stablehloReduceOptions 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
+ 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
+
+
+class StablehloSliceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = StablehloSliceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsStablehloSliceOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # StablehloSliceOptions
+ 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
+
+ # 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
+
+ # 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 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 StablehloSliceOptionsT(object):
+
+ # StablehloSliceOptionsT
+ def __init__(self):
+ self.startIndices = None # type: List[int]
+ self.limitIndices = None # type: List[int]
+ self.strides = None # type: List[int]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ stablehloSliceOptions = StablehloSliceOptions()
+ stablehloSliceOptions.Init(buf, pos)
+ return cls.InitFromObj(stablehloSliceOptions)
+
+ @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, stablehloSliceOptions):
+ x = StablehloSliceOptionsT()
+ x._UnPack(stablehloSliceOptions)
+ return x
+
+ # StablehloSliceOptionsT
+ def _UnPack(self, stablehloSliceOptions):
+ if stablehloSliceOptions 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
+ 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
+
class StablehloConvolutionOptions(object):
__slots__ = ['_tab']
@@ -12590,90 +5332,91 @@
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
return o == 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)
+def StablehloConvolutionOptionsStart(builder):
+ builder.StartObject(17)
+
+def StablehloConvolutionOptionsAddWindowStrides(builder, windowStrides):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(windowStrides), 0)
+
+def StablehloConvolutionOptionsStartWindowStridesVector(builder, numElems):
+ return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddPadding(builder, padding):
+ builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0)
+
+def StablehloConvolutionOptionsStartPaddingVector(builder, numElems):
+ return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddLhsDilation(builder, lhsDilation):
+ builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(lhsDilation), 0)
+
+def StablehloConvolutionOptionsStartLhsDilationVector(builder, numElems):
+ return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddRhsDilation(builder, rhsDilation):
+ builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(rhsDilation), 0)
+
+def StablehloConvolutionOptionsStartRhsDilationVector(builder, numElems):
+ return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddWindowReversal(builder, windowReversal):
+ builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(windowReversal), 0)
+
+def StablehloConvolutionOptionsStartWindowReversalVector(builder, numElems):
+ return builder.StartVector(1, numElems, 1)
+
+def StablehloConvolutionOptionsAddInputBatchDimension(builder, inputBatchDimension):
+ builder.PrependInt64Slot(5, inputBatchDimension, 0)
+
+def StablehloConvolutionOptionsAddInputFeatureDimension(builder, inputFeatureDimension):
+ builder.PrependInt64Slot(6, inputFeatureDimension, 0)
+
+def StablehloConvolutionOptionsAddInputSpatialDimensions(builder, inputSpatialDimensions):
+ builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(inputSpatialDimensions), 0)
+
+def StablehloConvolutionOptionsStartInputSpatialDimensionsVector(builder, numElems):
+ return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddKernelInputFeatureDimension(builder, kernelInputFeatureDimension):
+ builder.PrependInt64Slot(8, kernelInputFeatureDimension, 0)
+
+def StablehloConvolutionOptionsAddKernelOutputFeatureDimension(builder, kernelOutputFeatureDimension):
+ builder.PrependInt64Slot(9, kernelOutputFeatureDimension, 0)
+
+def StablehloConvolutionOptionsAddKernelSpatialDimensions(builder, kernelSpatialDimensions):
+ builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(kernelSpatialDimensions), 0)
+
+def StablehloConvolutionOptionsStartKernelSpatialDimensionsVector(builder, numElems):
+ return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddOutputBatchDimension(builder, outputBatchDimension):
+ builder.PrependInt64Slot(11, outputBatchDimension, 0)
+
+def StablehloConvolutionOptionsAddOutputFeatureDimension(builder, outputFeatureDimension):
+ builder.PrependInt64Slot(12, outputFeatureDimension, 0)
+
+def StablehloConvolutionOptionsAddOutputSpatialDimensions(builder, outputSpatialDimensions):
+ builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(outputSpatialDimensions), 0)
+
+def StablehloConvolutionOptionsStartOutputSpatialDimensionsVector(builder, numElems):
+ return builder.StartVector(8, numElems, 8)
+
+def StablehloConvolutionOptionsAddFeatureGroupCount(builder, featureGroupCount):
+ builder.PrependInt64Slot(14, featureGroupCount, 0)
+
+def StablehloConvolutionOptionsAddBatchGroupCount(builder, batchGroupCount):
+ builder.PrependInt64Slot(15, batchGroupCount, 0)
+
+def StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig):
+ builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(precisionConfig), 0)
+
+def StablehloConvolutionOptionsStartPrecisionConfigVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def StablehloConvolutionOptionsEnd(builder):
+ return builder.EndObject()
+
+
try:
from typing import List
except:
@@ -12708,6 +5451,11 @@
return cls.InitFromObj(stablehloConvolutionOptions)
@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, stablehloConvolutionOptions):
x = StablehloConvolutionOptionsT()
x._UnPack(stablehloConvolutionOptions)
@@ -12892,1822 +5640,7 @@
StablehloConvolutionOptionsAddPrecisionConfig(builder, precisionConfig)
stablehloConvolutionOptions = StablehloConvolutionOptionsEnd(builder)
return stablehloConvolutionOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloCustomCallOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = StablehloCustomCallOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsStablehloCustomCallOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # StablehloCustomCallOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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
-
- # 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
-
- # 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
-
- # 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
-
- # 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
-
-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):
-
- # StablehloCustomCallOptionsT
- 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]
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- stablehloCustomCallOptions = StablehloCustomCallOptions()
- stablehloCustomCallOptions.Init(buf, pos)
- return cls.InitFromObj(stablehloCustomCallOptions)
-
- @classmethod
- def InitFromObj(cls, stablehloCustomCallOptions):
- x = StablehloCustomCallOptionsT()
- x._UnPack(stablehloCustomCallOptions)
- return x
-
- # StablehloCustomCallOptionsT
- def _UnPack(self, stablehloCustomCallOptions):
- if stablehloCustomCallOptions 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
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 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
- 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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 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):
-
- # 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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 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):
-
- # 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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloIotaOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # StablehloIotaOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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 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)
-
-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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 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
-
-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
-
- # 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 StablehloPrecisionConfig(object):
- DEFAULT = 0
- HIGH = 1
- HIGHEST = 2
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloReduceOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = StablehloReduceOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsStablehloReduceOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # StablehloReduceOptions
- 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
-
- # 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.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):
-
- # StablehloReduceOptionsT
- def __init__(self):
- self.dimensions = None # type: List[int]
- self.bodySubgraphIndex = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- stablehloReduceOptions = StablehloReduceOptions()
- stablehloReduceOptions.Init(buf, pos)
- return cls.InitFromObj(stablehloReduceOptions)
-
- @classmethod
- def InitFromObj(cls, stablehloReduceOptions):
- x = StablehloReduceOptionsT()
- x._UnPack(stablehloReduceOptions)
- return x
-
- # StablehloReduceOptionsT
- def _UnPack(self, stablehloReduceOptions):
- if stablehloReduceOptions 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
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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 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
-
-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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloRngBitGeneratorOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = StablehloRngBitGeneratorOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsStablehloRngBitGeneratorOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # StablehloRngBitGeneratorOptions
- 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 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)
-
-class StablehloRngBitGeneratorOptionsT(object):
-
- # StablehloRngBitGeneratorOptionsT
- def __init__(self):
- self.algorithm = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptions()
- stablehloRngBitGeneratorOptions.Init(buf, pos)
- return cls.InitFromObj(stablehloRngBitGeneratorOptions)
-
- @classmethod
- def InitFromObj(cls, stablehloRngBitGeneratorOptions):
- x = StablehloRngBitGeneratorOptionsT()
- x._UnPack(stablehloRngBitGeneratorOptions)
- return x
-
- # StablehloRngBitGeneratorOptionsT
- def _UnPack(self, stablehloRngBitGeneratorOptions):
- if stablehloRngBitGeneratorOptions is None:
- return
- self.algorithm = stablehloRngBitGeneratorOptions.Algorithm()
-
- # StablehloRngBitGeneratorOptionsT
- 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
-from flatbuffers.compat import import_numpy
-np = import_numpy()
class StablehloScatterOptions(object):
__slots__ = ['_tab']
@@ -14840,42 +5773,43 @@
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)
+def StablehloScatterOptionsStart(builder):
+ builder.StartObject(7)
+
+def StablehloScatterOptionsAddIndicesAreSorted(builder, indicesAreSorted):
+ builder.PrependBoolSlot(0, indicesAreSorted, 0)
+
+def StablehloScatterOptionsAddUpdateWindowDims(builder, updateWindowDims):
+ builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(updateWindowDims), 0)
+
+def StablehloScatterOptionsStartUpdateWindowDimsVector(builder, numElems):
+ return builder.StartVector(8, numElems, 8)
+
+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:
@@ -14900,6 +5834,11 @@
return cls.InitFromObj(stablehloScatterOptions)
@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, stablehloScatterOptions):
x = StablehloScatterOptionsT()
x._UnPack(stablehloScatterOptions)
@@ -14974,541 +5913,4282 @@
StablehloScatterOptionsAddUpdateComputationSubgraphIndex(builder, self.updateComputationSubgraphIndex)
stablehloScatterOptions = StablehloScatterOptionsEnd(builder)
return stablehloScatterOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloSliceOptions(object):
+class StablehloRngBitGeneratorOptions(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = StablehloSliceOptions()
+ x = StablehloRngBitGeneratorOptions()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsStablehloSliceOptions(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 StablehloSliceOptionsBufferHasIdentifier(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)
- # StablehloSliceOptions
+ # StablehloRngBitGeneratorOptions
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
- # StablehloSliceOptions
- def StartIndices(self, j):
+ # StablehloRngBitGeneratorOptions
+ def Algorithm(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.Int8Flags, o + self._tab.Pos)
return 0
- # StablehloSliceOptions
- def StartIndicesAsNumpy(self):
+def StablehloRngBitGeneratorOptionsStart(builder):
+ builder.StartObject(1)
+
+def StablehloRngBitGeneratorOptionsAddAlgorithm(builder, algorithm):
+ builder.PrependInt8Slot(0, algorithm, 0)
+
+def StablehloRngBitGeneratorOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class StablehloRngBitGeneratorOptionsT(object):
+
+ # StablehloRngBitGeneratorOptionsT
+ def __init__(self):
+ self.algorithm = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptions()
+ stablehloRngBitGeneratorOptions.Init(buf, pos)
+ return cls.InitFromObj(stablehloRngBitGeneratorOptions)
+
+ @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, stablehloRngBitGeneratorOptions):
+ x = StablehloRngBitGeneratorOptionsT()
+ x._UnPack(stablehloRngBitGeneratorOptions)
+ return x
+
+ # StablehloRngBitGeneratorOptionsT
+ def _UnPack(self, stablehloRngBitGeneratorOptions):
+ if stablehloRngBitGeneratorOptions is None:
+ return
+ self.algorithm = stablehloRngBitGeneratorOptions.Algorithm()
+
+ # StablehloRngBitGeneratorOptionsT
+ def Pack(self, builder):
+ StablehloRngBitGeneratorOptionsStart(builder)
+ StablehloRngBitGeneratorOptionsAddAlgorithm(builder, self.algorithm)
+ stablehloRngBitGeneratorOptions = StablehloRngBitGeneratorOptionsEnd(builder)
+ return stablehloRngBitGeneratorOptions
+
+
+class Conv2DOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # Conv2DOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Conv2DOptions
+ def Padding(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 self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
return 0
- # StablehloSliceOptions
- def StartIndicesLength(self):
+ # 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
+
+ # 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
+
+ # Conv2DOptions
+ 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
+
+ # Conv2DOptions
+ def DilationWFactor(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 1
+
+ # Conv2DOptions
+ def DilationHFactor(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
+
+ # 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
+
+def Conv2DOptionsStart(builder):
+ builder.StartObject(7)
+
+def Conv2DOptionsAddPadding(builder, padding):
+ builder.PrependInt8Slot(0, padding, 0)
+
+def Conv2DOptionsAddStrideW(builder, strideW):
+ builder.PrependInt32Slot(1, strideW, 0)
+
+def Conv2DOptionsAddStrideH(builder, strideH):
+ builder.PrependInt32Slot(2, strideH, 0)
+
+def Conv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(3, fusedActivationFunction, 0)
+
+def Conv2DOptionsAddDilationWFactor(builder, dilationWFactor):
+ builder.PrependInt32Slot(4, dilationWFactor, 1)
+
+def Conv2DOptionsAddDilationHFactor(builder, dilationHFactor):
+ builder.PrependInt32Slot(5, dilationHFactor, 1)
+
+def Conv2DOptionsAddQuantizedBiasType(builder, quantizedBiasType):
+ builder.PrependInt8Slot(6, quantizedBiasType, 0)
+
+def Conv2DOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # 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
+
+
+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)
+
+ # Conv3DOptions
+ def Padding(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
- return self._tab.VectorLen(o)
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
return 0
- # StablehloSliceOptions
- def StartIndicesIsNone(self):
- o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
- return o == 0
+ # 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
- # StablehloSliceOptions
- def LimitIndices(self, j):
+ # 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.Int32Flags, o + self._tab.Pos)
+ return 0
+
+ # Conv3DOptions
+ def StrideH(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
+
+ # 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.Int8Flags, o + self._tab.Pos)
+ 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
+
+ # 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 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.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):
+ conv3Doptions = Conv3DOptions()
+ conv3Doptions.Init(buf, pos)
+ return cls.InitFromObj(conv3Doptions)
+
+ @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, conv3Doptions):
+ x = Conv3DOptionsT()
+ x._UnPack(conv3Doptions)
+ return x
+
+ # 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()
+
+ # 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
+
+
+class Pool2DOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Pool2DOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsPool2DOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # Pool2DOptions
+ 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
+
+ # 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 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):
+ pool2Doptions = Pool2DOptions()
+ pool2Doptions.Init(buf, pos)
+ return cls.InitFromObj(pool2Doptions)
+
+ @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, pool2Doptions):
+ x = Pool2DOptionsT()
+ x._UnPack(pool2Doptions)
+ return x
+
+ # Pool2DOptionsT
+ def _UnPack(self, pool2Doptions):
+ if pool2Doptions 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
+ 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
+
+
+class DepthwiseConv2DOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DepthwiseConv2DOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsDepthwiseConv2DOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # DepthwiseConv2DOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+ # 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
+
+ # 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
+
+ # 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
+ 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
+
+ # 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
+
+ # 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
+
+def DepthwiseConv2DOptionsStart(builder):
+ builder.StartObject(7)
+
+def DepthwiseConv2DOptionsAddPadding(builder, padding):
+ builder.PrependInt8Slot(0, padding, 0)
+
+def DepthwiseConv2DOptionsAddStrideW(builder, strideW):
+ builder.PrependInt32Slot(1, strideW, 0)
+
+def DepthwiseConv2DOptionsAddStrideH(builder, strideH):
+ builder.PrependInt32Slot(2, strideH, 0)
+
+def DepthwiseConv2DOptionsAddDepthMultiplier(builder, depthMultiplier):
+ builder.PrependInt32Slot(3, depthMultiplier, 0)
+
+def DepthwiseConv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(4, fusedActivationFunction, 0)
+
+def DepthwiseConv2DOptionsAddDilationWFactor(builder, dilationWFactor):
+ builder.PrependInt32Slot(5, dilationWFactor, 1)
+
+def DepthwiseConv2DOptionsAddDilationHFactor(builder, dilationHFactor):
+ builder.PrependInt32Slot(6, dilationHFactor, 1)
+
+def DepthwiseConv2DOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # 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
+
+
+class ConcatEmbeddingsOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ConcatEmbeddingsOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsConcatEmbeddingsOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ConcatEmbeddingsOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+ # 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.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
return 0
- # StablehloSliceOptions
- def LimitIndicesAsNumpy(self):
+ # 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.Int64Flags, o)
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
return 0
- # StablehloSliceOptions
- def LimitIndicesLength(self):
+ # 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
- # StablehloSliceOptions
- def LimitIndicesIsNone(self):
+ # ConcatEmbeddingsOptions
+ def NumColumnsPerChannelIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
return o == 0
- # StablehloSliceOptions
- def Strides(self, j):
+ # 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.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
return 0
- # StablehloSliceOptions
- def StridesAsNumpy(self):
+ # 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.Int64Flags, o)
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
return 0
- # StablehloSliceOptions
- def StridesLength(self):
+ # 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
- # StablehloSliceOptions
- def StridesIsNone(self):
+ # ConcatEmbeddingsOptions
+ def EmbeddingDimPerChannelIsNone(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)
+def ConcatEmbeddingsOptionsStart(builder):
+ builder.StartObject(3)
+
+def ConcatEmbeddingsOptionsAddNumChannels(builder, numChannels):
+ builder.PrependInt32Slot(0, numChannels, 0)
+
+def ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel):
+ builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(numColumnsPerChannel), 0)
+
+def ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel):
+ builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(embeddingDimPerChannel), 0)
+
+def ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ConcatEmbeddingsOptionsEnd(builder):
+ return builder.EndObject()
+
+
try:
from typing import List
except:
pass
-class StablehloSliceOptionsT(object):
+class ConcatEmbeddingsOptionsT(object):
- # StablehloSliceOptionsT
+ # ConcatEmbeddingsOptionsT
def __init__(self):
- self.startIndices = None # type: List[int]
- self.limitIndices = None # type: List[int]
- self.strides = None # type: List[int]
+ self.numChannels = 0 # type: int
+ self.numColumnsPerChannel = None # type: List[int]
+ self.embeddingDimPerChannel = None # type: List[int]
@classmethod
def InitFromBuf(cls, buf, pos):
- stablehloSliceOptions = StablehloSliceOptions()
- stablehloSliceOptions.Init(buf, pos)
- return cls.InitFromObj(stablehloSliceOptions)
+ concatEmbeddingsOptions = ConcatEmbeddingsOptions()
+ concatEmbeddingsOptions.Init(buf, pos)
+ return cls.InitFromObj(concatEmbeddingsOptions)
@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, concatEmbeddingsOptions):
+ x = ConcatEmbeddingsOptionsT()
+ x._UnPack(concatEmbeddingsOptions)
return x
- # StablehloSliceOptionsT
- def _UnPack(self, stablehloSliceOptions):
- if stablehloSliceOptions is None:
+ # ConcatEmbeddingsOptionsT
+ def _UnPack(self, concatEmbeddingsOptions):
+ if concatEmbeddingsOptions is None:
return
- if not stablehloSliceOptions.StartIndicesIsNone():
+ self.numChannels = concatEmbeddingsOptions.NumChannels()
+ if not concatEmbeddingsOptions.NumColumnsPerChannelIsNone():
if np is None:
- self.startIndices = []
- for i in range(stablehloSliceOptions.StartIndicesLength()):
- self.startIndices.append(stablehloSliceOptions.StartIndices(i))
+ self.numColumnsPerChannel = []
+ for i in range(concatEmbeddingsOptions.NumColumnsPerChannelLength()):
+ self.numColumnsPerChannel.append(concatEmbeddingsOptions.NumColumnsPerChannel(i))
else:
- self.startIndices = stablehloSliceOptions.StartIndicesAsNumpy()
- if not stablehloSliceOptions.LimitIndicesIsNone():
+ self.numColumnsPerChannel = concatEmbeddingsOptions.NumColumnsPerChannelAsNumpy()
+ if not concatEmbeddingsOptions.EmbeddingDimPerChannelIsNone():
if np is None:
- self.limitIndices = []
- for i in range(stablehloSliceOptions.LimitIndicesLength()):
- self.limitIndices.append(stablehloSliceOptions.LimitIndices(i))
+ self.embeddingDimPerChannel = []
+ for i in range(concatEmbeddingsOptions.EmbeddingDimPerChannelLength()):
+ self.embeddingDimPerChannel.append(concatEmbeddingsOptions.EmbeddingDimPerChannel(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()
+ self.embeddingDimPerChannel = concatEmbeddingsOptions.EmbeddingDimPerChannelAsNumpy()
- # StablehloSliceOptionsT
+ # ConcatEmbeddingsOptionsT
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)
+ if self.numColumnsPerChannel is not None:
+ if np is not None and type(self.numColumnsPerChannel) is np.ndarray:
+ numColumnsPerChannel = builder.CreateNumpyVector(self.numColumnsPerChannel)
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)
+ 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:
- 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
+ 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
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloSortOptions(object):
+class LSHProjectionOptions(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = StablehloSortOptions()
+ x = LSHProjectionOptions()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsStablehloSortOptions(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 StablehloSortOptionsBufferHasIdentifier(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)
- # StablehloSortOptions
+ # LSHProjectionOptions
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
- # StablehloSortOptions
- def Dimension(self):
+ # 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.Int64Flags, o + self._tab.Pos)
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
return 0
- # StablehloSortOptions
- def IsStable(self):
+def LSHProjectionOptionsStart(builder):
+ builder.StartObject(1)
+
+def LSHProjectionOptionsAddType(builder, type):
+ builder.PrependInt8Slot(0, type, 0)
+
+def LSHProjectionOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class LSHProjectionOptionsT(object):
+
+ # LSHProjectionOptionsT
+ def __init__(self):
+ self.type = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ lshprojectionOptions = LSHProjectionOptions()
+ lshprojectionOptions.Init(buf, pos)
+ return cls.InitFromObj(lshprojectionOptions)
+
+ @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, lshprojectionOptions):
+ x = LSHProjectionOptionsT()
+ x._UnPack(lshprojectionOptions)
+ return x
+
+ # LSHProjectionOptionsT
+ def _UnPack(self, lshprojectionOptions):
+ if lshprojectionOptions is None:
+ return
+ self.type = lshprojectionOptions.Type()
+
+ # LSHProjectionOptionsT
+ def Pack(self, builder):
+ LSHProjectionOptionsStart(builder)
+ LSHProjectionOptionsAddType(builder, self.type)
+ lshprojectionOptions = LSHProjectionOptionsEnd(builder)
+ return lshprojectionOptions
+
+
+class SVDFOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SVDFOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSVDFOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SVDFOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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.Int32Flags, o + self._tab.Pos)
+ return 0
+
+ # 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.Int8Flags, 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 SVDFOptionsStart(builder):
+ builder.StartObject(3)
+
+def SVDFOptionsAddRank(builder, rank):
+ builder.PrependInt32Slot(0, rank, 0)
+
+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.rank = 0 # type: int
+ self.fusedActivationFunction = 0 # type: int
+ self.asymmetricQuantizeInputs = False # type: bool
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ svdfoptions = SVDFOptions()
+ svdfoptions.Init(buf, pos)
+ return cls.InitFromObj(svdfoptions)
+
+ @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, svdfoptions):
+ x = SVDFOptionsT()
+ x._UnPack(svdfoptions)
+ return x
+
+ # SVDFOptionsT
+ def _UnPack(self, svdfoptions):
+ if svdfoptions is None:
+ return
+ self.rank = svdfoptions.Rank()
+ self.fusedActivationFunction = svdfoptions.FusedActivationFunction()
+ self.asymmetricQuantizeInputs = svdfoptions.AsymmetricQuantizeInputs()
+
+ # SVDFOptionsT
+ def Pack(self, builder):
+ SVDFOptionsStart(builder)
+ SVDFOptionsAddRank(builder, self.rank)
+ SVDFOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+ SVDFOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs)
+ svdfoptions = SVDFOptionsEnd(builder)
+ return svdfoptions
+
+
+class RNNOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = RNNOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsRNNOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # RNNOptions
+ 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
+
+ # 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
- # 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 RNNOptionsStart(builder):
+ builder.StartObject(2)
-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)
+def RNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(0, fusedActivationFunction, 0)
-class StablehloSortOptionsT(object):
+def RNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs):
+ builder.PrependBoolSlot(1, asymmetricQuantizeInputs, 0)
- # StablehloSortOptionsT
+def RNNOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class RNNOptionsT(object):
+
+ # RNNOptionsT
def __init__(self):
- self.dimension = 0 # type: int
- self.isStable = False # type: bool
- self.comparatorSubgraphIndex = 0 # type: int
+ self.fusedActivationFunction = 0 # type: int
+ self.asymmetricQuantizeInputs = False # type: bool
@classmethod
def InitFromBuf(cls, buf, pos):
- stablehloSortOptions = StablehloSortOptions()
- stablehloSortOptions.Init(buf, pos)
- return cls.InitFromObj(stablehloSortOptions)
+ rnnoptions = RNNOptions()
+ rnnoptions.Init(buf, pos)
+ return cls.InitFromObj(rnnoptions)
@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, rnnoptions):
+ x = RNNOptionsT()
+ x._UnPack(rnnoptions)
return x
- # StablehloSortOptionsT
- def _UnPack(self, stablehloSortOptions):
- if stablehloSortOptions is None:
+ # RNNOptionsT
+ def _UnPack(self, rnnoptions):
+ if rnnoptions is None:
return
- self.dimension = stablehloSortOptions.Dimension()
- self.isStable = stablehloSortOptions.IsStable()
- self.comparatorSubgraphIndex = stablehloSortOptions.ComparatorSubgraphIndex()
+ self.fusedActivationFunction = rnnoptions.FusedActivationFunction()
+ self.asymmetricQuantizeInputs = rnnoptions.AsymmetricQuantizeInputs()
- # StablehloSortOptionsT
+ # RNNOptionsT
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
+ RNNOptionsStart(builder)
+ RNNOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+ RNNOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs)
+ rnnoptions = RNNOptionsEnd(builder)
+ return rnnoptions
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloTransposeOptions(object):
+class SequenceRNNOptions(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = StablehloTransposeOptions()
+ x = SequenceRNNOptions()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsStablehloTransposeOptions(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 StablehloTransposeOptionsBufferHasIdentifier(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)
- # StablehloTransposeOptions
+ # SequenceRNNOptions
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
- # StablehloTransposeOptions
- def Permutation(self, j):
+ # 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
+
+ # 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
+
+ # 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):
+ self.timeMajor = False # type: bool
+ self.fusedActivationFunction = 0 # type: int
+ self.asymmetricQuantizeInputs = False # type: bool
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ sequenceRnnoptions = SequenceRNNOptions()
+ sequenceRnnoptions.Init(buf, pos)
+ return cls.InitFromObj(sequenceRnnoptions)
+
+ @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, sequenceRnnoptions):
+ x = SequenceRNNOptionsT()
+ x._UnPack(sequenceRnnoptions)
+ return x
+
+ # SequenceRNNOptionsT
+ def _UnPack(self, sequenceRnnoptions):
+ if sequenceRnnoptions 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
+
+
+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 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):
+ 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 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
+
+ # 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
+
+
+class FullyConnectedOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FullyConnectedOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsFullyConnectedOptions(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
+ def FullyConnectedOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # FullyConnectedOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # FullyConnectedOptions
+ 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
+
+ # FullyConnectedOptions
+ def WeightsFormat(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
+
+ # FullyConnectedOptions
+ def KeepNumDims(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
+
+ # FullyConnectedOptions
+ 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
+
+ # FullyConnectedOptions
+ 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 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):
+
+ # FullyConnectedOptionsT
+ def __init__(self):
+ self.fusedActivationFunction = 0 # type: int
+ self.weightsFormat = 0 # type: int
+ self.keepNumDims = False # type: bool
+ self.asymmetricQuantizeInputs = False # type: bool
+ self.quantizedBiasType = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ fullyConnectedOptions = FullyConnectedOptions()
+ 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()
+ x._UnPack(fullyConnectedOptions)
+ return x
+
+ # FullyConnectedOptionsT
+ def _UnPack(self, fullyConnectedOptions):
+ if fullyConnectedOptions is None:
+ return
+ self.fusedActivationFunction = fullyConnectedOptions.FusedActivationFunction()
+ self.weightsFormat = fullyConnectedOptions.WeightsFormat()
+ self.keepNumDims = fullyConnectedOptions.KeepNumDims()
+ self.asymmetricQuantizeInputs = fullyConnectedOptions.AsymmetricQuantizeInputs()
+ self.quantizedBiasType = fullyConnectedOptions.QuantizedBiasType()
+
+ # FullyConnectedOptionsT
+ def Pack(self, builder):
+ FullyConnectedOptionsStart(builder)
+ FullyConnectedOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+ FullyConnectedOptionsAddWeightsFormat(builder, self.weightsFormat)
+ FullyConnectedOptionsAddKeepNumDims(builder, self.keepNumDims)
+ FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, self.asymmetricQuantizeInputs)
+ FullyConnectedOptionsAddQuantizedBiasType(builder, self.quantizedBiasType)
+ fullyConnectedOptions = FullyConnectedOptionsEnd(builder)
+ return fullyConnectedOptions
+
+
+class SoftmaxOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SoftmaxOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSoftmaxOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SoftmaxOptions
+ 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 SoftmaxOptionsStart(builder):
+ builder.StartObject(1)
+
+def SoftmaxOptionsAddBeta(builder, beta):
+ builder.PrependFloat32Slot(0, beta, 0.0)
+
+def SoftmaxOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SoftmaxOptionsT(object):
+
+ # SoftmaxOptionsT
+ def __init__(self):
+ self.beta = 0.0 # type: float
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ softmaxOptions = SoftmaxOptions()
+ softmaxOptions.Init(buf, pos)
+ return cls.InitFromObj(softmaxOptions)
+
+ @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, softmaxOptions):
+ x = SoftmaxOptionsT()
+ x._UnPack(softmaxOptions)
+ return x
+
+ # SoftmaxOptionsT
+ def _UnPack(self, softmaxOptions):
+ if softmaxOptions is None:
+ return
+ self.beta = softmaxOptions.Beta()
+
+ # SoftmaxOptionsT
+ def Pack(self, builder):
+ SoftmaxOptionsStart(builder)
+ SoftmaxOptionsAddBeta(builder, self.beta)
+ softmaxOptions = SoftmaxOptionsEnd(builder)
+ return softmaxOptions
+
+
+class ConcatenationOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # ConcatenationOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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)
+
+def ConcatenationOptionsAddAxis(builder, axis):
+ builder.PrependInt32Slot(0, axis, 0)
+
+def ConcatenationOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(1, fusedActivationFunction, 0)
+
+def ConcatenationOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ConcatenationOptionsT(object):
+
+ # ConcatenationOptionsT
+ def __init__(self):
+ self.axis = 0 # type: int
+ self.fusedActivationFunction = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ concatenationOptions = ConcatenationOptions()
+ concatenationOptions.Init(buf, pos)
+ return cls.InitFromObj(concatenationOptions)
+
+ @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, concatenationOptions):
+ x = ConcatenationOptionsT()
+ x._UnPack(concatenationOptions)
+ return x
+
+ # ConcatenationOptionsT
+ def _UnPack(self, concatenationOptions):
+ if concatenationOptions is None:
+ return
+ self.axis = concatenationOptions.Axis()
+ self.fusedActivationFunction = concatenationOptions.FusedActivationFunction()
+
+ # ConcatenationOptionsT
+ def Pack(self, builder):
+ ConcatenationOptionsStart(builder)
+ ConcatenationOptionsAddAxis(builder, self.axis)
+ ConcatenationOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+ concatenationOptions = ConcatenationOptionsEnd(builder)
+ return concatenationOptions
+
+
+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
+
+ @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)
+
+ # 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
+
+ # 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 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):
+ 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 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
+
+ # 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
+
+
+class MulOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MulOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsMulOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # MulOptions
+ 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 MulOptionsStart(builder):
+ builder.StartObject(1)
+
+def MulOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+
+def MulOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class MulOptionsT(object):
+
+ # MulOptionsT
+ def __init__(self):
+ self.fusedActivationFunction = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ mulOptions = MulOptions()
+ mulOptions.Init(buf, pos)
+ return cls.InitFromObj(mulOptions)
+
+ @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, mulOptions):
+ x = MulOptionsT()
+ x._UnPack(mulOptions)
+ return x
+
+ # MulOptionsT
+ def _UnPack(self, mulOptions):
+ if mulOptions is None:
+ return
+ self.fusedActivationFunction = mulOptions.FusedActivationFunction()
+
+ # MulOptionsT
+ def Pack(self, builder):
+ MulOptionsStart(builder)
+ MulOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+ mulOptions = MulOptionsEnd(builder)
+ return mulOptions
+
+
+class L2NormOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # L2NormOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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)
+
+def L2NormOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+
+def L2NormOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class L2NormOptionsT(object):
+
+ # L2NormOptionsT
+ def __init__(self):
+ self.fusedActivationFunction = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ l2NormOptions = L2NormOptions()
+ l2NormOptions.Init(buf, pos)
+ return cls.InitFromObj(l2NormOptions)
+
+ @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, l2NormOptions):
+ x = L2NormOptionsT()
+ x._UnPack(l2NormOptions)
+ return x
+
+ # L2NormOptionsT
+ def _UnPack(self, l2NormOptions):
+ if l2NormOptions is None:
+ return
+ self.fusedActivationFunction = l2NormOptions.FusedActivationFunction()
+
+ # L2NormOptionsT
+ def Pack(self, builder):
+ L2NormOptionsStart(builder)
+ L2NormOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+ l2NormOptions = L2NormOptionsEnd(builder)
+ return l2NormOptions
+
+
+class LocalResponseNormalizationOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LocalResponseNormalizationOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLocalResponseNormalizationOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LocalResponseNormalizationOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+ # 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.Float32Flags, o + self._tab.Pos)
+ return 0.0
+
+ # 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.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 LocalResponseNormalizationOptionsStart(builder):
+ builder.StartObject(4)
+
+def LocalResponseNormalizationOptionsAddRadius(builder, radius):
+ builder.PrependInt32Slot(0, radius, 0)
+
+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.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):
+ localResponseNormalizationOptions = LocalResponseNormalizationOptions()
+ localResponseNormalizationOptions.Init(buf, pos)
+ return cls.InitFromObj(localResponseNormalizationOptions)
+
+ @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, localResponseNormalizationOptions):
+ x = LocalResponseNormalizationOptionsT()
+ x._UnPack(localResponseNormalizationOptions)
+ return x
+
+ # LocalResponseNormalizationOptionsT
+ def _UnPack(self, localResponseNormalizationOptions):
+ if localResponseNormalizationOptions is None:
+ return
+ self.radius = localResponseNormalizationOptions.Radius()
+ self.bias = localResponseNormalizationOptions.Bias()
+ self.alpha = localResponseNormalizationOptions.Alpha()
+ self.beta = localResponseNormalizationOptions.Beta()
+
+ # LocalResponseNormalizationOptionsT
+ 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
+
+
+class LSTMOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LSTMOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLSTMOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LSTMOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+ # 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
+
+ # 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):
+ 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):
+ lstmoptions = LSTMOptions()
+ lstmoptions.Init(buf, pos)
+ return cls.InitFromObj(lstmoptions)
+
+ @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, lstmoptions):
+ x = LSTMOptionsT()
+ x._UnPack(lstmoptions)
+ return x
+
+ # 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()
+
+ # 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
+
+
+class UnidirectionalSequenceLSTMOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # UnidirectionalSequenceLSTMOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # 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.Float32Flags, o + self._tab.Pos)
+ return 0.0
+
+ # 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
+
+ # 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
+
+ # 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.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):
+ unidirectionalSequenceLstmoptions = UnidirectionalSequenceLSTMOptions()
+ unidirectionalSequenceLstmoptions.Init(buf, pos)
+ return cls.InitFromObj(unidirectionalSequenceLstmoptions)
+
+ @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, unidirectionalSequenceLstmoptions):
+ x = UnidirectionalSequenceLSTMOptionsT()
+ x._UnPack(unidirectionalSequenceLstmoptions)
+ return x
+
+ # 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()
+
+ # 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
+
+
+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 BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+
+def BidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip):
+ builder.PrependFloat32Slot(1, cellClip, 0.0)
+
+def BidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip):
+ builder.PrependFloat32Slot(2, projClip, 0.0)
+
+def BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, mergeOutputs):
+ builder.PrependBoolSlot(3, mergeOutputs, 0)
+
+def BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor):
+ builder.PrependBoolSlot(4, timeMajor, 1)
+
+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):
+ bidirectionalSequenceLstmoptions = BidirectionalSequenceLSTMOptions()
+ bidirectionalSequenceLstmoptions.Init(buf, pos)
+ return cls.InitFromObj(bidirectionalSequenceLstmoptions)
+
+ @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, 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
+
+
+class ResizeBilinearOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ResizeBilinearOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsResizeBilinearOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ResizeBilinearOptions
+ 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
+
+ # 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 ResizeBilinearOptionsStart(builder):
+ builder.StartObject(4)
+
+def ResizeBilinearOptionsAddAlignCorners(builder, alignCorners):
+ builder.PrependBoolSlot(2, alignCorners, 0)
+
+def ResizeBilinearOptionsAddHalfPixelCenters(builder, halfPixelCenters):
+ builder.PrependBoolSlot(3, halfPixelCenters, 0)
+
+def ResizeBilinearOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ResizeBilinearOptionsT(object):
+
+ # ResizeBilinearOptionsT
+ def __init__(self):
+ self.alignCorners = False # type: bool
+ self.halfPixelCenters = False # type: bool
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ resizeBilinearOptions = ResizeBilinearOptions()
+ resizeBilinearOptions.Init(buf, pos)
+ return cls.InitFromObj(resizeBilinearOptions)
+
+ @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, resizeBilinearOptions):
+ x = ResizeBilinearOptionsT()
+ x._UnPack(resizeBilinearOptions)
+ return x
+
+ # ResizeBilinearOptionsT
+ def _UnPack(self, resizeBilinearOptions):
+ if resizeBilinearOptions is None:
+ return
+ self.alignCorners = resizeBilinearOptions.AlignCorners()
+ self.halfPixelCenters = resizeBilinearOptions.HalfPixelCenters()
+
+ # ResizeBilinearOptionsT
+ def Pack(self, builder):
+ ResizeBilinearOptionsStart(builder)
+ ResizeBilinearOptionsAddAlignCorners(builder, self.alignCorners)
+ ResizeBilinearOptionsAddHalfPixelCenters(builder, self.halfPixelCenters)
+ resizeBilinearOptions = ResizeBilinearOptionsEnd(builder)
+ return resizeBilinearOptions
+
+
+class ResizeNearestNeighborOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ResizeNearestNeighborOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsResizeNearestNeighborOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ResizeNearestNeighborOptions
+ 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
+
+ # 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 ResizeNearestNeighborOptionsStart(builder):
+ builder.StartObject(2)
+
+def ResizeNearestNeighborOptionsAddAlignCorners(builder, alignCorners):
+ builder.PrependBoolSlot(0, alignCorners, 0)
+
+def ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, halfPixelCenters):
+ builder.PrependBoolSlot(1, halfPixelCenters, 0)
+
+def ResizeNearestNeighborOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ResizeNearestNeighborOptionsT(object):
+
+ # ResizeNearestNeighborOptionsT
+ def __init__(self):
+ self.alignCorners = False # type: bool
+ self.halfPixelCenters = False # type: bool
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ resizeNearestNeighborOptions = ResizeNearestNeighborOptions()
+ resizeNearestNeighborOptions.Init(buf, pos)
+ return cls.InitFromObj(resizeNearestNeighborOptions)
+
+ @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, resizeNearestNeighborOptions):
+ x = ResizeNearestNeighborOptionsT()
+ x._UnPack(resizeNearestNeighborOptions)
+ return x
+
+ # ResizeNearestNeighborOptionsT
+ def _UnPack(self, resizeNearestNeighborOptions):
+ if resizeNearestNeighborOptions is None:
+ return
+ self.alignCorners = resizeNearestNeighborOptions.AlignCorners()
+ self.halfPixelCenters = resizeNearestNeighborOptions.HalfPixelCenters()
+
+ # ResizeNearestNeighborOptionsT
+ def Pack(self, builder):
+ ResizeNearestNeighborOptionsStart(builder)
+ ResizeNearestNeighborOptionsAddAlignCorners(builder, self.alignCorners)
+ ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, self.halfPixelCenters)
+ resizeNearestNeighborOptions = ResizeNearestNeighborOptionsEnd(builder)
+ return resizeNearestNeighborOptions
+
+
+class CallOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # CallOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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 CallOptionsStart(builder):
+ builder.StartObject(1)
+
+def CallOptionsAddSubgraph(builder, subgraph):
+ builder.PrependUint32Slot(0, subgraph, 0)
+
+def CallOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class CallOptionsT(object):
+
+ # CallOptionsT
+ def __init__(self):
+ self.subgraph = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ callOptions = CallOptions()
+ callOptions.Init(buf, pos)
+ return cls.InitFromObj(callOptions)
+
+ @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, callOptions):
+ x = CallOptionsT()
+ x._UnPack(callOptions)
+ return x
+
+ # CallOptionsT
+ def _UnPack(self, callOptions):
+ if callOptions is None:
+ return
+ self.subgraph = callOptions.Subgraph()
+
+ # CallOptionsT
+ def Pack(self, builder):
+ CallOptionsStart(builder)
+ CallOptionsAddSubgraph(builder, self.subgraph)
+ callOptions = CallOptionsEnd(builder)
+ return callOptions
+
+
+class PadOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = PadOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsPadOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # PadOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def PadOptionsStart(builder):
+ builder.StartObject(0)
+
+def PadOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class PadOptionsT(object):
+
+ # PadOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ padOptions = PadOptions()
+ padOptions.Init(buf, pos)
+ return cls.InitFromObj(padOptions)
+
+ @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, padOptions):
+ x = PadOptionsT()
+ x._UnPack(padOptions)
+ return x
+
+ # PadOptionsT
+ def _UnPack(self, padOptions):
+ if padOptions is None:
+ return
+
+ # PadOptionsT
+ def Pack(self, builder):
+ PadOptionsStart(builder)
+ padOptions = PadOptionsEnd(builder)
+ return padOptions
+
+
+class PadV2Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = PadV2Options()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsPadV2Options(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # PadV2Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def PadV2OptionsStart(builder):
+ builder.StartObject(0)
+
+def PadV2OptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class PadV2OptionsT(object):
+
+ # PadV2OptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ padV2Options = PadV2Options()
+ padV2Options.Init(buf, pos)
+ return cls.InitFromObj(padV2Options)
+
+ @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, padV2Options):
+ x = PadV2OptionsT()
+ x._UnPack(padV2Options)
+ return x
+
+ # PadV2OptionsT
+ def _UnPack(self, padV2Options):
+ if padV2Options is None:
+ return
+
+ # PadV2OptionsT
+ def Pack(self, builder):
+ PadV2OptionsStart(builder)
+ padV2Options = PadV2OptionsEnd(builder)
+ return padV2Options
+
+
+class ReshapeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReshapeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsReshapeOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ReshapeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ReshapeOptions
+ def NewShape(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 self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
return 0
- # StablehloTransposeOptions
- def PermutationAsNumpy(self):
+ # 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.Int64Flags, o)
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
return 0
- # StablehloTransposeOptions
- def PermutationLength(self):
+ # 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
- # StablehloTransposeOptions
- def PermutationIsNone(self):
+ # ReshapeOptions
+ def NewShapeIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
return o == 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)
+def ReshapeOptionsStart(builder):
+ builder.StartObject(1)
+
+def ReshapeOptionsAddNewShape(builder, newShape):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(newShape), 0)
+
+def ReshapeOptionsStartNewShapeVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ReshapeOptionsEnd(builder):
+ return builder.EndObject()
+
+
try:
from typing import List
except:
pass
-class StablehloTransposeOptionsT(object):
+class ReshapeOptionsT(object):
- # StablehloTransposeOptionsT
+ # ReshapeOptionsT
def __init__(self):
- self.permutation = None # type: List[int]
+ self.newShape = None # type: List[int]
@classmethod
def InitFromBuf(cls, buf, pos):
- stablehloTransposeOptions = StablehloTransposeOptions()
- stablehloTransposeOptions.Init(buf, pos)
- return cls.InitFromObj(stablehloTransposeOptions)
+ reshapeOptions = ReshapeOptions()
+ reshapeOptions.Init(buf, pos)
+ return cls.InitFromObj(reshapeOptions)
@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, reshapeOptions):
+ x = ReshapeOptionsT()
+ x._UnPack(reshapeOptions)
return x
- # StablehloTransposeOptionsT
- def _UnPack(self, stablehloTransposeOptions):
- if stablehloTransposeOptions is None:
+ # ReshapeOptionsT
+ def _UnPack(self, reshapeOptions):
+ if reshapeOptions is None:
return
- if not stablehloTransposeOptions.PermutationIsNone():
+ if not reshapeOptions.NewShapeIsNone():
if np is None:
- self.permutation = []
- for i in range(stablehloTransposeOptions.PermutationLength()):
- self.permutation.append(stablehloTransposeOptions.Permutation(i))
+ self.newShape = []
+ for i in range(reshapeOptions.NewShapeLength()):
+ self.newShape.append(reshapeOptions.NewShape(i))
else:
- self.permutation = stablehloTransposeOptions.PermutationAsNumpy()
+ self.newShape = reshapeOptions.NewShapeAsNumpy()
- # StablehloTransposeOptionsT
+ # ReshapeOptionsT
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)
+ if self.newShape is not None:
+ if np is not None and type(self.newShape) is np.ndarray:
+ newShape = builder.CreateNumpyVector(self.newShape)
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
+ 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
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class StablehloWhileOptions(object):
+class SpaceToBatchNDOptions(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = StablehloWhileOptions()
+ x = SpaceToBatchNDOptions()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsStablehloWhileOptions(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 StablehloWhileOptionsBufferHasIdentifier(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)
- # StablehloWhileOptions
+ # SpaceToBatchNDOptions
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
- # StablehloWhileOptions
- def CondSubgraphIndex(self):
+def SpaceToBatchNDOptionsStart(builder):
+ builder.StartObject(0)
+
+def SpaceToBatchNDOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SpaceToBatchNDOptionsT(object):
+
+ # SpaceToBatchNDOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ spaceToBatchNdoptions = SpaceToBatchNDOptions()
+ spaceToBatchNdoptions.Init(buf, pos)
+ return cls.InitFromObj(spaceToBatchNdoptions)
+
+ @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, spaceToBatchNdoptions):
+ x = SpaceToBatchNDOptionsT()
+ x._UnPack(spaceToBatchNdoptions)
+ return x
+
+ # SpaceToBatchNDOptionsT
+ def _UnPack(self, spaceToBatchNdoptions):
+ if spaceToBatchNdoptions is None:
+ return
+
+ # SpaceToBatchNDOptionsT
+ def Pack(self, builder):
+ SpaceToBatchNDOptionsStart(builder)
+ spaceToBatchNdoptions = SpaceToBatchNDOptionsEnd(builder)
+ return spaceToBatchNdoptions
+
+
+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 BatchToSpaceNDOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # BatchToSpaceNDOptionsT
+ def _UnPack(self, batchToSpaceNdoptions):
+ if batchToSpaceNdoptions is None:
+ return
+
+ # BatchToSpaceNDOptionsT
+ def Pack(self, builder):
+ BatchToSpaceNDOptionsStart(builder)
+ batchToSpaceNdoptions = BatchToSpaceNDOptionsEnd(builder)
+ return batchToSpaceNdoptions
+
+
+class SkipGramOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SkipGramOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSkipGramOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SkipGramOptions
+ 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
- # StablehloWhileOptions
- def BodySubgraphIndex(self):
+ # 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 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)
+ # 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
-class StablehloWhileOptionsT(object):
+def SkipGramOptionsStart(builder):
+ builder.StartObject(3)
- # StablehloWhileOptionsT
+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):
- self.condSubgraphIndex = 0 # type: int
- self.bodySubgraphIndex = 0 # type: int
+ self.ngramSize = 0 # type: int
+ self.maxSkipSize = 0 # type: int
+ self.includeAllNgrams = False # type: bool
@classmethod
def InitFromBuf(cls, buf, pos):
- stablehloWhileOptions = StablehloWhileOptions()
- stablehloWhileOptions.Init(buf, pos)
- return cls.InitFromObj(stablehloWhileOptions)
+ skipGramOptions = SkipGramOptions()
+ skipGramOptions.Init(buf, pos)
+ return cls.InitFromObj(skipGramOptions)
@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, skipGramOptions):
+ x = SkipGramOptionsT()
+ x._UnPack(skipGramOptions)
return x
- # StablehloWhileOptionsT
- def _UnPack(self, stablehloWhileOptions):
- if stablehloWhileOptions is None:
+ # SkipGramOptionsT
+ def _UnPack(self, skipGramOptions):
+ if skipGramOptions is None:
return
- self.condSubgraphIndex = stablehloWhileOptions.CondSubgraphIndex()
- self.bodySubgraphIndex = stablehloWhileOptions.BodySubgraphIndex()
+ self.ngramSize = skipGramOptions.NgramSize()
+ self.maxSkipSize = skipGramOptions.MaxSkipSize()
+ self.includeAllNgrams = skipGramOptions.IncludeAllNgrams()
- # StablehloWhileOptionsT
+ # SkipGramOptionsT
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
+ SkipGramOptionsStart(builder)
+ SkipGramOptionsAddNgramSize(builder, self.ngramSize)
+ SkipGramOptionsAddMaxSkipSize(builder, self.maxSkipSize)
+ SkipGramOptionsAddIncludeAllNgrams(builder, self.includeAllNgrams)
+ skipGramOptions = SkipGramOptionsEnd(builder)
+ return skipGramOptions
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
+class SpaceToDepthOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SpaceToDepthOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSpaceToDepthOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SpaceToDepthOptions
+ 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 SpaceToDepthOptionsStart(builder):
+ builder.StartObject(1)
+
+def SpaceToDepthOptionsAddBlockSize(builder, blockSize):
+ builder.PrependInt32Slot(0, blockSize, 0)
+
+def SpaceToDepthOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SpaceToDepthOptionsT(object):
+
+ # SpaceToDepthOptionsT
+ def __init__(self):
+ self.blockSize = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ spaceToDepthOptions = SpaceToDepthOptions()
+ spaceToDepthOptions.Init(buf, pos)
+ return cls.InitFromObj(spaceToDepthOptions)
+
+ @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, spaceToDepthOptions):
+ x = SpaceToDepthOptionsT()
+ x._UnPack(spaceToDepthOptions)
+ return x
+
+ # SpaceToDepthOptionsT
+ def _UnPack(self, spaceToDepthOptions):
+ if spaceToDepthOptions is None:
+ return
+ self.blockSize = spaceToDepthOptions.BlockSize()
+
+ # SpaceToDepthOptionsT
+ def Pack(self, builder):
+ SpaceToDepthOptionsStart(builder)
+ SpaceToDepthOptionsAddBlockSize(builder, self.blockSize)
+ spaceToDepthOptions = SpaceToDepthOptionsEnd(builder)
+ return spaceToDepthOptions
+
+
+class DepthToSpaceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DepthToSpaceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsDepthToSpaceOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # DepthToSpaceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+def DepthToSpaceOptionsStart(builder):
+ builder.StartObject(1)
+
+def DepthToSpaceOptionsAddBlockSize(builder, blockSize):
+ builder.PrependInt32Slot(0, blockSize, 0)
+
+def DepthToSpaceOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class DepthToSpaceOptionsT(object):
+
+ # DepthToSpaceOptionsT
+ def __init__(self):
+ self.blockSize = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ depthToSpaceOptions = DepthToSpaceOptions()
+ depthToSpaceOptions.Init(buf, pos)
+ return cls.InitFromObj(depthToSpaceOptions)
+
+ @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, depthToSpaceOptions):
+ x = DepthToSpaceOptionsT()
+ x._UnPack(depthToSpaceOptions)
+ return x
+
+ # DepthToSpaceOptionsT
+ def _UnPack(self, depthToSpaceOptions):
+ if depthToSpaceOptions is None:
+ return
+ self.blockSize = depthToSpaceOptions.BlockSize()
+
+ # DepthToSpaceOptionsT
+ def Pack(self, builder):
+ DepthToSpaceOptionsStart(builder)
+ DepthToSpaceOptionsAddBlockSize(builder, self.blockSize)
+ depthToSpaceOptions = DepthToSpaceOptionsEnd(builder)
+ return depthToSpaceOptions
+
+
+class SubOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SubOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSubOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SubOptions
+ 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
+
+ # 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)
+
+def SubOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+
+def SubOptionsAddPotScaleInt16(builder, potScaleInt16):
+ builder.PrependBoolSlot(1, potScaleInt16, 1)
+
+def SubOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SubOptionsT(object):
+
+ # SubOptionsT
+ def __init__(self):
+ self.fusedActivationFunction = 0 # type: int
+ self.potScaleInt16 = True # type: bool
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ subOptions = SubOptions()
+ subOptions.Init(buf, pos)
+ return cls.InitFromObj(subOptions)
+
+ @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, subOptions):
+ x = SubOptionsT()
+ x._UnPack(subOptions)
+ return x
+
+ # SubOptionsT
+ def _UnPack(self, subOptions):
+ if subOptions is None:
+ return
+ self.fusedActivationFunction = subOptions.FusedActivationFunction()
+ self.potScaleInt16 = subOptions.PotScaleInt16()
+
+ # SubOptionsT
+ def Pack(self, builder):
+ SubOptionsStart(builder)
+ SubOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+ SubOptionsAddPotScaleInt16(builder, self.potScaleInt16)
+ subOptions = SubOptionsEnd(builder)
+ return subOptions
+
+
+class DivOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DivOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsDivOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # DivOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+def DivOptionsStart(builder):
+ builder.StartObject(1)
+
+def DivOptionsAddFusedActivationFunction(builder, fusedActivationFunction):
+ builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+
+def DivOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class DivOptionsT(object):
+
+ # DivOptionsT
+ def __init__(self):
+ self.fusedActivationFunction = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ divOptions = DivOptions()
+ divOptions.Init(buf, pos)
+ return cls.InitFromObj(divOptions)
+
+ @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, divOptions):
+ x = DivOptionsT()
+ x._UnPack(divOptions)
+ return x
+
+ # DivOptionsT
+ def _UnPack(self, divOptions):
+ if divOptions is None:
+ return
+ self.fusedActivationFunction = divOptions.FusedActivationFunction()
+
+ # DivOptionsT
+ def Pack(self, builder):
+ DivOptionsStart(builder)
+ DivOptionsAddFusedActivationFunction(builder, self.fusedActivationFunction)
+ divOptions = DivOptionsEnd(builder)
+ return divOptions
+
+
+class TopKV2Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = TopKV2Options()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsTopKV2Options(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # TopKV2Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def TopKV2OptionsStart(builder):
+ builder.StartObject(0)
+
+def TopKV2OptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class TopKV2OptionsT(object):
+
+ # TopKV2OptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ topKv2Options = TopKV2Options()
+ topKv2Options.Init(buf, pos)
+ return cls.InitFromObj(topKv2Options)
+
+ @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, topKv2Options):
+ x = TopKV2OptionsT()
+ x._UnPack(topKv2Options)
+ return x
+
+ # TopKV2OptionsT
+ def _UnPack(self, topKv2Options):
+ if topKv2Options is None:
+ return
+
+ # TopKV2OptionsT
+ def Pack(self, builder):
+ TopKV2OptionsStart(builder)
+ topKv2Options = TopKV2OptionsEnd(builder)
+ return topKv2Options
+
+
+class EmbeddingLookupSparseOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # EmbeddingLookupSparseOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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 EmbeddingLookupSparseOptionsStart(builder):
+ builder.StartObject(1)
+
+def EmbeddingLookupSparseOptionsAddCombiner(builder, combiner):
+ builder.PrependInt8Slot(0, combiner, 0)
+
+def EmbeddingLookupSparseOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class EmbeddingLookupSparseOptionsT(object):
+
+ # EmbeddingLookupSparseOptionsT
+ def __init__(self):
+ self.combiner = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ embeddingLookupSparseOptions = EmbeddingLookupSparseOptions()
+ embeddingLookupSparseOptions.Init(buf, pos)
+ return cls.InitFromObj(embeddingLookupSparseOptions)
+
+ @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, embeddingLookupSparseOptions):
+ x = EmbeddingLookupSparseOptionsT()
+ x._UnPack(embeddingLookupSparseOptions)
+ return x
+
+ # EmbeddingLookupSparseOptionsT
+ def _UnPack(self, embeddingLookupSparseOptions):
+ if embeddingLookupSparseOptions is None:
+ return
+ self.combiner = embeddingLookupSparseOptions.Combiner()
+
+ # EmbeddingLookupSparseOptionsT
+ def Pack(self, builder):
+ EmbeddingLookupSparseOptionsStart(builder)
+ EmbeddingLookupSparseOptionsAddCombiner(builder, self.combiner)
+ embeddingLookupSparseOptions = EmbeddingLookupSparseOptionsEnd(builder)
+ return embeddingLookupSparseOptions
+
+
+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 GatherOptionsAddAxis(builder, axis):
+ builder.PrependInt32Slot(0, axis, 0)
+
+def GatherOptionsAddBatchDims(builder, batchDims):
+ builder.PrependInt32Slot(1, batchDims, 0)
+
+def GatherOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 InitFromPackedBuf(cls, buf, pos=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+ return cls.InitFromBuf(buf, pos+n)
+
+ @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
+
+
+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)
+
+ # TransposeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def TransposeOptionsStart(builder):
+ builder.StartObject(0)
+
+def TransposeOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class TransposeOptionsT(object):
+
+ # TransposeOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ transposeOptions = TransposeOptions()
+ transposeOptions.Init(buf, pos)
+ return cls.InitFromObj(transposeOptions)
+
+ @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, transposeOptions):
+ x = TransposeOptionsT()
+ x._UnPack(transposeOptions)
+ return x
+
+ # TransposeOptionsT
+ def _UnPack(self, transposeOptions):
+ if transposeOptions is None:
+ return
+
+ # TransposeOptionsT
+ def Pack(self, builder):
+ TransposeOptionsStart(builder)
+ transposeOptions = TransposeOptionsEnd(builder)
+ return transposeOptions
+
+
+class ExpOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # ExpOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ExpOptionsStart(builder):
+ builder.StartObject(0)
+
+def ExpOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ExpOptionsT(object):
+
+ # ExpOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ expOptions = ExpOptions()
+ expOptions.Init(buf, pos)
+ return cls.InitFromObj(expOptions)
+
+ @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, expOptions):
+ x = ExpOptionsT()
+ x._UnPack(expOptions)
+ return x
+
+ # ExpOptionsT
+ def _UnPack(self, expOptions):
+ if expOptions is None:
+ return
+
+ # ExpOptionsT
+ def Pack(self, builder):
+ ExpOptionsStart(builder)
+ expOptions = ExpOptionsEnd(builder)
+ return expOptions
+
+
+class CosOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # CosOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def CosOptionsStart(builder):
+ builder.StartObject(0)
+
+def CosOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class CosOptionsT(object):
+
+ # CosOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ cosOptions = CosOptions()
+ cosOptions.Init(buf, pos)
+ return cls.InitFromObj(cosOptions)
+
+ @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, cosOptions):
+ x = CosOptionsT()
+ x._UnPack(cosOptions)
+ return x
+
+ # CosOptionsT
+ def _UnPack(self, cosOptions):
+ if cosOptions is None:
+ return
+
+ # CosOptionsT
+ def Pack(self, builder):
+ CosOptionsStart(builder)
+ cosOptions = CosOptionsEnd(builder)
+ return cosOptions
+
+
+class ReducerOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReducerOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsReducerOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ReducerOptions
+ 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 ReducerOptionsStart(builder):
+ builder.StartObject(1)
+
+def ReducerOptionsAddKeepDims(builder, keepDims):
+ builder.PrependBoolSlot(0, keepDims, 0)
+
+def ReducerOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ReducerOptionsT(object):
+
+ # ReducerOptionsT
+ def __init__(self):
+ self.keepDims = False # type: bool
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ reducerOptions = ReducerOptions()
+ reducerOptions.Init(buf, pos)
+ return cls.InitFromObj(reducerOptions)
+
+ @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, reducerOptions):
+ x = ReducerOptionsT()
+ x._UnPack(reducerOptions)
+ return x
+
+ # ReducerOptionsT
+ def _UnPack(self, reducerOptions):
+ if reducerOptions is None:
+ return
+ self.keepDims = reducerOptions.KeepDims()
+
+ # ReducerOptionsT
+ def Pack(self, builder):
+ ReducerOptionsStart(builder)
+ ReducerOptionsAddKeepDims(builder, self.keepDims)
+ reducerOptions = ReducerOptionsEnd(builder)
+ return reducerOptions
+
+
+class SqueezeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SqueezeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSqueezeOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SqueezeOptions
+ 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
+
+ # 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):
+ self.squeezeDims = None # type: List[int]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ squeezeOptions = SqueezeOptions()
+ squeezeOptions.Init(buf, pos)
+ return cls.InitFromObj(squeezeOptions)
+
+ @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, squeezeOptions):
+ x = SqueezeOptionsT()
+ x._UnPack(squeezeOptions)
+ return x
+
+ # 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()
+
+ # SqueezeOptionsT
+ 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
+
+
+class SplitOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SplitOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSplitOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SplitOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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)
+
+def SplitOptionsAddNumSplits(builder, numSplits):
+ builder.PrependInt32Slot(0, numSplits, 0)
+
+def SplitOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SplitOptionsT(object):
+
+ # SplitOptionsT
+ def __init__(self):
+ self.numSplits = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ splitOptions = SplitOptions()
+ splitOptions.Init(buf, pos)
+ return cls.InitFromObj(splitOptions)
+
+ @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, splitOptions):
+ x = SplitOptionsT()
+ x._UnPack(splitOptions)
+ return x
+
+ # SplitOptionsT
+ def _UnPack(self, splitOptions):
+ if splitOptions is None:
+ return
+ self.numSplits = splitOptions.NumSplits()
+
+ # SplitOptionsT
+ def Pack(self, builder):
+ SplitOptionsStart(builder)
+ SplitOptionsAddNumSplits(builder, self.numSplits)
+ splitOptions = SplitOptionsEnd(builder)
+ return splitOptions
+
+
+class SplitVOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SplitVOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSplitVOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SplitVOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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 SplitVOptionsStart(builder):
+ builder.StartObject(1)
+
+def SplitVOptionsAddNumSplits(builder, numSplits):
+ builder.PrependInt32Slot(0, numSplits, 0)
+
+def SplitVOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SplitVOptionsT(object):
+
+ # SplitVOptionsT
+ def __init__(self):
+ self.numSplits = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ splitVoptions = SplitVOptions()
+ splitVoptions.Init(buf, pos)
+ return cls.InitFromObj(splitVoptions)
+
+ @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, splitVoptions):
+ x = SplitVOptionsT()
+ x._UnPack(splitVoptions)
+ return x
+
+ # SplitVOptionsT
+ def _UnPack(self, splitVoptions):
+ if splitVoptions is None:
+ return
+ self.numSplits = splitVoptions.NumSplits()
+
+ # SplitVOptionsT
+ def Pack(self, builder):
+ SplitVOptionsStart(builder)
+ SplitVOptionsAddNumSplits(builder, self.numSplits)
+ splitVoptions = SplitVOptionsEnd(builder)
+ return splitVoptions
+
class StridedSliceOptions(object):
__slots__ = ['_tab']
@@ -15574,30 +10254,31 @@
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)
+def StridedSliceOptionsStart(builder):
+ builder.StartObject(6)
+
+def StridedSliceOptionsAddBeginMask(builder, beginMask):
+ builder.PrependInt32Slot(0, beginMask, 0)
+
+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):
@@ -15617,6 +10298,11 @@
return cls.InitFromObj(stridedSliceOptions)
@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, stridedSliceOptions):
x = StridedSliceOptionsT()
x._UnPack(stridedSliceOptions)
@@ -15644,12 +10330,6633 @@
StridedSliceOptionsAddOffset(builder, self.offset)
stridedSliceOptions = StridedSliceOptionsEnd(builder)
return stridedSliceOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
+class LogSoftmaxOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LogSoftmaxOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLogSoftmaxOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LogSoftmaxOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LogSoftmaxOptionsStart(builder):
+ builder.StartObject(0)
+
+def LogSoftmaxOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class LogSoftmaxOptionsT(object):
+
+ # LogSoftmaxOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ logSoftmaxOptions = LogSoftmaxOptions()
+ logSoftmaxOptions.Init(buf, pos)
+ return cls.InitFromObj(logSoftmaxOptions)
+
+ @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, logSoftmaxOptions):
+ x = LogSoftmaxOptionsT()
+ x._UnPack(logSoftmaxOptions)
+ return x
+
+ # LogSoftmaxOptionsT
+ def _UnPack(self, logSoftmaxOptions):
+ if logSoftmaxOptions is None:
+ return
+
+ # LogSoftmaxOptionsT
+ def Pack(self, builder):
+ LogSoftmaxOptionsStart(builder)
+ logSoftmaxOptions = LogSoftmaxOptionsEnd(builder)
+ return logSoftmaxOptions
+
+
+class CastOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = CastOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsCastOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # CastOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # 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.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def CastOptionsStart(builder):
+ builder.StartObject(2)
+
+def CastOptionsAddInDataType(builder, inDataType):
+ builder.PrependInt8Slot(0, inDataType, 0)
+
+def CastOptionsAddOutDataType(builder, outDataType):
+ builder.PrependInt8Slot(1, outDataType, 0)
+
+def CastOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class CastOptionsT(object):
+
+ # CastOptionsT
+ def __init__(self):
+ self.inDataType = 0 # type: int
+ self.outDataType = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ castOptions = CastOptions()
+ castOptions.Init(buf, pos)
+ return cls.InitFromObj(castOptions)
+
+ @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, castOptions):
+ x = CastOptionsT()
+ x._UnPack(castOptions)
+ return x
+
+ # CastOptionsT
+ def _UnPack(self, castOptions):
+ if castOptions is None:
+ return
+ self.inDataType = castOptions.InDataType()
+ self.outDataType = castOptions.OutDataType()
+
+ # CastOptionsT
+ def Pack(self, builder):
+ CastOptionsStart(builder)
+ CastOptionsAddInDataType(builder, self.inDataType)
+ CastOptionsAddOutDataType(builder, self.outDataType)
+ castOptions = CastOptionsEnd(builder)
+ return castOptions
+
+
+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 DequantizeOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class DequantizeOptionsT(object):
+
+ # DequantizeOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ dequantizeOptions = DequantizeOptions()
+ dequantizeOptions.Init(buf, pos)
+ return cls.InitFromObj(dequantizeOptions)
+
+ @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, dequantizeOptions):
+ x = DequantizeOptionsT()
+ x._UnPack(dequantizeOptions)
+ return x
+
+ # DequantizeOptionsT
+ def _UnPack(self, dequantizeOptions):
+ if dequantizeOptions is None:
+ return
+
+ # DequantizeOptionsT
+ def Pack(self, builder):
+ DequantizeOptionsStart(builder)
+ dequantizeOptions = DequantizeOptionsEnd(builder)
+ return dequantizeOptions
+
+
+class MaximumMinimumOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MaximumMinimumOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsMaximumMinimumOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # MaximumMinimumOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def MaximumMinimumOptionsStart(builder):
+ builder.StartObject(0)
+
+def MaximumMinimumOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class MaximumMinimumOptionsT(object):
+
+ # MaximumMinimumOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ maximumMinimumOptions = MaximumMinimumOptions()
+ maximumMinimumOptions.Init(buf, pos)
+ return cls.InitFromObj(maximumMinimumOptions)
+
+ @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, maximumMinimumOptions):
+ x = MaximumMinimumOptionsT()
+ x._UnPack(maximumMinimumOptions)
+ return x
+
+ # MaximumMinimumOptionsT
+ def _UnPack(self, maximumMinimumOptions):
+ if maximumMinimumOptions is None:
+ return
+
+ # MaximumMinimumOptionsT
+ def Pack(self, builder):
+ MaximumMinimumOptionsStart(builder)
+ maximumMinimumOptions = MaximumMinimumOptionsEnd(builder)
+ return maximumMinimumOptions
+
+
+class TileOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = TileOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsTileOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # TileOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def TileOptionsStart(builder):
+ builder.StartObject(0)
+
+def TileOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class TileOptionsT(object):
+
+ # TileOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ tileOptions = TileOptions()
+ tileOptions.Init(buf, pos)
+ return cls.InitFromObj(tileOptions)
+
+ @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, tileOptions):
+ x = TileOptionsT()
+ x._UnPack(tileOptions)
+ return x
+
+ # TileOptionsT
+ def _UnPack(self, tileOptions):
+ if tileOptions is None:
+ return
+
+ # TileOptionsT
+ def Pack(self, builder):
+ TileOptionsStart(builder)
+ tileOptions = TileOptionsEnd(builder)
+ return tileOptions
+
+
+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
+
+ @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 ArgMaxOptionsAddOutputType(builder, outputType):
+ builder.PrependInt8Slot(0, outputType, 0)
+
+def ArgMaxOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # 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
+
+
+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 ArgMinOptionsAddOutputType(builder, outputType):
+ builder.PrependInt8Slot(0, outputType, 0)
+
+def ArgMinOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 InitFromPackedBuf(cls, buf, pos=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+ return cls.InitFromBuf(buf, pos+n)
+
+ @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
+
+
+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)
+
+ # GreaterOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def GreaterOptionsStart(builder):
+ builder.StartObject(0)
+
+def GreaterOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class GreaterOptionsT(object):
+
+ # GreaterOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ greaterOptions = GreaterOptions()
+ greaterOptions.Init(buf, pos)
+ return cls.InitFromObj(greaterOptions)
+
+ @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, greaterOptions):
+ x = GreaterOptionsT()
+ x._UnPack(greaterOptions)
+ return x
+
+ # GreaterOptionsT
+ def _UnPack(self, greaterOptions):
+ if greaterOptions is None:
+ return
+
+ # GreaterOptionsT
+ def Pack(self, builder):
+ GreaterOptionsStart(builder)
+ greaterOptions = GreaterOptionsEnd(builder)
+ return greaterOptions
+
+
+class GreaterEqualOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = GreaterEqualOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsGreaterEqualOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # GreaterEqualOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def GreaterEqualOptionsStart(builder):
+ builder.StartObject(0)
+
+def GreaterEqualOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class GreaterEqualOptionsT(object):
+
+ # GreaterEqualOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ greaterEqualOptions = GreaterEqualOptions()
+ greaterEqualOptions.Init(buf, pos)
+ return cls.InitFromObj(greaterEqualOptions)
+
+ @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, greaterEqualOptions):
+ x = GreaterEqualOptionsT()
+ x._UnPack(greaterEqualOptions)
+ return x
+
+ # GreaterEqualOptionsT
+ def _UnPack(self, greaterEqualOptions):
+ if greaterEqualOptions is None:
+ return
+
+ # GreaterEqualOptionsT
+ def Pack(self, builder):
+ GreaterEqualOptionsStart(builder)
+ greaterEqualOptions = GreaterEqualOptionsEnd(builder)
+ return greaterEqualOptions
+
+
+class LessOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LessOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLessOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LessOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LessOptionsStart(builder):
+ builder.StartObject(0)
+
+def LessOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class LessOptionsT(object):
+
+ # LessOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ 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, lessOptions):
+ x = LessOptionsT()
+ x._UnPack(lessOptions)
+ return x
+
+ # LessOptionsT
+ def _UnPack(self, lessOptions):
+ if lessOptions is None:
+ return
+
+ # LessOptionsT
+ def Pack(self, builder):
+ LessOptionsStart(builder)
+ lessOptions = LessOptionsEnd(builder)
+ return lessOptions
+
+
+class LessEqualOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LessEqualOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLessEqualOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LessEqualOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LessEqualOptionsStart(builder):
+ builder.StartObject(0)
+
+def LessEqualOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class LessEqualOptionsT(object):
+
+ # LessEqualOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ lessEqualOptions = LessEqualOptions()
+ lessEqualOptions.Init(buf, pos)
+ return cls.InitFromObj(lessEqualOptions)
+
+ @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, lessEqualOptions):
+ x = LessEqualOptionsT()
+ x._UnPack(lessEqualOptions)
+ return x
+
+ # LessEqualOptionsT
+ def _UnPack(self, lessEqualOptions):
+ if lessEqualOptions is None:
+ return
+
+ # LessEqualOptionsT
+ def Pack(self, builder):
+ LessEqualOptionsStart(builder)
+ lessEqualOptions = LessEqualOptionsEnd(builder)
+ return lessEqualOptions
+
+
+class NegOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = NegOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsNegOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # NegOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def NegOptionsStart(builder):
+ builder.StartObject(0)
+
+def NegOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class NegOptionsT(object):
+
+ # NegOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ negOptions = NegOptions()
+ negOptions.Init(buf, pos)
+ return cls.InitFromObj(negOptions)
+
+ @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, negOptions):
+ x = NegOptionsT()
+ x._UnPack(negOptions)
+ return x
+
+ # NegOptionsT
+ def _UnPack(self, negOptions):
+ if negOptions is None:
+ return
+
+ # NegOptionsT
+ def Pack(self, builder):
+ NegOptionsStart(builder)
+ negOptions = NegOptionsEnd(builder)
+ return negOptions
+
+
+class SelectOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SelectOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSelectOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SelectOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SelectOptionsStart(builder):
+ builder.StartObject(0)
+
+def SelectOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SelectOptionsT(object):
+
+ # SelectOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ selectOptions = SelectOptions()
+ selectOptions.Init(buf, pos)
+ return cls.InitFromObj(selectOptions)
+
+ @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, selectOptions):
+ x = SelectOptionsT()
+ x._UnPack(selectOptions)
+ return x
+
+ # SelectOptionsT
+ def _UnPack(self, selectOptions):
+ if selectOptions is None:
+ return
+
+ # SelectOptionsT
+ def Pack(self, builder):
+ SelectOptionsStart(builder)
+ selectOptions = SelectOptionsEnd(builder)
+ return selectOptions
+
+
+class SliceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SliceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSliceOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SliceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SliceOptionsStart(builder):
+ builder.StartObject(0)
+
+def SliceOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SliceOptionsT(object):
+
+ # SliceOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ sliceOptions = SliceOptions()
+ sliceOptions.Init(buf, pos)
+ return cls.InitFromObj(sliceOptions)
+
+ @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, sliceOptions):
+ x = SliceOptionsT()
+ x._UnPack(sliceOptions)
+ return x
+
+ # SliceOptionsT
+ def _UnPack(self, sliceOptions):
+ if sliceOptions is None:
+ return
+
+ # SliceOptionsT
+ def Pack(self, builder):
+ SliceOptionsStart(builder)
+ sliceOptions = SliceOptionsEnd(builder)
+ return sliceOptions
+
+
+class TransposeConvOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = TransposeConvOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsTransposeConvOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # TransposeConvOptions
+ 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
+
+ # 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
+
+ # 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.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):
+ transposeConvOptions = TransposeConvOptions()
+ transposeConvOptions.Init(buf, pos)
+ return cls.InitFromObj(transposeConvOptions)
+
+ @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, transposeConvOptions):
+ x = TransposeConvOptionsT()
+ x._UnPack(transposeConvOptions)
+ return x
+
+ # TransposeConvOptionsT
+ def _UnPack(self, transposeConvOptions):
+ if transposeConvOptions is None:
+ return
+ self.padding = transposeConvOptions.Padding()
+ self.strideW = transposeConvOptions.StrideW()
+ self.strideH = transposeConvOptions.StrideH()
+ self.fusedActivationFunction = transposeConvOptions.FusedActivationFunction()
+ self.quantizedBiasType = transposeConvOptions.QuantizedBiasType()
+
+ # TransposeConvOptionsT
+ 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
+
+
+class ExpandDimsOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ExpandDimsOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsExpandDimsOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ExpandDimsOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ExpandDimsOptionsStart(builder):
+ builder.StartObject(0)
+
+def ExpandDimsOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ExpandDimsOptionsT(object):
+
+ # ExpandDimsOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ expandDimsOptions = ExpandDimsOptions()
+ expandDimsOptions.Init(buf, pos)
+ return cls.InitFromObj(expandDimsOptions)
+
+ @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, expandDimsOptions):
+ x = ExpandDimsOptionsT()
+ x._UnPack(expandDimsOptions)
+ return x
+
+ # ExpandDimsOptionsT
+ def _UnPack(self, expandDimsOptions):
+ if expandDimsOptions is None:
+ return
+
+ # ExpandDimsOptionsT
+ def Pack(self, builder):
+ ExpandDimsOptionsStart(builder)
+ expandDimsOptions = ExpandDimsOptionsEnd(builder)
+ return expandDimsOptions
+
+
+class SparseToDenseOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SparseToDenseOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSparseToDenseOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SparseToDenseOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SparseToDenseOptions
+ def ValidateIndices(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 SparseToDenseOptionsStart(builder):
+ builder.StartObject(1)
+
+def SparseToDenseOptionsAddValidateIndices(builder, validateIndices):
+ builder.PrependBoolSlot(0, validateIndices, 0)
+
+def SparseToDenseOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SparseToDenseOptionsT(object):
+
+ # SparseToDenseOptionsT
+ def __init__(self):
+ self.validateIndices = False # type: bool
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ sparseToDenseOptions = SparseToDenseOptions()
+ sparseToDenseOptions.Init(buf, pos)
+ return cls.InitFromObj(sparseToDenseOptions)
+
+ @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, sparseToDenseOptions):
+ x = SparseToDenseOptionsT()
+ x._UnPack(sparseToDenseOptions)
+ return x
+
+ # SparseToDenseOptionsT
+ def _UnPack(self, sparseToDenseOptions):
+ if sparseToDenseOptions is None:
+ return
+ self.validateIndices = sparseToDenseOptions.ValidateIndices()
+
+ # SparseToDenseOptionsT
+ def Pack(self, builder):
+ SparseToDenseOptionsStart(builder)
+ SparseToDenseOptionsAddValidateIndices(builder, self.validateIndices)
+ sparseToDenseOptions = SparseToDenseOptionsEnd(builder)
+ return sparseToDenseOptions
+
+
+class EqualOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = EqualOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsEqualOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # EqualOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def EqualOptionsStart(builder):
+ builder.StartObject(0)
+
+def EqualOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class EqualOptionsT(object):
+
+ # EqualOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ equalOptions = EqualOptions()
+ equalOptions.Init(buf, pos)
+ return cls.InitFromObj(equalOptions)
+
+ @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, equalOptions):
+ x = EqualOptionsT()
+ x._UnPack(equalOptions)
+ return x
+
+ # EqualOptionsT
+ def _UnPack(self, equalOptions):
+ if equalOptions is None:
+ return
+
+ # EqualOptionsT
+ def Pack(self, builder):
+ EqualOptionsStart(builder)
+ equalOptions = EqualOptionsEnd(builder)
+ return equalOptions
+
+
+class NotEqualOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = NotEqualOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsNotEqualOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # NotEqualOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def NotEqualOptionsStart(builder):
+ builder.StartObject(0)
+
+def NotEqualOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class NotEqualOptionsT(object):
+
+ # NotEqualOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ notEqualOptions = NotEqualOptions()
+ notEqualOptions.Init(buf, pos)
+ return cls.InitFromObj(notEqualOptions)
+
+ @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, notEqualOptions):
+ x = NotEqualOptionsT()
+ x._UnPack(notEqualOptions)
+ return x
+
+ # NotEqualOptionsT
+ def _UnPack(self, notEqualOptions):
+ if notEqualOptions is None:
+ return
+
+ # NotEqualOptionsT
+ def Pack(self, builder):
+ NotEqualOptionsStart(builder)
+ notEqualOptions = NotEqualOptionsEnd(builder)
+ return notEqualOptions
+
+
+class ShapeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ShapeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsShapeOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ShapeOptions
+ 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 ShapeOptionsStart(builder):
+ builder.StartObject(1)
+
+def ShapeOptionsAddOutType(builder, outType):
+ builder.PrependInt8Slot(0, outType, 0)
+
+def ShapeOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ShapeOptionsT(object):
+
+ # ShapeOptionsT
+ def __init__(self):
+ self.outType = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ shapeOptions = ShapeOptions()
+ shapeOptions.Init(buf, pos)
+ return cls.InitFromObj(shapeOptions)
+
+ @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, shapeOptions):
+ x = ShapeOptionsT()
+ x._UnPack(shapeOptions)
+ return x
+
+ # ShapeOptionsT
+ def _UnPack(self, shapeOptions):
+ if shapeOptions is None:
+ return
+ self.outType = shapeOptions.OutType()
+
+ # ShapeOptionsT
+ def Pack(self, builder):
+ ShapeOptionsStart(builder)
+ ShapeOptionsAddOutType(builder, self.outType)
+ shapeOptions = ShapeOptionsEnd(builder)
+ return shapeOptions
+
+
+class RankOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = RankOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsRankOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # RankOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def RankOptionsStart(builder):
+ builder.StartObject(0)
+
+def RankOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class RankOptionsT(object):
+
+ # RankOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ rankOptions = RankOptions()
+ rankOptions.Init(buf, pos)
+ return cls.InitFromObj(rankOptions)
+
+ @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, rankOptions):
+ x = RankOptionsT()
+ x._UnPack(rankOptions)
+ return x
+
+ # RankOptionsT
+ def _UnPack(self, rankOptions):
+ if rankOptions is None:
+ return
+
+ # RankOptionsT
+ def Pack(self, builder):
+ RankOptionsStart(builder)
+ rankOptions = RankOptionsEnd(builder)
+ return rankOptions
+
+
+class PowOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = PowOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsPowOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # PowOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def PowOptionsStart(builder):
+ builder.StartObject(0)
+
+def PowOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class PowOptionsT(object):
+
+ # PowOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ powOptions = PowOptions()
+ powOptions.Init(buf, pos)
+ return cls.InitFromObj(powOptions)
+
+ @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, powOptions):
+ x = PowOptionsT()
+ x._UnPack(powOptions)
+ return x
+
+ # PowOptionsT
+ def _UnPack(self, powOptions):
+ if powOptions is None:
+ return
+
+ # PowOptionsT
+ def Pack(self, builder):
+ PowOptionsStart(builder)
+ powOptions = PowOptionsEnd(builder)
+ return powOptions
+
+
+class FakeQuantOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FakeQuantOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsFakeQuantOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # FakeQuantOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+ # 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
+
+ # 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):
+ 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):
+ fakeQuantOptions = FakeQuantOptions()
+ fakeQuantOptions.Init(buf, pos)
+ return cls.InitFromObj(fakeQuantOptions)
+
+ @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, fakeQuantOptions):
+ x = FakeQuantOptionsT()
+ x._UnPack(fakeQuantOptions)
+ return x
+
+ # 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()
+
+ # FakeQuantOptionsT
+ 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
+
+
+class PackOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = PackOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsPackOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # PackOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+ # 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.Int32Flags, o + self._tab.Pos)
+ return 0
+
+def PackOptionsStart(builder):
+ builder.StartObject(2)
+
+def PackOptionsAddValuesCount(builder, valuesCount):
+ builder.PrependInt32Slot(0, valuesCount, 0)
+
+def PackOptionsAddAxis(builder, axis):
+ builder.PrependInt32Slot(1, axis, 0)
+
+def PackOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class PackOptionsT(object):
+
+ # PackOptionsT
+ def __init__(self):
+ self.valuesCount = 0 # type: int
+ self.axis = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ packOptions = PackOptions()
+ packOptions.Init(buf, pos)
+ return cls.InitFromObj(packOptions)
+
+ @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, packOptions):
+ x = PackOptionsT()
+ x._UnPack(packOptions)
+ return x
+
+ # PackOptionsT
+ def _UnPack(self, packOptions):
+ if packOptions is None:
+ return
+ self.valuesCount = packOptions.ValuesCount()
+ self.axis = packOptions.Axis()
+
+ # PackOptionsT
+ def Pack(self, builder):
+ PackOptionsStart(builder)
+ PackOptionsAddValuesCount(builder, self.valuesCount)
+ PackOptionsAddAxis(builder, self.axis)
+ packOptions = PackOptionsEnd(builder)
+ return packOptions
+
+
+class LogicalOrOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LogicalOrOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLogicalOrOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LogicalOrOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LogicalOrOptionsStart(builder):
+ builder.StartObject(0)
+
+def LogicalOrOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class LogicalOrOptionsT(object):
+
+ # LogicalOrOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ logicalOrOptions = LogicalOrOptions()
+ logicalOrOptions.Init(buf, pos)
+ return cls.InitFromObj(logicalOrOptions)
+
+ @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, logicalOrOptions):
+ x = LogicalOrOptionsT()
+ x._UnPack(logicalOrOptions)
+ return x
+
+ # LogicalOrOptionsT
+ def _UnPack(self, logicalOrOptions):
+ if logicalOrOptions is None:
+ return
+
+ # LogicalOrOptionsT
+ def Pack(self, builder):
+ LogicalOrOptionsStart(builder)
+ logicalOrOptions = LogicalOrOptionsEnd(builder)
+ return logicalOrOptions
+
+
+class OneHotOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = OneHotOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsOneHotOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # OneHotOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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)
+
+def OneHotOptionsAddAxis(builder, axis):
+ builder.PrependInt32Slot(0, axis, 0)
+
+def OneHotOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class OneHotOptionsT(object):
+
+ # OneHotOptionsT
+ def __init__(self):
+ self.axis = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ oneHotOptions = OneHotOptions()
+ oneHotOptions.Init(buf, pos)
+ return cls.InitFromObj(oneHotOptions)
+
+ @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, oneHotOptions):
+ x = OneHotOptionsT()
+ x._UnPack(oneHotOptions)
+ return x
+
+ # OneHotOptionsT
+ def _UnPack(self, oneHotOptions):
+ if oneHotOptions is None:
+ return
+ self.axis = oneHotOptions.Axis()
+
+ # OneHotOptionsT
+ def Pack(self, builder):
+ OneHotOptionsStart(builder)
+ OneHotOptionsAddAxis(builder, self.axis)
+ oneHotOptions = OneHotOptionsEnd(builder)
+ return oneHotOptions
+
+
+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 AbsOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # AbsOptionsT
+ def _UnPack(self, absOptions):
+ if absOptions is None:
+ return
+
+ # AbsOptionsT
+ def Pack(self, builder):
+ AbsOptionsStart(builder)
+ absOptions = AbsOptionsEnd(builder)
+ return absOptions
+
+
+class HardSwishOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = HardSwishOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsHardSwishOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # HardSwishOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def HardSwishOptionsStart(builder):
+ builder.StartObject(0)
+
+def HardSwishOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class HardSwishOptionsT(object):
+
+ # HardSwishOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ hardSwishOptions = HardSwishOptions()
+ hardSwishOptions.Init(buf, pos)
+ return cls.InitFromObj(hardSwishOptions)
+
+ @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, hardSwishOptions):
+ x = HardSwishOptionsT()
+ x._UnPack(hardSwishOptions)
+ return x
+
+ # HardSwishOptionsT
+ def _UnPack(self, hardSwishOptions):
+ if hardSwishOptions is None:
+ return
+
+ # HardSwishOptionsT
+ def Pack(self, builder):
+ HardSwishOptionsStart(builder)
+ hardSwishOptions = HardSwishOptionsEnd(builder)
+ return hardSwishOptions
+
+
+class LogicalAndOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LogicalAndOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLogicalAndOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LogicalAndOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LogicalAndOptionsStart(builder):
+ builder.StartObject(0)
+
+def LogicalAndOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class LogicalAndOptionsT(object):
+
+ # LogicalAndOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ logicalAndOptions = LogicalAndOptions()
+ logicalAndOptions.Init(buf, pos)
+ return cls.InitFromObj(logicalAndOptions)
+
+ @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, logicalAndOptions):
+ x = LogicalAndOptionsT()
+ x._UnPack(logicalAndOptions)
+ return x
+
+ # LogicalAndOptionsT
+ def _UnPack(self, logicalAndOptions):
+ if logicalAndOptions is None:
+ return
+
+ # LogicalAndOptionsT
+ def Pack(self, builder):
+ LogicalAndOptionsStart(builder)
+ logicalAndOptions = LogicalAndOptionsEnd(builder)
+ return logicalAndOptions
+
+
+class LogicalNotOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LogicalNotOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLogicalNotOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LogicalNotOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LogicalNotOptionsStart(builder):
+ builder.StartObject(0)
+
+def LogicalNotOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class LogicalNotOptionsT(object):
+
+ # LogicalNotOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ logicalNotOptions = LogicalNotOptions()
+ logicalNotOptions.Init(buf, pos)
+ return cls.InitFromObj(logicalNotOptions)
+
+ @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, logicalNotOptions):
+ x = LogicalNotOptionsT()
+ x._UnPack(logicalNotOptions)
+ return x
+
+ # LogicalNotOptionsT
+ def _UnPack(self, logicalNotOptions):
+ if logicalNotOptions is None:
+ return
+
+ # LogicalNotOptionsT
+ def Pack(self, builder):
+ LogicalNotOptionsStart(builder)
+ logicalNotOptions = LogicalNotOptionsEnd(builder)
+ return logicalNotOptions
+
+
+class UnpackOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = UnpackOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsUnpackOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # UnpackOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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)
+
+def UnpackOptionsAddNum(builder, num):
+ builder.PrependInt32Slot(0, num, 0)
+
+def UnpackOptionsAddAxis(builder, axis):
+ builder.PrependInt32Slot(1, axis, 0)
+
+def UnpackOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class UnpackOptionsT(object):
+
+ # UnpackOptionsT
+ def __init__(self):
+ self.num = 0 # type: int
+ self.axis = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ unpackOptions = UnpackOptions()
+ unpackOptions.Init(buf, pos)
+ return cls.InitFromObj(unpackOptions)
+
+ @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, unpackOptions):
+ x = UnpackOptionsT()
+ x._UnPack(unpackOptions)
+ return x
+
+ # UnpackOptionsT
+ def _UnPack(self, unpackOptions):
+ if unpackOptions is None:
+ return
+ self.num = unpackOptions.Num()
+ self.axis = unpackOptions.Axis()
+
+ # UnpackOptionsT
+ def Pack(self, builder):
+ UnpackOptionsStart(builder)
+ UnpackOptionsAddNum(builder, self.num)
+ UnpackOptionsAddAxis(builder, self.axis)
+ unpackOptions = UnpackOptionsEnd(builder)
+ return unpackOptions
+
+
+class FloorDivOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FloorDivOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsFloorDivOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # FloorDivOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def FloorDivOptionsStart(builder):
+ builder.StartObject(0)
+
+def FloorDivOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class FloorDivOptionsT(object):
+
+ # FloorDivOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ floorDivOptions = FloorDivOptions()
+ floorDivOptions.Init(buf, pos)
+ return cls.InitFromObj(floorDivOptions)
+
+ @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, floorDivOptions):
+ x = FloorDivOptionsT()
+ x._UnPack(floorDivOptions)
+ return x
+
+ # FloorDivOptionsT
+ def _UnPack(self, floorDivOptions):
+ if floorDivOptions is None:
+ return
+
+ # FloorDivOptionsT
+ def Pack(self, builder):
+ FloorDivOptionsStart(builder)
+ floorDivOptions = FloorDivOptionsEnd(builder)
+ return floorDivOptions
+
+
+class SquareOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SquareOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSquareOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SquareOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SquareOptionsStart(builder):
+ builder.StartObject(0)
+
+def SquareOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SquareOptionsT(object):
+
+ # SquareOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ squareOptions = SquareOptions()
+ squareOptions.Init(buf, pos)
+ return cls.InitFromObj(squareOptions)
+
+ @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, squareOptions):
+ x = SquareOptionsT()
+ x._UnPack(squareOptions)
+ return x
+
+ # SquareOptionsT
+ def _UnPack(self, squareOptions):
+ if squareOptions is None:
+ return
+
+ # SquareOptionsT
+ def Pack(self, builder):
+ SquareOptionsStart(builder)
+ squareOptions = SquareOptionsEnd(builder)
+ return squareOptions
+
+
+class ZerosLikeOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # ZerosLikeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ZerosLikeOptionsStart(builder):
+ builder.StartObject(0)
+
+def ZerosLikeOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ZerosLikeOptionsT(object):
+
+ # ZerosLikeOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ zerosLikeOptions = ZerosLikeOptions()
+ zerosLikeOptions.Init(buf, pos)
+ return cls.InitFromObj(zerosLikeOptions)
+
+ @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, zerosLikeOptions):
+ x = ZerosLikeOptionsT()
+ x._UnPack(zerosLikeOptions)
+ return x
+
+ # ZerosLikeOptionsT
+ def _UnPack(self, zerosLikeOptions):
+ if zerosLikeOptions is None:
+ return
+
+ # ZerosLikeOptionsT
+ def Pack(self, builder):
+ ZerosLikeOptionsStart(builder)
+ zerosLikeOptions = ZerosLikeOptionsEnd(builder)
+ return zerosLikeOptions
+
+
+class FillOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FillOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsFillOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # FillOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def FillOptionsStart(builder):
+ builder.StartObject(0)
+
+def FillOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class FillOptionsT(object):
+
+ # FillOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ fillOptions = FillOptions()
+ fillOptions.Init(buf, pos)
+ return cls.InitFromObj(fillOptions)
+
+ @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, fillOptions):
+ x = FillOptionsT()
+ x._UnPack(fillOptions)
+ return x
+
+ # FillOptionsT
+ def _UnPack(self, fillOptions):
+ if fillOptions is None:
+ return
+
+ # FillOptionsT
+ def Pack(self, builder):
+ FillOptionsStart(builder)
+ fillOptions = FillOptionsEnd(builder)
+ return fillOptions
+
+
+class FloorModOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FloorModOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsFloorModOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # FloorModOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def FloorModOptionsStart(builder):
+ builder.StartObject(0)
+
+def FloorModOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class FloorModOptionsT(object):
+
+ # FloorModOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ floorModOptions = FloorModOptions()
+ floorModOptions.Init(buf, pos)
+ return cls.InitFromObj(floorModOptions)
+
+ @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, floorModOptions):
+ x = FloorModOptionsT()
+ x._UnPack(floorModOptions)
+ return x
+
+ # FloorModOptionsT
+ def _UnPack(self, floorModOptions):
+ if floorModOptions is None:
+ return
+
+ # FloorModOptionsT
+ def Pack(self, builder):
+ FloorModOptionsStart(builder)
+ floorModOptions = FloorModOptionsEnd(builder)
+ return floorModOptions
+
+
+class RangeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = RangeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsRangeOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # RangeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def RangeOptionsStart(builder):
+ builder.StartObject(0)
+
+def RangeOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class RangeOptionsT(object):
+
+ # RangeOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ rangeOptions = RangeOptions()
+ rangeOptions.Init(buf, pos)
+ return cls.InitFromObj(rangeOptions)
+
+ @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, rangeOptions):
+ x = RangeOptionsT()
+ x._UnPack(rangeOptions)
+ return x
+
+ # RangeOptionsT
+ def _UnPack(self, rangeOptions):
+ if rangeOptions is None:
+ return
+
+ # RangeOptionsT
+ def Pack(self, builder):
+ RangeOptionsStart(builder)
+ rangeOptions = RangeOptionsEnd(builder)
+ return rangeOptions
+
+
+class LeakyReluOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LeakyReluOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsLeakyReluOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # LeakyReluOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # LeakyReluOptions
+ def Alpha(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 LeakyReluOptionsStart(builder):
+ builder.StartObject(1)
+
+def LeakyReluOptionsAddAlpha(builder, alpha):
+ builder.PrependFloat32Slot(0, alpha, 0.0)
+
+def LeakyReluOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class LeakyReluOptionsT(object):
+
+ # LeakyReluOptionsT
+ def __init__(self):
+ self.alpha = 0.0 # type: float
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ leakyReluOptions = LeakyReluOptions()
+ leakyReluOptions.Init(buf, pos)
+ return cls.InitFromObj(leakyReluOptions)
+
+ @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, leakyReluOptions):
+ x = LeakyReluOptionsT()
+ x._UnPack(leakyReluOptions)
+ return x
+
+ # LeakyReluOptionsT
+ def _UnPack(self, leakyReluOptions):
+ if leakyReluOptions is None:
+ return
+ self.alpha = leakyReluOptions.Alpha()
+
+ # LeakyReluOptionsT
+ def Pack(self, builder):
+ LeakyReluOptionsStart(builder)
+ LeakyReluOptionsAddAlpha(builder, self.alpha)
+ leakyReluOptions = LeakyReluOptionsEnd(builder)
+ return leakyReluOptions
+
+
+class SquaredDifferenceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SquaredDifferenceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSquaredDifferenceOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SquaredDifferenceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SquaredDifferenceOptionsStart(builder):
+ builder.StartObject(0)
+
+def SquaredDifferenceOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SquaredDifferenceOptionsT(object):
+
+ # SquaredDifferenceOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ squaredDifferenceOptions = SquaredDifferenceOptions()
+ squaredDifferenceOptions.Init(buf, pos)
+ return cls.InitFromObj(squaredDifferenceOptions)
+
+ @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, squaredDifferenceOptions):
+ x = SquaredDifferenceOptionsT()
+ x._UnPack(squaredDifferenceOptions)
+ return x
+
+ # SquaredDifferenceOptionsT
+ def _UnPack(self, squaredDifferenceOptions):
+ if squaredDifferenceOptions is None:
+ return
+
+ # SquaredDifferenceOptionsT
+ def Pack(self, builder):
+ SquaredDifferenceOptionsStart(builder)
+ squaredDifferenceOptions = SquaredDifferenceOptionsEnd(builder)
+ return squaredDifferenceOptions
+
+
+class MirrorPadOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MirrorPadOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsMirrorPadOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # MirrorPadOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def MirrorPadOptionsStart(builder):
+ builder.StartObject(1)
+
+def MirrorPadOptionsAddMode(builder, mode):
+ builder.PrependInt8Slot(0, mode, 0)
+
+def MirrorPadOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class MirrorPadOptionsT(object):
+
+ # MirrorPadOptionsT
+ def __init__(self):
+ self.mode = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ mirrorPadOptions = MirrorPadOptions()
+ mirrorPadOptions.Init(buf, pos)
+ return cls.InitFromObj(mirrorPadOptions)
+
+ @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, mirrorPadOptions):
+ x = MirrorPadOptionsT()
+ x._UnPack(mirrorPadOptions)
+ return x
+
+ # MirrorPadOptionsT
+ def _UnPack(self, mirrorPadOptions):
+ if mirrorPadOptions is None:
+ return
+ self.mode = mirrorPadOptions.Mode()
+
+ # MirrorPadOptionsT
+ def Pack(self, builder):
+ MirrorPadOptionsStart(builder)
+ MirrorPadOptionsAddMode(builder, self.mode)
+ mirrorPadOptions = MirrorPadOptionsEnd(builder)
+ return mirrorPadOptions
+
+
+class UniqueOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # UniqueOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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 UniqueOptionsStart(builder):
+ builder.StartObject(1)
+
+def UniqueOptionsAddIdxOutType(builder, idxOutType):
+ builder.PrependInt8Slot(0, idxOutType, 2)
+
+def UniqueOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class UniqueOptionsT(object):
+
+ # UniqueOptionsT
+ def __init__(self):
+ self.idxOutType = 2 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ uniqueOptions = UniqueOptions()
+ uniqueOptions.Init(buf, pos)
+ return cls.InitFromObj(uniqueOptions)
+
+ @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, uniqueOptions):
+ x = UniqueOptionsT()
+ x._UnPack(uniqueOptions)
+ return x
+
+ # UniqueOptionsT
+ def _UnPack(self, uniqueOptions):
+ if uniqueOptions is None:
+ return
+ self.idxOutType = uniqueOptions.IdxOutType()
+
+ # UniqueOptionsT
+ def Pack(self, builder):
+ UniqueOptionsStart(builder)
+ UniqueOptionsAddIdxOutType(builder, self.idxOutType)
+ uniqueOptions = UniqueOptionsEnd(builder)
+ return uniqueOptions
+
+
+class ReverseV2Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReverseV2Options()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsReverseV2Options(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ReverseV2Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ReverseV2OptionsStart(builder):
+ builder.StartObject(0)
+
+def ReverseV2OptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ReverseV2OptionsT(object):
+
+ # ReverseV2OptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ reverseV2Options = ReverseV2Options()
+ reverseV2Options.Init(buf, pos)
+ return cls.InitFromObj(reverseV2Options)
+
+ @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, reverseV2Options):
+ x = ReverseV2OptionsT()
+ x._UnPack(reverseV2Options)
+ return x
+
+ # ReverseV2OptionsT
+ def _UnPack(self, reverseV2Options):
+ if reverseV2Options is None:
+ return
+
+ # ReverseV2OptionsT
+ def Pack(self, builder):
+ ReverseV2OptionsStart(builder)
+ reverseV2Options = ReverseV2OptionsEnd(builder)
+ return reverseV2Options
+
+
+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 AddNOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # AddNOptionsT
+ def _UnPack(self, addNoptions):
+ if addNoptions is None:
+ return
+
+ # AddNOptionsT
+ def Pack(self, builder):
+ AddNOptionsStart(builder)
+ addNoptions = AddNOptionsEnd(builder)
+ return addNoptions
+
+
+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 GatherNdOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # GatherNdOptionsT
+ def _UnPack(self, gatherNdOptions):
+ if gatherNdOptions is None:
+ return
+
+ # GatherNdOptionsT
+ def Pack(self, builder):
+ GatherNdOptionsStart(builder)
+ gatherNdOptions = GatherNdOptionsEnd(builder)
+ return gatherNdOptions
+
+
+class WhereOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # WhereOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def WhereOptionsStart(builder):
+ builder.StartObject(0)
+
+def WhereOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class WhereOptionsT(object):
+
+ # WhereOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ whereOptions = WhereOptions()
+ whereOptions.Init(buf, pos)
+ return cls.InitFromObj(whereOptions)
+
+ @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, whereOptions):
+ x = WhereOptionsT()
+ x._UnPack(whereOptions)
+ return x
+
+ # WhereOptionsT
+ def _UnPack(self, whereOptions):
+ if whereOptions is None:
+ return
+
+ # WhereOptionsT
+ def Pack(self, builder):
+ WhereOptionsStart(builder)
+ whereOptions = WhereOptionsEnd(builder)
+ return whereOptions
+
+
+class ReverseSequenceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReverseSequenceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsReverseSequenceOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ReverseSequenceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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.Int32Flags, 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 ReverseSequenceOptionsStart(builder):
+ builder.StartObject(2)
+
+def ReverseSequenceOptionsAddSeqDim(builder, seqDim):
+ builder.PrependInt32Slot(0, seqDim, 0)
+
+def ReverseSequenceOptionsAddBatchDim(builder, batchDim):
+ builder.PrependInt32Slot(1, batchDim, 0)
+
+def ReverseSequenceOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ReverseSequenceOptionsT(object):
+
+ # ReverseSequenceOptionsT
+ def __init__(self):
+ self.seqDim = 0 # type: int
+ self.batchDim = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ reverseSequenceOptions = ReverseSequenceOptions()
+ reverseSequenceOptions.Init(buf, pos)
+ return cls.InitFromObj(reverseSequenceOptions)
+
+ @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, reverseSequenceOptions):
+ x = ReverseSequenceOptionsT()
+ x._UnPack(reverseSequenceOptions)
+ return x
+
+ # ReverseSequenceOptionsT
+ def _UnPack(self, reverseSequenceOptions):
+ if reverseSequenceOptions is None:
+ return
+ self.seqDim = reverseSequenceOptions.SeqDim()
+ self.batchDim = reverseSequenceOptions.BatchDim()
+
+ # ReverseSequenceOptionsT
+ def Pack(self, builder):
+ ReverseSequenceOptionsStart(builder)
+ ReverseSequenceOptionsAddSeqDim(builder, self.seqDim)
+ ReverseSequenceOptionsAddBatchDim(builder, self.batchDim)
+ reverseSequenceOptions = ReverseSequenceOptionsEnd(builder)
+ return reverseSequenceOptions
+
+
+class MatrixDiagOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MatrixDiagOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsMatrixDiagOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # MatrixDiagOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def MatrixDiagOptionsStart(builder):
+ builder.StartObject(0)
+
+def MatrixDiagOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class MatrixDiagOptionsT(object):
+
+ # MatrixDiagOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ matrixDiagOptions = MatrixDiagOptions()
+ matrixDiagOptions.Init(buf, pos)
+ return cls.InitFromObj(matrixDiagOptions)
+
+ @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, matrixDiagOptions):
+ x = MatrixDiagOptionsT()
+ x._UnPack(matrixDiagOptions)
+ return x
+
+ # MatrixDiagOptionsT
+ def _UnPack(self, matrixDiagOptions):
+ if matrixDiagOptions is None:
+ return
+
+ # MatrixDiagOptionsT
+ def Pack(self, builder):
+ MatrixDiagOptionsStart(builder)
+ matrixDiagOptions = MatrixDiagOptionsEnd(builder)
+ return matrixDiagOptions
+
+
+class QuantizeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = QuantizeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsQuantizeOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # QuantizeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def QuantizeOptionsStart(builder):
+ builder.StartObject(0)
+
+def QuantizeOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class QuantizeOptionsT(object):
+
+ # QuantizeOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ quantizeOptions = QuantizeOptions()
+ quantizeOptions.Init(buf, pos)
+ return cls.InitFromObj(quantizeOptions)
+
+ @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, quantizeOptions):
+ x = QuantizeOptionsT()
+ x._UnPack(quantizeOptions)
+ return x
+
+ # QuantizeOptionsT
+ def _UnPack(self, quantizeOptions):
+ if quantizeOptions is None:
+ return
+
+ # QuantizeOptionsT
+ def Pack(self, builder):
+ QuantizeOptionsStart(builder)
+ quantizeOptions = QuantizeOptionsEnd(builder)
+ return quantizeOptions
+
+
+class MatrixSetDiagOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # MatrixSetDiagOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def MatrixSetDiagOptionsStart(builder):
+ builder.StartObject(0)
+
+def MatrixSetDiagOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class MatrixSetDiagOptionsT(object):
+
+ # MatrixSetDiagOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ matrixSetDiagOptions = MatrixSetDiagOptions()
+ matrixSetDiagOptions.Init(buf, pos)
+ return cls.InitFromObj(matrixSetDiagOptions)
+
+ @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, matrixSetDiagOptions):
+ x = MatrixSetDiagOptionsT()
+ x._UnPack(matrixSetDiagOptions)
+ return x
+
+ # MatrixSetDiagOptionsT
+ def _UnPack(self, matrixSetDiagOptions):
+ if matrixSetDiagOptions is None:
+ return
+
+ # MatrixSetDiagOptionsT
+ def Pack(self, builder):
+ MatrixSetDiagOptionsStart(builder)
+ matrixSetDiagOptions = MatrixSetDiagOptionsEnd(builder)
+ return matrixSetDiagOptions
+
+
+class IfOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # IfOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # IfOptions
+ def ThenSubgraphIndex(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
+
+ # IfOptions
+ def ElseSubgraphIndex(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 IfOptionsStart(builder):
+ builder.StartObject(2)
+
+def IfOptionsAddThenSubgraphIndex(builder, thenSubgraphIndex):
+ builder.PrependInt32Slot(0, thenSubgraphIndex, 0)
+
+def IfOptionsAddElseSubgraphIndex(builder, elseSubgraphIndex):
+ builder.PrependInt32Slot(1, elseSubgraphIndex, 0)
+
+def IfOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class IfOptionsT(object):
+
+ # IfOptionsT
+ def __init__(self):
+ self.thenSubgraphIndex = 0 # type: int
+ self.elseSubgraphIndex = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ ifOptions = IfOptions()
+ ifOptions.Init(buf, pos)
+ return cls.InitFromObj(ifOptions)
+
+ @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, ifOptions):
+ x = IfOptionsT()
+ x._UnPack(ifOptions)
+ return x
+
+ # IfOptionsT
+ def _UnPack(self, ifOptions):
+ if ifOptions is None:
+ return
+ self.thenSubgraphIndex = ifOptions.ThenSubgraphIndex()
+ self.elseSubgraphIndex = ifOptions.ElseSubgraphIndex()
+
+ # IfOptionsT
+ def Pack(self, builder):
+ 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)
+
+ # 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
+
+def CallOnceOptionsStart(builder):
+ builder.StartObject(1)
+
+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 = WhileOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsWhileOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # WhileOptions
+ 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))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+ return 0
+
+ # WhileOptions
+ 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 WhileOptionsStart(builder):
+ builder.StartObject(2)
+
+def WhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex):
+ builder.PrependInt32Slot(0, condSubgraphIndex, 0)
+
+def WhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex):
+ builder.PrependInt32Slot(1, bodySubgraphIndex, 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)
+
+ # ScatterNdOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ScatterNdOptionsStart(builder):
+ builder.StartObject(0)
+
+def ScatterNdOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ScatterNdOptionsT(object):
+
+ # ScatterNdOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ scatterNdOptions = ScatterNdOptions()
+ scatterNdOptions.Init(buf, pos)
+ return cls.InitFromObj(scatterNdOptions)
+
+ @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, scatterNdOptions):
+ x = ScatterNdOptionsT()
+ x._UnPack(scatterNdOptions)
+ return x
+
+ # ScatterNdOptionsT
+ def _UnPack(self, scatterNdOptions):
+ if scatterNdOptions is None:
+ return
+
+ # ScatterNdOptionsT
+ def Pack(self, builder):
+ ScatterNdOptionsStart(builder)
+ scatterNdOptions = ScatterNdOptionsEnd(builder)
+ return scatterNdOptions
+
+
+class SelectV2Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SelectV2Options()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSelectV2Options(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SelectV2Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SelectV2OptionsStart(builder):
+ builder.StartObject(0)
+
+def SelectV2OptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SelectV2OptionsT(object):
+
+ # SelectV2OptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ selectV2Options = SelectV2Options()
+ selectV2Options.Init(buf, pos)
+ return cls.InitFromObj(selectV2Options)
+
+ @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, selectV2Options):
+ x = SelectV2OptionsT()
+ x._UnPack(selectV2Options)
+ return x
+
+ # SelectV2OptionsT
+ def _UnPack(self, selectV2Options):
+ if selectV2Options is None:
+ return
+
+ # SelectV2OptionsT
+ def Pack(self, builder):
+ SelectV2OptionsStart(builder)
+ selectV2Options = SelectV2OptionsEnd(builder)
+ return selectV2Options
+
+
+class DensifyOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # DensifyOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def DensifyOptionsStart(builder):
+ builder.StartObject(0)
+
+def DensifyOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class DensifyOptionsT(object):
+
+ # DensifyOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ densifyOptions = DensifyOptions()
+ densifyOptions.Init(buf, pos)
+ return cls.InitFromObj(densifyOptions)
+
+ @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, densifyOptions):
+ x = DensifyOptionsT()
+ x._UnPack(densifyOptions)
+ return x
+
+ # DensifyOptionsT
+ def _UnPack(self, densifyOptions):
+ if densifyOptions is None:
+ return
+
+ # DensifyOptionsT
+ def Pack(self, builder):
+ DensifyOptionsStart(builder)
+ densifyOptions = DensifyOptionsEnd(builder)
+ return densifyOptions
+
+
+class SegmentSumOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SegmentSumOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSegmentSumOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SegmentSumOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SegmentSumOptionsStart(builder):
+ builder.StartObject(0)
+
+def SegmentSumOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SegmentSumOptionsT(object):
+
+ # SegmentSumOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ segmentSumOptions = SegmentSumOptions()
+ segmentSumOptions.Init(buf, pos)
+ return cls.InitFromObj(segmentSumOptions)
+
+ @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, segmentSumOptions):
+ x = SegmentSumOptionsT()
+ x._UnPack(segmentSumOptions)
+ return x
+
+ # SegmentSumOptionsT
+ def _UnPack(self, segmentSumOptions):
+ if segmentSumOptions is None:
+ return
+
+ # SegmentSumOptionsT
+ def Pack(self, builder):
+ SegmentSumOptionsStart(builder)
+ segmentSumOptions = SegmentSumOptionsEnd(builder)
+ return segmentSumOptions
+
+
+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 BatchMatMulOptionsAddAdjX(builder, adjX):
+ builder.PrependBoolSlot(0, adjX, 0)
+
+def BatchMatMulOptionsAddAdjY(builder, adjY):
+ builder.PrependBoolSlot(1, adjY, 0)
+
+def BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs):
+ builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0)
+
+def BatchMatMulOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # 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
+
+
+class CumsumOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # CumsumOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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
+
+ # 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 CumsumOptionsAddExclusive(builder, exclusive):
+ builder.PrependBoolSlot(0, exclusive, 0)
+
+def CumsumOptionsAddReverse(builder, reverse):
+ builder.PrependBoolSlot(1, reverse, 0)
+
+def CumsumOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class CumsumOptionsT(object):
+
+ # CumsumOptionsT
+ def __init__(self):
+ self.exclusive = False # type: bool
+ self.reverse = False # type: bool
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ cumsumOptions = CumsumOptions()
+ cumsumOptions.Init(buf, pos)
+ return cls.InitFromObj(cumsumOptions)
+
+ @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, cumsumOptions):
+ x = CumsumOptionsT()
+ x._UnPack(cumsumOptions)
+ return x
+
+ # CumsumOptionsT
+ def _UnPack(self, cumsumOptions):
+ if cumsumOptions is None:
+ return
+ self.exclusive = cumsumOptions.Exclusive()
+ self.reverse = cumsumOptions.Reverse()
+
+ # CumsumOptionsT
+ def Pack(self, builder):
+ CumsumOptionsStart(builder)
+ CumsumOptionsAddExclusive(builder, self.exclusive)
+ CumsumOptionsAddReverse(builder, self.reverse)
+ cumsumOptions = CumsumOptionsEnd(builder)
+ return cumsumOptions
+
+
+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 BroadcastToOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 InitFromPackedBuf(cls, buf, pos=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+ return cls.InitFromBuf(buf, pos+n)
+
+ @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 = Rfft2dOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsRfft2dOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # Rfft2dOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def Rfft2dOptionsStart(builder):
+ builder.StartObject(0)
+
+def Rfft2dOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class Rfft2dOptionsT(object):
+
+ # Rfft2dOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ rfft2dOptions = Rfft2dOptions()
+ rfft2dOptions.Init(buf, pos)
+ return cls.InitFromObj(rfft2dOptions)
+
+ @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, rfft2dOptions):
+ x = Rfft2dOptionsT()
+ x._UnPack(rfft2dOptions)
+ return x
+
+ # Rfft2dOptionsT
+ def _UnPack(self, rfft2dOptions):
+ if rfft2dOptions is None:
+ return
+
+ # Rfft2dOptionsT
+ def Pack(self, builder):
+ Rfft2dOptionsStart(builder)
+ rfft2dOptions = Rfft2dOptionsEnd(builder)
+ return rfft2dOptions
+
+
+class HashtableOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = HashtableOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsHashtableOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # HashtableOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # HashtableOptions
+ def TableId(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):
+ 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
+
+ # HashtableOptions
+ def ValueDtype(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
+
+def HashtableOptionsStart(builder):
+ builder.StartObject(3)
+
+def HashtableOptionsAddTableId(builder, tableId):
+ builder.PrependInt32Slot(0, tableId, 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)
+
+def HashtableFindOptionsStart(builder):
+ builder.StartObject(0)
+
+def HashtableFindOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class HashtableFindOptionsT(object):
+
+ # HashtableFindOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ hashtableFindOptions = HashtableFindOptions()
+ hashtableFindOptions.Init(buf, pos)
+ return cls.InitFromObj(hashtableFindOptions)
+
+ @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, hashtableFindOptions):
+ x = HashtableFindOptionsT()
+ x._UnPack(hashtableFindOptions)
+ return x
+
+ # HashtableFindOptionsT
+ def _UnPack(self, hashtableFindOptions):
+ if hashtableFindOptions is None:
+ return
+
+ # HashtableFindOptionsT
+ def Pack(self, builder):
+ HashtableFindOptionsStart(builder)
+ hashtableFindOptions = HashtableFindOptionsEnd(builder)
+ return hashtableFindOptions
+
+
+class HashtableImportOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # HashtableImportOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def HashtableImportOptionsStart(builder):
+ builder.StartObject(0)
+
+def HashtableImportOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class HashtableImportOptionsT(object):
+
+ # HashtableImportOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ hashtableImportOptions = HashtableImportOptions()
+ hashtableImportOptions.Init(buf, pos)
+ return cls.InitFromObj(hashtableImportOptions)
+
+ @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, hashtableImportOptions):
+ x = HashtableImportOptionsT()
+ x._UnPack(hashtableImportOptions)
+ return x
+
+ # HashtableImportOptionsT
+ def _UnPack(self, hashtableImportOptions):
+ if hashtableImportOptions is None:
+ return
+
+ # HashtableImportOptionsT
+ def Pack(self, builder):
+ HashtableImportOptionsStart(builder)
+ hashtableImportOptions = HashtableImportOptionsEnd(builder)
+ return hashtableImportOptions
+
+
+class HashtableSizeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = HashtableSizeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsHashtableSizeOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # HashtableSizeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def HashtableSizeOptionsStart(builder):
+ builder.StartObject(0)
+
+def HashtableSizeOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class HashtableSizeOptionsT(object):
+
+ # HashtableSizeOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ hashtableSizeOptions = HashtableSizeOptions()
+ hashtableSizeOptions.Init(buf, pos)
+ return cls.InitFromObj(hashtableSizeOptions)
+
+ @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, hashtableSizeOptions):
+ x = HashtableSizeOptionsT()
+ x._UnPack(hashtableSizeOptions)
+ return x
+
+ # HashtableSizeOptionsT
+ def _UnPack(self, hashtableSizeOptions):
+ if hashtableSizeOptions is None:
+ return
+
+ # HashtableSizeOptionsT
+ def Pack(self, builder):
+ HashtableSizeOptionsStart(builder)
+ hashtableSizeOptions = HashtableSizeOptionsEnd(builder)
+ return hashtableSizeOptions
+
+
+class VarHandleOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = VarHandleOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsVarHandleOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # VarHandleOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # VarHandleOptions
+ def Container(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):
+ 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 VarHandleOptionsStart(builder):
+ builder.StartObject(2)
+
+def VarHandleOptionsAddContainer(builder, container):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(container), 0)
+
+def VarHandleOptionsAddSharedName(builder, sharedName):
+ builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(sharedName), 0)
+
+def VarHandleOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class VarHandleOptionsT(object):
+
+ # VarHandleOptionsT
+ def __init__(self):
+ self.container = None # type: str
+ self.sharedName = None # type: str
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ varHandleOptions = VarHandleOptions()
+ varHandleOptions.Init(buf, pos)
+ return cls.InitFromObj(varHandleOptions)
+
+ @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, varHandleOptions):
+ x = VarHandleOptionsT()
+ x._UnPack(varHandleOptions)
+ return x
+
+ # VarHandleOptionsT
+ def _UnPack(self, varHandleOptions):
+ if varHandleOptions is None:
+ return
+ self.container = varHandleOptions.Container()
+ self.sharedName = varHandleOptions.SharedName()
+
+ # VarHandleOptionsT
+ 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
+
+
+class ReadVariableOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReadVariableOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsReadVariableOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ReadVariableOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ReadVariableOptionsStart(builder):
+ builder.StartObject(0)
+
+def ReadVariableOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ReadVariableOptionsT(object):
+
+ # ReadVariableOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ readVariableOptions = ReadVariableOptions()
+ readVariableOptions.Init(buf, pos)
+ return cls.InitFromObj(readVariableOptions)
+
+ @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, readVariableOptions):
+ x = ReadVariableOptionsT()
+ x._UnPack(readVariableOptions)
+ return x
+
+ # ReadVariableOptionsT
+ def _UnPack(self, readVariableOptions):
+ if readVariableOptions is None:
+ return
+
+ # ReadVariableOptionsT
+ def Pack(self, builder):
+ ReadVariableOptionsStart(builder)
+ readVariableOptions = ReadVariableOptionsEnd(builder)
+ return readVariableOptions
+
+
+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 AssignVariableOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # AssignVariableOptionsT
+ def _UnPack(self, assignVariableOptions):
+ if assignVariableOptions is None:
+ return
+
+ # AssignVariableOptionsT
+ def Pack(self, builder):
+ AssignVariableOptionsStart(builder)
+ assignVariableOptions = AssignVariableOptionsEnd(builder)
+ return assignVariableOptions
+
+
+class RandomOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = RandomOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsRandomOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # RandomOptions
+ 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
+
+ # 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 RandomOptionsStart(builder):
+ builder.StartObject(2)
+
+def RandomOptionsAddSeed(builder, seed):
+ builder.PrependInt64Slot(0, seed, 0)
+
+def RandomOptionsAddSeed2(builder, seed2):
+ builder.PrependInt64Slot(1, seed2, 0)
+
+def RandomOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class RandomOptionsT(object):
+
+ # RandomOptionsT
+ def __init__(self):
+ self.seed = 0 # type: int
+ self.seed2 = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ randomOptions = RandomOptions()
+ randomOptions.Init(buf, pos)
+ return cls.InitFromObj(randomOptions)
+
+ @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, randomOptions):
+ x = RandomOptionsT()
+ x._UnPack(randomOptions)
+ return x
+
+ # RandomOptionsT
+ def _UnPack(self, randomOptions):
+ if randomOptions is None:
+ return
+ self.seed = randomOptions.Seed()
+ self.seed2 = randomOptions.Seed2()
+
+ # RandomOptionsT
+ def Pack(self, builder):
+ RandomOptionsStart(builder)
+ RandomOptionsAddSeed(builder, self.seed)
+ RandomOptionsAddSeed2(builder, self.seed2)
+ randomOptions = RandomOptionsEnd(builder)
+ return randomOptions
+
+
+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 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.boundaries = None # type: List[float]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ bucketizeOptions = BucketizeOptions()
+ bucketizeOptions.Init(buf, pos)
+ return cls.InitFromObj(bucketizeOptions)
+
+ @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, 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
+
+
+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 GeluOptionsAddApproximate(builder, approximate):
+ builder.PrependBoolSlot(0, approximate, 0)
+
+def GeluOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # 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
+
+
+class DynamicUpdateSliceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DynamicUpdateSliceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsDynamicUpdateSliceOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # DynamicUpdateSliceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def DynamicUpdateSliceOptionsStart(builder):
+ builder.StartObject(0)
+
+def DynamicUpdateSliceOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class DynamicUpdateSliceOptionsT(object):
+
+ # DynamicUpdateSliceOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ dynamicUpdateSliceOptions = DynamicUpdateSliceOptions()
+ dynamicUpdateSliceOptions.Init(buf, pos)
+ return cls.InitFromObj(dynamicUpdateSliceOptions)
+
+ @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, dynamicUpdateSliceOptions):
+ x = DynamicUpdateSliceOptionsT()
+ x._UnPack(dynamicUpdateSliceOptions)
+ return x
+
+ # DynamicUpdateSliceOptionsT
+ def _UnPack(self, dynamicUpdateSliceOptions):
+ if dynamicUpdateSliceOptions is None:
+ return
+
+ # DynamicUpdateSliceOptionsT
+ def Pack(self, builder):
+ DynamicUpdateSliceOptionsStart(builder)
+ dynamicUpdateSliceOptions = DynamicUpdateSliceOptionsEnd(builder)
+ return dynamicUpdateSliceOptions
+
+
+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)
+
+def UnsortedSegmentProdOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # UnsortedSegmentProdOptionsT
+ def _UnPack(self, unsortedSegmentProdOptions):
+ if unsortedSegmentProdOptions is None:
+ return
+
+ # UnsortedSegmentProdOptionsT
+ def Pack(self, builder):
+ UnsortedSegmentProdOptionsStart(builder)
+ unsortedSegmentProdOptions = UnsortedSegmentProdOptionsEnd(builder)
+ return unsortedSegmentProdOptions
+
+
+class UnsortedSegmentMaxOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = UnsortedSegmentMaxOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsUnsortedSegmentMaxOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # UnsortedSegmentMaxOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def UnsortedSegmentMaxOptionsStart(builder):
+ builder.StartObject(0)
+
+def UnsortedSegmentMaxOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class UnsortedSegmentMaxOptionsT(object):
+
+ # UnsortedSegmentMaxOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ unsortedSegmentMaxOptions = UnsortedSegmentMaxOptions()
+ unsortedSegmentMaxOptions.Init(buf, pos)
+ return cls.InitFromObj(unsortedSegmentMaxOptions)
+
+ @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, unsortedSegmentMaxOptions):
+ x = UnsortedSegmentMaxOptionsT()
+ x._UnPack(unsortedSegmentMaxOptions)
+ return x
+
+ # UnsortedSegmentMaxOptionsT
+ def _UnPack(self, unsortedSegmentMaxOptions):
+ if unsortedSegmentMaxOptions is None:
+ return
+
+ # UnsortedSegmentMaxOptionsT
+ def Pack(self, builder):
+ UnsortedSegmentMaxOptionsStart(builder)
+ unsortedSegmentMaxOptions = UnsortedSegmentMaxOptionsEnd(builder)
+ return unsortedSegmentMaxOptions
+
+
+class UnsortedSegmentSumOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # UnsortedSegmentSumOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def UnsortedSegmentSumOptionsStart(builder):
+ builder.StartObject(0)
+
+def UnsortedSegmentSumOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class UnsortedSegmentSumOptionsT(object):
+
+ # UnsortedSegmentSumOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ unsortedSegmentSumOptions = UnsortedSegmentSumOptions()
+ unsortedSegmentSumOptions.Init(buf, pos)
+ return cls.InitFromObj(unsortedSegmentSumOptions)
+
+ @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, unsortedSegmentSumOptions):
+ x = UnsortedSegmentSumOptionsT()
+ x._UnPack(unsortedSegmentSumOptions)
+ return x
+
+ # UnsortedSegmentSumOptionsT
+ def _UnPack(self, unsortedSegmentSumOptions):
+ if unsortedSegmentSumOptions is None:
+ return
+
+ # UnsortedSegmentSumOptionsT
+ def Pack(self, builder):
+ UnsortedSegmentSumOptionsStart(builder)
+ unsortedSegmentSumOptions = UnsortedSegmentSumOptionsEnd(builder)
+ return unsortedSegmentSumOptions
+
+
+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 ATan2OptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # ATan2OptionsT
+ def _UnPack(self, atan2Options):
+ if atan2Options is None:
+ return
+
+ # ATan2OptionsT
+ def Pack(self, builder):
+ 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)
+
+def UnsortedSegmentMinOptionsStart(builder):
+ builder.StartObject(0)
+
+def UnsortedSegmentMinOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 = SignOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsSignOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # SignOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SignOptionsStart(builder):
+ builder.StartObject(0)
+
+def SignOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class SignOptionsT(object):
+
+ # SignOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ signOptions = SignOptions()
+ signOptions.Init(buf, pos)
+ return cls.InitFromObj(signOptions)
+
+ @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, signOptions):
+ x = SignOptionsT()
+ x._UnPack(signOptions)
+ return x
+
+ # SignOptionsT
+ def _UnPack(self, signOptions):
+ if signOptions is None:
+ return
+
+ # SignOptionsT
+ def Pack(self, builder):
+ SignOptionsStart(builder)
+ signOptions = SignOptionsEnd(builder)
+ return signOptions
+
+
+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 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 = 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 BitwiseXorOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+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 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
+
+ # BitwiseXorOptionsT
+ def _UnPack(self, bitwiseXorOptions):
+ if bitwiseXorOptions is None:
+ return
+
+ # BitwiseXorOptionsT
+ def Pack(self, builder):
+ BitwiseXorOptionsStart(builder)
+ bitwiseXorOptions = BitwiseXorOptionsEnd(builder)
+ return bitwiseXorOptions
+
+
+class RightShiftOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = RightShiftOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsRightShiftOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # RightShiftOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def RightShiftOptionsStart(builder):
+ builder.StartObject(0)
+
+def RightShiftOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class RightShiftOptionsT(object):
+
+ # RightShiftOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ rightShiftOptions = RightShiftOptions()
+ rightShiftOptions.Init(buf, pos)
+ return cls.InitFromObj(rightShiftOptions)
+
+ @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, rightShiftOptions):
+ x = RightShiftOptionsT()
+ x._UnPack(rightShiftOptions)
+ return x
+
+ # RightShiftOptionsT
+ def _UnPack(self, rightShiftOptions):
+ if rightShiftOptions is None:
+ return
+
+ # RightShiftOptionsT
+ def Pack(self, builder):
+ RightShiftOptionsStart(builder)
+ rightShiftOptions = RightShiftOptionsEnd(builder)
+ return rightShiftOptions
+
+
+class DilateOptions(object):
+ __slots__ = ['_tab']
+
+ @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
+
+ @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)
+
+ # DilateOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def DilateOptionsStart(builder):
+ builder.StartObject(0)
+
+def DilateOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class DilateOptionsT(object):
+
+ # DilateOptionsT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ dilateOptions = DilateOptions()
+ dilateOptions.Init(buf, pos)
+ return cls.InitFromObj(dilateOptions)
+
+ @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, dilateOptions):
+ x = DilateOptionsT()
+ x._UnPack(dilateOptions)
+ return x
+
+ # DilateOptionsT
+ def _UnPack(self, dilateOptions):
+ if dilateOptions is None:
+ return
+
+ # DilateOptionsT
+ def Pack(self, builder):
+ DilateOptionsStart(builder)
+ dilateOptions = DilateOptionsEnd(builder)
+ return dilateOptions
+
+
+class ReduceWindowOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReduceWindowOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsReduceWindowOptions(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # ReduceWindowOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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)
+
+def ReduceWindowOptionsAddReduceFunction(builder, reduceFunction):
+ builder.PrependInt32Slot(0, reduceFunction, 0)
+
+def ReduceWindowOptionsEnd(builder):
+ return builder.EndObject()
+
+
+
+class ReduceWindowOptionsT(object):
+
+ # ReduceWindowOptionsT
+ def __init__(self):
+ self.reduceFunction = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ reduceWindowOptions = ReduceWindowOptions()
+ reduceWindowOptions.Init(buf, pos)
+ return cls.InitFromObj(reduceWindowOptions)
+
+ @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, reduceWindowOptions):
+ x = ReduceWindowOptionsT()
+ x._UnPack(reduceWindowOptions)
+ return x
+
+ # ReduceWindowOptionsT
+ def _UnPack(self, reduceWindowOptions):
+ if reduceWindowOptions is None:
+ return
+ self.reduceFunction = reduceWindowOptions.ReduceFunction()
+
+ # ReduceWindowOptionsT
+ def Pack(self, builder):
+ ReduceWindowOptionsStart(builder)
+ ReduceWindowOptionsAddReduceFunction(builder, self.reduceFunction)
+ reduceWindowOptions = ReduceWindowOptionsEnd(builder)
+ return reduceWindowOptions
+
+
+class OperatorCode(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = OperatorCode()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsOperatorCode(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # OperatorCode
+ 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
+
+ # 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
+
+ # 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 OperatorCodeAddDeprecatedBuiltinCode(builder, deprecatedBuiltinCode):
+ builder.PrependInt8Slot(0, deprecatedBuiltinCode, 0)
+
+def OperatorCodeAddCustomCode(builder, customCode):
+ builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(customCode), 0)
+
+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.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):
+ operatorCode = OperatorCode()
+ operatorCode.Init(buf, pos)
+ return cls.InitFromObj(operatorCode)
+
+ @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, operatorCode):
+ x = OperatorCodeT()
+ x._UnPack(operatorCode)
+ return x
+
+ # 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()
+
+ # OperatorCodeT
+ 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
+
+
+class Operator(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Operator()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsOperator(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # Operator
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # 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.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 0
+
+ # Operator
+ def InputsIsNone(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 0
+
+ # Operator
+ def OutputsIsNone(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 0
+
+ # 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.Uint64Flags, o + self._tab.Pos)
+ return 0
+
+ # 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.Uint8Flags, o + self._tab.Pos)
+ return 0
+
+ # Operator
+ def BuiltinOptions2(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+ if o != 0:
+ from flatbuffers.table import Table
+ obj = Table(bytearray(), 0)
+ self._tab.Union(obj, o)
+ return obj
+ return None
+
+def OperatorStart(builder):
+ builder.StartObject(13)
+
+def OperatorAddOpcodeIndex(builder, opcodeIndex):
+ builder.PrependUint32Slot(0, opcodeIndex, 0)
+
+def OperatorAddInputs(builder, inputs):
+ builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0)
+
+def OperatorStartInputsVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def OperatorAddOutputs(builder, outputs):
+ builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0)
+
+def OperatorStartOutputsVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def OperatorAddBuiltinOptionsType(builder, builtinOptionsType):
+ builder.PrependUint8Slot(3, builtinOptionsType, 0)
+
+def OperatorAddBuiltinOptions(builder, builtinOptions):
+ builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions), 0)
+
+def OperatorAddCustomOptions(builder, customOptions):
+ builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customOptions), 0)
+
+def OperatorStartCustomOptionsVector(builder, numElems):
+ return builder.StartVector(1, numElems, 1)
+
+def OperatorAddCustomOptionsFormat(builder, customOptionsFormat):
+ builder.PrependInt8Slot(6, customOptionsFormat, 0)
+
+def OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs):
+ builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(mutatingVariableInputs), 0)
+
+def OperatorStartMutatingVariableInputsVector(builder, numElems):
+ return builder.StartVector(1, numElems, 1)
+
+def OperatorAddIntermediates(builder, intermediates):
+ builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(intermediates), 0)
+
+def OperatorStartIntermediatesVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def OperatorAddLargeCustomOptionsOffset(builder, largeCustomOptionsOffset):
+ builder.PrependUint64Slot(9, largeCustomOptionsOffset, 0)
+
+def OperatorAddLargeCustomOptionsSize(builder, largeCustomOptionsSize):
+ builder.PrependUint64Slot(10, largeCustomOptionsSize, 0)
+
+def OperatorAddBuiltinOptions2Type(builder, builtinOptions2Type):
+ builder.PrependUint8Slot(11, builtinOptions2Type, 0)
+
+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.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):
+ operator = Operator()
+ operator.Init(buf, pos)
+ return cls.InitFromObj(operator)
+
+ @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, operator):
+ x = OperatorT()
+ x._UnPack(operator)
+ return x
+
+ # OperatorT
+ def _UnPack(self, operator):
+ if operator 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())
+
+ # OperatorT
+ 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
+
class SubGraph(object):
__slots__ = ['_tab']
@@ -15782,39 +17089,40 @@
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)
+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:
@@ -15837,6 +17145,11 @@
return cls.InitFromObj(subGraph)
@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, subGraph):
x = SubGraphT()
x._UnPack(subGraph)
@@ -15927,427 +17240,245 @@
SubGraphAddName(builder, name)
subGraph = SubGraphEnd(builder)
return subGraph
-# automatically generated by the FlatBuffers compiler, do not modify
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class SubOptions(object):
+class Buffer(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = SubOptions()
+ x = Buffer()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsSubOptions(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 SubOptionsBufferHasIdentifier(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)
- # SubOptions
+ # Buffer
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
-
- # 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)
-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
- def __init__(self):
- self.fusedActivationFunction = 0 # type: int
- self.potScaleInt16 = True # type: bool
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- subOptions = SubOptions()
- subOptions.Init(buf, pos)
- return cls.InitFromObj(subOptions)
-
- @classmethod
- def InitFromObj(cls, subOptions):
- x = SubOptionsT()
- x._UnPack(subOptions)
- return x
-
- # SubOptionsT
- def _UnPack(self, subOptions):
- if subOptions is None:
- return
- self.fusedActivationFunction = subOptions.FusedActivationFunction()
- self.potScaleInt16 = subOptions.PotScaleInt16()
-
- # SubOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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):
+ # 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.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
return 0
- # Tensor
- def ShapeAsNumpy(self):
+ # 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.Int32Flags, o)
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
return 0
- # Tensor
- def ShapeLength(self):
+ # 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
- # Tensor
- def ShapeIsNone(self):
+ # Buffer
+ def DataIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
return o == 0
- # Tensor
- def Type(self):
+ # 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.Int8Flags, o + self._tab.Pos)
+ return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
- # Tensor
- def Buffer(self):
+ # 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.Uint32Flags, o + self._tab.Pos)
+ return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
- # Tensor
+def BufferStart(builder):
+ builder.StartObject(3)
+
+def BufferAddData(builder, data):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
+
+def BufferStartDataVector(builder, numElems):
+ return builder.StartVector(1, numElems, 1)
+
+def BufferAddOffset(builder, offset):
+ builder.PrependUint64Slot(1, offset, 0)
+
+def BufferAddSize(builder, size):
+ builder.PrependUint64Slot(2, size, 0)
+
+def BufferEnd(builder):
+ return builder.EndObject()
+
+
+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 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
+
+ # 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
+
+
+class Metadata(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAs(cls, buf, offset=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Metadata()
+ x.Init(buf, n + offset)
+ return x
+
+ @classmethod
+ def GetRootAsMetadata(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):
+ return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+ # Metadata
+ 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(10))
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
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))
+ # Metadata
+ def Buffer(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
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 self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
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
+def MetadataStart(builder):
+ builder.StartObject(2)
- # 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
+def MetadataAddName(builder, name):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
- # Tensor
- def ShapeSignatureIsNone(self):
- o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
- return o == 0
+def MetadataAddBuffer(builder, buffer):
+ builder.PrependUint32Slot(1, buffer, 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
+def MetadataEnd(builder):
+ return builder.EndObject()
- # 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
+class MetadataT(object):
-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):
-
- # TensorT
+ # MetadataT
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]
+ self.buffer = 0 # type: int
@classmethod
def InitFromBuf(cls, buf, pos):
- tensor = Tensor()
- tensor.Init(buf, pos)
- return cls.InitFromObj(tensor)
+ metadata = Metadata()
+ metadata.Init(buf, pos)
+ return cls.InitFromObj(metadata)
@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, metadata):
+ x = MetadataT()
+ x._UnPack(metadata)
return x
- # TensorT
- def _UnPack(self, tensor):
- if tensor is None:
+ # MetadataT
+ def _UnPack(self, metadata):
+ if metadata 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_)
+ self.name = metadata.Name()
+ self.buffer = metadata.Buffer()
- # TensorT
+ # MetadataT
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)
+ MetadataStart(builder)
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
+ MetadataAddName(builder, name)
+ MetadataAddBuffer(builder, self.buffer)
+ metadata = MetadataEnd(builder)
+ return metadata
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
class TensorMap(object):
__slots__ = ['_tab']
@@ -16385,18 +17516,19 @@
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
-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)
+def TensorMapStart(builder):
+ builder.StartObject(2)
+
+def TensorMapAddName(builder, name):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def TensorMapAddTensorIndex(builder, tensorIndex):
+ builder.PrependUint32Slot(1, tensorIndex, 0)
+
+def TensorMapEnd(builder):
+ return builder.EndObject()
+
+
class TensorMapT(object):
@@ -16412,6 +17544,11 @@
return cls.InitFromObj(tensorMap)
@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, tensorMap):
x = TensorMapT()
x._UnPack(tensorMap)
@@ -16434,1600 +17571,593 @@
TensorMapAddTensorIndex(builder, self.tensorIndex)
tensorMap = TensorMapEnd(builder)
return tensorMap
-# automatically generated by the FlatBuffers compiler, do not modify
-# 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
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class TileOptions(object):
+class SignatureDef(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = TileOptions()
+ x = SignatureDef()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsTileOptions(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 TileOptionsBufferHasIdentifier(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)
- # TileOptions
+ # SignatureDef
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)
-
-class TileOptionsT(object):
-
- # TileOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- tileOptions = TileOptions()
- tileOptions.Init(buf, pos)
- return cls.InitFromObj(tileOptions)
-
- @classmethod
- def InitFromObj(cls, tileOptions):
- x = TileOptionsT()
- x._UnPack(tileOptions)
- return x
-
- # TileOptionsT
- def _UnPack(self, tileOptions):
- if tileOptions is None:
- return
-
- # TileOptionsT
- def Pack(self, builder):
- TileOptionsStart(builder)
- tileOptions = TileOptionsEnd(builder)
- return tileOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class TopKV2Options(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = TopKV2Options()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsTopKV2Options(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # TopKV2Options
- 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)
-
-class TopKV2OptionsT(object):
-
- # TopKV2OptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- topKv2options = TopKV2Options()
- topKv2options.Init(buf, pos)
- return cls.InitFromObj(topKv2options)
-
- @classmethod
- def InitFromObj(cls, topKv2options):
- x = TopKV2OptionsT()
- x._UnPack(topKv2options)
- return x
-
- # TopKV2OptionsT
- def _UnPack(self, topKv2options):
- if topKv2options is None:
- return
-
- # TopKV2OptionsT
- def Pack(self, builder):
- TopKV2OptionsStart(builder)
- topKv2options = TopKV2OptionsEnd(builder)
- return topKv2options
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class TransposeConvOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = TransposeConvOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsTransposeConvOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # TransposeConvOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # TransposeConvOptions
- def Padding(self):
+ # SignatureDef
+ def Inputs(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)
- 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
- # 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
-
- # 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
-
- # 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):
-
- # TransposeConvOptionsT
- 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
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- transposeConvOptions = TransposeConvOptions()
- transposeConvOptions.Init(buf, pos)
- return cls.InitFromObj(transposeConvOptions)
-
- @classmethod
- def InitFromObj(cls, transposeConvOptions):
- x = TransposeConvOptionsT()
- x._UnPack(transposeConvOptions)
- return x
-
- # TransposeConvOptionsT
- def _UnPack(self, transposeConvOptions):
- if transposeConvOptions is None:
- return
- self.padding = transposeConvOptions.Padding()
- self.strideW = transposeConvOptions.StrideW()
- self.strideH = transposeConvOptions.StrideH()
- self.fusedActivationFunction = transposeConvOptions.FusedActivationFunction()
- self.quantizedBiasType = transposeConvOptions.QuantizedBiasType()
-
- # TransposeConvOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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)
-
- # TransposeOptions
- 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)
-
-class TransposeOptionsT(object):
-
- # TransposeOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- transposeOptions = TransposeOptions()
- transposeOptions.Init(buf, pos)
- return cls.InitFromObj(transposeOptions)
-
- @classmethod
- def InitFromObj(cls, transposeOptions):
- x = TransposeOptionsT()
- x._UnPack(transposeOptions)
- return x
-
- # TransposeOptionsT
- def _UnPack(self, transposeOptions):
- if transposeOptions is None:
- return
-
- # TransposeOptionsT
- def Pack(self, builder):
- TransposeOptionsStart(builder)
- transposeOptions = TransposeOptionsEnd(builder)
- return transposeOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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):
+ # 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
- # Uint16Vector
- def ValuesIsNone(self):
+ # SignatureDef
+ def InputsIsNone(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
return o == 0
-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
-
-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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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))
+ # SignatureDef
+ def Outputs(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 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
- # 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))
+ # 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
- # Uint8Vector
- def ValuesIsNone(self):
- o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ # SignatureDef
+ def OutputsIsNone(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)
+ # 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
+
+ # 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 SignatureDefAddInputs(builder, inputs):
+ builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0)
+
+def SignatureDefStartInputsVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def SignatureDefAddOutputs(builder, outputs):
+ builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0)
+
+def SignatureDefStartOutputsVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def SignatureDefAddSignatureKey(builder, signatureKey):
+ builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(signatureKey), 0)
+
+def SignatureDefAddSubgraphIndex(builder, subgraphIndex):
+ builder.PrependUint32Slot(4, subgraphIndex, 0)
+
+def SignatureDefEnd(builder):
+ return builder.EndObject()
+
+
try:
from typing import List
except:
pass
-class Uint8VectorT(object):
+class SignatureDefT(object):
- # Uint8VectorT
+ # SignatureDefT
def __init__(self):
- self.values = None # type: List[int]
+ 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):
- uint8vector = Uint8Vector()
- uint8vector.Init(buf, pos)
- return cls.InitFromObj(uint8vector)
+ signatureDef = SignatureDef()
+ signatureDef.Init(buf, pos)
+ return cls.InitFromObj(signatureDef)
@classmethod
- def InitFromObj(cls, uint8vector):
- x = Uint8VectorT()
- x._UnPack(uint8vector)
+ 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
- # Uint8VectorT
- def _UnPack(self, uint8vector):
- if uint8vector is None:
+ # SignatureDefT
+ def _UnPack(self, signatureDef):
+ if signatureDef 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()
+ 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()
- # Uint8VectorT
+ # SignatureDefT
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
+ 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
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class UnidirectionalSequenceLSTMOptions(object):
+class Model(object):
__slots__ = ['_tab']
@classmethod
def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = UnidirectionalSequenceLSTMOptions()
+ x = Model()
x.Init(buf, n + offset)
return x
@classmethod
- def GetRootAsUnidirectionalSequenceLSTMOptions(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 UnidirectionalSequenceLSTMOptionsBufferHasIdentifier(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)
- # UnidirectionalSequenceLSTMOptions
+ # Model
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
- # UnidirectionalSequenceLSTMOptions
- def FusedActivationFunction(self):
+ # 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.Int8Flags, o + self._tab.Pos)
+ return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
return 0
- # UnidirectionalSequenceLSTMOptions
- def CellClip(self):
+ # Model
+ def OperatorCodes(self, j):
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
+ 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
- # UnidirectionalSequenceLSTMOptions
- def ProjClip(self):
+ # 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:
- return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
- return 0.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
- # UnidirectionalSequenceLSTMOptions
- def TimeMajor(self):
+ # 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 bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
- return False
+ return self._tab.String(o + self._tab.Pos)
+ return None
- # UnidirectionalSequenceLSTMOptions
- def AsymmetricQuantizeInputs(self):
+ # Model
+ def Buffers(self, j):
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
+ 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
- # UnidirectionalSequenceLSTMOptions
- def DiagonalRecurrentTensors(self):
+ # 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:
- return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
- return False
-
-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)
-
-class UnidirectionalSequenceLSTMOptionsT(object):
-
- # 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
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- unidirectionalSequenceLstmoptions = UnidirectionalSequenceLSTMOptions()
- unidirectionalSequenceLstmoptions.Init(buf, pos)
- return cls.InitFromObj(unidirectionalSequenceLstmoptions)
-
- @classmethod
- def InitFromObj(cls, unidirectionalSequenceLstmoptions):
- x = UnidirectionalSequenceLSTMOptionsT()
- x._UnPack(unidirectionalSequenceLstmoptions)
- return x
-
- # 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()
-
- # 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
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class UniqueOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # UniqueOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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 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)
-
-class UniqueOptionsT(object):
-
- # UniqueOptionsT
- def __init__(self):
- self.idxOutType = 2 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- uniqueOptions = UniqueOptions()
- uniqueOptions.Init(buf, pos)
- return cls.InitFromObj(uniqueOptions)
-
- @classmethod
- def InitFromObj(cls, uniqueOptions):
- x = UniqueOptionsT()
- x._UnPack(uniqueOptions)
- return x
-
- # UniqueOptionsT
- def _UnPack(self, uniqueOptions):
- if uniqueOptions is None:
- return
- self.idxOutType = uniqueOptions.IdxOutType()
-
- # UniqueOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class UnpackOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = UnpackOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsUnpackOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # UnpackOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # 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)
-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)
-
-class UnpackOptionsT(object):
-
- # UnpackOptionsT
- def __init__(self):
- self.num = 0 # type: int
- self.axis = 0 # type: int
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- unpackOptions = UnpackOptions()
- unpackOptions.Init(buf, pos)
- return cls.InitFromObj(unpackOptions)
-
- @classmethod
- def InitFromObj(cls, unpackOptions):
- x = UnpackOptionsT()
- x._UnPack(unpackOptions)
- return x
-
- # UnpackOptionsT
- def _UnPack(self, unpackOptions):
- if unpackOptions is None:
- return
- self.num = unpackOptions.Num()
- self.axis = unpackOptions.Axis()
-
- # UnpackOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class UnsortedSegmentMaxOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = UnsortedSegmentMaxOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsUnsortedSegmentMaxOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # UnsortedSegmentMaxOptions
- 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)
-
-class UnsortedSegmentMaxOptionsT(object):
-
- # UnsortedSegmentMaxOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- unsortedSegmentMaxOptions = UnsortedSegmentMaxOptions()
- unsortedSegmentMaxOptions.Init(buf, pos)
- return cls.InitFromObj(unsortedSegmentMaxOptions)
-
- @classmethod
- def InitFromObj(cls, unsortedSegmentMaxOptions):
- x = UnsortedSegmentMaxOptionsT()
- x._UnPack(unsortedSegmentMaxOptions)
- return x
-
- # UnsortedSegmentMaxOptionsT
- def _UnPack(self, unsortedSegmentMaxOptions):
- if unsortedSegmentMaxOptions is None:
- return
-
- # UnsortedSegmentMaxOptionsT
- def Pack(self, builder):
- UnsortedSegmentMaxOptionsStart(builder)
- unsortedSegmentMaxOptions = UnsortedSegmentMaxOptionsEnd(builder)
- return unsortedSegmentMaxOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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)
-
-def UnsortedSegmentMinOptionsStart(builder): builder.StartObject(0)
-def Start(builder):
- return UnsortedSegmentMinOptionsStart(builder)
-def UnsortedSegmentMinOptionsEnd(builder): return builder.EndObject()
-def End(builder):
- return UnsortedSegmentMinOptionsEnd(builder)
-
-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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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)
-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
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class UnsortedSegmentSumOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # 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):
-
- # UnsortedSegmentSumOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- unsortedSegmentSumOptions = UnsortedSegmentSumOptions()
- unsortedSegmentSumOptions.Init(buf, pos)
- return cls.InitFromObj(unsortedSegmentSumOptions)
-
- @classmethod
- def InitFromObj(cls, unsortedSegmentSumOptions):
- x = UnsortedSegmentSumOptionsT()
- x._UnPack(unsortedSegmentSumOptions)
- return x
-
- # UnsortedSegmentSumOptionsT
- def _UnPack(self, unsortedSegmentSumOptions):
- if unsortedSegmentSumOptions is None:
- return
-
- # UnsortedSegmentSumOptionsT
- def Pack(self, builder):
- UnsortedSegmentSumOptionsStart(builder)
- unsortedSegmentSumOptions = UnsortedSegmentSumOptionsEnd(builder)
- return unsortedSegmentSumOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class VarHandleOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = VarHandleOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsVarHandleOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # VarHandleOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
- # VarHandleOptions
- def Container(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):
- 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 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)
-
-class VarHandleOptionsT(object):
-
- # VarHandleOptionsT
- def __init__(self):
- self.container = None # type: str
- self.sharedName = None # type: str
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- varHandleOptions = VarHandleOptions()
- varHandleOptions.Init(buf, pos)
- return cls.InitFromObj(varHandleOptions)
-
- @classmethod
- def InitFromObj(cls, varHandleOptions):
- x = VarHandleOptionsT()
- x._UnPack(varHandleOptions)
- return x
-
- # VarHandleOptionsT
- def _UnPack(self, varHandleOptions):
- if varHandleOptions is None:
- return
- self.container = varHandleOptions.Container()
- self.sharedName = varHandleOptions.SharedName()
-
- # VarHandleOptionsT
- 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
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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))
+ # 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
- # VariantSubType
- def ShapeLength(self):
- o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ # 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
- # VariantSubType
- def ShapeIsNone(self):
- o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ # Model
+ def MetadataBufferIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
return o == 0
- # VariantSubType
- def Type(self):
- o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ # Model
+ def Metadata(self, j):
+ 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)
+ 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.VectorLen(o)
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
+ # Model
+ def MetadataIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ return o == 0
-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)
+ # 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
+
+ # 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
+
+ # Model
+ def SignatureDefsIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+ return o == 0
+
+def ModelStart(builder):
+ builder.StartObject(8)
+
+def ModelAddVersion(builder, version):
+ builder.PrependUint32Slot(0, version, 0)
+
+def ModelAddOperatorCodes(builder, operatorCodes):
+ builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operatorCodes), 0)
+
+def ModelStartOperatorCodesVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ModelAddSubgraphs(builder, subgraphs):
+ builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subgraphs), 0)
+
+def ModelStartSubgraphsVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ModelAddDescription(builder, description):
+ builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0)
+
+def ModelAddBuffers(builder, buffers):
+ builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(buffers), 0)
+
+def ModelStartBuffersVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ModelAddMetadataBuffer(builder, metadataBuffer):
+ builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(metadataBuffer), 0)
+
+def ModelStartMetadataBufferVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ModelAddMetadata(builder, metadata):
+ builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(metadata), 0)
+
+def ModelStartMetadataVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ModelAddSignatureDefs(builder, signatureDefs):
+ builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(signatureDefs), 0)
+
+def ModelStartSignatureDefsVector(builder, numElems):
+ return builder.StartVector(4, numElems, 4)
+
+def ModelEnd(builder):
+ return builder.EndObject()
+
+
try:
from typing import List
except:
pass
-class VariantSubTypeT(object):
+class ModelT(object):
- # VariantSubTypeT
+ # ModelT
def __init__(self):
- self.shape = None # type: List[int]
- self.type = 0 # type: int
- self.hasRank = False # type: bool
+ 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):
- variantSubType = VariantSubType()
- variantSubType.Init(buf, pos)
- return cls.InitFromObj(variantSubType)
+ model = Model()
+ model.Init(buf, pos)
+ return cls.InitFromObj(model)
@classmethod
- def InitFromObj(cls, variantSubType):
- x = VariantSubTypeT()
- x._UnPack(variantSubType)
+ 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
- # VariantSubTypeT
- def _UnPack(self, variantSubType):
- if variantSubType is None:
+ # ModelT
+ def _UnPack(self, model):
+ if model is None:
return
- if not variantSubType.ShapeIsNone():
+ 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.shape = []
- for i in range(variantSubType.ShapeLength()):
- self.shape.append(variantSubType.Shape(i))
+ self.metadataBuffer = []
+ for i in range(model.MetadataBufferLength()):
+ self.metadataBuffer.append(model.MetadataBuffer(i))
else:
- self.shape = variantSubType.ShapeAsNumpy()
- self.type = variantSubType.Type()
- self.hasRank = variantSubType.HasRank()
+ 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_)
- # VariantSubTypeT
+ # ModelT
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)
+ 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:
- 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
+ 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
-# namespace: tflite
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class WhereOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # WhereOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
-def WhereOptionsStart(builder): builder.StartObject(0)
-def Start(builder):
- return WhereOptionsStart(builder)
-def WhereOptionsEnd(builder): return builder.EndObject()
-def End(builder):
- return WhereOptionsEnd(builder)
-
-class WhereOptionsT(object):
-
- # WhereOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- whereOptions = WhereOptions()
- whereOptions.Init(buf, pos)
- return cls.InitFromObj(whereOptions)
-
- @classmethod
- def InitFromObj(cls, whereOptions):
- x = WhereOptionsT()
- x._UnPack(whereOptions)
- return x
-
- # WhereOptionsT
- def _UnPack(self, whereOptions):
- if whereOptions is None:
- return
-
- # WhereOptionsT
- def Pack(self, builder):
- WhereOptionsStart(builder)
- whereOptions = WhereOptionsEnd(builder)
- return whereOptions
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class WhileOptions(object):
- __slots__ = ['_tab']
-
- @classmethod
- def GetRootAs(cls, buf, offset=0):
- n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
- x = WhileOptions()
- x.Init(buf, n + offset)
- return x
-
- @classmethod
- def GetRootAsWhileOptions(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):
- return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
-
- # WhileOptions
- 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))
- if o != 0:
- return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
- return 0
-
- # WhileOptions
- 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 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)
-
-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 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
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tflite
-
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-class ZerosLikeOptions(object):
- __slots__ = ['_tab']
-
- @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
-
- @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)
-
- # ZerosLikeOptions
- def Init(self, buf, pos):
- self._tab = flatbuffers.table.Table(buf, pos)
-
-def ZerosLikeOptionsStart(builder): builder.StartObject(0)
-def Start(builder):
- return ZerosLikeOptionsStart(builder)
-def ZerosLikeOptionsEnd(builder): return builder.EndObject()
-def End(builder):
- return ZerosLikeOptionsEnd(builder)
-
-class ZerosLikeOptionsT(object):
-
- # ZerosLikeOptionsT
- def __init__(self):
- pass
-
- @classmethod
- def InitFromBuf(cls, buf, pos):
- zerosLikeOptions = ZerosLikeOptions()
- zerosLikeOptions.Init(buf, pos)
- return cls.InitFromObj(zerosLikeOptions)
-
- @classmethod
- def InitFromObj(cls, zerosLikeOptions):
- x = ZerosLikeOptionsT()
- x._UnPack(zerosLikeOptions)
- return x
-
- # ZerosLikeOptionsT
- def _UnPack(self, zerosLikeOptions):
- if zerosLikeOptions is None:
- return
-
- # ZerosLikeOptionsT
- def Pack(self, builder):
- ZerosLikeOptionsStart(builder)
- zerosLikeOptions = ZerosLikeOptionsEnd(builder)
- return zerosLikeOptions
diff --git a/tensorflow/lite/schema/schema_generated.h b/tensorflow/lite/schema/schema_generated.h
index e8adbfd..758e6ee 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 *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<size_t>(e);
return EnumNamesTensorType()[index];
}
@@ -770,7 +770,7 @@
}
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<size_t>(e);
return EnumNamesQuantizationDetails()[index];
}
@@ -818,8 +818,8 @@
}
}
- static void *UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver);
- flatbuffers::Offset<void> 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<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
tflite::CustomQuantizationT *AsCustomQuantization() {
return type == QuantizationDetails_CustomQuantization ?
@@ -831,8 +831,8 @@
}
};
-bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type);
-bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+bool VerifyQuantizationDetails(::flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type);
+bool VerifyQuantizationDetailsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum DimensionType : int8_t {
DimensionType_DENSE = 0,
@@ -859,7 +859,7 @@
}
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<size_t>(e);
return EnumNamesDimensionType()[index];
}
@@ -895,7 +895,7 @@
}
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<size_t>(e);
return EnumNamesSparseIndexVector()[index];
}
@@ -959,8 +959,8 @@
}
}
- static void *UnPack(const void *obj, SparseIndexVector type, const flatbuffers::resolver_function_t *resolver);
- flatbuffers::Offset<void> 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<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
tflite::Int32VectorT *AsInt32Vector() {
return type == SparseIndexVector_Int32Vector ?
@@ -988,8 +988,8 @@
}
};
-bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type);
-bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+bool VerifySparseIndexVector(::flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type);
+bool VerifySparseIndexVectorVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum BuiltinOperator : int32_t {
BuiltinOperator_ADD = 0,
@@ -1628,7 +1628,7 @@
}
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<size_t>(e);
return EnumNamesBuiltinOperator()[index];
}
@@ -2033,7 +2033,7 @@
}
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<size_t>(e);
return EnumNamesBuiltinOptions()[index];
}
@@ -3081,8 +3081,8 @@
}
}
- static void *UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver);
- flatbuffers::Offset<void> 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<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
tflite::Conv2DOptionsT *AsConv2DOptions() {
return type == BuiltinOptions_Conv2DOptions ?
@@ -4094,8 +4094,8 @@
}
};
-bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
-bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+bool VerifyBuiltinOptions(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
+bool VerifyBuiltinOptionsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum BuiltinOptions2 : uint8_t {
BuiltinOptions2_NONE = 0,
@@ -4179,7 +4179,7 @@
}
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<size_t>(e);
return EnumNamesBuiltinOptions2()[index];
}
@@ -4379,8 +4379,8 @@
}
}
- static void *UnPack(const void *obj, BuiltinOptions2 type, const flatbuffers::resolver_function_t *resolver);
- flatbuffers::Offset<void> 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<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
tflite::StablehloConcatenateOptionsT *AsStablehloConcatenateOptions() {
return type == BuiltinOptions2_StablehloConcatenateOptions ?
@@ -4544,8 +4544,8 @@
}
};
-bool VerifyBuiltinOptions2(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions2 type);
-bool VerifyBuiltinOptions2Vector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+bool VerifyBuiltinOptions2(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions2 type);
+bool VerifyBuiltinOptions2Vector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum StablehloPrecisionConfig : uint32_t {
StablehloPrecisionConfig_DEFAULT = 0,
@@ -4575,7 +4575,7 @@
}
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<size_t>(e);
return EnumNamesStablehloPrecisionConfig()[index];
}
@@ -4617,7 +4617,7 @@
}
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<size_t>(e);
return EnumNamesStablehloComparisonDirection()[index];
}
@@ -4656,7 +4656,7 @@
}
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<size_t>(e);
return EnumNamesStablehloComparisonType()[index];
}
@@ -4689,7 +4689,7 @@
}
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<size_t>(e);
return EnumNamesRngAlgorithm()[index];
}
@@ -4719,7 +4719,7 @@
}
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<size_t>(e);
return EnumNamesPadding()[index];
}
@@ -4761,7 +4761,7 @@
}
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<size_t>(e);
return EnumNamesActivationFunctionType()[index];
}
@@ -4794,7 +4794,7 @@
}
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<size_t>(e);
return EnumNamesLSHProjectionType()[index];
}
@@ -4824,7 +4824,7 @@
}
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<size_t>(e);
return EnumNamesFullyConnectedOptionsWeightsFormat()[index];
}
@@ -4854,7 +4854,7 @@
}
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<size_t>(e);
return EnumNamesLSTMKernelType()[index];
}
@@ -4887,7 +4887,7 @@
}
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<size_t>(e);
return EnumNamesCombinerType()[index];
}
@@ -4917,7 +4917,7 @@
}
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<size_t>(e);
return EnumNamesMirrorPadMode()[index];
}
@@ -4962,7 +4962,7 @@
}
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<size_t>(e);
return EnumNamesReduceWindowFunction()[index];
}
@@ -4989,64 +4989,64 @@
}
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<size_t>(e);
return EnumNamesCustomOptionsFormat()[index];
}
-struct CustomQuantizationT : public flatbuffers::NativeTable {
+struct CustomQuantizationT : public ::flatbuffers::NativeTable {
typedef CustomQuantization TableType;
std::vector<uint8_t> 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<uint8_t> *custom() const {
- return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
+ const ::flatbuffers::Vector<uint8_t> *custom() const {
+ return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(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<CustomQuantization> 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<CustomQuantization> 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<flatbuffers::Vector<uint8_t>> custom) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_custom(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom) {
fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
}
- explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit CustomQuantizationBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<CustomQuantization> Finish() {
+ ::flatbuffers::Offset<CustomQuantization> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<CustomQuantization>(end);
+ auto o = ::flatbuffers::Offset<CustomQuantization>(end);
return o;
}
};
-inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0) {
+inline ::flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom = 0) {
CustomQuantizationBuilder builder_(_fbb);
builder_.add_custom(custom);
return builder_.Finish();
}
-inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *custom = nullptr) {
if (custom) { _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), 16); }
auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : 0;
@@ -5055,9 +5055,9 @@
custom__);
}
-flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<CustomQuantization> 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<float> min{};
std::vector<float> max{};
@@ -5067,7 +5067,7 @@
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 @@
VT_DETAILS = 14,
VT_QUANTIZED_DIMENSION = 16
};
- const flatbuffers::Vector<float> *min() const {
- return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
+ const ::flatbuffers::Vector<float> *min() const {
+ return GetPointer<const ::flatbuffers::Vector<float> *>(VT_MIN);
}
- const flatbuffers::Vector<float> *max() const {
- return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
+ const ::flatbuffers::Vector<float> *max() const {
+ return GetPointer<const ::flatbuffers::Vector<float> *>(VT_MAX);
}
- const flatbuffers::Vector<float> *scale() const {
- return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
+ const ::flatbuffers::Vector<float> *scale() const {
+ return GetPointer<const ::flatbuffers::Vector<float> *>(VT_SCALE);
}
- const flatbuffers::Vector<int64_t> *zero_point() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
+ const ::flatbuffers::Vector<int64_t> *zero_point() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
}
tflite::QuantizationDetails details_type() const {
return static_cast<tflite::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
@@ -5104,7 +5104,7 @@
int32_t quantized_dimension() const {
return GetField<int32_t>(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 @@
VerifyField<int32_t>(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<QuantizationParameters> 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<QuantizationParameters> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
template<> inline const tflite::CustomQuantization *QuantizationParameters::details_as<tflite::CustomQuantization>() const {
@@ -5131,48 +5131,48 @@
struct QuantizationParametersBuilder {
typedef QuantizationParameters Table;
- flatbuffers::FlatBufferBuilder &fbb_;
- flatbuffers::uoffset_t start_;
- void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_min(::flatbuffers::Offset<::flatbuffers::Vector<float>> min) {
fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
}
- void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max) {
+ void add_max(::flatbuffers::Offset<::flatbuffers::Vector<float>> max) {
fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
}
- void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale) {
+ void add_scale(::flatbuffers::Offset<::flatbuffers::Vector<float>> scale) {
fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
}
- void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point) {
+ void add_zero_point(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> zero_point) {
fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
}
void add_details_type(tflite::QuantizationDetails details_type) {
fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0);
}
- void add_details(flatbuffers::Offset<void> details) {
+ void add_details(::flatbuffers::Offset<void> details) {
fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
}
void add_quantized_dimension(int32_t quantized_dimension) {
fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, 0);
}
- explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit QuantizationParametersBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<QuantizationParameters> Finish() {
+ ::flatbuffers::Offset<QuantizationParameters> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<QuantizationParameters>(end);
+ auto o = ::flatbuffers::Offset<QuantizationParameters>(end);
return o;
}
};
-inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<float>> min = 0,
- flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
- flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0,
+inline ::flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<float>> min = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<float>> max = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<float>> scale = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> zero_point = 0,
tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE,
- flatbuffers::Offset<void> details = 0,
+ ::flatbuffers::Offset<void> details = 0,
int32_t quantized_dimension = 0) {
QuantizationParametersBuilder builder_(_fbb);
builder_.add_quantized_dimension(quantized_dimension);
@@ -5185,14 +5185,14 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<float> *min = nullptr,
const std::vector<float> *max = nullptr,
const std::vector<float> *scale = nullptr,
const std::vector<int64_t> *zero_point = nullptr,
tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE,
- flatbuffers::Offset<void> details = 0,
+ ::flatbuffers::Offset<void> details = 0,
int32_t quantized_dimension = 0) {
auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
@@ -5209,61 +5209,61 @@
quantized_dimension);
}
-flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<QuantizationParameters> 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<int32_t> 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<int32_t> *values() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
+ const ::flatbuffers::Vector<int32_t> *values() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(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<Int32Vector> 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<Int32Vector> 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<flatbuffers::Vector<int32_t>> values) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_values(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> values) {
fbb_.AddOffset(Int32Vector::VT_VALUES, values);
}
- explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit Int32VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<Int32Vector> Finish() {
+ ::flatbuffers::Offset<Int32Vector> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Int32Vector>(end);
+ auto o = ::flatbuffers::Offset<Int32Vector>(end);
return o;
}
};
-inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = 0) {
+inline ::flatbuffers::Offset<Int32Vector> CreateInt32Vector(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> values = 0) {
Int32VectorBuilder builder_(_fbb);
builder_.add_values(values);
return builder_.Finish();
}
-inline flatbuffers::Offset<Int32Vector> CreateInt32VectorDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Int32Vector> CreateInt32VectorDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *values = nullptr) {
auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : 0;
return tflite::CreateInt32Vector(
@@ -5271,61 +5271,61 @@
values__);
}
-flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Int32Vector> 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<uint16_t> 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<uint16_t> *values() const {
- return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
+ const ::flatbuffers::Vector<uint16_t> *values() const {
+ return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(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<Uint16Vector> 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<Uint16Vector> 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<flatbuffers::Vector<uint16_t>> values) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_values(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> values) {
fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
}
- explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit Uint16VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<Uint16Vector> Finish() {
+ ::flatbuffers::Offset<Uint16Vector> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Uint16Vector>(end);
+ auto o = ::flatbuffers::Offset<Uint16Vector>(end);
return o;
}
};
-inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = 0) {
+inline ::flatbuffers::Offset<Uint16Vector> CreateUint16Vector(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> values = 0) {
Uint16VectorBuilder builder_(_fbb);
builder_.add_values(values);
return builder_.Finish();
}
-inline flatbuffers::Offset<Uint16Vector> CreateUint16VectorDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Uint16Vector> CreateUint16VectorDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint16_t> *values = nullptr) {
if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), 4); }
auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : 0;
@@ -5334,61 +5334,61 @@
values__);
}
-flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Uint16Vector> 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<uint8_t> 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<uint8_t> *values() const {
- return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
+ const ::flatbuffers::Vector<uint8_t> *values() const {
+ return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(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<Uint8Vector> 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<Uint8Vector> 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<flatbuffers::Vector<uint8_t>> values) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_values(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values) {
fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
}
- explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit Uint8VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<Uint8Vector> Finish() {
+ ::flatbuffers::Offset<Uint8Vector> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Uint8Vector>(end);
+ auto o = ::flatbuffers::Offset<Uint8Vector>(end);
return o;
}
};
-inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = 0) {
+inline ::flatbuffers::Offset<Uint8Vector> CreateUint8Vector(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values = 0) {
Uint8VectorBuilder builder_(_fbb);
builder_.add_values(values);
return builder_.Finish();
}
-inline flatbuffers::Offset<Uint8Vector> CreateUint8VectorDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Uint8Vector> CreateUint8VectorDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *values = nullptr) {
if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), 4); }
auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : 0;
@@ -5397,9 +5397,9 @@
values__);
}
-flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Uint8Vector> 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 @@
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 @@
const tflite::Uint8Vector *array_indices_as_Uint8Vector() const {
return array_indices_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector *>(array_indices()) : nullptr;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FORMAT, 1) &&
VerifyField<int32_t>(verifier, VT_DENSE_SIZE, 4) &&
@@ -5468,9 +5468,9 @@
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<DimensionMetadata> 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<DimensionMetadata> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
template<> inline const tflite::Int32Vector *DimensionMetadata::array_segments_as<tflite::Int32Vector>() const {
@@ -5499,8 +5499,8 @@
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<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
}
@@ -5510,34 +5510,34 @@
void add_array_segments_type(tflite::SparseIndexVector array_segments_type) {
fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE, static_cast<uint8_t>(array_segments_type), 0);
}
- void add_array_segments(flatbuffers::Offset<void> array_segments) {
+ void add_array_segments(::flatbuffers::Offset<void> array_segments) {
fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
}
void add_array_indices_type(tflite::SparseIndexVector array_indices_type) {
fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE, static_cast<uint8_t>(array_indices_type), 0);
}
- void add_array_indices(flatbuffers::Offset<void> array_indices) {
+ void add_array_indices(::flatbuffers::Offset<void> 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<DimensionMetadata> Finish() {
+ ::flatbuffers::Offset<DimensionMetadata> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<DimensionMetadata>(end);
+ auto o = ::flatbuffers::Offset<DimensionMetadata>(end);
return o;
}
};
-inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<DimensionMetadata> 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<void> array_segments = 0,
+ ::flatbuffers::Offset<void> array_segments = 0,
tflite::SparseIndexVector array_indices_type = tflite::SparseIndexVector_NONE,
- flatbuffers::Offset<void> array_indices = 0) {
+ ::flatbuffers::Offset<void> array_indices = 0) {
DimensionMetadataBuilder builder_(_fbb);
builder_.add_array_indices(array_indices);
builder_.add_array_segments(array_segments);
@@ -5548,9 +5548,9 @@
return builder_.Finish();
}
-flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<DimensionMetadata> 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<int32_t> traversal_order{};
std::vector<int32_t> block_map{};
@@ -5561,7 +5561,7 @@
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 @@
VT_BLOCK_MAP = 6,
VT_DIM_METADATA = 8
};
- const flatbuffers::Vector<int32_t> *traversal_order() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
+ const ::flatbuffers::Vector<int32_t> *traversal_order() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
}
- const flatbuffers::Vector<int32_t> *block_map() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
+ const ::flatbuffers::Vector<int32_t> *block_map() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> *>(VT_DIM_METADATA);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>> *>(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 @@
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<SparsityParameters> 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<SparsityParameters> 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<flatbuffers::Vector<int32_t>> traversal_order) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_traversal_order(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> traversal_order) {
fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
}
- void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map) {
+ void add_block_map(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> block_map) {
fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
}
- void add_dim_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata) {
+ void add_dim_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>>> 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<SparsityParameters> Finish() {
+ ::flatbuffers::Offset<SparsityParameters> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SparsityParameters>(end);
+ auto o = ::flatbuffers::Offset<SparsityParameters>(end);
return o;
}
};
-inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata = 0) {
+inline ::flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> traversal_order = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> block_map = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata = 0) {
SparsityParametersBuilder builder_(_fbb);
builder_.add_dim_metadata(dim_metadata);
builder_.add_block_map(block_map);
@@ -5630,14 +5630,14 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *traversal_order = nullptr,
const std::vector<int32_t> *block_map = nullptr,
- const std::vector<flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata = nullptr) {
+ const std::vector<::flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata = nullptr) {
auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0;
auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0;
- auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>>(*dim_metadata) : 0;
+ auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<::flatbuffers::Offset<tflite::DimensionMetadata>>(*dim_metadata) : 0;
return tflite::CreateSparsityParameters(
_fbb,
traversal_order__,
@@ -5645,16 +5645,16 @@
dim_metadata__);
}
-flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SparsityParameters> 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<int32_t> 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 @@
VT_TYPE = 6,
VT_HAS_RANK = 8
};
- const flatbuffers::Vector<int32_t> *shape() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
+ const ::flatbuffers::Vector<int32_t> *shape() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
}
tflite::TensorType type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, 0));
@@ -5671,7 +5671,7 @@
bool has_rank() const {
return GetField<uint8_t>(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 @@
VerifyField<uint8_t>(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<VariantSubType> 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<VariantSubType> 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<flatbuffers::Vector<int32_t>> shape) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
fbb_.AddOffset(VariantSubType::VT_SHAPE, shape);
}
void add_type(tflite::TensorType type) {
@@ -5697,20 +5697,20 @@
void add_has_rank(bool has_rank) {
fbb_.AddElement<uint8_t>(VariantSubType::VT_HAS_RANK, static_cast<uint8_t>(has_rank), 0);
}
- explicit VariantSubTypeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit VariantSubTypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<VariantSubType> Finish() {
+ ::flatbuffers::Offset<VariantSubType> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<VariantSubType>(end);
+ auto o = ::flatbuffers::Offset<VariantSubType>(end);
return o;
}
};
-inline flatbuffers::Offset<VariantSubType> CreateVariantSubType(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
+inline ::flatbuffers::Offset<VariantSubType> CreateVariantSubType(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
tflite::TensorType type = tflite::TensorType_FLOAT32,
bool has_rank = false) {
VariantSubTypeBuilder builder_(_fbb);
@@ -5720,8 +5720,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<VariantSubType> CreateVariantSubTypeDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<VariantSubType> CreateVariantSubTypeDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *shape = nullptr,
tflite::TensorType type = tflite::TensorType_FLOAT32,
bool has_rank = false) {
@@ -5733,9 +5733,9 @@
has_rank);
}
-flatbuffers::Offset<VariantSubType> CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<VariantSubType> 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<int32_t> shape{};
tflite::TensorType type = tflite::TensorType_FLOAT32;
@@ -5753,7 +5753,7 @@
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 @@
VT_HAS_RANK = 20,
VT_VARIANT_TENSORS = 22
};
- const flatbuffers::Vector<int32_t> *shape() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
+ const ::flatbuffers::Vector<int32_t> *shape() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
}
tflite::TensorType type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, 0));
@@ -5777,8 +5777,8 @@
uint32_t buffer() const {
return GetField<uint32_t>(VT_BUFFER, 0);
}
- const flatbuffers::String *name() const {
- return GetPointer<const flatbuffers::String *>(VT_NAME);
+ const ::flatbuffers::String *name() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
const tflite::QuantizationParameters *quantization() const {
return GetPointer<const tflite::QuantizationParameters *>(VT_QUANTIZATION);
@@ -5789,16 +5789,16 @@
const tflite::SparsityParameters *sparsity() const {
return GetPointer<const tflite::SparsityParameters *>(VT_SPARSITY);
}
- const flatbuffers::Vector<int32_t> *shape_signature() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
+ const ::flatbuffers::Vector<int32_t> *shape_signature() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
}
bool has_rank() const {
return GetField<uint8_t>(VT_HAS_RANK, 0) != 0;
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>> *variant_tensors() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>> *>(VT_VARIANT_TENSORS);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>> *variant_tensors() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>> *>(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 @@
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<Tensor> 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<Tensor> 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<flatbuffers::Vector<int32_t>> shape) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
fbb_.AddOffset(Tensor::VT_SHAPE, shape);
}
void add_type(tflite::TensorType type) {
@@ -5837,50 +5837,50 @@
void add_buffer(uint32_t buffer) {
fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0);
}
- void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+ void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(Tensor::VT_NAME, name);
}
- void add_quantization(flatbuffers::Offset<tflite::QuantizationParameters> quantization) {
+ void add_quantization(::flatbuffers::Offset<tflite::QuantizationParameters> quantization) {
fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
}
void add_is_variable(bool is_variable) {
fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
}
- void add_sparsity(flatbuffers::Offset<tflite::SparsityParameters> sparsity) {
+ void add_sparsity(::flatbuffers::Offset<tflite::SparsityParameters> sparsity) {
fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
}
- void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature) {
+ void add_shape_signature(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape_signature) {
fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
}
void add_has_rank(bool has_rank) {
fbb_.AddElement<uint8_t>(Tensor::VT_HAS_RANK, static_cast<uint8_t>(has_rank), 0);
}
- void add_variant_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors) {
+ void add_variant_tensors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>>> 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<Tensor> Finish() {
+ ::flatbuffers::Offset<Tensor> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Tensor>(end);
+ auto o = ::flatbuffers::Offset<Tensor>(end);
return o;
}
};
-inline flatbuffers::Offset<Tensor> CreateTensor(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
+inline ::flatbuffers::Offset<Tensor> CreateTensor(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
tflite::TensorType type = tflite::TensorType_FLOAT32,
uint32_t buffer = 0,
- flatbuffers::Offset<flatbuffers::String> name = 0,
- flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
+ ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+ ::flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
bool is_variable = false,
- flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = 0,
+ ::flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape_signature = 0,
bool has_rank = false,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors = 0) {
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors = 0) {
TensorBuilder builder_(_fbb);
builder_.add_variant_tensors(variant_tensors);
builder_.add_shape_signature(shape_signature);
@@ -5895,22 +5895,22 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<Tensor> CreateTensorDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Tensor> CreateTensorDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *shape = nullptr,
tflite::TensorType type = tflite::TensorType_FLOAT32,
uint32_t buffer = 0,
const char *name = nullptr,
- flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
+ ::flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
bool is_variable = false,
- flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
+ ::flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
const std::vector<int32_t> *shape_signature = nullptr,
bool has_rank = false,
- const std::vector<flatbuffers::Offset<tflite::VariantSubType>> *variant_tensors = nullptr) {
+ const std::vector<::flatbuffers::Offset<tflite::VariantSubType>> *variant_tensors = nullptr) {
auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
auto name__ = name ? _fbb.CreateString(name) : 0;
auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : 0;
- auto variant_tensors__ = variant_tensors ? _fbb.CreateVector<flatbuffers::Offset<tflite::VariantSubType>>(*variant_tensors) : 0;
+ auto variant_tensors__ = variant_tensors ? _fbb.CreateVector<::flatbuffers::Offset<tflite::VariantSubType>>(*variant_tensors) : 0;
return tflite::CreateTensor(
_fbb,
shape__,
@@ -5925,9 +5925,9 @@
variant_tensors__);
}
-flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Tensor> 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<int64_t> offset_dims{};
std::vector<int64_t> collapsed_slice_dims{};
@@ -5937,7 +5937,7 @@
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 @@
VT_SLICE_SIZES = 12,
VT_INDICES_ARE_SORTED = 14
};
- const flatbuffers::Vector<int64_t> *offset_dims() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_OFFSET_DIMS);
+ const ::flatbuffers::Vector<int64_t> *offset_dims() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_OFFSET_DIMS);
}
- const flatbuffers::Vector<int64_t> *collapsed_slice_dims() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_COLLAPSED_SLICE_DIMS);
+ const ::flatbuffers::Vector<int64_t> *collapsed_slice_dims() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_COLLAPSED_SLICE_DIMS);
}
- const flatbuffers::Vector<int64_t> *start_index_map() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_START_INDEX_MAP);
+ const ::flatbuffers::Vector<int64_t> *start_index_map() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_START_INDEX_MAP);
}
int64_t index_vector_dim() const {
return GetField<int64_t>(VT_INDEX_VECTOR_DIM, 0);
}
- const flatbuffers::Vector<int64_t> *slice_sizes() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_SLICE_SIZES);
+ const ::flatbuffers::Vector<int64_t> *slice_sizes() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SLICE_SIZES);
}
bool indices_are_sorted() const {
return GetField<uint8_t>(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 @@
VerifyField<uint8_t>(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<StablehloGatherOptions> 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<StablehloGatherOptions> 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<flatbuffers::Vector<int64_t>> offset_dims) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_offset_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> offset_dims) {
fbb_.AddOffset(StablehloGatherOptions::VT_OFFSET_DIMS, offset_dims);
}
- void add_collapsed_slice_dims(flatbuffers::Offset<flatbuffers::Vector<int64_t>> collapsed_slice_dims) {
+ void add_collapsed_slice_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> collapsed_slice_dims) {
fbb_.AddOffset(StablehloGatherOptions::VT_COLLAPSED_SLICE_DIMS, collapsed_slice_dims);
}
- void add_start_index_map(flatbuffers::Offset<flatbuffers::Vector<int64_t>> start_index_map) {
+ void add_start_index_map(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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<int64_t>(StablehloGatherOptions::VT_INDEX_VECTOR_DIM, index_vector_dim, 0);
}
- void add_slice_sizes(flatbuffers::Offset<flatbuffers::Vector<int64_t>> slice_sizes) {
+ void add_slice_sizes(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> slice_sizes) {
fbb_.AddOffset(StablehloGatherOptions::VT_SLICE_SIZES, slice_sizes);
}
void add_indices_are_sorted(bool indices_are_sorted) {
fbb_.AddElement<uint8_t>(StablehloGatherOptions::VT_INDICES_ARE_SORTED, static_cast<uint8_t>(indices_are_sorted), 0);
}
- explicit StablehloGatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit StablehloGatherOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StablehloGatherOptions> Finish() {
+ ::flatbuffers::Offset<StablehloGatherOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloGatherOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloGatherOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloGatherOptions> CreateStablehloGatherOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> offset_dims = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> collapsed_slice_dims = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> start_index_map = 0,
+inline ::flatbuffers::Offset<StablehloGatherOptions> CreateStablehloGatherOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> offset_dims = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> collapsed_slice_dims = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> start_index_map = 0,
int64_t index_vector_dim = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> slice_sizes = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> slice_sizes = 0,
bool indices_are_sorted = false) {
StablehloGatherOptionsBuilder builder_(_fbb);
builder_.add_index_vector_dim(index_vector_dim);
@@ -6036,8 +6036,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloGatherOptions> CreateStablehloGatherOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloGatherOptions> CreateStablehloGatherOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *offset_dims = nullptr,
const std::vector<int64_t> *collapsed_slice_dims = nullptr,
const std::vector<int64_t> *start_index_map = nullptr,
@@ -6058,61 +6058,61 @@
indices_are_sorted);
}
-flatbuffers::Offset<StablehloGatherOptions> CreateStablehloGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloGatherOptions> 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<int64_t> 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<int64_t> *permutation() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_PERMUTATION);
+ const ::flatbuffers::Vector<int64_t> *permutation() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(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<StablehloTransposeOptions> 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<StablehloTransposeOptions> 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<flatbuffers::Vector<int64_t>> permutation) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_permutation(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> permutation) {
fbb_.AddOffset(StablehloTransposeOptions::VT_PERMUTATION, permutation);
}
- explicit StablehloTransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit StablehloTransposeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StablehloTransposeOptions> Finish() {
+ ::flatbuffers::Offset<StablehloTransposeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloTransposeOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloTransposeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloTransposeOptions> CreateStablehloTransposeOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> permutation = 0) {
+inline ::flatbuffers::Offset<StablehloTransposeOptions> CreateStablehloTransposeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> permutation = 0) {
StablehloTransposeOptionsBuilder builder_(_fbb);
builder_.add_permutation(permutation);
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloTransposeOptions> CreateStablehloTransposeOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloTransposeOptions> CreateStablehloTransposeOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *permutation = nullptr) {
auto permutation__ = permutation ? _fbb.CreateVector<int64_t>(*permutation) : 0;
return tflite::CreateStablehloTransposeOptions(
@@ -6120,9 +6120,9 @@
permutation__);
}
-flatbuffers::Offset<StablehloTransposeOptions> CreateStablehloTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloTransposeOptions> 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<int64_t> lhs_batching_dimensions{};
std::vector<int64_t> rhs_batching_dimensions{};
@@ -6131,7 +6131,7 @@
std::vector<tflite::StablehloPrecisionConfig> 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 @@
VT_RHS_CONTRACTING_DIMENSIONS = 10,
VT_PRECISION_CONFIG = 12
};
- const flatbuffers::Vector<int64_t> *lhs_batching_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_LHS_BATCHING_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *lhs_batching_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_LHS_BATCHING_DIMENSIONS);
}
- const flatbuffers::Vector<int64_t> *rhs_batching_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_RHS_BATCHING_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *rhs_batching_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_RHS_BATCHING_DIMENSIONS);
}
- const flatbuffers::Vector<int64_t> *lhs_contracting_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_LHS_CONTRACTING_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *lhs_contracting_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_LHS_CONTRACTING_DIMENSIONS);
}
- const flatbuffers::Vector<int64_t> *rhs_contracting_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_RHS_CONTRACTING_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *rhs_contracting_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_RHS_CONTRACTING_DIMENSIONS);
}
- const flatbuffers::Vector<uint32_t> *precision_config() const {
- return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_PRECISION_CONFIG);
+ const ::flatbuffers::Vector<uint32_t> *precision_config() const {
+ return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(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 @@
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<StablehloDotGeneralOptions> 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<StablehloDotGeneralOptions> 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<flatbuffers::Vector<int64_t>> lhs_batching_dimensions) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_lhs_batching_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_batching_dimensions) {
fbb_.AddOffset(StablehloDotGeneralOptions::VT_LHS_BATCHING_DIMENSIONS, lhs_batching_dimensions);
}
- void add_rhs_batching_dimensions(flatbuffers::Offset<flatbuffers::Vector<int64_t>> rhs_batching_dimensions) {
+ void add_rhs_batching_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_batching_dimensions) {
fbb_.AddOffset(StablehloDotGeneralOptions::VT_RHS_BATCHING_DIMENSIONS, rhs_batching_dimensions);
}
- void add_lhs_contracting_dimensions(flatbuffers::Offset<flatbuffers::Vector<int64_t>> lhs_contracting_dimensions) {
+ void add_lhs_contracting_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_contracting_dimensions) {
fbb_.AddOffset(StablehloDotGeneralOptions::VT_LHS_CONTRACTING_DIMENSIONS, lhs_contracting_dimensions);
}
- void add_rhs_contracting_dimensions(flatbuffers::Offset<flatbuffers::Vector<int64_t>> rhs_contracting_dimensions) {
+ void add_rhs_contracting_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_contracting_dimensions) {
fbb_.AddOffset(StablehloDotGeneralOptions::VT_RHS_CONTRACTING_DIMENSIONS, rhs_contracting_dimensions);
}
- void add_precision_config(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> precision_config) {
+ void add_precision_config(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> 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<StablehloDotGeneralOptions> Finish() {
+ ::flatbuffers::Offset<StablehloDotGeneralOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloDotGeneralOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloDotGeneralOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloDotGeneralOptions> CreateStablehloDotGeneralOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> lhs_batching_dimensions = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> rhs_batching_dimensions = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> lhs_contracting_dimensions = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> rhs_contracting_dimensions = 0,
- flatbuffers::Offset<flatbuffers::Vector<uint32_t>> precision_config = 0) {
+inline ::flatbuffers::Offset<StablehloDotGeneralOptions> CreateStablehloDotGeneralOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_batching_dimensions = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_batching_dimensions = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_contracting_dimensions = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_contracting_dimensions = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> precision_config = 0) {
StablehloDotGeneralOptionsBuilder builder_(_fbb);
builder_.add_precision_config(precision_config);
builder_.add_rhs_contracting_dimensions(rhs_contracting_dimensions);
@@ -6221,8 +6221,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloDotGeneralOptions> CreateStablehloDotGeneralOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloDotGeneralOptions> CreateStablehloDotGeneralOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *lhs_batching_dimensions = nullptr,
const std::vector<int64_t> *rhs_batching_dimensions = nullptr,
const std::vector<int64_t> *lhs_contracting_dimensions = nullptr,
@@ -6242,9 +6242,9 @@
precision_config__);
}
-flatbuffers::Offset<StablehloDotGeneralOptions> CreateStablehloDotGeneralOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloDotGeneralOptions> 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<int64_t> window_dimensions{};
std::vector<int64_t> window_strides{};
@@ -6254,7 +6254,7 @@
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 @@
VT_PADDING = 12,
VT_BODY_SUBGRAPH_INDEX = 14
};
- const flatbuffers::Vector<int64_t> *window_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_WINDOW_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *window_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_WINDOW_DIMENSIONS);
}
- const flatbuffers::Vector<int64_t> *window_strides() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_WINDOW_STRIDES);
+ const ::flatbuffers::Vector<int64_t> *window_strides() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_WINDOW_STRIDES);
}
- const flatbuffers::Vector<int64_t> *base_dilations() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_BASE_DILATIONS);
+ const ::flatbuffers::Vector<int64_t> *base_dilations() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_BASE_DILATIONS);
}
- const flatbuffers::Vector<int64_t> *window_dilations() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_WINDOW_DILATIONS);
+ const ::flatbuffers::Vector<int64_t> *window_dilations() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_WINDOW_DILATIONS);
}
- const flatbuffers::Vector<int64_t> *padding() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_PADDING);
+ const ::flatbuffers::Vector<int64_t> *padding() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_PADDING);
}
int32_t body_subgraph_index() const {
return GetField<int32_t>(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 @@
VerifyField<int32_t>(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<StablehloReduceWindowOptions> 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<StablehloReduceWindowOptions> 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<flatbuffers::Vector<int64_t>> window_dimensions) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_window_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_dimensions) {
fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_DIMENSIONS, window_dimensions);
}
- void add_window_strides(flatbuffers::Offset<flatbuffers::Vector<int64_t>> window_strides) {
+ void add_window_strides(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_strides) {
fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_STRIDES, window_strides);
}
- void add_base_dilations(flatbuffers::Offset<flatbuffers::Vector<int64_t>> base_dilations) {
+ void add_base_dilations(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> base_dilations) {
fbb_.AddOffset(StablehloReduceWindowOptions::VT_BASE_DILATIONS, base_dilations);
}
- void add_window_dilations(flatbuffers::Offset<flatbuffers::Vector<int64_t>> window_dilations) {
+ void add_window_dilations(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_dilations) {
fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_DILATIONS, window_dilations);
}
- void add_padding(flatbuffers::Offset<flatbuffers::Vector<int64_t>> padding) {
+ void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> padding) {
fbb_.AddOffset(StablehloReduceWindowOptions::VT_PADDING, padding);
}
void add_body_subgraph_index(int32_t body_subgraph_index) {
fbb_.AddElement<int32_t>(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<StablehloReduceWindowOptions> Finish() {
+ ::flatbuffers::Offset<StablehloReduceWindowOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloReduceWindowOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloReduceWindowOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloReduceWindowOptions> CreateStablehloReduceWindowOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> window_dimensions = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> window_strides = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> base_dilations = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> window_dilations = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> padding = 0,
+inline ::flatbuffers::Offset<StablehloReduceWindowOptions> CreateStablehloReduceWindowOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_dimensions = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_strides = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> base_dilations = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_dilations = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> padding = 0,
int32_t body_subgraph_index = 0) {
StablehloReduceWindowOptionsBuilder builder_(_fbb);
builder_.add_body_subgraph_index(body_subgraph_index);
@@ -6354,8 +6354,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloReduceWindowOptions> CreateStablehloReduceWindowOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloReduceWindowOptions> CreateStablehloReduceWindowOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *window_dimensions = nullptr,
const std::vector<int64_t> *window_strides = nullptr,
const std::vector<int64_t> *base_dilations = nullptr,
@@ -6377,15 +6377,15 @@
body_subgraph_index);
}
-flatbuffers::Offset<StablehloReduceWindowOptions> CreateStablehloReduceWindowOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloReduceWindowOptions> 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 @@
int32_t body_subgraph_index() const {
return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX, 4) &&
VerifyField<int32_t>(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<StablehloWhileOptions> 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<StablehloWhileOptions> 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<int32_t>(StablehloWhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
}
void add_body_subgraph_index(int32_t body_subgraph_index) {
fbb_.AddElement<int32_t>(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<StablehloWhileOptions> Finish() {
+ ::flatbuffers::Offset<StablehloWhileOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloWhileOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloWhileOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloWhileOptions> CreateStablehloWhileOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloWhileOptions> CreateStablehloWhileOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t cond_subgraph_index = 0,
int32_t body_subgraph_index = 0) {
StablehloWhileOptionsBuilder builder_(_fbb);
@@ -6440,16 +6440,16 @@
return builder_.Finish();
}
-flatbuffers::Offset<StablehloWhileOptions> CreateStablehloWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloWhileOptions> 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 @@
int32_t comparator_subgraph_index() const {
return GetField<int32_t>(VT_COMPARATOR_SUBGRAPH_INDEX, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_DIMENSION, 8) &&
VerifyField<uint8_t>(verifier, VT_IS_STABLE, 1) &&
VerifyField<int32_t>(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<StablehloSortOptions> 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<StablehloSortOptions> 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<int64_t>(StablehloSortOptions::VT_DIMENSION, dimension, 0);
}
@@ -6491,19 +6491,19 @@
void add_comparator_subgraph_index(int32_t comparator_subgraph_index) {
fbb_.AddElement<int32_t>(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<StablehloSortOptions> Finish() {
+ ::flatbuffers::Offset<StablehloSortOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloSortOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloSortOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloSortOptions> CreateStablehloSortOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloSortOptions> CreateStablehloSortOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int64_t dimension = 0,
bool is_stable = false,
int32_t comparator_subgraph_index = 0) {
@@ -6514,14 +6514,14 @@
return builder_.Finish();
}
-flatbuffers::Offset<StablehloSortOptions> CreateStablehloSortOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloSortOptions> 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 @@
int64_t dimension() const {
return GetField<int64_t>(VT_DIMENSION, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(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<StablehloConcatenateOptions> 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<StablehloConcatenateOptions> 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<int64_t>(StablehloConcatenateOptions::VT_DIMENSION, dimension, 0);
}
- explicit StablehloConcatenateOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit StablehloConcatenateOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StablehloConcatenateOptions> Finish() {
+ ::flatbuffers::Offset<StablehloConcatenateOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloConcatenateOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloConcatenateOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloConcatenateOptions> CreateStablehloConcatenateOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloConcatenateOptions> CreateStablehloConcatenateOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int64_t dimension = 0) {
StablehloConcatenateOptionsBuilder builder_(_fbb);
builder_.add_dimension(dimension);
return builder_.Finish();
}
-flatbuffers::Offset<StablehloConcatenateOptions> CreateStablehloConcatenateOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloConcatenateOptions> 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<int64_t> 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<int64_t> *broadcast_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_BROADCAST_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *broadcast_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(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<StablehloBroadcastInDimOptions> 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<StablehloBroadcastInDimOptions> 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<flatbuffers::Vector<int64_t>> broadcast_dimensions) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_broadcast_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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<StablehloBroadcastInDimOptions> Finish() {
+ ::flatbuffers::Offset<StablehloBroadcastInDimOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloBroadcastInDimOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloBroadcastInDimOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloBroadcastInDimOptions> CreateStablehloBroadcastInDimOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> broadcast_dimensions = 0) {
+inline ::flatbuffers::Offset<StablehloBroadcastInDimOptions> CreateStablehloBroadcastInDimOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> broadcast_dimensions = 0) {
StablehloBroadcastInDimOptionsBuilder builder_(_fbb);
builder_.add_broadcast_dimensions(broadcast_dimensions);
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloBroadcastInDimOptions> CreateStablehloBroadcastInDimOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloBroadcastInDimOptions> CreateStablehloBroadcastInDimOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *broadcast_dimensions = nullptr) {
auto broadcast_dimensions__ = broadcast_dimensions ? _fbb.CreateVector<int64_t>(*broadcast_dimensions) : 0;
return tflite::CreateStablehloBroadcastInDimOptions(
@@ -6628,15 +6628,15 @@
broadcast_dimensions__);
}
-flatbuffers::Offset<StablehloBroadcastInDimOptions> CreateStablehloBroadcastInDimOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloBroadcastInDimOptions> 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 @@
tflite::StablehloComparisonType compare_type() const {
return static_cast<tflite::StablehloComparisonType>(GetField<uint32_t>(VT_COMPARE_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_COMPARISON_DIRECTION, 4) &&
VerifyField<uint32_t>(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<StablehloCompareOptions> 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<StablehloCompareOptions> 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<uint32_t>(StablehloCompareOptions::VT_COMPARISON_DIRECTION, static_cast<uint32_t>(comparison_direction), 0);
}
void add_compare_type(tflite::StablehloComparisonType compare_type) {
fbb_.AddElement<uint32_t>(StablehloCompareOptions::VT_COMPARE_TYPE, static_cast<uint32_t>(compare_type), 0);
}
- explicit StablehloCompareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit StablehloCompareOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StablehloCompareOptions> Finish() {
+ ::flatbuffers::Offset<StablehloCompareOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloCompareOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloCompareOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloCompareOptions> CreateStablehloCompareOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloCompareOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<StablehloCompareOptions> CreateStablehloCompareOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloCompareOptions> 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<int64_t> 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<int64_t> *slice_sizes() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_SLICE_SIZES);
+ const ::flatbuffers::Vector<int64_t> *slice_sizes() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(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<StablehloDynamicSliceOptions> 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<StablehloDynamicSliceOptions> 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<flatbuffers::Vector<int64_t>> slice_sizes) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_slice_sizes(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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<StablehloDynamicSliceOptions> Finish() {
+ ::flatbuffers::Offset<StablehloDynamicSliceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloDynamicSliceOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloDynamicSliceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloDynamicSliceOptions> CreateStablehloDynamicSliceOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> slice_sizes = 0) {
+inline ::flatbuffers::Offset<StablehloDynamicSliceOptions> CreateStablehloDynamicSliceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> slice_sizes = 0) {
StablehloDynamicSliceOptionsBuilder builder_(_fbb);
builder_.add_slice_sizes(slice_sizes);
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloDynamicSliceOptions> CreateStablehloDynamicSliceOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloDynamicSliceOptions> CreateStablehloDynamicSliceOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *slice_sizes = nullptr) {
auto slice_sizes__ = slice_sizes ? _fbb.CreateVector<int64_t>(*slice_sizes) : 0;
return tflite::CreateStablehloDynamicSliceOptions(
@@ -6753,16 +6753,16 @@
slice_sizes__);
}
-flatbuffers::Offset<StablehloDynamicSliceOptions> CreateStablehloDynamicSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloDynamicSliceOptions> 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<int64_t> edge_padding_low{};
std::vector<int64_t> edge_padding_high{};
std::vector<int64_t> 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 @@
VT_EDGE_PADDING_HIGH = 6,
VT_INTERIOR_PADDING = 8
};
- const flatbuffers::Vector<int64_t> *edge_padding_low() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_EDGE_PADDING_LOW);
+ const ::flatbuffers::Vector<int64_t> *edge_padding_low() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_EDGE_PADDING_LOW);
}
- const flatbuffers::Vector<int64_t> *edge_padding_high() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_EDGE_PADDING_HIGH);
+ const ::flatbuffers::Vector<int64_t> *edge_padding_high() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_EDGE_PADDING_HIGH);
}
- const flatbuffers::Vector<int64_t> *interior_padding() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_INTERIOR_PADDING);
+ const ::flatbuffers::Vector<int64_t> *interior_padding() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(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 @@
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<StablehloPadOptions> 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<StablehloPadOptions> 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<flatbuffers::Vector<int64_t>> edge_padding_low) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_edge_padding_low(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> edge_padding_low) {
fbb_.AddOffset(StablehloPadOptions::VT_EDGE_PADDING_LOW, edge_padding_low);
}
- void add_edge_padding_high(flatbuffers::Offset<flatbuffers::Vector<int64_t>> edge_padding_high) {
+ void add_edge_padding_high(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> edge_padding_high) {
fbb_.AddOffset(StablehloPadOptions::VT_EDGE_PADDING_HIGH, edge_padding_high);
}
- void add_interior_padding(flatbuffers::Offset<flatbuffers::Vector<int64_t>> interior_padding) {
+ void add_interior_padding(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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<StablehloPadOptions> Finish() {
+ ::flatbuffers::Offset<StablehloPadOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloPadOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloPadOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloPadOptions> CreateStablehloPadOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> edge_padding_low = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> edge_padding_high = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> interior_padding = 0) {
+inline ::flatbuffers::Offset<StablehloPadOptions> CreateStablehloPadOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> edge_padding_low = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> edge_padding_high = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> interior_padding = 0) {
StablehloPadOptionsBuilder builder_(_fbb);
builder_.add_interior_padding(interior_padding);
builder_.add_edge_padding_high(edge_padding_high);
@@ -6830,8 +6830,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloPadOptions> CreateStablehloPadOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloPadOptions> CreateStablehloPadOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *edge_padding_low = nullptr,
const std::vector<int64_t> *edge_padding_high = nullptr,
const std::vector<int64_t> *interior_padding = nullptr) {
@@ -6845,14 +6845,14 @@
interior_padding__);
}
-flatbuffers::Offset<StablehloPadOptions> CreateStablehloPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloPadOptions> 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 @@
int64_t iota_dimension() const {
return GetField<int64_t>(VT_IOTA_DIMENSION, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(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<StablehloIotaOptions> 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<StablehloIotaOptions> 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<int64_t>(StablehloIotaOptions::VT_IOTA_DIMENSION, iota_dimension, 0);
}
- explicit StablehloIotaOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit StablehloIotaOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StablehloIotaOptions> Finish() {
+ ::flatbuffers::Offset<StablehloIotaOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloIotaOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloIotaOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloIotaOptions> CreateStablehloIotaOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloIotaOptions> CreateStablehloIotaOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int64_t iota_dimension = 0) {
StablehloIotaOptionsBuilder builder_(_fbb);
builder_.add_iota_dimension(iota_dimension);
return builder_.Finish();
}
-flatbuffers::Offset<StablehloIotaOptions> CreateStablehloIotaOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloIotaOptions> 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 @@
std::vector<uint8_t> 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 @@
VT_CALLED_COMPUTATIONS = 12,
VT_CUSTOM_ATTRIBUTES = 14
};
- const flatbuffers::String *call_target_name() const {
- return GetPointer<const flatbuffers::String *>(VT_CALL_TARGET_NAME);
+ const ::flatbuffers::String *call_target_name() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_CALL_TARGET_NAME);
}
bool has_side_effect() const {
return GetField<uint8_t>(VT_HAS_SIDE_EFFECT, 0) != 0;
}
- const flatbuffers::String *backend_config() const {
- return GetPointer<const flatbuffers::String *>(VT_BACKEND_CONFIG);
+ const ::flatbuffers::String *backend_config() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_BACKEND_CONFIG);
}
int32_t api_version() const {
return GetField<int32_t>(VT_API_VERSION, 0);
}
- const flatbuffers::Vector<int32_t> *called_computations() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_CALLED_COMPUTATIONS);
+ const ::flatbuffers::Vector<int32_t> *called_computations() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_CALLED_COMPUTATIONS);
}
- const flatbuffers::Vector<uint8_t> *custom_attributes() const {
- return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_ATTRIBUTES);
+ const ::flatbuffers::Vector<uint8_t> *custom_attributes() const {
+ return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(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 @@
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<StablehloCustomCallOptions> 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<StablehloCustomCallOptions> 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<flatbuffers::String> 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<uint8_t>(StablehloCustomCallOptions::VT_HAS_SIDE_EFFECT, static_cast<uint8_t>(has_side_effect), 0);
}
- void add_backend_config(flatbuffers::Offset<flatbuffers::String> 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<int32_t>(StablehloCustomCallOptions::VT_API_VERSION, api_version, 0);
}
- void add_called_computations(flatbuffers::Offset<flatbuffers::Vector<int32_t>> called_computations) {
+ void add_called_computations(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> called_computations) {
fbb_.AddOffset(StablehloCustomCallOptions::VT_CALLED_COMPUTATIONS, called_computations);
}
- void add_custom_attributes(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_attributes) {
+ void add_custom_attributes(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> 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<StablehloCustomCallOptions> Finish() {
+ ::flatbuffers::Offset<StablehloCustomCallOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloCustomCallOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloCustomCallOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloCustomCallOptions> CreateStablehloCustomCallOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::String> call_target_name = 0,
+inline ::flatbuffers::Offset<StablehloCustomCallOptions> CreateStablehloCustomCallOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::String> call_target_name = 0,
bool has_side_effect = false,
- flatbuffers::Offset<flatbuffers::String> backend_config = 0,
+ ::flatbuffers::Offset<::flatbuffers::String> backend_config = 0,
int32_t api_version = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> called_computations = 0,
- flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_attributes = 0) {
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> called_computations = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom_attributes = 0) {
StablehloCustomCallOptionsBuilder builder_(_fbb);
builder_.add_custom_attributes(custom_attributes);
builder_.add_called_computations(called_computations);
@@ -7008,8 +7008,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloCustomCallOptions> CreateStablehloCustomCallOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloCustomCallOptions> CreateStablehloCustomCallOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const char *call_target_name = nullptr,
bool has_side_effect = false,
const char *backend_config = nullptr,
@@ -7030,63 +7030,63 @@
custom_attributes__);
}
-flatbuffers::Offset<StablehloCustomCallOptions> CreateStablehloCustomCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloCustomCallOptions> 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<int64_t> 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<int64_t> *dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_DIMENSIONS);
}
int32_t body_subgraph_index() const {
return GetField<int32_t>(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<int32_t>(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<StablehloReduceOptions> 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<StablehloReduceOptions> 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<flatbuffers::Vector<int64_t>> dimensions) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> dimensions) {
fbb_.AddOffset(StablehloReduceOptions::VT_DIMENSIONS, dimensions);
}
void add_body_subgraph_index(int32_t body_subgraph_index) {
fbb_.AddElement<int32_t>(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<StablehloReduceOptions> Finish() {
+ ::flatbuffers::Offset<StablehloReduceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloReduceOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloReduceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloReduceOptions> CreateStablehloReduceOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> dimensions = 0,
+inline ::flatbuffers::Offset<StablehloReduceOptions> CreateStablehloReduceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> dimensions = 0,
int32_t body_subgraph_index = 0) {
StablehloReduceOptionsBuilder builder_(_fbb);
builder_.add_body_subgraph_index(body_subgraph_index);
@@ -7094,8 +7094,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloReduceOptions> CreateStablehloReduceOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloReduceOptions> CreateStablehloReduceOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *dimensions = nullptr,
int32_t body_subgraph_index = 0) {
auto dimensions__ = dimensions ? _fbb.CreateVector<int64_t>(*dimensions) : 0;
@@ -7105,16 +7105,16 @@
body_subgraph_index);
}
-flatbuffers::Offset<StablehloReduceOptions> CreateStablehloReduceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloReduceOptions> 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<int64_t> start_indices{};
std::vector<int64_t> limit_indices{};
std::vector<int64_t> 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 @@
VT_LIMIT_INDICES = 6,
VT_STRIDES = 8
};
- const flatbuffers::Vector<int64_t> *start_indices() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_START_INDICES);
+ const ::flatbuffers::Vector<int64_t> *start_indices() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_START_INDICES);
}
- const flatbuffers::Vector<int64_t> *limit_indices() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_LIMIT_INDICES);
+ const ::flatbuffers::Vector<int64_t> *limit_indices() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_LIMIT_INDICES);
}
- const flatbuffers::Vector<int64_t> *strides() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_STRIDES);
+ const ::flatbuffers::Vector<int64_t> *strides() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(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 @@
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<StablehloSliceOptions> 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<StablehloSliceOptions> 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<flatbuffers::Vector<int64_t>> start_indices) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_start_indices(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> start_indices) {
fbb_.AddOffset(StablehloSliceOptions::VT_START_INDICES, start_indices);
}
- void add_limit_indices(flatbuffers::Offset<flatbuffers::Vector<int64_t>> limit_indices) {
+ void add_limit_indices(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> limit_indices) {
fbb_.AddOffset(StablehloSliceOptions::VT_LIMIT_INDICES, limit_indices);
}
- void add_strides(flatbuffers::Offset<flatbuffers::Vector<int64_t>> strides) {
+ void add_strides(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> strides) {
fbb_.AddOffset(StablehloSliceOptions::VT_STRIDES, strides);
}
- explicit StablehloSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit StablehloSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StablehloSliceOptions> Finish() {
+ ::flatbuffers::Offset<StablehloSliceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloSliceOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloSliceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloSliceOptions> CreateStablehloSliceOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> start_indices = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> limit_indices = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> strides = 0) {
+inline ::flatbuffers::Offset<StablehloSliceOptions> CreateStablehloSliceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> start_indices = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> limit_indices = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> strides = 0) {
StablehloSliceOptionsBuilder builder_(_fbb);
builder_.add_strides(strides);
builder_.add_limit_indices(limit_indices);
@@ -7182,8 +7182,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloSliceOptions> CreateStablehloSliceOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloSliceOptions> CreateStablehloSliceOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *start_indices = nullptr,
const std::vector<int64_t> *limit_indices = nullptr,
const std::vector<int64_t> *strides = nullptr) {
@@ -7197,9 +7197,9 @@
strides__);
}
-flatbuffers::Offset<StablehloSliceOptions> CreateStablehloSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloSliceOptions> 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<int64_t> window_strides{};
std::vector<int64_t> padding{};
@@ -7220,7 +7220,7 @@
std::vector<tflite::StablehloPrecisionConfig> 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 @@
VT_BATCH_GROUP_COUNT = 34,
VT_PRECISION_CONFIG = 36
};
- const flatbuffers::Vector<int64_t> *window_strides() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_WINDOW_STRIDES);
+ const ::flatbuffers::Vector<int64_t> *window_strides() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_WINDOW_STRIDES);
}
- const flatbuffers::Vector<int64_t> *padding() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_PADDING);
+ const ::flatbuffers::Vector<int64_t> *padding() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_PADDING);
}
- const flatbuffers::Vector<int64_t> *lhs_dilation() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_LHS_DILATION);
+ const ::flatbuffers::Vector<int64_t> *lhs_dilation() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_LHS_DILATION);
}
- const flatbuffers::Vector<int64_t> *rhs_dilation() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_RHS_DILATION);
+ const ::flatbuffers::Vector<int64_t> *rhs_dilation() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_RHS_DILATION);
}
- const flatbuffers::Vector<uint8_t> *window_reversal() const {
- return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_WINDOW_REVERSAL);
+ const ::flatbuffers::Vector<uint8_t> *window_reversal() const {
+ return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_WINDOW_REVERSAL);
}
int64_t input_batch_dimension() const {
return GetField<int64_t>(VT_INPUT_BATCH_DIMENSION, 0);
@@ -7263,8 +7263,8 @@
int64_t input_feature_dimension() const {
return GetField<int64_t>(VT_INPUT_FEATURE_DIMENSION, 0);
}
- const flatbuffers::Vector<int64_t> *input_spatial_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_INPUT_SPATIAL_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *input_spatial_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_INPUT_SPATIAL_DIMENSIONS);
}
int64_t kernel_input_feature_dimension() const {
return GetField<int64_t>(VT_KERNEL_INPUT_FEATURE_DIMENSION, 0);
@@ -7272,8 +7272,8 @@
int64_t kernel_output_feature_dimension() const {
return GetField<int64_t>(VT_KERNEL_OUTPUT_FEATURE_DIMENSION, 0);
}
- const flatbuffers::Vector<int64_t> *kernel_spatial_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_KERNEL_SPATIAL_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *kernel_spatial_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_KERNEL_SPATIAL_DIMENSIONS);
}
int64_t output_batch_dimension() const {
return GetField<int64_t>(VT_OUTPUT_BATCH_DIMENSION, 0);
@@ -7281,8 +7281,8 @@
int64_t output_feature_dimension() const {
return GetField<int64_t>(VT_OUTPUT_FEATURE_DIMENSION, 0);
}
- const flatbuffers::Vector<int64_t> *output_spatial_dimensions() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_OUTPUT_SPATIAL_DIMENSIONS);
+ const ::flatbuffers::Vector<int64_t> *output_spatial_dimensions() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_OUTPUT_SPATIAL_DIMENSIONS);
}
int64_t feature_group_count() const {
return GetField<int64_t>(VT_FEATURE_GROUP_COUNT, 0);
@@ -7290,10 +7290,10 @@
int64_t batch_group_count() const {
return GetField<int64_t>(VT_BATCH_GROUP_COUNT, 0);
}
- const flatbuffers::Vector<uint32_t> *precision_config() const {
- return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_PRECISION_CONFIG);
+ const ::flatbuffers::Vector<uint32_t> *precision_config() const {
+ return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(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 @@
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<StablehloConvolutionOptions> 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<StablehloConvolutionOptions> 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<flatbuffers::Vector<int64_t>> window_strides) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_window_strides(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_strides) {
fbb_.AddOffset(StablehloConvolutionOptions::VT_WINDOW_STRIDES, window_strides);
}
- void add_padding(flatbuffers::Offset<flatbuffers::Vector<int64_t>> padding) {
+ void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> padding) {
fbb_.AddOffset(StablehloConvolutionOptions::VT_PADDING, padding);
}
- void add_lhs_dilation(flatbuffers::Offset<flatbuffers::Vector<int64_t>> lhs_dilation) {
+ void add_lhs_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_dilation) {
fbb_.AddOffset(StablehloConvolutionOptions::VT_LHS_DILATION, lhs_dilation);
}
- void add_rhs_dilation(flatbuffers::Offset<flatbuffers::Vector<int64_t>> rhs_dilation) {
+ void add_rhs_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_dilation) {
fbb_.AddOffset(StablehloConvolutionOptions::VT_RHS_DILATION, rhs_dilation);
}
- void add_window_reversal(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> window_reversal) {
+ void add_window_reversal(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> window_reversal) {
fbb_.AddOffset(StablehloConvolutionOptions::VT_WINDOW_REVERSAL, window_reversal);
}
void add_input_batch_dimension(int64_t input_batch_dimension) {
@@ -7353,7 +7353,7 @@
void add_input_feature_dimension(int64_t input_feature_dimension) {
fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_INPUT_FEATURE_DIMENSION, input_feature_dimension, 0);
}
- void add_input_spatial_dimensions(flatbuffers::Offset<flatbuffers::Vector<int64_t>> input_spatial_dimensions) {
+ void add_input_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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 @@
void add_kernel_output_feature_dimension(int64_t kernel_output_feature_dimension) {
fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_KERNEL_OUTPUT_FEATURE_DIMENSION, kernel_output_feature_dimension, 0);
}
- void add_kernel_spatial_dimensions(flatbuffers::Offset<flatbuffers::Vector<int64_t>> kernel_spatial_dimensions) {
+ void add_kernel_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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 @@
void add_output_feature_dimension(int64_t output_feature_dimension) {
fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_OUTPUT_FEATURE_DIMENSION, output_feature_dimension, 0);
}
- void add_output_spatial_dimensions(flatbuffers::Offset<flatbuffers::Vector<int64_t>> output_spatial_dimensions) {
+ void add_output_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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 @@
void add_batch_group_count(int64_t batch_group_count) {
fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_BATCH_GROUP_COUNT, batch_group_count, 0);
}
- void add_precision_config(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> precision_config) {
+ void add_precision_config(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> 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<StablehloConvolutionOptions> Finish() {
+ ::flatbuffers::Offset<StablehloConvolutionOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloConvolutionOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloConvolutionOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloConvolutionOptions> CreateStablehloConvolutionOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> window_strides = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> padding = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> lhs_dilation = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> rhs_dilation = 0,
- flatbuffers::Offset<flatbuffers::Vector<uint8_t>> window_reversal = 0,
+inline ::flatbuffers::Offset<StablehloConvolutionOptions> CreateStablehloConvolutionOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_strides = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> padding = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_dilation = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_dilation = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> window_reversal = 0,
int64_t input_batch_dimension = 0,
int64_t input_feature_dimension = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> input_spatial_dimensions = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> input_spatial_dimensions = 0,
int64_t kernel_input_feature_dimension = 0,
int64_t kernel_output_feature_dimension = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> kernel_spatial_dimensions = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> kernel_spatial_dimensions = 0,
int64_t output_batch_dimension = 0,
int64_t output_feature_dimension = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> output_spatial_dimensions = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> output_spatial_dimensions = 0,
int64_t feature_group_count = 0,
int64_t batch_group_count = 0,
- flatbuffers::Offset<flatbuffers::Vector<uint32_t>> precision_config = 0) {
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> 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 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloConvolutionOptions> CreateStablehloConvolutionOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloConvolutionOptions> CreateStablehloConvolutionOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int64_t> *window_strides = nullptr,
const std::vector<int64_t> *padding = nullptr,
const std::vector<int64_t> *lhs_dilation = nullptr,
@@ -7483,9 +7483,9 @@
precision_config__);
}
-flatbuffers::Offset<StablehloConvolutionOptions> CreateStablehloConvolutionOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloConvolutionOptions> 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<int64_t> update_window_dims{};
@@ -7496,7 +7496,7 @@
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 @@
bool indices_are_sorted() const {
return GetField<uint8_t>(VT_INDICES_ARE_SORTED, 0) != 0;
}
- const flatbuffers::Vector<int64_t> *update_window_dims() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_UPDATE_WINDOW_DIMS);
+ const ::flatbuffers::Vector<int64_t> *update_window_dims() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_UPDATE_WINDOW_DIMS);
}
- const flatbuffers::Vector<int64_t> *inserted_window_dims() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_INSERTED_WINDOW_DIMS);
+ const ::flatbuffers::Vector<int64_t> *inserted_window_dims() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_INSERTED_WINDOW_DIMS);
}
- const flatbuffers::Vector<int64_t> *scatter_dims_to_operand_dims() const {
- return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_SCATTER_DIMS_TO_OPERAND_DIMS);
+ const ::flatbuffers::Vector<int64_t> *scatter_dims_to_operand_dims() const {
+ return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SCATTER_DIMS_TO_OPERAND_DIMS);
}
int64_t index_vector_dim() const {
return GetField<int64_t>(VT_INDEX_VECTOR_DIM, 0);
@@ -7529,7 +7529,7 @@
int32_t update_computation_subgraph_index() const {
return GetField<int32_t>(VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_INDICES_ARE_SORTED, 1) &&
VerifyOffset(verifier, VT_UPDATE_WINDOW_DIMS) &&
@@ -7543,25 +7543,25 @@
VerifyField<int32_t>(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<StablehloScatterOptions> 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<StablehloScatterOptions> 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<uint8_t>(StablehloScatterOptions::VT_INDICES_ARE_SORTED, static_cast<uint8_t>(indices_are_sorted), 0);
}
- void add_update_window_dims(flatbuffers::Offset<flatbuffers::Vector<int64_t>> update_window_dims) {
+ void add_update_window_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> update_window_dims) {
fbb_.AddOffset(StablehloScatterOptions::VT_UPDATE_WINDOW_DIMS, update_window_dims);
}
- void add_inserted_window_dims(flatbuffers::Offset<flatbuffers::Vector<int64_t>> inserted_window_dims) {
+ void add_inserted_window_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> inserted_window_dims) {
fbb_.AddOffset(StablehloScatterOptions::VT_INSERTED_WINDOW_DIMS, inserted_window_dims);
}
- void add_scatter_dims_to_operand_dims(flatbuffers::Offset<flatbuffers::Vector<int64_t>> scatter_dims_to_operand_dims) {
+ void add_scatter_dims_to_operand_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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 @@
void add_update_computation_subgraph_index(int32_t update_computation_subgraph_index) {
fbb_.AddElement<int32_t>(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<StablehloScatterOptions> Finish() {
+ ::flatbuffers::Offset<StablehloScatterOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloScatterOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloScatterOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloScatterOptions> CreateStablehloScatterOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloScatterOptions> CreateStablehloScatterOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool indices_are_sorted = false,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> update_window_dims = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> inserted_window_dims = 0,
- flatbuffers::Offset<flatbuffers::Vector<int64_t>> scatter_dims_to_operand_dims = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> update_window_dims = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> inserted_window_dims = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> 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 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<StablehloScatterOptions> CreateStablehloScatterOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloScatterOptions> CreateStablehloScatterOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool indices_are_sorted = false,
const std::vector<int64_t> *update_window_dims = nullptr,
const std::vector<int64_t> *inserted_window_dims = nullptr,
@@ -7627,14 +7627,14 @@
update_computation_subgraph_index);
}
-flatbuffers::Offset<StablehloScatterOptions> CreateStablehloScatterOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloScatterOptions> 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 @@
tflite::RngAlgorithm algorithm() const {
return static_cast<tflite::RngAlgorithm>(GetField<int8_t>(VT_ALGORITHM, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<StablehloRngBitGeneratorOptions> 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<StablehloRngBitGeneratorOptions> 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<int8_t>(StablehloRngBitGeneratorOptions::VT_ALGORITHM, static_cast<int8_t>(algorithm), 0);
}
- explicit StablehloRngBitGeneratorOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit StablehloRngBitGeneratorOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StablehloRngBitGeneratorOptions> Finish() {
+ ::flatbuffers::Offset<StablehloRngBitGeneratorOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StablehloRngBitGeneratorOptions>(end);
+ auto o = ::flatbuffers::Offset<StablehloRngBitGeneratorOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StablehloRngBitGeneratorOptions> CreateStablehloRngBitGeneratorOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StablehloRngBitGeneratorOptions> CreateStablehloRngBitGeneratorOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::RngAlgorithm algorithm = tflite::RngAlgorithm_DEFAULT) {
StablehloRngBitGeneratorOptionsBuilder builder_(_fbb);
builder_.add_algorithm(algorithm);
return builder_.Finish();
}
-flatbuffers::Offset<StablehloRngBitGeneratorOptions> CreateStablehloRngBitGeneratorOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StablehloRngBitGeneratorOptions> 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 @@
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 @@
tflite::TensorType quantized_bias_type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
@@ -7736,15 +7736,15 @@
VerifyField<int8_t>(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<Conv2DOptions> 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<Conv2DOptions> 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<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
@@ -7766,19 +7766,19 @@
void add_quantized_bias_type(tflite::TensorType quantized_bias_type) {
fbb_.AddElement<int8_t>(Conv2DOptions::VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(quantized_bias_type), 0);
}
- explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit Conv2DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<Conv2DOptions> Finish() {
+ ::flatbuffers::Offset<Conv2DOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Conv2DOptions>(end);
+ auto o = ::flatbuffers::Offset<Conv2DOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::Padding padding = tflite::Padding_SAME,
int32_t stride_w = 0,
int32_t stride_h = 0,
@@ -7797,9 +7797,9 @@
return builder_.Finish();
}
-flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Conv2DOptions> 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 @@
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 @@
int32_t dilation_h_factor() const {
return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
VerifyField<int32_t>(verifier, VT_STRIDE_D, 4) &&
@@ -7860,15 +7860,15 @@
VerifyField<int32_t>(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<Conv3DOptions> 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<Conv3DOptions> 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<int8_t>(Conv3DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
@@ -7893,19 +7893,19 @@
void add_dilation_h_factor(int32_t dilation_h_factor) {
fbb_.AddElement<int32_t>(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<Conv3DOptions> Finish() {
+ ::flatbuffers::Offset<Conv3DOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Conv3DOptions>(end);
+ auto o = ::flatbuffers::Offset<Conv3DOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::Padding padding = tflite::Padding_SAME,
int32_t stride_d = 0,
int32_t stride_w = 0,
@@ -7926,9 +7926,9 @@
return builder_.Finish();
}
-flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Conv3DOptions> 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 @@
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 @@
tflite::ActivationFunctionType fused_activation_function() const {
return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
@@ -7977,15 +7977,15 @@
VerifyField<int8_t>(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<Pool2DOptions> 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<Pool2DOptions> 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<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
@@ -8004,19 +8004,19 @@
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit Pool2DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<Pool2DOptions> Finish() {
+ ::flatbuffers::Offset<Pool2DOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Pool2DOptions>(end);
+ auto o = ::flatbuffers::Offset<Pool2DOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::Padding padding = tflite::Padding_SAME,
int32_t stride_w = 0,
int32_t stride_h = 0,
@@ -8033,9 +8033,9 @@
return builder_.Finish();
}
-flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Pool2DOptions> 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 @@
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 @@
int32_t dilation_h_factor() const {
return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
@@ -8090,15 +8090,15 @@
VerifyField<int32_t>(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<DepthwiseConv2DOptions> 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<DepthwiseConv2DOptions> 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<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
@@ -8120,19 +8120,19 @@
void add_dilation_h_factor(int32_t dilation_h_factor) {
fbb_.AddElement<int32_t>(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<DepthwiseConv2DOptions> Finish() {
+ ::flatbuffers::Offset<DepthwiseConv2DOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
+ auto o = ::flatbuffers::Offset<DepthwiseConv2DOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::Padding padding = tflite::Padding_SAME,
int32_t stride_w = 0,
int32_t stride_h = 0,
@@ -8151,16 +8151,16 @@
return builder_.Finish();
}
-flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<DepthwiseConv2DOptions> 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<int32_t> num_columns_per_channel{};
std::vector<int32_t> 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 @@
int32_t num_channels() const {
return GetField<int32_t>(VT_NUM_CHANNELS, 0);
}
- const flatbuffers::Vector<int32_t> *num_columns_per_channel() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
+ const ::flatbuffers::Vector<int32_t> *num_columns_per_channel() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
}
- const flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
+ const ::flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NUM_CHANNELS, 4) &&
VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
@@ -8186,40 +8186,40 @@
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<ConcatEmbeddingsOptions> 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<ConcatEmbeddingsOptions> 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<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
}
- void add_num_columns_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel) {
+ void add_num_columns_per_channel(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> num_columns_per_channel) {
fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
}
- void add_embedding_dim_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel) {
+ void add_embedding_dim_per_channel(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> 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<ConcatEmbeddingsOptions> Finish() {
+ ::flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
+ auto o = ::flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t num_channels = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0) {
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> 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 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t num_channels = 0,
const std::vector<int32_t> *num_columns_per_channel = nullptr,
const std::vector<int32_t> *embedding_dim_per_channel = nullptr) {
@@ -8241,14 +8241,14 @@
embedding_dim_per_channel__);
}
-flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ConcatEmbeddingsOptions> 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 @@
tflite::LSHProjectionType type() const {
return static_cast<tflite::LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<LSHProjectionOptions> 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<LSHProjectionOptions> 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<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
}
- explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit LSHProjectionOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<LSHProjectionOptions> Finish() {
+ ::flatbuffers::Offset<LSHProjectionOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
+ auto o = ::flatbuffers::Offset<LSHProjectionOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::LSHProjectionType type = tflite::LSHProjectionType_UNKNOWN) {
LSHProjectionOptionsBuilder builder_(_fbb);
builder_.add_type(type);
return builder_.Finish();
}
-flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LSHProjectionOptions> 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 @@
bool asymmetric_quantize_inputs() const {
return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_RANK, 4) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<uint8_t>(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<SVDFOptions> 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<SVDFOptions> 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<int32_t>(SVDFOptions::VT_RANK, rank, 0);
}
@@ -8344,19 +8344,19 @@
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
}
- explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SVDFOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SVDFOptions> Finish() {
+ ::flatbuffers::Offset<SVDFOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SVDFOptions>(end);
+ auto o = ::flatbuffers::Offset<SVDFOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SVDFOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SVDFOptions> 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 @@
bool asymmetric_quantize_inputs() const {
return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<uint8_t>(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<RNNOptions> 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<RNNOptions> 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<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
}
- explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit RNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<RNNOptions> Finish() {
+ ::flatbuffers::Offset<RNNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<RNNOptions>(end);
+ auto o = ::flatbuffers::Offset<RNNOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<RNNOptions> CreateRNNOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
bool asymmetric_quantize_inputs = false) {
RNNOptionsBuilder builder_(_fbb);
@@ -8430,16 +8430,16 @@
return builder_.Finish();
}
-flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<RNNOptions> 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 @@
bool asymmetric_quantize_inputs() const {
return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<uint8_t>(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<SequenceRNNOptions> 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<SequenceRNNOptions> 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<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
}
@@ -8481,19 +8481,19 @@
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
}
- explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SequenceRNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SequenceRNNOptions> Finish() {
+ ::flatbuffers::Offset<SequenceRNNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
+ auto o = ::flatbuffers::Offset<SequenceRNNOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SequenceRNNOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SequenceRNNOptions> 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 @@
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 @@
bool asymmetric_quantize_inputs() const {
return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
@@ -8543,15 +8543,15 @@
VerifyField<uint8_t>(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<BidirectionalSequenceRNNOptions> 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<BidirectionalSequenceRNNOptions> 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<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
}
@@ -8564,19 +8564,19 @@
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
}
- explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit BidirectionalSequenceRNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
+ ::flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
+ auto o = ::flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool time_major = false,
tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
bool merge_outputs = false,
@@ -8589,9 +8589,9 @@
return builder_.Finish();
}
-flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<BidirectionalSequenceRNNOptions> 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 @@
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 @@
tflite::TensorType quantized_bias_type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT, 1) &&
@@ -8634,15 +8634,15 @@
VerifyField<int8_t>(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<FullyConnectedOptions> 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<FullyConnectedOptions> 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<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
@@ -8658,19 +8658,19 @@
void add_quantized_bias_type(tflite::TensorType quantized_bias_type) {
fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(quantized_bias_type), 0);
}
- explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit FullyConnectedOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<FullyConnectedOptions> Finish() {
+ ::flatbuffers::Offset<FullyConnectedOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
+ auto o = ::flatbuffers::Offset<FullyConnectedOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<FullyConnectedOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<FullyConnectedOptions> 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 @@
float beta() const {
return GetField<float>(VT_BETA, 0.0f);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(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<SoftmaxOptions> 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<SoftmaxOptions> 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<float>(SoftmaxOptions::VT_BETA, beta, 0.0f);
}
- explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SoftmaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SoftmaxOptions> Finish() {
+ ::flatbuffers::Offset<SoftmaxOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SoftmaxOptions>(end);
+ auto o = ::flatbuffers::Offset<SoftmaxOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
float beta = 0.0f) {
SoftmaxOptionsBuilder builder_(_fbb);
builder_.add_beta(beta);
return builder_.Finish();
}
-flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SoftmaxOptions> 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 @@
tflite::ActivationFunctionType fused_activation_function() const {
return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
VerifyField<int8_t>(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<ConcatenationOptions> 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<ConcatenationOptions> 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<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0);
}
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ConcatenationOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ConcatenationOptions> Finish() {
+ ::flatbuffers::Offset<ConcatenationOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ConcatenationOptions>(end);
+ auto o = ::flatbuffers::Offset<ConcatenationOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t axis = 0,
tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
ConcatenationOptionsBuilder builder_(_fbb);
@@ -8800,15 +8800,15 @@
return builder_.Finish();
}
-flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ConcatenationOptions> 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 @@
bool pot_scale_int16() const {
return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<uint8_t>(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<AddOptions> 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<AddOptions> 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<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_pot_scale_int16(bool pot_scale_int16) {
fbb_.AddElement<uint8_t>(AddOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), 1);
}
- explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit AddOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<AddOptions> Finish() {
+ ::flatbuffers::Offset<AddOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<AddOptions>(end);
+ auto o = ::flatbuffers::Offset<AddOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<AddOptions> CreateAddOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<AddOptions> CreateAddOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
bool pot_scale_int16 = true) {
AddOptionsBuilder builder_(_fbb);
@@ -8863,14 +8863,14 @@
return builder_.Finish();
}
-flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<AddOptions> 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 @@
tflite::ActivationFunctionType fused_activation_function() const {
return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<MulOptions> 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<MulOptions> 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<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit MulOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<MulOptions> Finish() {
+ ::flatbuffers::Offset<MulOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<MulOptions>(end);
+ auto o = ::flatbuffers::Offset<MulOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<MulOptions> CreateMulOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<MulOptions> 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<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<MulOptions> 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 @@
tflite::ActivationFunctionType fused_activation_function() const {
return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<L2NormOptions> 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<L2NormOptions> 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<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit L2NormOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<L2NormOptions> Finish() {
+ ::flatbuffers::Offset<L2NormOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<L2NormOptions>(end);
+ auto o = ::flatbuffers::Offset<L2NormOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<L2NormOptions> 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<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<L2NormOptions> 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 @@
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 @@
float beta() const {
return GetField<float>(VT_BETA, 0.0f);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_RADIUS, 4) &&
VerifyField<float>(verifier, VT_BIAS, 4) &&
@@ -9006,15 +9006,15 @@
VerifyField<float>(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<LocalResponseNormalizationOptions> 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<LocalResponseNormalizationOptions> 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<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
}
@@ -9027,19 +9027,19 @@
void add_beta(float beta) {
fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
}
- explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit LocalResponseNormalizationOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
+ ::flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
+ auto o = ::flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t radius = 0,
float bias = 0.0f,
float alpha = 0.0f,
@@ -9052,9 +9052,9 @@
return builder_.Finish();
}
-flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LocalResponseNormalizationOptions> 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 @@
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 @@
bool asymmetric_quantize_inputs() const {
return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
@@ -9097,15 +9097,15 @@
VerifyField<uint8_t>(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<LSTMOptions> 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<LSTMOptions> 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<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
@@ -9121,19 +9121,19 @@
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
}
- explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit LSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<LSTMOptions> Finish() {
+ ::flatbuffers::Offset<LSTMOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LSTMOptions>(end);
+ auto o = ::flatbuffers::Offset<LSTMOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<LSTMOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LSTMOptions> 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 @@
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 @@
bool diagonal_recurrent_tensors() const {
return GetField<uint8_t>(VT_DIAGONAL_RECURRENT_TENSORS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
@@ -9199,15 +9199,15 @@
VerifyField<uint8_t>(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<UnidirectionalSequenceLSTMOptions> 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<UnidirectionalSequenceLSTMOptions> 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<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
@@ -9226,19 +9226,19 @@
void add_diagonal_recurrent_tensors(bool diagonal_recurrent_tensors) {
fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_DIAGONAL_RECURRENT_TENSORS, static_cast<uint8_t>(diagonal_recurrent_tensors), 0);
}
- explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit UnidirectionalSequenceLSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() {
+ ::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
+ auto o = ::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> 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 @@
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 @@
bool asymmetric_quantize_inputs() const {
return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
@@ -9306,15 +9306,15 @@
VerifyField<uint8_t>(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<BidirectionalSequenceLSTMOptions> 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<BidirectionalSequenceLSTMOptions> 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<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
@@ -9333,19 +9333,19 @@
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
}
- explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit BidirectionalSequenceLSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() {
+ ::flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
+ auto o = ::flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<BidirectionalSequenceLSTMOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<BidirectionalSequenceLSTMOptions> 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 @@
bool half_pixel_centers() const {
return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS, 1) &&
VerifyField<uint8_t>(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<ResizeBilinearOptions> 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<ResizeBilinearOptions> 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<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
}
void add_half_pixel_centers(bool half_pixel_centers) {
fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), 0);
}
- explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ResizeBilinearOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ResizeBilinearOptions> Finish() {
+ ::flatbuffers::Offset<ResizeBilinearOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
+ auto o = ::flatbuffers::Offset<ResizeBilinearOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool align_corners = false,
bool half_pixel_centers = false) {
ResizeBilinearOptionsBuilder builder_(_fbb);
@@ -9425,15 +9425,15 @@
return builder_.Finish();
}
-flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ResizeBilinearOptions> 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 @@
bool half_pixel_centers() const {
return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS, 1) &&
VerifyField<uint8_t>(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<ResizeNearestNeighborOptions> 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<ResizeNearestNeighborOptions> 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<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
}
void add_half_pixel_centers(bool half_pixel_centers) {
fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), 0);
}
- explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ResizeNearestNeighborOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() {
+ ::flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
+ auto o = ::flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool align_corners = false,
bool half_pixel_centers = false) {
ResizeNearestNeighborOptionsBuilder builder_(_fbb);
@@ -9488,14 +9488,14 @@
return builder_.Finish();
}
-flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ResizeNearestNeighborOptions> 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 @@
uint32_t subgraph() const {
return GetField<uint32_t>(VT_SUBGRAPH, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(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<CallOptions> 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<CallOptions> 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<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
}
- explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit CallOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<CallOptions> Finish() {
+ ::flatbuffers::Offset<CallOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<CallOptions>(end);
+ auto o = ::flatbuffers::Offset<CallOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<CallOptions> CreateCallOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<CallOptions> CreateCallOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t subgraph = 0) {
CallOptionsBuilder builder_(_fbb);
builder_.add_subgraph(subgraph);
return builder_.Finish();
}
-flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<CallOptions> 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<PadOptions> 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<PadOptions> 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<PadOptions> Finish() {
+ ::flatbuffers::Offset<PadOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<PadOptions>(end);
+ auto o = ::flatbuffers::Offset<PadOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<PadOptions> CreatePadOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<PadOptions> CreatePadOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
PadOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<PadOptions> 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<PadV2Options> 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<PadV2Options> 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<PadV2Options> Finish() {
+ ::flatbuffers::Offset<PadV2Options> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<PadV2Options>(end);
+ auto o = ::flatbuffers::Offset<PadV2Options>(end);
return o;
}
};
-inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<PadV2Options> CreatePadV2Options(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
PadV2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<PadV2Options> 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<int32_t> 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<int32_t> *new_shape() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
+ const ::flatbuffers::Vector<int32_t> *new_shape() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(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<ReshapeOptions> 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<ReshapeOptions> 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<flatbuffers::Vector<int32_t>> new_shape) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_new_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> 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<ReshapeOptions> Finish() {
+ ::flatbuffers::Offset<ReshapeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ReshapeOptions>(end);
+ auto o = ::flatbuffers::Offset<ReshapeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0) {
+inline ::flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> new_shape = 0) {
ReshapeOptionsBuilder builder_(_fbb);
builder_.add_new_shape(new_shape);
return builder_.Finish();
}
-inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *new_shape = nullptr) {
auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0;
return tflite::CreateReshapeOptions(
@@ -9680,94 +9680,94 @@
new_shape__);
}
-flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ReshapeOptions> 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<SpaceToBatchNDOptions> 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<SpaceToBatchNDOptions> 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<SpaceToBatchNDOptions> Finish() {
+ ::flatbuffers::Offset<SpaceToBatchNDOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
+ auto o = ::flatbuffers::Offset<SpaceToBatchNDOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
SpaceToBatchNDOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SpaceToBatchNDOptions> 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<BatchToSpaceNDOptions> 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<BatchToSpaceNDOptions> 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<BatchToSpaceNDOptions> Finish() {
+ ::flatbuffers::Offset<BatchToSpaceNDOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
+ auto o = ::flatbuffers::Offset<BatchToSpaceNDOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
BatchToSpaceNDOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<BatchToSpaceNDOptions> 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 @@
bool include_all_ngrams() const {
return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NGRAM_SIZE, 4) &&
VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE, 4) &&
VerifyField<uint8_t>(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<SkipGramOptions> 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<SkipGramOptions> 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<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
}
@@ -9809,19 +9809,19 @@
void add_include_all_ngrams(bool include_all_ngrams) {
fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), 0);
}
- explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SkipGramOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SkipGramOptions> Finish() {
+ ::flatbuffers::Offset<SkipGramOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SkipGramOptions>(end);
+ auto o = ::flatbuffers::Offset<SkipGramOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t ngram_size = 0,
int32_t max_skip_size = 0,
bool include_all_ngrams = false) {
@@ -9832,14 +9832,14 @@
return builder_.Finish();
}
-flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SkipGramOptions> 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 @@
int32_t block_size() const {
return GetField<int32_t>(VT_BLOCK_SIZE, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(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<SpaceToDepthOptions> 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<SpaceToDepthOptions> 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<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
}
- explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SpaceToDepthOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SpaceToDepthOptions> Finish() {
+ ::flatbuffers::Offset<SpaceToDepthOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
+ auto o = ::flatbuffers::Offset<SpaceToDepthOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t block_size = 0) {
SpaceToDepthOptionsBuilder builder_(_fbb);
builder_.add_block_size(block_size);
return builder_.Finish();
}
-flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SpaceToDepthOptions> 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 @@
int32_t block_size() const {
return GetField<int32_t>(VT_BLOCK_SIZE, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(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<DepthToSpaceOptions> 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<DepthToSpaceOptions> 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<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
}
- explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit DepthToSpaceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<DepthToSpaceOptions> Finish() {
+ ::flatbuffers::Offset<DepthToSpaceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
+ auto o = ::flatbuffers::Offset<DepthToSpaceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t block_size = 0) {
DepthToSpaceOptionsBuilder builder_(_fbb);
builder_.add_block_size(block_size);
return builder_.Finish();
}
-flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<DepthToSpaceOptions> 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 @@
bool pot_scale_int16() const {
return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
VerifyField<uint8_t>(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<SubOptions> 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<SubOptions> 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<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_pot_scale_int16(bool pot_scale_int16) {
fbb_.AddElement<uint8_t>(SubOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), 1);
}
- explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SubOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SubOptions> Finish() {
+ ::flatbuffers::Offset<SubOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SubOptions>(end);
+ auto o = ::flatbuffers::Offset<SubOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SubOptions> CreateSubOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SubOptions> CreateSubOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
bool pot_scale_int16 = true) {
SubOptionsBuilder builder_(_fbb);
@@ -9999,14 +9999,14 @@
return builder_.Finish();
}
-flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SubOptions> 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 @@
tflite::ActivationFunctionType fused_activation_function() const {
return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<DivOptions> 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<DivOptions> 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<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit DivOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<DivOptions> Finish() {
+ ::flatbuffers::Offset<DivOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<DivOptions>(end);
+ auto o = ::flatbuffers::Offset<DivOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<DivOptions> CreateDivOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<DivOptions> 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<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<DivOptions> 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<TopKV2Options> 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<TopKV2Options> 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<TopKV2Options> Finish() {
+ ::flatbuffers::Offset<TopKV2Options> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<TopKV2Options>(end);
+ auto o = ::flatbuffers::Offset<TopKV2Options>(end);
return o;
}
};
-inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
TopKV2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<TopKV2Options> 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 @@
tflite::CombinerType combiner() const {
return static_cast<tflite::CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<EmbeddingLookupSparseOptions> 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<EmbeddingLookupSparseOptions> 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<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), 0);
}
- explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit EmbeddingLookupSparseOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
+ ::flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
+ auto o = ::flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::CombinerType combiner = tflite::CombinerType_SUM) {
EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
builder_.add_combiner(combiner);
return builder_.Finish();
}
-flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<EmbeddingLookupSparseOptions> 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 @@
int32_t batch_dims() const {
return GetField<int32_t>(VT_BATCH_DIMS, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
VerifyField<int32_t>(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<GatherOptions> 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<GatherOptions> 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<int32_t>(GatherOptions::VT_AXIS, axis, 0);
}
void add_batch_dims(int32_t batch_dims) {
fbb_.AddElement<int32_t>(GatherOptions::VT_BATCH_DIMS, batch_dims, 0);
}
- explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit GatherOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<GatherOptions> Finish() {
+ ::flatbuffers::Offset<GatherOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<GatherOptions>(end);
+ auto o = ::flatbuffers::Offset<GatherOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<GatherOptions> CreateGatherOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t axis = 0,
int32_t batch_dims = 0) {
GatherOptionsBuilder builder_(_fbb);
@@ -10205,131 +10205,131 @@
return builder_.Finish();
}
-flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<GatherOptions> 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<TransposeOptions> 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<TransposeOptions> 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<TransposeOptions> Finish() {
+ ::flatbuffers::Offset<TransposeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<TransposeOptions>(end);
+ auto o = ::flatbuffers::Offset<TransposeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
TransposeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<TransposeOptions> 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<ExpOptions> 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<ExpOptions> 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<ExpOptions> Finish() {
+ ::flatbuffers::Offset<ExpOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ExpOptions>(end);
+ auto o = ::flatbuffers::Offset<ExpOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ExpOptions> CreateExpOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<ExpOptions> CreateExpOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
ExpOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ExpOptions> 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<CosOptions> 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<CosOptions> 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<CosOptions> Finish() {
+ ::flatbuffers::Offset<CosOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<CosOptions>(end);
+ auto o = ::flatbuffers::Offset<CosOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<CosOptions> CreateCosOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<CosOptions> CreateCosOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
CosOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<CosOptions> 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 @@
bool keep_dims() const {
return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(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<ReducerOptions> 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<ReducerOptions> 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<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
}
- explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ReducerOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ReducerOptions> Finish() {
+ ::flatbuffers::Offset<ReducerOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ReducerOptions>(end);
+ auto o = ::flatbuffers::Offset<ReducerOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ReducerOptions> CreateReducerOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool keep_dims = false) {
ReducerOptionsBuilder builder_(_fbb);
builder_.add_keep_dims(keep_dims);
return builder_.Finish();
}
-flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ReducerOptions> 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<int32_t> 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<int32_t> *squeeze_dims() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
+ const ::flatbuffers::Vector<int32_t> *squeeze_dims() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(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<SqueezeOptions> 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<SqueezeOptions> 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<flatbuffers::Vector<int32_t>> squeeze_dims) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_squeeze_dims(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> 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<SqueezeOptions> Finish() {
+ ::flatbuffers::Offset<SqueezeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SqueezeOptions>(end);
+ auto o = ::flatbuffers::Offset<SqueezeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0) {
+inline ::flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> squeeze_dims = 0) {
SqueezeOptionsBuilder builder_(_fbb);
builder_.add_squeeze_dims(squeeze_dims);
return builder_.Finish();
}
-inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *squeeze_dims = nullptr) {
auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0;
return tflite::CreateSqueezeOptions(
@@ -10436,14 +10436,14 @@
squeeze_dims__);
}
-flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SqueezeOptions> 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 @@
int32_t num_splits() const {
return GetField<int32_t>(VT_NUM_SPLITS, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(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<SplitOptions> 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<SplitOptions> 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<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
}
- explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SplitOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SplitOptions> Finish() {
+ ::flatbuffers::Offset<SplitOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SplitOptions>(end);
+ auto o = ::flatbuffers::Offset<SplitOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SplitOptions> CreateSplitOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t num_splits = 0) {
SplitOptionsBuilder builder_(_fbb);
builder_.add_num_splits(num_splits);
return builder_.Finish();
}
-flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SplitOptions> 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 @@
int32_t num_splits() const {
return GetField<int32_t>(VT_NUM_SPLITS, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(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<SplitVOptions> 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<SplitVOptions> 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<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
}
- explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SplitVOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SplitVOptions> Finish() {
+ ::flatbuffers::Offset<SplitVOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SplitVOptions>(end);
+ auto o = ::flatbuffers::Offset<SplitVOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t num_splits = 0) {
SplitVOptionsBuilder builder_(_fbb);
builder_.add_num_splits(num_splits);
return builder_.Finish();
}
-flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SplitVOptions> 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 @@
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 @@
bool offset() const {
return GetField<uint8_t>(VT_OFFSET, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_BEGIN_MASK, 4) &&
VerifyField<int32_t>(verifier, VT_END_MASK, 4) &&
@@ -10591,15 +10591,15 @@
VerifyField<uint8_t>(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<StridedSliceOptions> 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<StridedSliceOptions> 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<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
}
@@ -10618,19 +10618,19 @@
void add_offset(bool offset) {
fbb_.AddElement<uint8_t>(StridedSliceOptions::VT_OFFSET, static_cast<uint8_t>(offset), 0);
}
- explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit StridedSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<StridedSliceOptions> Finish() {
+ ::flatbuffers::Offset<StridedSliceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<StridedSliceOptions>(end);
+ auto o = ::flatbuffers::Offset<StridedSliceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t begin_mask = 0,
int32_t end_mask = 0,
int32_t ellipsis_mask = 0,
@@ -10647,54 +10647,54 @@
return builder_.Finish();
}
-flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<StridedSliceOptions> 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<LogSoftmaxOptions> 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<LogSoftmaxOptions> 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<LogSoftmaxOptions> Finish() {
+ ::flatbuffers::Offset<LogSoftmaxOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
+ auto o = ::flatbuffers::Offset<LogSoftmaxOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
LogSoftmaxOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LogSoftmaxOptions> 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 @@
tflite::TensorType out_data_type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE, 1) &&
VerifyField<int8_t>(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<CastOptions> 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<CastOptions> 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<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
}
void add_out_data_type(tflite::TensorType out_data_type) {
fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
}
- explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit CastOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<CastOptions> Finish() {
+ ::flatbuffers::Offset<CastOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<CastOptions>(end);
+ auto o = ::flatbuffers::Offset<CastOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<CastOptions> CreateCastOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<CastOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<CastOptions> 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<DequantizeOptions> 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<DequantizeOptions> 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<DequantizeOptions> Finish() {
+ ::flatbuffers::Offset<DequantizeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<DequantizeOptions>(end);
+ auto o = ::flatbuffers::Offset<DequantizeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
DequantizeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<DequantizeOptions> 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<MaximumMinimumOptions> 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<MaximumMinimumOptions> 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<MaximumMinimumOptions> Finish() {
+ ::flatbuffers::Offset<MaximumMinimumOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
+ auto o = ::flatbuffers::Offset<MaximumMinimumOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
MaximumMinimumOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<MaximumMinimumOptions> 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<TileOptions> 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<TileOptions> 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<TileOptions> Finish() {
+ ::flatbuffers::Offset<TileOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<TileOptions>(end);
+ auto o = ::flatbuffers::Offset<TileOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<TileOptions> CreateTileOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<TileOptions> CreateTileOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
TileOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<TileOptions> 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 @@
tflite::TensorType output_type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<ArgMaxOptions> 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<ArgMaxOptions> 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<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
}
- explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ArgMaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ArgMaxOptions> Finish() {
+ ::flatbuffers::Offset<ArgMaxOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ArgMaxOptions>(end);
+ auto o = ::flatbuffers::Offset<ArgMaxOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ArgMaxOptions> 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<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ArgMaxOptions> 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 @@
tflite::TensorType output_type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<ArgMinOptions> 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<ArgMinOptions> 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<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
}
- explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ArgMinOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ArgMinOptions> Finish() {
+ ::flatbuffers::Offset<ArgMinOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ArgMinOptions>(end);
+ auto o = ::flatbuffers::Offset<ArgMinOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ArgMinOptions> 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<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ArgMinOptions> 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<GreaterOptions> 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<GreaterOptions> 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<GreaterOptions> Finish() {
+ ::flatbuffers::Offset<GreaterOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<GreaterOptions>(end);
+ auto o = ::flatbuffers::Offset<GreaterOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
GreaterOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<GreaterOptions> 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<GreaterEqualOptions> 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<GreaterEqualOptions> 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<GreaterEqualOptions> Finish() {
+ ::flatbuffers::Offset<GreaterEqualOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
+ auto o = ::flatbuffers::Offset<GreaterEqualOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
GreaterEqualOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<GreaterEqualOptions> 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<LessOptions> 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<LessOptions> 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<LessOptions> Finish() {
+ ::flatbuffers::Offset<LessOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LessOptions>(end);
+ auto o = ::flatbuffers::Offset<LessOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LessOptions> CreateLessOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LessOptions> CreateLessOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
LessOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LessOptions> 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<LessEqualOptions> 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<LessEqualOptions> 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<LessEqualOptions> Finish() {
+ ::flatbuffers::Offset<LessEqualOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LessEqualOptions>(end);
+ auto o = ::flatbuffers::Offset<LessEqualOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
LessEqualOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LessEqualOptions> 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<NegOptions> 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<NegOptions> 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<NegOptions> Finish() {
+ ::flatbuffers::Offset<NegOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<NegOptions>(end);
+ auto o = ::flatbuffers::Offset<NegOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<NegOptions> CreateNegOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<NegOptions> CreateNegOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
NegOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<NegOptions> 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<SelectOptions> 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<SelectOptions> 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<SelectOptions> Finish() {
+ ::flatbuffers::Offset<SelectOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SelectOptions>(end);
+ auto o = ::flatbuffers::Offset<SelectOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<SelectOptions> CreateSelectOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
SelectOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SelectOptions> 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<SliceOptions> 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<SliceOptions> 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<SliceOptions> Finish() {
+ ::flatbuffers::Offset<SliceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SliceOptions>(end);
+ auto o = ::flatbuffers::Offset<SliceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<SliceOptions> CreateSliceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
SliceOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SliceOptions> 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 @@
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 @@
tflite::TensorType quantized_bias_type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
@@ -11288,15 +11288,15 @@
VerifyField<int8_t>(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<TransposeConvOptions> 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<TransposeConvOptions> 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<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
@@ -11312,19 +11312,19 @@
void add_quantized_bias_type(tflite::TensorType quantized_bias_type) {
fbb_.AddElement<int8_t>(TransposeConvOptions::VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(quantized_bias_type), 0);
}
- explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit TransposeConvOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<TransposeConvOptions> Finish() {
+ ::flatbuffers::Offset<TransposeConvOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<TransposeConvOptions>(end);
+ auto o = ::flatbuffers::Offset<TransposeConvOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::Padding padding = tflite::Padding_SAME,
int32_t stride_w = 0,
int32_t stride_h = 0,
@@ -11339,53 +11339,53 @@
return builder_.Finish();
}
-flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<TransposeConvOptions> 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<ExpandDimsOptions> 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<ExpandDimsOptions> 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<ExpandDimsOptions> Finish() {
+ ::flatbuffers::Offset<ExpandDimsOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
+ auto o = ::flatbuffers::Offset<ExpandDimsOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
ExpandDimsOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ExpandDimsOptions> 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 @@
bool validate_indices() const {
return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(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<SparseToDenseOptions> 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<SparseToDenseOptions> 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<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast<uint8_t>(validate_indices), 0);
}
- explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SparseToDenseOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SparseToDenseOptions> Finish() {
+ ::flatbuffers::Offset<SparseToDenseOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
+ auto o = ::flatbuffers::Offset<SparseToDenseOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool validate_indices = false) {
SparseToDenseOptionsBuilder builder_(_fbb);
builder_.add_validate_indices(validate_indices);
return builder_.Finish();
}
-flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SparseToDenseOptions> 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<EqualOptions> 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<EqualOptions> 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<EqualOptions> Finish() {
+ ::flatbuffers::Offset<EqualOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<EqualOptions>(end);
+ auto o = ::flatbuffers::Offset<EqualOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<EqualOptions> CreateEqualOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
EqualOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<EqualOptions> 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<NotEqualOptions> 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<NotEqualOptions> 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<NotEqualOptions> Finish() {
+ ::flatbuffers::Offset<NotEqualOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<NotEqualOptions>(end);
+ auto o = ::flatbuffers::Offset<NotEqualOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
NotEqualOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<NotEqualOptions> 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 @@
tflite::TensorType out_type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<ShapeOptions> 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<ShapeOptions> 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<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
}
- explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ShapeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ShapeOptions> Finish() {
+ ::flatbuffers::Offset<ShapeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ShapeOptions>(end);
+ auto o = ::flatbuffers::Offset<ShapeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ShapeOptions> 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<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ShapeOptions> 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<RankOptions> 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<RankOptions> 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<RankOptions> Finish() {
+ ::flatbuffers::Offset<RankOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<RankOptions>(end);
+ auto o = ::flatbuffers::Offset<RankOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<RankOptions> CreateRankOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<RankOptions> CreateRankOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
RankOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<RankOptions> 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<PowOptions> 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<PowOptions> 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<PowOptions> Finish() {
+ ::flatbuffers::Offset<PowOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<PowOptions>(end);
+ auto o = ::flatbuffers::Offset<PowOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<PowOptions> CreatePowOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<PowOptions> CreatePowOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
PowOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<PowOptions> 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 @@
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 @@
bool narrow_range() const {
return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_MIN, 4) &&
VerifyField<float>(verifier, VT_MAX, 4) &&
@@ -11677,15 +11677,15 @@
VerifyField<uint8_t>(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<FakeQuantOptions> 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<FakeQuantOptions> 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<float>(FakeQuantOptions::VT_MIN, min, 0.0f);
}
@@ -11698,19 +11698,19 @@
void add_narrow_range(bool narrow_range) {
fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range), 0);
}
- explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit FakeQuantOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<FakeQuantOptions> Finish() {
+ ::flatbuffers::Offset<FakeQuantOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<FakeQuantOptions>(end);
+ auto o = ::flatbuffers::Offset<FakeQuantOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
float min = 0.0f,
float max = 0.0f,
int32_t num_bits = 0,
@@ -11723,15 +11723,15 @@
return builder_.Finish();
}
-flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<FakeQuantOptions> 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 @@
int32_t axis() const {
return GetField<int32_t>(VT_AXIS, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_VALUES_COUNT, 4) &&
VerifyField<int32_t>(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<PackOptions> 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<PackOptions> 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<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
}
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0);
}
- explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit PackOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<PackOptions> Finish() {
+ ::flatbuffers::Offset<PackOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<PackOptions>(end);
+ auto o = ::flatbuffers::Offset<PackOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<PackOptions> CreatePackOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<PackOptions> CreatePackOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t values_count = 0,
int32_t axis = 0) {
PackOptionsBuilder builder_(_fbb);
@@ -11786,53 +11786,53 @@
return builder_.Finish();
}
-flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<PackOptions> 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<LogicalOrOptions> 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<LogicalOrOptions> 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<LogicalOrOptions> Finish() {
+ ::flatbuffers::Offset<LogicalOrOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LogicalOrOptions>(end);
+ auto o = ::flatbuffers::Offset<LogicalOrOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
LogicalOrOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LogicalOrOptions> 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 @@
int32_t axis() const {
return GetField<int32_t>(VT_AXIS, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(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<OneHotOptions> 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<OneHotOptions> 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<int32_t>(OneHotOptions::VT_AXIS, axis, 0);
}
- explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit OneHotOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<OneHotOptions> Finish() {
+ ::flatbuffers::Offset<OneHotOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<OneHotOptions>(end);
+ auto o = ::flatbuffers::Offset<OneHotOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t axis = 0) {
OneHotOptionsBuilder builder_(_fbb);
builder_.add_axis(axis);
return builder_.Finish();
}
-flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<OneHotOptions> 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<AbsOptions> 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<AbsOptions> 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<AbsOptions> Finish() {
+ ::flatbuffers::Offset<AbsOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<AbsOptions>(end);
+ auto o = ::flatbuffers::Offset<AbsOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<AbsOptions> CreateAbsOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
AbsOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<AbsOptions> 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<HardSwishOptions> 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<HardSwishOptions> 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<HardSwishOptions> Finish() {
+ ::flatbuffers::Offset<HardSwishOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<HardSwishOptions>(end);
+ auto o = ::flatbuffers::Offset<HardSwishOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
HardSwishOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<HardSwishOptions> 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<LogicalAndOptions> 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<LogicalAndOptions> 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<LogicalAndOptions> Finish() {
+ ::flatbuffers::Offset<LogicalAndOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LogicalAndOptions>(end);
+ auto o = ::flatbuffers::Offset<LogicalAndOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
LogicalAndOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LogicalAndOptions> 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<LogicalNotOptions> 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<LogicalNotOptions> 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<LogicalNotOptions> Finish() {
+ ::flatbuffers::Offset<LogicalNotOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LogicalNotOptions>(end);
+ auto o = ::flatbuffers::Offset<LogicalNotOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
LogicalNotOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LogicalNotOptions> 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 @@
int32_t axis() const {
return GetField<int32_t>(VT_AXIS, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NUM, 4) &&
VerifyField<int32_t>(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<UnpackOptions> 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<UnpackOptions> 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<int32_t>(UnpackOptions::VT_NUM, num, 0);
}
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0);
}
- explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit UnpackOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<UnpackOptions> Finish() {
+ ::flatbuffers::Offset<UnpackOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<UnpackOptions>(end);
+ auto o = ::flatbuffers::Offset<UnpackOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t num = 0,
int32_t axis = 0) {
UnpackOptionsBuilder builder_(_fbb);
@@ -12096,248 +12096,248 @@
return builder_.Finish();
}
-flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<UnpackOptions> 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<FloorDivOptions> 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<FloorDivOptions> 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<FloorDivOptions> Finish() {
+ ::flatbuffers::Offset<FloorDivOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<FloorDivOptions>(end);
+ auto o = ::flatbuffers::Offset<FloorDivOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
FloorDivOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<FloorDivOptions> 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<SquareOptions> 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<SquareOptions> 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<SquareOptions> Finish() {
+ ::flatbuffers::Offset<SquareOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SquareOptions>(end);
+ auto o = ::flatbuffers::Offset<SquareOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<SquareOptions> CreateSquareOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
SquareOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SquareOptions> 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<ZerosLikeOptions> 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<ZerosLikeOptions> 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<ZerosLikeOptions> Finish() {
+ ::flatbuffers::Offset<ZerosLikeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
+ auto o = ::flatbuffers::Offset<ZerosLikeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
ZerosLikeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ZerosLikeOptions> 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<FillOptions> 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<FillOptions> 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<FillOptions> Finish() {
+ ::flatbuffers::Offset<FillOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<FillOptions>(end);
+ auto o = ::flatbuffers::Offset<FillOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<FillOptions> CreateFillOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<FillOptions> CreateFillOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
FillOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<FillOptions> 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<FloorModOptions> 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<FloorModOptions> 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<FloorModOptions> Finish() {
+ ::flatbuffers::Offset<FloorModOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<FloorModOptions>(end);
+ auto o = ::flatbuffers::Offset<FloorModOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
FloorModOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<FloorModOptions> 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<RangeOptions> 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<RangeOptions> 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<RangeOptions> Finish() {
+ ::flatbuffers::Offset<RangeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<RangeOptions>(end);
+ auto o = ::flatbuffers::Offset<RangeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<RangeOptions> CreateRangeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
RangeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<RangeOptions> 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 @@
float alpha() const {
return GetField<float>(VT_ALPHA, 0.0f);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<float>(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<LeakyReluOptions> 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<LeakyReluOptions> 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<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f);
}
- explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit LeakyReluOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<LeakyReluOptions> Finish() {
+ ::flatbuffers::Offset<LeakyReluOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<LeakyReluOptions>(end);
+ auto o = ::flatbuffers::Offset<LeakyReluOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
float alpha = 0.0f) {
LeakyReluOptionsBuilder builder_(_fbb);
builder_.add_alpha(alpha);
return builder_.Finish();
}
-flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<LeakyReluOptions> 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<SquaredDifferenceOptions> 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<SquaredDifferenceOptions> 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<SquaredDifferenceOptions> Finish() {
+ ::flatbuffers::Offset<SquaredDifferenceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
+ auto o = ::flatbuffers::Offset<SquaredDifferenceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
SquaredDifferenceOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SquaredDifferenceOptions> 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 @@
tflite::MirrorPadMode mode() const {
return static_cast<tflite::MirrorPadMode>(GetField<int8_t>(VT_MODE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<MirrorPadOptions> 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<MirrorPadOptions> 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<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
}
- explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit MirrorPadOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<MirrorPadOptions> Finish() {
+ ::flatbuffers::Offset<MirrorPadOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<MirrorPadOptions>(end);
+ auto o = ::flatbuffers::Offset<MirrorPadOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
tflite::MirrorPadMode mode = tflite::MirrorPadMode_REFLECT) {
MirrorPadOptionsBuilder builder_(_fbb);
builder_.add_mode(mode);
return builder_.Finish();
}
-flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<MirrorPadOptions> 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 @@
tflite::TensorType idx_out_type() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(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<UniqueOptions> 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<UniqueOptions> 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<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
}
- explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit UniqueOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<UniqueOptions> Finish() {
+ ::flatbuffers::Offset<UniqueOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<UniqueOptions>(end);
+ auto o = ::flatbuffers::Offset<UniqueOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<UniqueOptions> 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<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<UniqueOptions> 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<ReverseV2Options> 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<ReverseV2Options> 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<ReverseV2Options> Finish() {
+ ::flatbuffers::Offset<ReverseV2Options> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ReverseV2Options>(end);
+ auto o = ::flatbuffers::Offset<ReverseV2Options>(end);
return o;
}
};
-inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
ReverseV2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ReverseV2Options> 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<AddNOptions> 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<AddNOptions> 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<AddNOptions> Finish() {
+ ::flatbuffers::Offset<AddNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<AddNOptions>(end);
+ auto o = ::flatbuffers::Offset<AddNOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<AddNOptions> CreateAddNOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
AddNOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<AddNOptions> 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<GatherNdOptions> 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<GatherNdOptions> 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<GatherNdOptions> Finish() {
+ ::flatbuffers::Offset<GatherNdOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<GatherNdOptions>(end);
+ auto o = ::flatbuffers::Offset<GatherNdOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
GatherNdOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<GatherNdOptions> 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<WhereOptions> 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<WhereOptions> 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<WhereOptions> Finish() {
+ ::flatbuffers::Offset<WhereOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<WhereOptions>(end);
+ auto o = ::flatbuffers::Offset<WhereOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<WhereOptions> CreateWhereOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
WhereOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<WhereOptions> 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 @@
int32_t batch_dim() const {
return GetField<int32_t>(VT_BATCH_DIM, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SEQ_DIM, 4) &&
VerifyField<int32_t>(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<ReverseSequenceOptions> 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<ReverseSequenceOptions> 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<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
}
void add_batch_dim(int32_t batch_dim) {
fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
}
- explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ReverseSequenceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ReverseSequenceOptions> Finish() {
+ ::flatbuffers::Offset<ReverseSequenceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
+ auto o = ::flatbuffers::Offset<ReverseSequenceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t seq_dim = 0,
int32_t batch_dim = 0) {
ReverseSequenceOptionsBuilder builder_(_fbb);
@@ -12744,132 +12744,132 @@
return builder_.Finish();
}
-flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ReverseSequenceOptions> 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<MatrixDiagOptions> 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<MatrixDiagOptions> 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<MatrixDiagOptions> Finish() {
+ ::flatbuffers::Offset<MatrixDiagOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
+ auto o = ::flatbuffers::Offset<MatrixDiagOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
MatrixDiagOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<MatrixDiagOptions> 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<QuantizeOptions> 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<QuantizeOptions> 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<QuantizeOptions> Finish() {
+ ::flatbuffers::Offset<QuantizeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<QuantizeOptions>(end);
+ auto o = ::flatbuffers::Offset<QuantizeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
QuantizeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<QuantizeOptions> 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<MatrixSetDiagOptions> 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<MatrixSetDiagOptions> 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<MatrixSetDiagOptions> Finish() {
+ ::flatbuffers::Offset<MatrixSetDiagOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
+ auto o = ::flatbuffers::Offset<MatrixSetDiagOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
MatrixSetDiagOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<MatrixSetDiagOptions> 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 @@
int32_t else_subgraph_index() const {
return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX, 4) &&
VerifyField<int32_t>(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<IfOptions> 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<IfOptions> 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<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
}
void add_else_subgraph_index(int32_t else_subgraph_index) {
fbb_.AddElement<int32_t>(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<IfOptions> Finish() {
+ ::flatbuffers::Offset<IfOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<IfOptions>(end);
+ auto o = ::flatbuffers::Offset<IfOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<IfOptions> CreateIfOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<IfOptions> CreateIfOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t then_subgraph_index = 0,
int32_t else_subgraph_index = 0) {
IfOptionsBuilder builder_(_fbb);
@@ -12924,14 +12924,14 @@
return builder_.Finish();
}
-flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<IfOptions> 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 @@
int32_t init_subgraph_index() const {
return GetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(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<CallOnceOptions> 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<CallOnceOptions> 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<int32_t>(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<CallOnceOptions> Finish() {
+ ::flatbuffers::Offset<CallOnceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<CallOnceOptions>(end);
+ auto o = ::flatbuffers::Offset<CallOnceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<CallOnceOptions> 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<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<CallOnceOptions> 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 @@
int32_t body_subgraph_index() const {
return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX, 4) &&
VerifyField<int32_t>(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<WhileOptions> 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<WhileOptions> 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<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
}
void add_body_subgraph_index(int32_t body_subgraph_index) {
fbb_.AddElement<int32_t>(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<WhileOptions> Finish() {
+ ::flatbuffers::Offset<WhileOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<WhileOptions>(end);
+ auto o = ::flatbuffers::Offset<WhileOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<WhileOptions> CreateWhileOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t cond_subgraph_index = 0,
int32_t body_subgraph_index = 0) {
WhileOptionsBuilder builder_(_fbb);
@@ -13039,250 +13039,250 @@
return builder_.Finish();
}
-flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<WhileOptions> 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<NonMaxSuppressionV4Options> 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<NonMaxSuppressionV4Options> 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<NonMaxSuppressionV4Options> Finish() {
+ ::flatbuffers::Offset<NonMaxSuppressionV4Options> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
+ auto o = ::flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
return o;
}
};
-inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<NonMaxSuppressionV4Options> 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<NonMaxSuppressionV5Options> 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<NonMaxSuppressionV5Options> 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<NonMaxSuppressionV5Options> Finish() {
+ ::flatbuffers::Offset<NonMaxSuppressionV5Options> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
+ auto o = ::flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
return o;
}
};
-inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<NonMaxSuppressionV5Options> 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<ScatterNdOptions> 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<ScatterNdOptions> 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<ScatterNdOptions> Finish() {
+ ::flatbuffers::Offset<ScatterNdOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ScatterNdOptions>(end);
+ auto o = ::flatbuffers::Offset<ScatterNdOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
ScatterNdOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ScatterNdOptions> 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<SelectV2Options> 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<SelectV2Options> 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<SelectV2Options> Finish() {
+ ::flatbuffers::Offset<SelectV2Options> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SelectV2Options>(end);
+ auto o = ::flatbuffers::Offset<SelectV2Options>(end);
return o;
}
};
-inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
SelectV2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SelectV2Options> 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<DensifyOptions> 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<DensifyOptions> 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<DensifyOptions> Finish() {
+ ::flatbuffers::Offset<DensifyOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<DensifyOptions>(end);
+ auto o = ::flatbuffers::Offset<DensifyOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
DensifyOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<DensifyOptions> 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<SegmentSumOptions> 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<SegmentSumOptions> 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<SegmentSumOptions> Finish() {
+ ::flatbuffers::Offset<SegmentSumOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SegmentSumOptions>(end);
+ auto o = ::flatbuffers::Offset<SegmentSumOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
SegmentSumOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SegmentSumOptions> 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 @@
bool asymmetric_quantize_inputs() const {
return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_ADJ_X, 1) &&
VerifyField<uint8_t>(verifier, VT_ADJ_Y, 1) &&
VerifyField<uint8_t>(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<BatchMatMulOptions> 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<BatchMatMulOptions> 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<uint8_t>(BatchMatMulOptions::VT_ADJ_X, static_cast<uint8_t>(adj_x), 0);
}
@@ -13324,19 +13324,19 @@
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
}
- explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit BatchMatMulOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<BatchMatMulOptions> Finish() {
+ ::flatbuffers::Offset<BatchMatMulOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
+ auto o = ::flatbuffers::Offset<BatchMatMulOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool adj_x = false,
bool adj_y = false,
bool asymmetric_quantize_inputs = false) {
@@ -13347,15 +13347,15 @@
return builder_.Finish();
}
-flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<BatchMatMulOptions> 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 @@
bool reverse() const {
return GetField<uint8_t>(VT_REVERSE, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_EXCLUSIVE, 1) &&
VerifyField<uint8_t>(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<CumsumOptions> 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<CumsumOptions> 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<uint8_t>(CumsumOptions::VT_EXCLUSIVE, static_cast<uint8_t>(exclusive), 0);
}
void add_reverse(bool reverse) {
fbb_.AddElement<uint8_t>(CumsumOptions::VT_REVERSE, static_cast<uint8_t>(reverse), 0);
}
- explicit CumsumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit CumsumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<CumsumOptions> Finish() {
+ ::flatbuffers::Offset<CumsumOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<CumsumOptions>(end);
+ auto o = ::flatbuffers::Offset<CumsumOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool exclusive = false,
bool reverse = false) {
CumsumOptionsBuilder builder_(_fbb);
@@ -13410,94 +13410,94 @@
return builder_.Finish();
}
-flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<CumsumOptions> 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<BroadcastToOptions> 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<BroadcastToOptions> 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<BroadcastToOptions> Finish() {
+ ::flatbuffers::Offset<BroadcastToOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<BroadcastToOptions>(end);
+ auto o = ::flatbuffers::Offset<BroadcastToOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
BroadcastToOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<BroadcastToOptions> 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<Rfft2dOptions> 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<Rfft2dOptions> 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<Rfft2dOptions> Finish() {
+ ::flatbuffers::Offset<Rfft2dOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Rfft2dOptions>(end);
+ auto o = ::flatbuffers::Offset<Rfft2dOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
Rfft2dOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Rfft2dOptions> 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 @@
tflite::TensorType value_dtype() const {
return static_cast<tflite::TensorType>(GetField<int8_t>(VT_VALUE_DTYPE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_TABLE_ID, 4) &&
VerifyField<int8_t>(verifier, VT_KEY_DTYPE, 1) &&
VerifyField<int8_t>(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<HashtableOptions> 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<HashtableOptions> 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<int32_t>(HashtableOptions::VT_TABLE_ID, table_id, 0);
}
@@ -13539,19 +13539,19 @@
void add_value_dtype(tflite::TensorType value_dtype) {
fbb_.AddElement<int8_t>(HashtableOptions::VT_VALUE_DTYPE, static_cast<int8_t>(value_dtype), 0);
}
- explicit HashtableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit HashtableOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<HashtableOptions> Finish() {
+ ::flatbuffers::Offset<HashtableOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<HashtableOptions>(end);
+ auto o = ::flatbuffers::Offset<HashtableOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<HashtableOptions> 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 @@
return builder_.Finish();
}
-flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<HashtableOptions> 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<HashtableFindOptions> 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<HashtableFindOptions> 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<HashtableFindOptions> Finish() {
+ ::flatbuffers::Offset<HashtableFindOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<HashtableFindOptions>(end);
+ auto o = ::flatbuffers::Offset<HashtableFindOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
HashtableFindOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<HashtableFindOptions> 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<HashtableImportOptions> 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<HashtableImportOptions> 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<HashtableImportOptions> Finish() {
+ ::flatbuffers::Offset<HashtableImportOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<HashtableImportOptions>(end);
+ auto o = ::flatbuffers::Offset<HashtableImportOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
HashtableImportOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<HashtableImportOptions> 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<HashtableSizeOptions> 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<HashtableSizeOptions> 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<HashtableSizeOptions> Finish() {
+ ::flatbuffers::Offset<HashtableSizeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<HashtableSizeOptions>(end);
+ auto o = ::flatbuffers::Offset<HashtableSizeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
HashtableSizeOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<HashtableSizeOptions> 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<const flatbuffers::String *>(VT_CONTAINER);
+ const ::flatbuffers::String *container() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_CONTAINER);
}
- const flatbuffers::String *shared_name() const {
- return GetPointer<const flatbuffers::String *>(VT_SHARED_NAME);
+ const ::flatbuffers::String *shared_name() const {
+ return GetPointer<const ::flatbuffers::String *>(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 @@
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<VarHandleOptions> 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<VarHandleOptions> 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<flatbuffers::String> 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<flatbuffers::String> 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<VarHandleOptions> Finish() {
+ ::flatbuffers::Offset<VarHandleOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<VarHandleOptions>(end);
+ auto o = ::flatbuffers::Offset<VarHandleOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::String> container = 0,
- flatbuffers::Offset<flatbuffers::String> shared_name = 0) {
+inline ::flatbuffers::Offset<VarHandleOptions> 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<VarHandleOptions> CreateVarHandleOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const char *container = nullptr,
const char *shared_name = nullptr) {
auto container__ = container ? _fbb.CreateString(container) : 0;
@@ -13756,93 +13756,93 @@
shared_name__);
}
-flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<VarHandleOptions> 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<ReadVariableOptions> 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<ReadVariableOptions> 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<ReadVariableOptions> Finish() {
+ ::flatbuffers::Offset<ReadVariableOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ReadVariableOptions>(end);
+ auto o = ::flatbuffers::Offset<ReadVariableOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
ReadVariableOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ReadVariableOptions> 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<AssignVariableOptions> 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<AssignVariableOptions> 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<AssignVariableOptions> Finish() {
+ ::flatbuffers::Offset<AssignVariableOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<AssignVariableOptions>(end);
+ auto o = ::flatbuffers::Offset<AssignVariableOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
AssignVariableOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<AssignVariableOptions> 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 @@
int64_t seed2() const {
return GetField<int64_t>(VT_SEED2, 0);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int64_t>(verifier, VT_SEED, 8) &&
VerifyField<int64_t>(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<RandomOptions> 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<RandomOptions> 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<int64_t>(RandomOptions::VT_SEED, seed, 0);
}
void add_seed2(int64_t seed2) {
fbb_.AddElement<int64_t>(RandomOptions::VT_SEED2, seed2, 0);
}
- explicit RandomOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit RandomOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<RandomOptions> Finish() {
+ ::flatbuffers::Offset<RandomOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<RandomOptions>(end);
+ auto o = ::flatbuffers::Offset<RandomOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<RandomOptions> CreateRandomOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<RandomOptions> CreateRandomOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int64_t seed = 0,
int64_t seed2 = 0) {
RandomOptionsBuilder builder_(_fbb);
@@ -13897,61 +13897,61 @@
return builder_.Finish();
}
-flatbuffers::Offset<RandomOptions> CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<RandomOptions> 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<float> 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<float> *boundaries() const {
- return GetPointer<const flatbuffers::Vector<float> *>(VT_BOUNDARIES);
+ const ::flatbuffers::Vector<float> *boundaries() const {
+ return GetPointer<const ::flatbuffers::Vector<float> *>(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<BucketizeOptions> 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<BucketizeOptions> 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<flatbuffers::Vector<float>> boundaries) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_boundaries(::flatbuffers::Offset<::flatbuffers::Vector<float>> boundaries) {
fbb_.AddOffset(BucketizeOptions::VT_BOUNDARIES, boundaries);
}
- explicit BucketizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit BucketizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<BucketizeOptions> Finish() {
+ ::flatbuffers::Offset<BucketizeOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<BucketizeOptions>(end);
+ auto o = ::flatbuffers::Offset<BucketizeOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<float>> boundaries = 0) {
+inline ::flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<float>> boundaries = 0) {
BucketizeOptionsBuilder builder_(_fbb);
builder_.add_boundaries(boundaries);
return builder_.Finish();
}
-inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptionsDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<float> *boundaries = nullptr) {
auto boundaries__ = boundaries ? _fbb.CreateVector<float>(*boundaries) : 0;
return tflite::CreateBucketizeOptions(
@@ -13959,14 +13959,14 @@
boundaries__);
}
-flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<BucketizeOptions> 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 @@
bool approximate() const {
return GetField<uint8_t>(VT_APPROXIMATE, 0) != 0;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(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<GeluOptions> 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<GeluOptions> 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<uint8_t>(GeluOptions::VT_APPROXIMATE, static_cast<uint8_t>(approximate), 0);
}
- explicit GeluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit GeluOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<GeluOptions> Finish() {
+ ::flatbuffers::Offset<GeluOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<GeluOptions>(end);
+ auto o = ::flatbuffers::Offset<GeluOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<GeluOptions> CreateGeluOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<GeluOptions> CreateGeluOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
bool approximate = false) {
GeluOptionsBuilder builder_(_fbb);
builder_.add_approximate(approximate);
return builder_.Finish();
}
-flatbuffers::Offset<GeluOptions> CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<GeluOptions> 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<DynamicUpdateSliceOptions> 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<DynamicUpdateSliceOptions> 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<DynamicUpdateSliceOptions> Finish() {
+ ::flatbuffers::Offset<DynamicUpdateSliceOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<DynamicUpdateSliceOptions>(end);
+ auto o = ::flatbuffers::Offset<DynamicUpdateSliceOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
DynamicUpdateSliceOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<DynamicUpdateSliceOptions> 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<UnsortedSegmentProdOptions> 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<UnsortedSegmentProdOptions> 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<UnsortedSegmentProdOptions> Finish() {
+ ::flatbuffers::Offset<UnsortedSegmentProdOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<UnsortedSegmentProdOptions>(end);
+ auto o = ::flatbuffers::Offset<UnsortedSegmentProdOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
UnsortedSegmentProdOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<UnsortedSegmentProdOptions> 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<UnsortedSegmentMaxOptions> 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<UnsortedSegmentMaxOptions> 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<UnsortedSegmentMaxOptions> Finish() {
+ ::flatbuffers::Offset<UnsortedSegmentMaxOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<UnsortedSegmentMaxOptions>(end);
+ auto o = ::flatbuffers::Offset<UnsortedSegmentMaxOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
UnsortedSegmentMaxOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<UnsortedSegmentMaxOptions> 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<UnsortedSegmentSumOptions> 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<UnsortedSegmentSumOptions> 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<UnsortedSegmentSumOptions> Finish() {
+ ::flatbuffers::Offset<UnsortedSegmentSumOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<UnsortedSegmentSumOptions>(end);
+ auto o = ::flatbuffers::Offset<UnsortedSegmentSumOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
UnsortedSegmentSumOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<UnsortedSegmentSumOptions> 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<ATan2Options> 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<ATan2Options> 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<ATan2Options> Finish() {
+ ::flatbuffers::Offset<ATan2Options> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ATan2Options>(end);
+ auto o = ::flatbuffers::Offset<ATan2Options>(end);
return o;
}
};
-inline flatbuffers::Offset<ATan2Options> CreateATan2Options(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<ATan2Options> CreateATan2Options(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
ATan2OptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<ATan2Options> CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ATan2Options> 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<UnsortedSegmentMinOptions> 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<UnsortedSegmentMinOptions> 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<UnsortedSegmentMinOptions> Finish() {
+ ::flatbuffers::Offset<UnsortedSegmentMinOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<UnsortedSegmentMinOptions>(end);
+ auto o = ::flatbuffers::Offset<UnsortedSegmentMinOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
UnsortedSegmentMinOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<UnsortedSegmentMinOptions> 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<SignOptions> 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<SignOptions> 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<SignOptions> Finish() {
+ ::flatbuffers::Offset<SignOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SignOptions>(end);
+ auto o = ::flatbuffers::Offset<SignOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<SignOptions> CreateSignOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<SignOptions> CreateSignOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
SignOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<SignOptions> CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SignOptions> 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<BitcastOptions> 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<BitcastOptions> 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<BitcastOptions> Finish() {
+ ::flatbuffers::Offset<BitcastOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<BitcastOptions>(end);
+ auto o = ::flatbuffers::Offset<BitcastOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<BitcastOptions> CreateBitcastOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<BitcastOptions> CreateBitcastOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
BitcastOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<BitcastOptions> CreateBitcastOptions(flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<BitcastOptions> 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<BitwiseXorOptions> 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<BitwiseXorOptions> 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<BitwiseXorOptions> Finish() {
+ ::flatbuffers::Offset<BitwiseXorOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<BitwiseXorOptions>(end);
+ auto o = ::flatbuffers::Offset<BitwiseXorOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<BitwiseXorOptions> CreateBitwiseXorOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<BitwiseXorOptions> CreateBitwiseXorOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
BitwiseXorOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<BitwiseXorOptions> CreateBitwiseXorOptions(flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<BitwiseXorOptions> 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<RightShiftOptions> 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<RightShiftOptions> 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<RightShiftOptions> Finish() {
+ ::flatbuffers::Offset<RightShiftOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<RightShiftOptions>(end);
+ auto o = ::flatbuffers::Offset<RightShiftOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<RightShiftOptions> CreateRightShiftOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<RightShiftOptions> CreateRightShiftOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
RightShiftOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<RightShiftOptions> CreateRightShiftOptions(flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<RightShiftOptions> 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<DilateOptions> 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<DilateOptions> 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<DilateOptions> Finish() {
+ ::flatbuffers::Offset<DilateOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<DilateOptions>(end);
+ auto o = ::flatbuffers::Offset<DilateOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<DilateOptions> CreateDilateOptions(
- flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<DilateOptions> CreateDilateOptions(
+ ::flatbuffers::FlatBufferBuilder &_fbb) {
DilateOptionsBuilder builder_(_fbb);
return builder_.Finish();
}
-flatbuffers::Offset<DilateOptions> CreateDilateOptions(flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<DilateOptions> 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 @@
tflite::ReduceWindowFunction reduce_function() const {
return static_cast<tflite::ReduceWindowFunction>(GetField<int32_t>(VT_REDUCE_FUNCTION, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(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<ReduceWindowOptions> 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<ReduceWindowOptions> 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<int32_t>(ReduceWindowOptions::VT_REDUCE_FUNCTION, static_cast<int32_t>(reduce_function), 0);
}
- explicit ReduceWindowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit ReduceWindowOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<ReduceWindowOptions> Finish() {
+ ::flatbuffers::Offset<ReduceWindowOptions> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<ReduceWindowOptions>(end);
+ auto o = ::flatbuffers::Offset<ReduceWindowOptions>(end);
return o;
}
};
-inline flatbuffers::Offset<ReduceWindowOptions> CreateReduceWindowOptions(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ReduceWindowOptions> 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<ReduceWindowOptions> CreateReduceWindowOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<ReduceWindowOptions> 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 @@
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 @@
int8_t deprecated_builtin_code() const {
return GetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, 0);
}
- const flatbuffers::String *custom_code() const {
- return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
+ const ::flatbuffers::String *custom_code() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_CUSTOM_CODE);
}
int32_t version() const {
return GetField<int32_t>(VT_VERSION, 1);
@@ -14523,7 +14523,7 @@
tflite::BuiltinOperator builtin_code() const {
return static_cast<tflite::BuiltinOperator>(GetField<int32_t>(VT_BUILTIN_CODE, 0));
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_DEPRECATED_BUILTIN_CODE, 1) &&
VerifyOffset(verifier, VT_CUSTOM_CODE) &&
@@ -14532,19 +14532,19 @@
VerifyField<int32_t>(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<OperatorCode> 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<OperatorCode> 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<int8_t>(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, 0);
}
- void add_custom_code(flatbuffers::Offset<flatbuffers::String> 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 @@
void add_builtin_code(tflite::BuiltinOperator builtin_code) {
fbb_.AddElement<int32_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int32_t>(builtin_code), 0);
}
- explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit OperatorCodeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<OperatorCode> Finish() {
+ ::flatbuffers::Offset<OperatorCode> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<OperatorCode>(end);
+ auto o = ::flatbuffers::Offset<OperatorCode>(end);
return o;
}
};
-inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<OperatorCode> CreateOperatorCode(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int8_t deprecated_builtin_code = 0,
- flatbuffers::Offset<flatbuffers::String> 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 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
int8_t deprecated_builtin_code = 0,
const char *custom_code = nullptr,
int32_t version = 1,
@@ -14593,9 +14593,9 @@
builtin_code);
}
-flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<OperatorCode> 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<int32_t> inputs{};
@@ -14610,7 +14610,7 @@
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 @@
uint32_t opcode_index() const {
return GetField<uint32_t>(VT_OPCODE_INDEX, 0);
}
- const flatbuffers::Vector<int32_t> *inputs() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
+ const ::flatbuffers::Vector<int32_t> *inputs() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_INPUTS);
}
- const flatbuffers::Vector<int32_t> *outputs() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
+ const ::flatbuffers::Vector<int32_t> *outputs() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
}
tflite::BuiltinOptions builtin_options_type() const {
return static_cast<tflite::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
@@ -15022,17 +15022,17 @@
const tflite::RightShiftOptions *builtin_options_as_RightShiftOptions() const {
return builtin_options_type() == tflite::BuiltinOptions_RightShiftOptions ? static_cast<const tflite::RightShiftOptions *>(builtin_options()) : nullptr;
}
- const flatbuffers::Vector<uint8_t> *custom_options() const {
- return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
+ const ::flatbuffers::Vector<uint8_t> *custom_options() const {
+ return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
}
tflite::CustomOptionsFormat custom_options_format() const {
return static_cast<tflite::CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
}
- const flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const {
- return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
+ const ::flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const {
+ return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
}
- const flatbuffers::Vector<int32_t> *intermediates() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
+ const ::flatbuffers::Vector<int32_t> *intermediates() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
}
uint64_t large_custom_options_offset() const {
return GetField<uint64_t>(VT_LARGE_CUSTOM_OPTIONS_OFFSET, 0);
@@ -15107,7 +15107,7 @@
const tflite::ReduceWindowOptions *builtin_options_2_as_ReduceWindowOptions() const {
return builtin_options_2_type() == tflite::BuiltinOptions2_ReduceWindowOptions ? static_cast<const tflite::ReduceWindowOptions *>(builtin_options_2()) : nullptr;
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX, 4) &&
VerifyOffset(verifier, VT_INPUTS) &&
@@ -15131,9 +15131,9 @@
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<Operator> 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<Operator> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
template<> inline const tflite::Conv2DOptions *Operator::builtin_options_as<tflite::Conv2DOptions>() const {
@@ -15722,33 +15722,33 @@
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<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
}
- void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
+ void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs) {
fbb_.AddOffset(Operator::VT_INPUTS, inputs);
}
- void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
+ void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs) {
fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
}
void add_builtin_options_type(tflite::BuiltinOptions builtin_options_type) {
fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast<uint8_t>(builtin_options_type), 0);
}
- void add_builtin_options(flatbuffers::Offset<void> builtin_options) {
+ void add_builtin_options(::flatbuffers::Offset<void> builtin_options) {
fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
}
- void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options) {
+ void add_custom_options(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom_options) {
fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
}
void add_custom_options_format(tflite::CustomOptionsFormat custom_options_format) {
fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), 0);
}
- void add_mutating_variable_inputs(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs) {
+ void add_mutating_variable_inputs(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> mutating_variable_inputs) {
fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
}
- void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates) {
+ void add_intermediates(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> intermediates) {
fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
}
void add_large_custom_options_offset(uint64_t large_custom_options_offset) {
@@ -15760,35 +15760,35 @@
void add_builtin_options_2_type(tflite::BuiltinOptions2 builtin_options_2_type) {
fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_2_TYPE, static_cast<uint8_t>(builtin_options_2_type), 0);
}
- void add_builtin_options_2(flatbuffers::Offset<void> builtin_options_2) {
+ void add_builtin_options_2(::flatbuffers::Offset<void> 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<Operator> Finish() {
+ ::flatbuffers::Offset<Operator> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Operator>(end);
+ auto o = ::flatbuffers::Offset<Operator>(end);
return o;
}
};
-inline flatbuffers::Offset<Operator> CreateOperator(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Operator> CreateOperator(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t opcode_index = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs = 0,
tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE,
- flatbuffers::Offset<void> builtin_options = 0,
- flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
+ ::flatbuffers::Offset<void> builtin_options = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom_options = 0,
tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS,
- flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> 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<void> builtin_options_2 = 0) {
+ ::flatbuffers::Offset<void> 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 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<Operator> CreateOperatorDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Operator> CreateOperatorDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t opcode_index = 0,
const std::vector<int32_t> *inputs = nullptr,
const std::vector<int32_t> *outputs = nullptr,
tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE,
- flatbuffers::Offset<void> builtin_options = 0,
+ ::flatbuffers::Offset<void> builtin_options = 0,
const std::vector<uint8_t> *custom_options = nullptr,
tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS,
const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
@@ -15820,7 +15820,7 @@
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<void> builtin_options_2 = 0) {
+ ::flatbuffers::Offset<void> builtin_options_2 = 0) {
auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0;
@@ -15843,9 +15843,9 @@
builtin_options_2);
}
-flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Operator> 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<std::unique_ptr<tflite::TensorT>> tensors{};
std::vector<int32_t> inputs{};
@@ -15858,7 +15858,7 @@
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 @@
VT_OPERATORS = 10,
VT_NAME = 12
};
- const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> *tensors() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> *>(VT_TENSORS);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>> *tensors() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>> *>(VT_TENSORS);
}
- const flatbuffers::Vector<int32_t> *inputs() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
+ const ::flatbuffers::Vector<int32_t> *inputs() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_INPUTS);
}
- const flatbuffers::Vector<int32_t> *outputs() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
+ const ::flatbuffers::Vector<int32_t> *outputs() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> *operators() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> *>(VT_OPERATORS);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>> *operators() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>> *>(VT_OPERATORS);
}
- const flatbuffers::String *name() const {
- return GetPointer<const flatbuffers::String *>(VT_NAME);
+ const ::flatbuffers::String *name() const {
+ return GetPointer<const ::flatbuffers::String *>(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 @@
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<SubGraph> 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<SubGraph> 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<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_tensors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>>> tensors) {
fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
}
- void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
+ void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs) {
fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
}
- void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
+ void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs) {
fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
}
- void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators) {
+ void add_operators(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>>> operators) {
fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
}
- void add_name(flatbuffers::Offset<flatbuffers::String> 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<SubGraph> Finish() {
+ ::flatbuffers::Offset<SubGraph> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SubGraph>(end);
+ auto o = ::flatbuffers::Offset<SubGraph>(end);
return o;
}
};
-inline flatbuffers::Offset<SubGraph> CreateSubGraph(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators = 0,
- flatbuffers::Offset<flatbuffers::String> name = 0) {
+inline ::flatbuffers::Offset<SubGraph> CreateSubGraph(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>>> tensors = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>>> operators = 0,
+ ::flatbuffers::Offset<::flatbuffers::String> name = 0) {
SubGraphBuilder builder_(_fbb);
builder_.add_name(name);
builder_.add_operators(operators);
@@ -15950,17 +15950,17 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
- const std::vector<flatbuffers::Offset<tflite::Tensor>> *tensors = nullptr,
+inline ::flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<::flatbuffers::Offset<tflite::Tensor>> *tensors = nullptr,
const std::vector<int32_t> *inputs = nullptr,
const std::vector<int32_t> *outputs = nullptr,
- const std::vector<flatbuffers::Offset<tflite::Operator>> *operators = nullptr,
+ const std::vector<::flatbuffers::Offset<tflite::Operator>> *operators = nullptr,
const char *name = nullptr) {
- auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>>(*tensors) : 0;
+ auto tensors__ = tensors ? _fbb.CreateVector<::flatbuffers::Offset<tflite::Tensor>>(*tensors) : 0;
auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
- auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>>(*operators) : 0;
+ auto operators__ = operators ? _fbb.CreateVector<::flatbuffers::Offset<tflite::Operator>>(*operators) : 0;
auto name__ = name ? _fbb.CreateString(name) : 0;
return tflite::CreateSubGraph(
_fbb,
@@ -15971,16 +15971,16 @@
name__);
}
-flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SubGraph> 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<uint8_t> 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 @@
VT_OFFSET = 6,
VT_SIZE = 8
};
- const flatbuffers::Vector<uint8_t> *data() const {
- return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
+ const ::flatbuffers::Vector<uint8_t> *data() const {
+ return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
uint64_t offset() const {
return GetField<uint64_t>(VT_OFFSET, 0);
@@ -15997,7 +15997,7 @@
uint64_t size() const {
return GetField<uint64_t>(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 @@
VerifyField<uint64_t>(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<Buffer> 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<Buffer> 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<flatbuffers::Vector<uint8_t>> data) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(Buffer::VT_DATA, data);
}
void add_offset(uint64_t offset) {
@@ -16023,20 +16023,20 @@
void add_size(uint64_t size) {
fbb_.AddElement<uint64_t>(Buffer::VT_SIZE, size, 0);
}
- explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit BufferBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<Buffer> Finish() {
+ ::flatbuffers::Offset<Buffer> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Buffer>(end);
+ auto o = ::flatbuffers::Offset<Buffer>(end);
return o;
}
};
-inline flatbuffers::Offset<Buffer> CreateBuffer(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0,
+inline ::flatbuffers::Offset<Buffer> CreateBuffer(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0,
uint64_t offset = 0,
uint64_t size = 0) {
BufferBuilder builder_(_fbb);
@@ -16046,8 +16046,8 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<Buffer> CreateBufferDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Buffer> CreateBufferDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *data = nullptr,
uint64_t offset = 0,
uint64_t size = 0) {
@@ -16060,63 +16060,63 @@
size);
}
-flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Buffer> 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<const flatbuffers::String *>(VT_NAME);
+ const ::flatbuffers::String *name() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
uint32_t buffer() const {
return GetField<uint32_t>(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<uint32_t>(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<Metadata> 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<Metadata> 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<flatbuffers::String> 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<uint32_t>(Metadata::VT_BUFFER, buffer, 0);
}
- explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit MetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<Metadata> Finish() {
+ ::flatbuffers::Offset<Metadata> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Metadata>(end);
+ auto o = ::flatbuffers::Offset<Metadata>(end);
return o;
}
};
-inline flatbuffers::Offset<Metadata> CreateMetadata(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::String> name = 0,
+inline ::flatbuffers::Offset<Metadata> 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 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<Metadata> CreateMetadataDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Metadata> CreateMetadataDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const char *name = nullptr,
uint32_t buffer = 0) {
auto name__ = name ? _fbb.CreateString(name) : 0;
@@ -16135,63 +16135,63 @@
buffer);
}
-flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Metadata> 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<const flatbuffers::String *>(VT_NAME);
+ const ::flatbuffers::String *name() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_NAME);
}
uint32_t tensor_index() const {
return GetField<uint32_t>(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<uint32_t>(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<TensorMap> 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<TensorMap> 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<flatbuffers::String> 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<uint32_t>(TensorMap::VT_TENSOR_INDEX, tensor_index, 0);
}
- explicit TensorMapBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit TensorMapBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<TensorMap> Finish() {
+ ::flatbuffers::Offset<TensorMap> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<TensorMap>(end);
+ auto o = ::flatbuffers::Offset<TensorMap>(end);
return o;
}
};
-inline flatbuffers::Offset<TensorMap> CreateTensorMap(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::String> name = 0,
+inline ::flatbuffers::Offset<TensorMap> 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 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<TensorMap> CreateTensorMapDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<TensorMap> CreateTensorMapDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
const char *name = nullptr,
uint32_t tensor_index = 0) {
auto name__ = name ? _fbb.CreateString(name) : 0;
@@ -16210,9 +16210,9 @@
tensor_index);
}
-flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<TensorMap> 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<std::unique_ptr<tflite::TensorMapT>> inputs{};
std::vector<std::unique_ptr<tflite::TensorMapT>> outputs{};
@@ -16224,7 +16224,7 @@
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 @@
VT_SIGNATURE_KEY = 8,
VT_SUBGRAPH_INDEX = 12
};
- const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *inputs() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_INPUTS);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *inputs() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *>(VT_INPUTS);
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *outputs() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_OUTPUTS);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *outputs() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *>(VT_OUTPUTS);
}
- const flatbuffers::String *signature_key() const {
- return GetPointer<const flatbuffers::String *>(VT_SIGNATURE_KEY);
+ const ::flatbuffers::String *signature_key() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_SIGNATURE_KEY);
}
uint32_t subgraph_index() const {
return GetField<uint32_t>(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 @@
VerifyField<uint32_t>(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<SignatureDef> 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<SignatureDef> 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<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs) {
+ ::flatbuffers::FlatBufferBuilder &fbb_;
+ ::flatbuffers::uoffset_t start_;
+ void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>>> inputs) {
fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs);
}
- void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs) {
+ void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>>> outputs) {
fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs);
}
- void add_signature_key(flatbuffers::Offset<flatbuffers::String> 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<uint32_t>(SignatureDef::VT_SUBGRAPH_INDEX, subgraph_index, 0);
}
- explicit SignatureDefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ explicit SignatureDefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- flatbuffers::Offset<SignatureDef> Finish() {
+ ::flatbuffers::Offset<SignatureDef> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<SignatureDef>(end);
+ auto o = ::flatbuffers::Offset<SignatureDef>(end);
return o;
}
};
-inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(
- flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs = 0,
- flatbuffers::Offset<flatbuffers::String> signature_key = 0,
+inline ::flatbuffers::Offset<SignatureDef> CreateSignatureDef(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>>> inputs = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>>> 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 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
- const std::vector<flatbuffers::Offset<tflite::TensorMap>> *inputs = nullptr,
- const std::vector<flatbuffers::Offset<tflite::TensorMap>> *outputs = nullptr,
+inline ::flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<::flatbuffers::Offset<tflite::TensorMap>> *inputs = nullptr,
+ const std::vector<::flatbuffers::Offset<tflite::TensorMap>> *outputs = nullptr,
const char *signature_key = nullptr,
uint32_t subgraph_index = 0) {
- auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*inputs) : 0;
- auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*outputs) : 0;
+ auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<tflite::TensorMap>>(*inputs) : 0;
+ auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<tflite::TensorMap>>(*outputs) : 0;
auto signature_key__ = signature_key ? _fbb.CreateString(signature_key) : 0;
return tflite::CreateSignatureDef(
_fbb,
@@ -16321,9 +16321,9 @@
subgraph_index);
}
-flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<SignatureDef> 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<std::unique_ptr<tflite::OperatorCodeT>> operator_codes{};
@@ -16339,7 +16339,7 @@
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 @@
uint32_t version() const {
return GetField<uint32_t>(VT_VERSION, 0);
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> *operator_codes() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> *>(VT_OPERATOR_CODES);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>> *operator_codes() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>> *>(VT_OPERATOR_CODES);
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> *subgraphs() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> *>(VT_SUBGRAPHS);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>> *subgraphs() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>> *>(VT_SUBGRAPHS);
}
- const flatbuffers::String *description() const {
- return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
+ const ::flatbuffers::String *description() const {
+ return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> *buffers() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> *>(VT_BUFFERS);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>> *buffers() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>> *>(VT_BUFFERS);
}
- const flatbuffers::Vector<int32_t> *metadata_buffer() const {
- return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
+ const ::flatbuffers::Vector<int32_t> *metadata_buffer() const {
+ return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> *metadata() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> *>(VT_METADATA);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>> *metadata() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>> *>(VT_METADATA);
}
- const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> *signature_defs() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> *>(VT_SIGNATURE_DEFS);
+ const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>> *signature_defs() const {
+ return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>> *>(VT_SIGNATURE_DEFS);
}
- bool Verify(flatbuffers::Verifier &verifier) const {
+ bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_VERSION, 4) &&
VerifyOffset(verifier, VT_OPERATOR_CODES) &&
@@ -16400,60 +16400,60 @@
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<Model> 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<Model> 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<uint32_t>(Model::VT_VERSION, version, 0);
}
- void add_operator_codes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes) {
+ void add_operator_codes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>>> operator_codes) {
fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
}
- void add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs) {
+ void add_subgraphs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>>> subgraphs) {
fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
}
- void add_description(flatbuffers::Offset<flatbuffers::String> description) {
+ void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
fbb_.AddOffset(Model::VT_DESCRIPTION, description);
}
- void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers) {
+ void add_buffers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>>> buffers) {
fbb_.AddOffset(Model::VT_BUFFERS, buffers);
}
- void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer) {
+ void add_metadata_buffer(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> metadata_buffer) {
fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
}
- void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata) {
+ void add_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>>> metadata) {
fbb_.AddOffset(Model::VT_METADATA, metadata);
}
- void add_signature_defs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs) {
+ void add_signature_defs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>>> 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<Model> Finish() {
+ ::flatbuffers::Offset<Model> Finish() {
const auto end = fbb_.EndTable(start_);
- auto o = flatbuffers::Offset<Model>(end);
+ auto o = ::flatbuffers::Offset<Model>(end);
return o;
}
};
-inline flatbuffers::Offset<Model> CreateModel(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Model> CreateModel(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t version = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs = 0,
- flatbuffers::Offset<flatbuffers::String> description = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers = 0,
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs = 0) {
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>>> operator_codes = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>>> subgraphs = 0,
+ ::flatbuffers::Offset<::flatbuffers::String> description = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>>> buffers = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> metadata_buffer = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>>> metadata = 0,
+ ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>>> signature_defs = 0) {
ModelBuilder builder_(_fbb);
builder_.add_signature_defs(signature_defs);
builder_.add_metadata(metadata);
@@ -16466,23 +16466,23 @@
return builder_.Finish();
}
-inline flatbuffers::Offset<Model> CreateModelDirect(
- flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Model> CreateModelDirect(
+ ::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t version = 0,
- const std::vector<flatbuffers::Offset<tflite::OperatorCode>> *operator_codes = nullptr,
- const std::vector<flatbuffers::Offset<tflite::SubGraph>> *subgraphs = nullptr,
+ const std::vector<::flatbuffers::Offset<tflite::OperatorCode>> *operator_codes = nullptr,
+ const std::vector<::flatbuffers::Offset<tflite::SubGraph>> *subgraphs = nullptr,
const char *description = nullptr,
- const std::vector<flatbuffers::Offset<tflite::Buffer>> *buffers = nullptr,
+ const std::vector<::flatbuffers::Offset<tflite::Buffer>> *buffers = nullptr,
const std::vector<int32_t> *metadata_buffer = nullptr,
- const std::vector<flatbuffers::Offset<tflite::Metadata>> *metadata = nullptr,
- const std::vector<flatbuffers::Offset<tflite::SignatureDef>> *signature_defs = nullptr) {
- auto operator_codes__ = operator_codes ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>>(*operator_codes) : 0;
- auto subgraphs__ = subgraphs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>>(*subgraphs) : 0;
+ const std::vector<::flatbuffers::Offset<tflite::Metadata>> *metadata = nullptr,
+ const std::vector<::flatbuffers::Offset<tflite::SignatureDef>> *signature_defs = nullptr) {
+ auto operator_codes__ = operator_codes ? _fbb.CreateVector<::flatbuffers::Offset<tflite::OperatorCode>>(*operator_codes) : 0;
+ auto subgraphs__ = subgraphs ? _fbb.CreateVector<::flatbuffers::Offset<tflite::SubGraph>>(*subgraphs) : 0;
auto description__ = description ? _fbb.CreateString(description) : 0;
- auto buffers__ = buffers ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>>(*buffers) : 0;
+ auto buffers__ = buffers ? _fbb.CreateVector<::flatbuffers::Offset<tflite::Buffer>>(*buffers) : 0;
auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0;
- auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>>(*metadata) : 0;
- auto signature_defs__ = signature_defs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>>(*signature_defs) : 0;
+ auto metadata__ = metadata ? _fbb.CreateVector<::flatbuffers::Offset<tflite::Metadata>>(*metadata) : 0;
+ auto signature_defs__ = signature_defs ? _fbb.CreateVector<::flatbuffers::Offset<tflite::SignatureDef>>(*signature_defs) : 0;
return tflite::CreateModel(
_fbb,
version,
@@ -16495,28 +16495,28 @@
signature_defs__);
}
-flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+::flatbuffers::Offset<Model> 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<CustomQuantizationT>(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> CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CustomQuantization> CustomQuantization::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateCustomQuantization(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CustomQuantization> 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 @@
_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<QuantizationParametersT>(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> QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<QuantizationParameters> QuantizationParameters::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateQuantizationParameters(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<QuantizationParameters> 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 @@
_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<Int32VectorT>(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> Int32Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Int32Vector> Int32Vector::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateInt32Vector(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Int32Vector> 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<Uint16VectorT>(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> Uint16Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Uint16Vector> Uint16Vector::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUint16Vector(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Uint16Vector> 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 @@
_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<Uint8VectorT>(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> Uint8Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Uint8Vector> Uint8Vector::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUint8Vector(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Uint8Vector> 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 @@
_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<DimensionMetadataT>(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 @@
{ auto _e = array_indices(); if (_e) _o->array_indices.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_indices_type(), _resolver); }
}
-inline flatbuffers::Offset<DimensionMetadata> DimensionMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DimensionMetadata> DimensionMetadata::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateDimensionMetadata(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DimensionMetadata> 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 @@
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<SparsityParametersT>(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<tflite::DimensionMetadataT>(_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<tflite::DimensionMetadataT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->dim_metadata.resize(0); } }
}
-inline flatbuffers::Offset<SparsityParameters> SparsityParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SparsityParameters> SparsityParameters::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSparsityParameters(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SparsityParameters> 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<flatbuffers::Offset<tflite::DimensionMetadata>> (_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<tflite::DimensionMetadata>> (_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 @@
_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<VariantSubTypeT>(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> VariantSubType::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<VariantSubType> VariantSubType::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateVariantSubType(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<VariantSubType> CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<VariantSubType> 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 @@
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<TensorT>(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<tflite::QuantizationParametersT>(_e->UnPack(_resolver)); } } }
+ { auto _e = quantization(); if (_e) { if(_o->quantization) { _e->UnPackTo(_o->quantization.get(), _resolver); } else { _o->quantization = std::unique_ptr<tflite::QuantizationParametersT>(_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<tflite::SparsityParametersT>(_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<tflite::SparsityParametersT>(_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<tflite::VariantSubTypeT>(_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<tflite::VariantSubTypeT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->variant_tensors.resize(0); } }
}
-inline flatbuffers::Offset<Tensor> Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Tensor> Tensor::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTensor(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Tensor> 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 @@
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<flatbuffers::Offset<tflite::VariantSubType>> (_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<tflite::VariantSubType>> (_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 @@
_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<StablehloGatherOptionsT>(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> StablehloGatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloGatherOptions> StablehloGatherOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloGatherOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloGatherOptions> CreateStablehloGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloGatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloGatherOptions> 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 @@
_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<StablehloTransposeOptionsT>(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> StablehloTransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloTransposeOptions> StablehloTransposeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloTransposeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloTransposeOptions> CreateStablehloTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloTransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloTransposeOptions> 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<StablehloDotGeneralOptionsT>(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<tflite::StablehloPrecisionConfig>(_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<tflite::StablehloPrecisionConfig>(_e->Get(_i)); } } else { _o->precision_config.resize(0); } }
}
-inline flatbuffers::Offset<StablehloDotGeneralOptions> StablehloDotGeneralOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloDotGeneralOptions> StablehloDotGeneralOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloDotGeneralOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloDotGeneralOptions> CreateStablehloDotGeneralOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDotGeneralOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloDotGeneralOptions> 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<uint32_t>(flatbuffers::data(_o->precision_config), _o->precision_config.size()) : 0;
+ auto _precision_config = _o->precision_config.size() ? _fbb.CreateVectorScalarCast<uint32_t>(::flatbuffers::data(_o->precision_config), _o->precision_config.size()) : 0;
return tflite::CreateStablehloDotGeneralOptions(
_fbb,
_lhs_batching_dimensions,
@@ -16953,31 +16953,31 @@
_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<StablehloReduceWindowOptionsT>(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> StablehloReduceWindowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloReduceWindowOptions> StablehloReduceWindowOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloReduceWindowOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloReduceWindowOptions> CreateStablehloReduceWindowOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceWindowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloReduceWindowOptions> 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 @@
_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<StablehloWhileOptionsT>(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> StablehloWhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloWhileOptions> StablehloWhileOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloWhileOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloWhileOptions> CreateStablehloWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloWhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloWhileOptions> 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 @@
_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<StablehloSortOptionsT>(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 @@
{ auto _e = comparator_subgraph_index(); _o->comparator_subgraph_index = _e; }
}
-inline flatbuffers::Offset<StablehloSortOptions> StablehloSortOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloSortOptions> StablehloSortOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloSortOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloSortOptions> CreateStablehloSortOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSortOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloSortOptions> 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 @@
_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<StablehloConcatenateOptionsT>(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> StablehloConcatenateOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloConcatenateOptions> StablehloConcatenateOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloConcatenateOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloConcatenateOptions> CreateStablehloConcatenateOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConcatenateOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloConcatenateOptions> 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<StablehloBroadcastInDimOptionsT>(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> StablehloBroadcastInDimOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloBroadcastInDimOptions> StablehloBroadcastInDimOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloBroadcastInDimOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloBroadcastInDimOptions> CreateStablehloBroadcastInDimOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloBroadcastInDimOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloBroadcastInDimOptions> 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<StablehloCompareOptionsT>(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> StablehloCompareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloCompareOptions> StablehloCompareOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloCompareOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloCompareOptions> CreateStablehloCompareOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCompareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloCompareOptions> 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 @@
_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<StablehloDynamicSliceOptionsT>(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> StablehloDynamicSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloDynamicSliceOptions> StablehloDynamicSliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloDynamicSliceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloDynamicSliceOptions> CreateStablehloDynamicSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloDynamicSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloDynamicSliceOptions> 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<StablehloPadOptionsT>(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> StablehloPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloPadOptions> StablehloPadOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloPadOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloPadOptions> CreateStablehloPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloPadOptions> 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 @@
_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<StablehloIotaOptionsT>(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> StablehloIotaOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloIotaOptions> StablehloIotaOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloIotaOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloIotaOptions> CreateStablehloIotaOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloIotaOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloIotaOptions> 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<StablehloCustomCallOptionsT>(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> StablehloCustomCallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloCustomCallOptions> StablehloCustomCallOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloCustomCallOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloCustomCallOptions> CreateStablehloCustomCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloCustomCallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloCustomCallOptions> 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 @@
_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<StablehloReduceOptionsT>(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> StablehloReduceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloReduceOptions> StablehloReduceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloReduceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloReduceOptions> CreateStablehloReduceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloReduceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloReduceOptions> 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 @@
_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<StablehloSliceOptionsT>(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> StablehloSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloSliceOptions> StablehloSliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloSliceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloSliceOptions> CreateStablehloSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloSliceOptions> 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 @@
_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<StablehloConvolutionOptionsT>(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<tflite::StablehloPrecisionConfig>(_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<tflite::StablehloPrecisionConfig>(_e->Get(_i)); } } else { _o->precision_config.resize(0); } }
}
-inline flatbuffers::Offset<StablehloConvolutionOptions> StablehloConvolutionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloConvolutionOptions> StablehloConvolutionOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloConvolutionOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloConvolutionOptions> CreateStablehloConvolutionOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloConvolutionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloConvolutionOptions> 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 @@
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<uint32_t>(flatbuffers::data(_o->precision_config), _o->precision_config.size()) : 0;
+ auto _precision_config = _o->precision_config.size() ? _fbb.CreateVectorScalarCast<uint32_t>(::flatbuffers::data(_o->precision_config), _o->precision_config.size()) : 0;
return tflite::CreateStablehloConvolutionOptions(
_fbb,
_window_strides,
@@ -17396,32 +17396,32 @@
_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<StablehloScatterOptionsT>(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> StablehloScatterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloScatterOptions> StablehloScatterOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloScatterOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloScatterOptions> CreateStablehloScatterOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloScatterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloScatterOptions> 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 @@
_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<StablehloRngBitGeneratorOptionsT>(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> StablehloRngBitGeneratorOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloRngBitGeneratorOptions> StablehloRngBitGeneratorOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStablehloRngBitGeneratorOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StablehloRngBitGeneratorOptions> CreateStablehloRngBitGeneratorOptions(flatbuffers::FlatBufferBuilder &_fbb, const StablehloRngBitGeneratorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StablehloRngBitGeneratorOptions> 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<Conv2DOptionsT>(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 @@
{ auto _e = quantized_bias_type(); _o->quantized_bias_type = _e; }
}
-inline flatbuffers::Offset<Conv2DOptions> Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Conv2DOptions> Conv2DOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateConv2DOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Conv2DOptions> 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 @@
_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<Conv3DOptionsT>(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 @@
{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
}
-inline flatbuffers::Offset<Conv3DOptions> Conv3DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Conv3DOptions> Conv3DOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateConv3DOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Conv3DOptions> 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 @@
_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<Pool2DOptionsT>(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 @@
{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
}
-inline flatbuffers::Offset<Pool2DOptions> Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Pool2DOptions> Pool2DOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreatePool2DOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Pool2DOptions> 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 @@
_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<DepthwiseConv2DOptionsT>(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 @@
{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
}
-inline flatbuffers::Offset<DepthwiseConv2DOptions> DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DepthwiseConv2DOptions> DepthwiseConv2DOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DepthwiseConv2DOptions> 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 @@
_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<ConcatEmbeddingsOptionsT>(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> ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ConcatEmbeddingsOptions> ConcatEmbeddingsOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ConcatEmbeddingsOptions> 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 @@
_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<LSHProjectionOptionsT>(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> LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LSHProjectionOptions> LSHProjectionOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLSHProjectionOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LSHProjectionOptions> 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<SVDFOptionsT>(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 @@
{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
}
-inline flatbuffers::Offset<SVDFOptions> SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SVDFOptions> SVDFOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSVDFOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SVDFOptions> 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 @@
_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<RNNOptionsT>(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> RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RNNOptions> RNNOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateRNNOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RNNOptions> 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 @@
_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<SequenceRNNOptionsT>(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 @@
{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
}
-inline flatbuffers::Offset<SequenceRNNOptions> SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SequenceRNNOptions> SequenceRNNOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSequenceRNNOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SequenceRNNOptions> 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 @@
_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<BidirectionalSequenceRNNOptionsT>(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 @@
{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
}
-inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BidirectionalSequenceRNNOptions> BidirectionalSequenceRNNOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BidirectionalSequenceRNNOptions> 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 @@
_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<FullyConnectedOptionsT>(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 @@
{ auto _e = quantized_bias_type(); _o->quantized_bias_type = _e; }
}
-inline flatbuffers::Offset<FullyConnectedOptions> FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FullyConnectedOptions> FullyConnectedOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateFullyConnectedOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FullyConnectedOptions> 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 @@
_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<SoftmaxOptionsT>(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> SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SoftmaxOptions> SoftmaxOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSoftmaxOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SoftmaxOptions> 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<ConcatenationOptionsT>(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> ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ConcatenationOptions> ConcatenationOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateConcatenationOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ConcatenationOptions> 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 @@
_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<AddOptionsT>(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> AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<AddOptions> AddOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateAddOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<AddOptions> 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 @@
_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<MulOptionsT>(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> MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MulOptions> MulOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMulOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MulOptions> 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<L2NormOptionsT>(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> L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<L2NormOptions> L2NormOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateL2NormOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<L2NormOptions> 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<LocalResponseNormalizationOptionsT>(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 @@
{ auto _e = beta(); _o->beta = _e; }
}
-inline flatbuffers::Offset<LocalResponseNormalizationOptions> LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LocalResponseNormalizationOptions> LocalResponseNormalizationOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LocalResponseNormalizationOptions> 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 @@
_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<LSTMOptionsT>(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 @@
{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
}
-inline flatbuffers::Offset<LSTMOptions> LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LSTMOptions> LSTMOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLSTMOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LSTMOptions> 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 @@
_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<UnidirectionalSequenceLSTMOptionsT>(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 @@
{ auto _e = diagonal_recurrent_tensors(); _o->diagonal_recurrent_tensors = _e; }
}
-inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> UnidirectionalSequenceLSTMOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> 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 @@
_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<BidirectionalSequenceLSTMOptionsT>(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 @@
{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
}
-inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BidirectionalSequenceLSTMOptions> BidirectionalSequenceLSTMOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BidirectionalSequenceLSTMOptions> 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 @@
_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<ResizeBilinearOptionsT>(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> ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ResizeBilinearOptions> ResizeBilinearOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateResizeBilinearOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ResizeBilinearOptions> 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 @@
_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<ResizeNearestNeighborOptionsT>(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> ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ResizeNearestNeighborOptions> ResizeNearestNeighborOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ResizeNearestNeighborOptions> 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 @@
_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<CallOptionsT>(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> CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CallOptions> CallOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateCallOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CallOptions> 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<PadOptionsT>(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> PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<PadOptions> PadOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreatePadOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<PadOptions> 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<PadV2OptionsT>(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> PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<PadV2Options> PadV2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreatePadV2Options(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<PadV2Options> 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<ReshapeOptionsT>(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> ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReshapeOptions> ReshapeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateReshapeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReshapeOptions> 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<SpaceToBatchNDOptionsT>(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> SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SpaceToBatchNDOptions> SpaceToBatchNDOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SpaceToBatchNDOptions> 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<BatchToSpaceNDOptionsT>(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> BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BatchToSpaceNDOptions> BatchToSpaceNDOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BatchToSpaceNDOptions> 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<SkipGramOptionsT>(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 @@
{ auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; }
}
-inline flatbuffers::Offset<SkipGramOptions> SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SkipGramOptions> SkipGramOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSkipGramOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SkipGramOptions> 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 @@
_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<SpaceToDepthOptionsT>(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> SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SpaceToDepthOptions> SpaceToDepthOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSpaceToDepthOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SpaceToDepthOptions> 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<DepthToSpaceOptionsT>(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> DepthToSpaceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DepthToSpaceOptions> DepthToSpaceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateDepthToSpaceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DepthToSpaceOptions> 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<SubOptionsT>(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> SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SubOptions> SubOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSubOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SubOptions> 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 @@
_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<DivOptionsT>(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> DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DivOptions> DivOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateDivOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DivOptions> 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<TopKV2OptionsT>(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> TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TopKV2Options> TopKV2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTopKV2Options(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TopKV2Options> 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<EmbeddingLookupSparseOptionsT>(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> EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<EmbeddingLookupSparseOptions> EmbeddingLookupSparseOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<EmbeddingLookupSparseOptions> 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<GatherOptionsT>(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> GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GatherOptions> GatherOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateGatherOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GatherOptions> 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 @@
_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<TransposeOptionsT>(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> TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TransposeOptions> TransposeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTransposeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TransposeOptions> 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<ExpOptionsT>(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> ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ExpOptions> ExpOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateExpOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ExpOptions> 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<CosOptionsT>(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> CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CosOptions> CosOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateCosOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CosOptions> 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<ReducerOptionsT>(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> ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReducerOptions> ReducerOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateReducerOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReducerOptions> 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<SqueezeOptionsT>(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> SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SqueezeOptions> SqueezeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSqueezeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SqueezeOptions> 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<SplitOptionsT>(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> SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SplitOptions> SplitOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSplitOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SplitOptions> 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<SplitVOptionsT>(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> SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SplitVOptions> SplitVOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSplitVOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SplitVOptions> 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<StridedSliceOptionsT>(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 @@
{ auto _e = offset(); _o->offset = _e; }
}
-inline flatbuffers::Offset<StridedSliceOptions> StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StridedSliceOptions> StridedSliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateStridedSliceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<StridedSliceOptions> 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 @@
_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<LogSoftmaxOptionsT>(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> LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LogSoftmaxOptions> LogSoftmaxOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLogSoftmaxOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LogSoftmaxOptions> 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<CastOptionsT>(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> CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CastOptions> CastOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateCastOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CastOptions> 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 @@
_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<DequantizeOptionsT>(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> DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DequantizeOptions> DequantizeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateDequantizeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DequantizeOptions> 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<MaximumMinimumOptionsT>(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> MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MaximumMinimumOptions> MaximumMinimumOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMaximumMinimumOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MaximumMinimumOptions> 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<TileOptionsT>(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> TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TileOptions> TileOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTileOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TileOptions> 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<ArgMaxOptionsT>(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> ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ArgMaxOptions> ArgMaxOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateArgMaxOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ArgMaxOptions> 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<ArgMinOptionsT>(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> ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ArgMinOptions> ArgMinOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateArgMinOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ArgMinOptions> 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<GreaterOptionsT>(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> GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GreaterOptions> GreaterOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateGreaterOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GreaterOptions> 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<GreaterEqualOptionsT>(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> GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GreaterEqualOptions> GreaterEqualOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateGreaterEqualOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GreaterEqualOptions> 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<LessOptionsT>(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> LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LessOptions> LessOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLessOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LessOptions> 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<LessEqualOptionsT>(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> LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LessEqualOptions> LessEqualOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLessEqualOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LessEqualOptions> 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<NegOptionsT>(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> NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<NegOptions> NegOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateNegOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<NegOptions> 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<SelectOptionsT>(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> SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SelectOptions> SelectOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSelectOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SelectOptions> 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<SliceOptionsT>(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> SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SliceOptions> SliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSliceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SliceOptions> 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<TransposeConvOptionsT>(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 @@
{ auto _e = quantized_bias_type(); _o->quantized_bias_type = _e; }
}
-inline flatbuffers::Offset<TransposeConvOptions> TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TransposeConvOptions> TransposeConvOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTransposeConvOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TransposeConvOptions> 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 @@
_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<ExpandDimsOptionsT>(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> ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ExpandDimsOptions> ExpandDimsOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateExpandDimsOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ExpandDimsOptions> 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<SparseToDenseOptionsT>(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> SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SparseToDenseOptions> SparseToDenseOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSparseToDenseOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SparseToDenseOptions> 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<EqualOptionsT>(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> EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<EqualOptions> EqualOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateEqualOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<EqualOptions> 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<NotEqualOptionsT>(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> NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<NotEqualOptions> NotEqualOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateNotEqualOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<NotEqualOptions> 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<ShapeOptionsT>(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> ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ShapeOptions> ShapeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateShapeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ShapeOptions> 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<RankOptionsT>(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> RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RankOptions> RankOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateRankOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RankOptions> 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<PowOptionsT>(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> PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<PowOptions> PowOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreatePowOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<PowOptions> 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<FakeQuantOptionsT>(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 @@
{ auto _e = narrow_range(); _o->narrow_range = _e; }
}
-inline flatbuffers::Offset<FakeQuantOptions> FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FakeQuantOptions> FakeQuantOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateFakeQuantOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FakeQuantOptions> 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 @@
_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<PackOptionsT>(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> PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<PackOptions> PackOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreatePackOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<PackOptions> 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 @@
_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<LogicalOrOptionsT>(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> LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LogicalOrOptions> LogicalOrOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLogicalOrOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LogicalOrOptions> 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<OneHotOptionsT>(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> OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<OneHotOptions> OneHotOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateOneHotOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<OneHotOptions> 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<AbsOptionsT>(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> AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<AbsOptions> AbsOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateAbsOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<AbsOptions> 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<HardSwishOptionsT>(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> HardSwishOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HardSwishOptions> HardSwishOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateHardSwishOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HardSwishOptions> 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<LogicalAndOptionsT>(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> LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LogicalAndOptions> LogicalAndOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLogicalAndOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LogicalAndOptions> 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<LogicalNotOptionsT>(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> LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LogicalNotOptions> LogicalNotOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLogicalNotOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LogicalNotOptions> 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<UnpackOptionsT>(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> UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnpackOptions> UnpackOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUnpackOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnpackOptions> 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 @@
_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<FloorDivOptionsT>(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> FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FloorDivOptions> FloorDivOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateFloorDivOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FloorDivOptions> 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<SquareOptionsT>(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> SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SquareOptions> SquareOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSquareOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SquareOptions> 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<ZerosLikeOptionsT>(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> ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ZerosLikeOptions> ZerosLikeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateZerosLikeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ZerosLikeOptions> 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<FillOptionsT>(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> FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FillOptions> FillOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateFillOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FillOptions> 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<FloorModOptionsT>(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> FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FloorModOptions> FloorModOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateFloorModOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<FloorModOptions> 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<RangeOptionsT>(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> RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RangeOptions> RangeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateRangeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RangeOptions> 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<LeakyReluOptionsT>(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> LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LeakyReluOptions> LeakyReluOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateLeakyReluOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<LeakyReluOptions> 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<SquaredDifferenceOptionsT>(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> SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SquaredDifferenceOptions> SquaredDifferenceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SquaredDifferenceOptions> 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<MirrorPadOptionsT>(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> MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MirrorPadOptions> MirrorPadOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMirrorPadOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MirrorPadOptions> 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<UniqueOptionsT>(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> UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UniqueOptions> UniqueOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUniqueOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UniqueOptions> 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<ReverseV2OptionsT>(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> ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReverseV2Options> ReverseV2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateReverseV2Options(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReverseV2Options> 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<AddNOptionsT>(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> AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<AddNOptions> AddNOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateAddNOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<AddNOptions> 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<GatherNdOptionsT>(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> GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GatherNdOptions> GatherNdOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateGatherNdOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GatherNdOptions> 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<WhereOptionsT>(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> WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<WhereOptions> WhereOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateWhereOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<WhereOptions> 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<ReverseSequenceOptionsT>(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> ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReverseSequenceOptions> ReverseSequenceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateReverseSequenceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReverseSequenceOptions> 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 @@
_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<MatrixDiagOptionsT>(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> MatrixDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MatrixDiagOptions> MatrixDiagOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMatrixDiagOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MatrixDiagOptions> 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<QuantizeOptionsT>(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> QuantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<QuantizeOptions> QuantizeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateQuantizeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<QuantizeOptions> 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<MatrixSetDiagOptionsT>(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> MatrixSetDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MatrixSetDiagOptions> MatrixSetDiagOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMatrixSetDiagOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<MatrixSetDiagOptions> 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<IfOptionsT>(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> IfOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<IfOptions> IfOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateIfOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<IfOptions> 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 @@
_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<CallOnceOptionsT>(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> CallOnceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CallOnceOptions> CallOnceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateCallOnceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CallOnceOptions> 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<WhileOptionsT>(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> WhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<WhileOptions> WhileOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateWhileOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<WhileOptions> 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 @@
_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<NonMaxSuppressionV4OptionsT>(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> NonMaxSuppressionV4Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<NonMaxSuppressionV4Options> NonMaxSuppressionV4Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateNonMaxSuppressionV4Options(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<NonMaxSuppressionV4Options> 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<NonMaxSuppressionV5OptionsT>(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> NonMaxSuppressionV5Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<NonMaxSuppressionV5Options> NonMaxSuppressionV5Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateNonMaxSuppressionV5Options(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<NonMaxSuppressionV5Options> 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<ScatterNdOptionsT>(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> ScatterNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ScatterNdOptions> ScatterNdOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateScatterNdOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ScatterNdOptions> 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<SelectV2OptionsT>(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> SelectV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SelectV2Options> SelectV2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSelectV2Options(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SelectV2Options> 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<DensifyOptionsT>(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> DensifyOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DensifyOptions> DensifyOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateDensifyOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DensifyOptions> 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<SegmentSumOptionsT>(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> SegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SegmentSumOptions> SegmentSumOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSegmentSumOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SegmentSumOptions> 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<BatchMatMulOptionsT>(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 @@
{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
}
-inline flatbuffers::Offset<BatchMatMulOptions> BatchMatMulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BatchMatMulOptions> BatchMatMulOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBatchMatMulOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BatchMatMulOptions> 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 @@
_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<CumsumOptionsT>(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> CumsumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CumsumOptions> CumsumOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateCumsumOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<CumsumOptions> 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 @@
_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<BroadcastToOptionsT>(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> BroadcastToOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BroadcastToOptions> BroadcastToOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBroadcastToOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BroadcastToOptions> 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<Rfft2dOptionsT>(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> Rfft2dOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Rfft2dOptions> Rfft2dOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateRfft2dOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Rfft2dOptions> 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<HashtableOptionsT>(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 @@
{ auto _e = value_dtype(); _o->value_dtype = _e; }
}
-inline flatbuffers::Offset<HashtableOptions> HashtableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HashtableOptions> HashtableOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateHashtableOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HashtableOptions> 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 @@
_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<HashtableFindOptionsT>(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> HashtableFindOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HashtableFindOptions> HashtableFindOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateHashtableFindOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HashtableFindOptions> 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<HashtableImportOptionsT>(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> HashtableImportOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HashtableImportOptions> HashtableImportOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateHashtableImportOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HashtableImportOptions> 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<HashtableSizeOptionsT>(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> HashtableSizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HashtableSizeOptions> HashtableSizeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateHashtableSizeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<HashtableSizeOptions> 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<VarHandleOptionsT>(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> VarHandleOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<VarHandleOptions> VarHandleOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateVarHandleOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<VarHandleOptions> 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 @@
_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<ReadVariableOptionsT>(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> ReadVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReadVariableOptions> ReadVariableOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateReadVariableOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReadVariableOptions> 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<AssignVariableOptionsT>(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> AssignVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<AssignVariableOptions> AssignVariableOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateAssignVariableOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<AssignVariableOptions> 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<RandomOptionsT>(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> RandomOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RandomOptions> RandomOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateRandomOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<RandomOptions> CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RandomOptions> 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 @@
_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<BucketizeOptionsT>(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> BucketizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BucketizeOptions> BucketizeOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBucketizeOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BucketizeOptions> 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<GeluOptionsT>(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> GeluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GeluOptions> GeluOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateGeluOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<GeluOptions> CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<GeluOptions> 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<DynamicUpdateSliceOptionsT>(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> DynamicUpdateSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DynamicUpdateSliceOptions> DynamicUpdateSliceOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateDynamicUpdateSliceOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DynamicUpdateSliceOptions> 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<UnsortedSegmentProdOptionsT>(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> UnsortedSegmentProdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnsortedSegmentProdOptions> UnsortedSegmentProdOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUnsortedSegmentProdOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnsortedSegmentProdOptions> 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<UnsortedSegmentMaxOptionsT>(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> UnsortedSegmentMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnsortedSegmentMaxOptions> UnsortedSegmentMaxOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUnsortedSegmentMaxOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnsortedSegmentMaxOptions> 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<UnsortedSegmentSumOptionsT>(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> UnsortedSegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnsortedSegmentSumOptions> UnsortedSegmentSumOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUnsortedSegmentSumOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnsortedSegmentSumOptions> 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<ATan2OptionsT>(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> ATan2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ATan2Options> ATan2Options::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateATan2Options(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ATan2Options> CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ATan2Options> 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<UnsortedSegmentMinOptionsT>(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> UnsortedSegmentMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnsortedSegmentMinOptions> UnsortedSegmentMinOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateUnsortedSegmentMinOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<UnsortedSegmentMinOptions> 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<SignOptionsT>(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> SignOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SignOptions> SignOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSignOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SignOptions> CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SignOptions> 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<BitcastOptionsT>(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> BitcastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BitcastOptions> BitcastOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBitcastOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<BitcastOptions> CreateBitcastOptions(flatbuffers::FlatBufferBuilder &_fbb, const BitcastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BitcastOptions> 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<BitwiseXorOptionsT>(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> BitwiseXorOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BitwiseXorOptions> BitwiseXorOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBitwiseXorOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<BitwiseXorOptions> CreateBitwiseXorOptions(flatbuffers::FlatBufferBuilder &_fbb, const BitwiseXorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<BitwiseXorOptions> 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<RightShiftOptionsT>(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> RightShiftOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RightShiftOptions> RightShiftOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateRightShiftOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<RightShiftOptions> CreateRightShiftOptions(flatbuffers::FlatBufferBuilder &_fbb, const RightShiftOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<RightShiftOptions> 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<DilateOptionsT>(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> DilateOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DilateOptions> DilateOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateDilateOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<DilateOptions> CreateDilateOptions(flatbuffers::FlatBufferBuilder &_fbb, const DilateOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<DilateOptions> 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<ReduceWindowOptionsT>(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> ReduceWindowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReduceWindowOptions> ReduceWindowOptions::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateReduceWindowOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<ReduceWindowOptions> CreateReduceWindowOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReduceWindowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<ReduceWindowOptions> 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<OperatorCodeT>(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 @@
{ auto _e = builtin_code(); _o->builtin_code = _e; }
}
-inline flatbuffers::Offset<OperatorCode> OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<OperatorCode> OperatorCode::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateOperatorCode(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<OperatorCode> 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 @@
_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<OperatorT>(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> Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Operator> Operator::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateOperator(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Operator> 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 @@
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<SubGraphT>(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<tflite::TensorT>(_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<tflite::OperatorT>(_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<tflite::TensorT>(_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<tflite::OperatorT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->operators.resize(0); } }
{ auto _e = name(); if (_e) _o->name = _e->str(); }
}
-inline flatbuffers::Offset<SubGraph> SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SubGraph> SubGraph::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSubGraph(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SubGraph> 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<flatbuffers::Offset<tflite::Tensor>> (_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<tflite::Tensor>> (_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<flatbuffers::Offset<tflite::Operator>> (_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<tflite::Operator>> (_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 @@
_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<BufferT>(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 @@
{ auto _e = size(); _o->size = _e; }
}
-inline flatbuffers::Offset<Buffer> Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Buffer> Buffer::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBuffer(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Buffer> 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 @@
_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<MetadataT>(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> Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Metadata> Metadata::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMetadata(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Metadata> 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 @@
_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<TensorMapT>(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> TensorMap::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TensorMap> TensorMap::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTensorMap(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<TensorMap> 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 @@
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<SignatureDefT>(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<tflite::TensorMapT>(_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<tflite::TensorMapT>(_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<tflite::TensorMapT>(_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<tflite::TensorMapT>(_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> SignatureDef::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SignatureDef> SignatureDef::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSignatureDef(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<SignatureDef> 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<flatbuffers::Offset<tflite::TensorMap>> (_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<tflite::TensorMap>> (_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<tflite::TensorMap>> (_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<tflite::TensorMap>> (_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 @@
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<ModelT>(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<tflite::OperatorCodeT>(_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<tflite::SubGraphT>(_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<tflite::OperatorCodeT>(_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<tflite::SubGraphT>(_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<tflite::BufferT>(_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<tflite::MetadataT>(_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<tflite::SignatureDefT>(_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<tflite::BufferT>(_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<tflite::MetadataT>(_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<tflite::SignatureDefT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->signature_defs.resize(0); } }
}
-inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Model> Model::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateModel(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+inline ::flatbuffers::Offset<Model> 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<flatbuffers::Offset<tflite::OperatorCode>> (_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<tflite::SubGraph>> (_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<tflite::OperatorCode>> (_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<tflite::SubGraph>> (_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<flatbuffers::Offset<tflite::Buffer>> (_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<tflite::Buffer>> (_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<flatbuffers::Offset<tflite::Metadata>> (_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<tflite::SignatureDef>> (_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<tflite::Metadata>> (_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<tflite::SignatureDef>> (_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 @@
_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 VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifyQuantizationDetailsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *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<QuantizationDetails>(i))) {
return false;
@@ -21254,7 +21254,7 @@
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 flatbuffers::Offset<void> QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+inline ::flatbuffers::Offset<void> QuantizationDetailsUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case QuantizationDetails_CustomQuantization: {
@@ -21300,7 +21300,7 @@
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 VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifySparseIndexVectorVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *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<SparseIndexVector>(i))) {
return false;
@@ -21333,7 +21333,7 @@
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 flatbuffers::Offset<void> SparseIndexVectorUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+inline ::flatbuffers::Offset<void> SparseIndexVectorUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case SparseIndexVector_Int32Vector: {
@@ -21413,7 +21413,7 @@
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 VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifyBuiltinOptionsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *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<BuiltinOptions>(i))) {
return false;
@@ -21938,7 +21938,7 @@
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 flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+inline ::flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case BuiltinOptions_Conv2DOptions: {
@@ -24109,7 +24109,7 @@
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 VerifyBuiltinOptions2Vector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifyBuiltinOptions2Vector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *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<BuiltinOptions2>(i))) {
return false;
@@ -24210,7 +24210,7 @@
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 flatbuffers::Offset<void> BuiltinOptions2Union::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+inline ::flatbuffers::Offset<void> BuiltinOptions2Union::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher;
switch (type) {
case BuiltinOptions2_StablehloConcatenateOptions: {
@@ -24580,11 +24580,11 @@
}
inline const tflite::Model *GetModel(const void *buf) {
- return flatbuffers::GetRoot<tflite::Model>(buf);
+ return ::flatbuffers::GetRoot<tflite::Model>(buf);
}
inline const tflite::Model *GetSizePrefixedModel(const void *buf) {
- return flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf);
+ return ::flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf);
}
inline const char *ModelIdentifier() {
@@ -24592,22 +24592,22 @@
}
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<tflite::Model>(ModelIdentifier());
}
inline bool VerifySizePrefixedModelBuffer(
- flatbuffers::Verifier &verifier) {
+ ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<tflite::Model>(ModelIdentifier());
}
@@ -24616,26 +24616,26 @@
}
inline void FinishModelBuffer(
- flatbuffers::FlatBufferBuilder &fbb,
- flatbuffers::Offset<tflite::Model> root) {
+ ::flatbuffers::FlatBufferBuilder &fbb,
+ ::flatbuffers::Offset<tflite::Model> root) {
fbb.Finish(root, ModelIdentifier());
}
inline void FinishSizePrefixedModelBuffer(
- flatbuffers::FlatBufferBuilder &fbb,
- flatbuffers::Offset<tflite::Model> root) {
+ ::flatbuffers::FlatBufferBuilder &fbb,
+ ::flatbuffers::Offset<tflite::Model> root) {
fbb.FinishSizePrefixed(root, ModelIdentifier());
}
inline std::unique_ptr<tflite::ModelT> UnPackModel(
const void *buf,
- const flatbuffers::resolver_function_t *res = nullptr) {
+ const ::flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<tflite::ModelT>(GetModel(buf)->UnPack(res));
}
inline std::unique_ptr<tflite::ModelT> UnPackSizePrefixedModel(
const void *buf,
- const flatbuffers::resolver_function_t *res = nullptr) {
+ const ::flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<tflite::ModelT>(GetSizePrefixedModel(buf)->UnPack(res));
}
diff --git a/third_party/flatbuffers/BUILD.external b/third_party/flatbuffers/BUILD.external
index dfd3a16..8f9d4eb 100644
--- a/third_party/flatbuffers/BUILD.external
+++ b/third_party/flatbuffers/BUILD.external
@@ -2,30 +2,23 @@
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 @@
"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 @@
"include/flatbuffers/vector_downward.h",
"include/flatbuffers/verifier.h",
],
- visibility = ["//:__subpackages__"],
+ visibility = ["//visibility:public"],
)
# Public flatc compiler library.
@@ -90,9 +84,11 @@
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 @@
srcs = [
"include/flatbuffers/flatc.h",
],
- visibility = ["//:__subpackages__"],
+ visibility = ["//visibility:public"],
)
# Library used by flatbuffer_cc_library rules.
@@ -120,22 +116,13 @@
"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 @@
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 1a84928..f746b67 100644
--- a/third_party/flatbuffers/build_defs.bzl
+++ b/third_party/flatbuffers/build_defs.bzl
@@ -279,6 +279,11 @@
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 @@
"-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 @@
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 @@
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 e799a70..c22ca37 100644
--- a/third_party/flatbuffers/workspace.bzl
+++ b/third_party/flatbuffers/workspace.bzl
@@ -5,10 +5,10 @@
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",
