Skip to content

Instantly share code, notes, and snippets.

@StanislawAntol

StanislawAntol/add_maximum_to_tflite.diff

Created February 15, 2018 23:18
Show Gist options
  • Save StanislawAntol/ce9fb48d112a133cabb92be1c093f1cd to your computer and use it in GitHub Desktop.
Save StanislawAntol/ce9fb48d112a133cabb92be1c093f1cd to your computer and use it in GitHub Desktop.
Download ZIP
Add support for tf.maximum to TensorFlowLite (v1.6.0-rc1)
Raw
add_maximum_to_tflite.diff
From a17ed8b28455874e7bd42a9c4f784790d771be7c Mon Sep 17 00:00:00 2001
From: Stanislaw Antol <[email protected]>
Date: Thu, 15 Feb 2018 14:29:39 -0800
Subject: [PATCH] TFLite patch for tf.maximum
---
tensorflow/contrib/lite/kernels/BUILD | 1 +
.../kernels/internal/reference/reference_ops.h | 29 +
tensorflow/contrib/lite/kernels/register.cc | 2 +
tensorflow/contrib/lite/kernels/tfmaximum.cc | 108 +
tensorflow/contrib/lite/model.cc | 3 +
tensorflow/contrib/lite/nnapi_delegate.cc | 1 +
tensorflow/contrib/lite/schema/schema.fbs | 5 +
tensorflow/contrib/lite/schema/schema_generated.h | 5020 ++++++++------------
tensorflow/contrib/lite/toco/tflite/operator.cc | 3 +
9 files changed, 2117 insertions(+), 3055 deletions(-)
create mode 100644 tensorflow/contrib/lite/kernels/tfmaximum.cc
diff --git a/tensorflow/contrib/lite/kernels/BUILD b/tensorflow/contrib/lite/kernels/BUILD
index a8ef0daede..e5bfe087f6 100644
--- a/tensorflow/contrib/lite/kernels/BUILD
+++ b/tensorflow/contrib/lite/kernels/BUILD
@@ -132,6 +132,7 @@ cc_library(
"strided_slice.cc",
"sub.cc",
"svdf.cc",
+ "tfmaximum.cc",
"transpose.cc",
"unidirectional_sequence_lstm.cc",
"unidirectional_sequence_rnn.cc",
diff --git a/tensorflow/contrib/lite/kernels/internal/reference/reference_ops.h b/tensorflow/contrib/lite/kernels/internal/reference/reference_ops.h
index f18543f4e4..5b5f57ce8b 100644
--- a/tensorflow/contrib/lite/kernels/internal/reference/reference_ops.h
+++ b/tensorflow/contrib/lite/kernels/internal/reference/reference_ops.h
@@ -2934,6 +2934,35 @@ void TensorFlowMaximum(const T* input1_data, const Dims<4>& input1_dims,
}
}
+template <typename T>
+void TensorFlowMaximum(const T* input1_data, const Dims<4>& input1_dims,
+ const T* input2_data, const Dims<4>& input2_dims,
+ T* output_data, const Dims<4>& output_dims) {
+ int batches = MatchingArraySize(input1_dims, 3, output_dims, 3);
+ int input_height = MatchingArraySize(input1_dims, 2, output_dims, 2);
+ int input_width = MatchingArraySize(input1_dims, 1, output_dims, 1);
+ int depth = MatchingArraySize(input1_dims, 0, output_dims, 0);
+
+ NdArrayDesc<4> desc1;
+ NdArrayDesc<4> desc2;
+ NdArrayDescsForElementwiseBroadcast(input1_dims, input2_dims, &desc1, &desc2);
+
+ for (int b = 0; b < ArraySize(output_dims, 3); ++b) {
+ for (int y = 0; y < ArraySize(output_dims, 2); ++y) {
+ for (int x = 0; x < ArraySize(output_dims, 1); ++x) {
+ for (int c = 0; c < ArraySize(output_dims, 0); ++c) {
+ auto out_idx = Offset(output_dims, c, x, y, b);
+ auto in1_idx = SubscriptToIndex(desc1, c, x, y, b);
+ auto in2_idx = SubscriptToIndex(desc2, c, x, y, b);
+ auto in1_val = input1_data[in1_idx];
+ auto in2_val = input2_data[in2_idx];
+ output_data[out_idx] = in1_val > in2_val ? in1_val : in2_val;
+ }
+ }
+ }
+ }
+}
+
template <typename T1, typename T2, typename T3>
void ArgMax(const T3* axis, const T1* input_data, const Dims<4>& input_dims,
T2* output_data, const Dims<4>& output_dims) {
diff --git a/tensorflow/contrib/lite/kernels/register.cc b/tensorflow/contrib/lite/kernels/register.cc
index 1fb779fd51..2ad1bc0f5d 100644
--- a/tensorflow/contrib/lite/kernels/register.cc
+++ b/tensorflow/contrib/lite/kernels/register.cc
@@ -60,6 +60,7 @@ TfLiteRegistration* Register_TRANSPOSE();
TfLiteRegistration* Register_MEAN();
TfLiteRegistration* Register_SQUEEZE();
TfLiteRegistration* Register_STRIDED_SLICE();
+TfLiteRegistration* Register_TFMAXIMUM();
BuiltinOpResolver::BuiltinOpResolver() {
AddBuiltin(BuiltinOperator_RELU, Register_RELU());
@@ -108,6 +109,7 @@ BuiltinOpResolver::BuiltinOpResolver() {
AddBuiltin(BuiltinOperator_SUB, Register_SUB());
AddBuiltin(BuiltinOperator_SQUEEZE, Register_SQUEEZE());
AddBuiltin(BuiltinOperator_STRIDED_SLICE, Register_STRIDED_SLICE());
+ AddBuiltin(BuiltinOperator_TFMAXIMUM, Register_TFMAXIMUM());
}
TfLiteRegistration* BuiltinOpResolver::FindOp(
diff --git a/tensorflow/contrib/lite/kernels/tfmaximum.cc b/tensorflow/contrib/lite/kernels/tfmaximum.cc
new file mode 100644
index 0000000000..8b87f414bb
--- /dev/null
+++ b/tensorflow/contrib/lite/kernels/tfmaximum.cc
@@ -0,0 +1,108 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include <string.h>
+#include <vector>
+#include "tensorflow/contrib/lite/builtin_op_data.h"
+#include "tensorflow/contrib/lite/context.h"
+#include "tensorflow/contrib/lite/kernels/internal/reference/reference_ops.h"
+#include "tensorflow/contrib/lite/kernels/internal/tensor.h"
+#include "tensorflow/contrib/lite/kernels/kernel_util.h"
+#include "tensorflow/contrib/lite/kernels/op_macros.h"
+
+namespace tflite {
+namespace ops {
+namespace builtin {
+namespace tfmaximum {
+
+// This file has a reference implemenation of TFMaximum.
+enum KernelType {
+ kReference,
+};
+
+constexpr int kInputTensor1 = 0;
+constexpr int kInputTensor2 = 1;
+constexpr int kOutputTensor = 0;
+
+struct TFMaximumContext {
+ TFMaximumContext(TfLiteContext* context, TfLiteNode* node) {
+ input1 = GetInput(context, node, kInputTensor1);
+ input2 = GetInput(context, node, kInputTensor2);
+ output = GetOutput(context, node, kOutputTensor);
+ }
+ TfLiteTensor* input1;
+ TfLiteTensor* input2;
+ TfLiteTensor* output;
+};
+
+TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+ TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
+ TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
+
+ TFMaximumContext op_context(context, node);
+ TF_LITE_ENSURE_EQ(context, op_context.input1->type, op_context.input2->type);
+ TfLiteIntArray* output_dims = TfLiteIntArrayCopy(op_context.input2->dims);
+ op_context.output->type = op_context.input2->type;
+ return context->ResizeTensor(context, op_context.output, output_dims);
+}
+
+template <KernelType kernel_type>
+TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+ TFMaximumContext op_context(context, node);
+
+#define TF_LITE_TFMAXIMUM(kernel_type, data_type) \
+ kernel_type::TensorFlowMaximum<data_type>( \
+ GetTensorData<data_type>(op_context.input1), \
+ GetTensorDims(op_context.input1), \
+ GetTensorData<data_type>(op_context.input2), \
+ GetTensorDims(op_context.input2), \
+ GetTensorData<data_type>(op_context.output), \
+ GetTensorDims(op_context.output))
+
+ if (kernel_type == kReference) {
+ switch (op_context.output->type) {
+ case kTfLiteFloat32:
+ TF_LITE_TFMAXIMUM(reference_ops, float);
+ break;
+ default:
+ context->ReportError(context,
+ "Type %d is currently not supported by TFMaximum.",
+ op_context.output->type);
+ return kTfLiteError;
+ }
+ } else {
+ context->ReportError(context,
+ "Type %d is currently not supported by TFMaximum.",
+ op_context.output->type);
+ return kTfLiteError;
+ }
+#undef TF_LITE_TFMAXIUM
+ return kTfLiteOk;
+}
+
+} // namespace tfmaximum
+
+TfLiteRegistration* Register_TFMAXIMUM_REF() {
+ static TfLiteRegistration r = {nullptr, nullptr, tfmaximum::Prepare,
+ tfmaximum::Eval<tfmaximum::kReference>};
+ return &r;
+}
+
+TfLiteRegistration* Register_TFMAXIMUM() {
+ return Register_TFMAXIMUM_REF();
+}
+
+} // namespace builtin
+} // namespace ops
+} // namespace tflite
diff --git a/tensorflow/contrib/lite/model.cc b/tensorflow/contrib/lite/model.cc
index 14b6709964..86a02e413b 100644
--- a/tensorflow/contrib/lite/model.cc
+++ b/tensorflow/contrib/lite/model.cc
@@ -556,6 +556,9 @@ void* ParseOpData(const Operator* op, BuiltinOperator op_type,
builtin_data = reinterpret_cast<void*>(params);
break;
}
+ case BuiltinOperator_TFMAXIMUM: {
+ break;
+ }
}
return builtin_data;
}
diff --git a/tensorflow/contrib/lite/nnapi_delegate.cc b/tensorflow/contrib/lite/nnapi_delegate.cc
index da9ceec2f1..e3e090bf94 100644
--- a/tensorflow/contrib/lite/nnapi_delegate.cc
+++ b/tensorflow/contrib/lite/nnapi_delegate.cc
@@ -341,6 +341,7 @@ void AddOpsAndParams(tflite::Interpreter* interpreter,
case tflite::BuiltinOperator_SUB:
case tflite::BuiltinOperator_SQUEEZE:
case tflite::BuiltinOperator_STRIDED_SLICE:
+ case tflite::BuiltinOperator_TFMAXIMUM:
FATAL("Op code %d is currently not delegated to NNAPI", builtin);
nn_op_type = -1; // set to invalid
break;
diff --git a/tensorflow/contrib/lite/schema/schema.fbs b/tensorflow/contrib/lite/schema/schema.fbs
index 36cc2724eb..bb280e2afd 100644
--- a/tensorflow/contrib/lite/schema/schema.fbs
+++ b/tensorflow/contrib/lite/schema/schema.fbs
@@ -120,6 +120,7 @@ enum BuiltinOperator : byte {
UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
STRIDED_SLICE = 45,
BIDIRECTIONAL_SEQUENCE_RNN = 46,
+ TFMAXIMUM = 47,
}
// Options for the builtin operators.
@@ -156,6 +157,7 @@ union BuiltinOptions {
SqueezeOptions,
SequenceRNNOptions,
StridedSliceOptions,
+ TFMaximumOptions,
}
enum Padding : byte { SAME, VALID }
@@ -348,6 +350,9 @@ table StridedSliceOptions {
shrink_axis_mask: int;
}
+table TFMaximumOptions {
+}
+
// An OperatorCode can be an enum value (BuiltinOperator) if the operator is a
// builtin, or a string if the operator is custom.
table OperatorCode {
diff --git a/tensorflow/contrib/lite/schema/schema_generated.h b/tensorflow/contrib/lite/schema/schema_generated.h
index e2ac0b9d1e..2c7279df7e 100755
--- a/tensorflow/contrib/lite/schema/schema_generated.h
+++ b/tensorflow/contrib/lite/schema/schema_generated.h
@@ -1,19 +1,6 @@
-/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
// automatically generated by the FlatBuffers compiler, do not modify
+
#ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
#define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
@@ -126,6 +113,9 @@ struct SqueezeOptionsT;
struct StridedSliceOptions;
struct StridedSliceOptionsT;
+struct TFMaximumOptions;
+struct TFMaximumOptionsT;
+
struct OperatorCode;
struct OperatorCodeT;
@@ -153,15 +143,27 @@ enum TensorType {
};
inline TensorType (&EnumValuesTensorType())[6] {
- static TensorType values[] = {TensorType_FLOAT32, TensorType_FLOAT16,
- TensorType_INT32, TensorType_UINT8,
- TensorType_INT64, TensorType_STRING};
+ static TensorType values[] = {
+ TensorType_FLOAT32,
+ TensorType_FLOAT16,
+ TensorType_INT32,
+ TensorType_UINT8,
+ TensorType_INT64,
+ TensorType_STRING
+ };
return values;
}
inline const char **EnumNamesTensorType() {
- static const char *names[] = {"FLOAT32", "FLOAT16", "INT32", "UINT8",
- "INT64", "STRING", nullptr};
+ static const char *names[] = {
+ "FLOAT32",
+ "FLOAT16",
+ "INT32",
+ "UINT8",
+ "INT64",
+ "STRING",
+ nullptr
+ };
return names;
}
@@ -215,108 +217,114 @@ enum BuiltinOperator {
BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
BuiltinOperator_STRIDED_SLICE = 45,
BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = 46,
+ BuiltinOperator_TFMAXIMUM = 47,
BuiltinOperator_MIN = BuiltinOperator_ADD,
- BuiltinOperator_MAX = BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN
+ BuiltinOperator_MAX = BuiltinOperator_TFMAXIMUM
};
-inline BuiltinOperator (&EnumValuesBuiltinOperator())[44] {
+inline BuiltinOperator (&EnumValuesBuiltinOperator())[45] {
static BuiltinOperator values[] = {
- BuiltinOperator_ADD,
- BuiltinOperator_AVERAGE_POOL_2D,
- BuiltinOperator_CONCATENATION,
- BuiltinOperator_CONV_2D,
- BuiltinOperator_DEPTHWISE_CONV_2D,
- BuiltinOperator_EMBEDDING_LOOKUP,
- BuiltinOperator_FULLY_CONNECTED,
- BuiltinOperator_HASHTABLE_LOOKUP,
- BuiltinOperator_L2_NORMALIZATION,
- BuiltinOperator_L2_POOL_2D,
- BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
- BuiltinOperator_LOGISTIC,
- BuiltinOperator_LSH_PROJECTION,
- BuiltinOperator_LSTM,
- BuiltinOperator_MAX_POOL_2D,
- BuiltinOperator_MUL,
- BuiltinOperator_RELU,
- BuiltinOperator_RELU_N1_TO_1,
- BuiltinOperator_RELU6,
- BuiltinOperator_RESHAPE,
- BuiltinOperator_RESIZE_BILINEAR,
- BuiltinOperator_RNN,
- BuiltinOperator_SOFTMAX,
- BuiltinOperator_SPACE_TO_DEPTH,
- BuiltinOperator_SVDF,
- BuiltinOperator_TANH,
- BuiltinOperator_CONCAT_EMBEDDINGS,
- BuiltinOperator_SKIP_GRAM,
- BuiltinOperator_CALL,
- BuiltinOperator_CUSTOM,
- BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
- BuiltinOperator_PAD,
- BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
- BuiltinOperator_GATHER,
- BuiltinOperator_BATCH_TO_SPACE_ND,
- BuiltinOperator_SPACE_TO_BATCH_ND,
- BuiltinOperator_TRANSPOSE,
- BuiltinOperator_MEAN,
- BuiltinOperator_SUB,
- BuiltinOperator_DIV,
- BuiltinOperator_SQUEEZE,
- BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
- BuiltinOperator_STRIDED_SLICE,
- BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN};
+ BuiltinOperator_ADD,
+ BuiltinOperator_AVERAGE_POOL_2D,
+ BuiltinOperator_CONCATENATION,
+ BuiltinOperator_CONV_2D,
+ BuiltinOperator_DEPTHWISE_CONV_2D,
+ BuiltinOperator_EMBEDDING_LOOKUP,
+ BuiltinOperator_FULLY_CONNECTED,
+ BuiltinOperator_HASHTABLE_LOOKUP,
+ BuiltinOperator_L2_NORMALIZATION,
+ BuiltinOperator_L2_POOL_2D,
+ BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
+ BuiltinOperator_LOGISTIC,
+ BuiltinOperator_LSH_PROJECTION,
+ BuiltinOperator_LSTM,
+ BuiltinOperator_MAX_POOL_2D,
+ BuiltinOperator_MUL,
+ BuiltinOperator_RELU,
+ BuiltinOperator_RELU_N1_TO_1,
+ BuiltinOperator_RELU6,
+ BuiltinOperator_RESHAPE,
+ BuiltinOperator_RESIZE_BILINEAR,
+ BuiltinOperator_RNN,
+ BuiltinOperator_SOFTMAX,
+ BuiltinOperator_SPACE_TO_DEPTH,
+ BuiltinOperator_SVDF,
+ BuiltinOperator_TANH,
+ BuiltinOperator_CONCAT_EMBEDDINGS,
+ BuiltinOperator_SKIP_GRAM,
+ BuiltinOperator_CALL,
+ BuiltinOperator_CUSTOM,
+ BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
+ BuiltinOperator_PAD,
+ BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
+ BuiltinOperator_GATHER,
+ BuiltinOperator_BATCH_TO_SPACE_ND,
+ BuiltinOperator_SPACE_TO_BATCH_ND,
+ BuiltinOperator_TRANSPOSE,
+ BuiltinOperator_MEAN,
+ BuiltinOperator_SUB,
+ BuiltinOperator_DIV,
+ BuiltinOperator_SQUEEZE,
+ BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
+ BuiltinOperator_STRIDED_SLICE,
+ BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
+ BuiltinOperator_TFMAXIMUM
+ };
return values;
}
inline const char **EnumNamesBuiltinOperator() {
- static const char *names[] = {"ADD",
- "AVERAGE_POOL_2D",
- "CONCATENATION",
- "CONV_2D",
- "DEPTHWISE_CONV_2D",
- "",
- "",
- "EMBEDDING_LOOKUP",
- "",
- "FULLY_CONNECTED",
- "HASHTABLE_LOOKUP",
- "L2_NORMALIZATION",
- "L2_POOL_2D",
- "LOCAL_RESPONSE_NORMALIZATION",
- "LOGISTIC",
- "LSH_PROJECTION",
- "LSTM",
- "MAX_POOL_2D",
- "MUL",
- "RELU",
- "RELU_N1_TO_1",
- "RELU6",
- "RESHAPE",
- "RESIZE_BILINEAR",
- "RNN",
- "SOFTMAX",
- "SPACE_TO_DEPTH",
- "SVDF",
- "TANH",
- "CONCAT_EMBEDDINGS",
- "SKIP_GRAM",
- "CALL",
- "CUSTOM",
- "EMBEDDING_LOOKUP_SPARSE",
- "PAD",
- "UNIDIRECTIONAL_SEQUENCE_RNN",
- "GATHER",
- "BATCH_TO_SPACE_ND",
- "SPACE_TO_BATCH_ND",
- "TRANSPOSE",
- "MEAN",
- "SUB",
- "DIV",
- "SQUEEZE",
- "UNIDIRECTIONAL_SEQUENCE_LSTM",
- "STRIDED_SLICE",
- "BIDIRECTIONAL_SEQUENCE_RNN",
- nullptr};
+ static const char *names[] = {
+ "ADD",
+ "AVERAGE_POOL_2D",
+ "CONCATENATION",
+ "CONV_2D",
+ "DEPTHWISE_CONV_2D",
+ "",
+ "",
+ "EMBEDDING_LOOKUP",
+ "",
+ "FULLY_CONNECTED",
+ "HASHTABLE_LOOKUP",
+ "L2_NORMALIZATION",
+ "L2_POOL_2D",
+ "LOCAL_RESPONSE_NORMALIZATION",
+ "LOGISTIC",
+ "LSH_PROJECTION",
+ "LSTM",
+ "MAX_POOL_2D",
+ "MUL",
+ "RELU",
+ "RELU_N1_TO_1",
+ "RELU6",
+ "RESHAPE",
+ "RESIZE_BILINEAR",
+ "RNN",
+ "SOFTMAX",
+ "SPACE_TO_DEPTH",
+ "SVDF",
+ "TANH",
+ "CONCAT_EMBEDDINGS",
+ "SKIP_GRAM",
+ "CALL",
+ "CUSTOM",
+ "EMBEDDING_LOOKUP_SPARSE",
+ "PAD",
+ "UNIDIRECTIONAL_SEQUENCE_RNN",
+ "GATHER",
+ "BATCH_TO_SPACE_ND",
+ "SPACE_TO_BATCH_ND",
+ "TRANSPOSE",
+ "MEAN",
+ "SUB",
+ "DIV",
+ "SQUEEZE",
+ "UNIDIRECTIONAL_SEQUENCE_LSTM",
+ "STRIDED_SLICE",
+ "BIDIRECTIONAL_SEQUENCE_RNN",
+ "TFMAXIMUM",
+ nullptr
+ };
return names;
}
@@ -359,83 +367,89 @@ enum BuiltinOptions {
BuiltinOptions_SqueezeOptions = 30,
BuiltinOptions_SequenceRNNOptions = 31,
BuiltinOptions_StridedSliceOptions = 32,
+ BuiltinOptions_TFMaximumOptions = 33,
BuiltinOptions_MIN = BuiltinOptions_NONE,
- BuiltinOptions_MAX = BuiltinOptions_StridedSliceOptions
+ BuiltinOptions_MAX = BuiltinOptions_TFMaximumOptions
};
-inline BuiltinOptions (&EnumValuesBuiltinOptions())[33] {
+inline BuiltinOptions (&EnumValuesBuiltinOptions())[34] {
static BuiltinOptions values[] = {
- BuiltinOptions_NONE,
- BuiltinOptions_Conv2DOptions,
- BuiltinOptions_DepthwiseConv2DOptions,
- BuiltinOptions_ConcatEmbeddingsOptions,
- BuiltinOptions_LSHProjectionOptions,
- BuiltinOptions_Pool2DOptions,
- BuiltinOptions_SVDFOptions,
- BuiltinOptions_RNNOptions,
- BuiltinOptions_FullyConnectedOptions,
- BuiltinOptions_SoftmaxOptions,
- BuiltinOptions_ConcatenationOptions,
- BuiltinOptions_AddOptions,
- BuiltinOptions_L2NormOptions,
- BuiltinOptions_LocalResponseNormalizationOptions,
- BuiltinOptions_LSTMOptions,
- BuiltinOptions_ResizeBilinearOptions,
- BuiltinOptions_CallOptions,
- BuiltinOptions_ReshapeOptions,
- BuiltinOptions_SkipGramOptions,
- BuiltinOptions_SpaceToDepthOptions,
- BuiltinOptions_EmbeddingLookupSparseOptions,
- BuiltinOptions_MulOptions,
- BuiltinOptions_PadOptions,
- BuiltinOptions_GatherOptions,
- BuiltinOptions_BatchToSpaceNDOptions,
- BuiltinOptions_SpaceToBatchNDOptions,
- BuiltinOptions_TransposeOptions,
- BuiltinOptions_MeanOptions,
- BuiltinOptions_SubOptions,
- BuiltinOptions_DivOptions,
- BuiltinOptions_SqueezeOptions,
- BuiltinOptions_SequenceRNNOptions,
- BuiltinOptions_StridedSliceOptions};
+ BuiltinOptions_NONE,
+ BuiltinOptions_Conv2DOptions,
+ BuiltinOptions_DepthwiseConv2DOptions,
+ BuiltinOptions_ConcatEmbeddingsOptions,
+ BuiltinOptions_LSHProjectionOptions,
+ BuiltinOptions_Pool2DOptions,
+ BuiltinOptions_SVDFOptions,
+ BuiltinOptions_RNNOptions,
+ BuiltinOptions_FullyConnectedOptions,
+ BuiltinOptions_SoftmaxOptions,
+ BuiltinOptions_ConcatenationOptions,
+ BuiltinOptions_AddOptions,
+ BuiltinOptions_L2NormOptions,
+ BuiltinOptions_LocalResponseNormalizationOptions,
+ BuiltinOptions_LSTMOptions,
+ BuiltinOptions_ResizeBilinearOptions,
+ BuiltinOptions_CallOptions,
+ BuiltinOptions_ReshapeOptions,
+ BuiltinOptions_SkipGramOptions,
+ BuiltinOptions_SpaceToDepthOptions,
+ BuiltinOptions_EmbeddingLookupSparseOptions,
+ BuiltinOptions_MulOptions,
+ BuiltinOptions_PadOptions,
+ BuiltinOptions_GatherOptions,
+ BuiltinOptions_BatchToSpaceNDOptions,
+ BuiltinOptions_SpaceToBatchNDOptions,
+ BuiltinOptions_TransposeOptions,
+ BuiltinOptions_MeanOptions,
+ BuiltinOptions_SubOptions,
+ BuiltinOptions_DivOptions,
+ BuiltinOptions_SqueezeOptions,
+ BuiltinOptions_SequenceRNNOptions,
+ BuiltinOptions_StridedSliceOptions,
+ BuiltinOptions_TFMaximumOptions
+ };
return values;
}
inline const char **EnumNamesBuiltinOptions() {
- static const char *names[] = {"NONE",
- "Conv2DOptions",
- "DepthwiseConv2DOptions",
- "ConcatEmbeddingsOptions",
- "LSHProjectionOptions",
- "Pool2DOptions",
- "SVDFOptions",
- "RNNOptions",
- "FullyConnectedOptions",
- "SoftmaxOptions",
- "ConcatenationOptions",
- "AddOptions",
- "L2NormOptions",
- "LocalResponseNormalizationOptions",
- "LSTMOptions",
- "ResizeBilinearOptions",
- "CallOptions",
- "ReshapeOptions",
- "SkipGramOptions",
- "SpaceToDepthOptions",
- "EmbeddingLookupSparseOptions",
- "MulOptions",
- "PadOptions",
- "GatherOptions",
- "BatchToSpaceNDOptions",
- "SpaceToBatchNDOptions",
- "TransposeOptions",
- "MeanOptions",
- "SubOptions",
- "DivOptions",
- "SqueezeOptions",
- "SequenceRNNOptions",
- "StridedSliceOptions",
- nullptr};
+ static const char *names[] = {
+ "NONE",
+ "Conv2DOptions",
+ "DepthwiseConv2DOptions",
+ "ConcatEmbeddingsOptions",
+ "LSHProjectionOptions",
+ "Pool2DOptions",
+ "SVDFOptions",
+ "RNNOptions",
+ "FullyConnectedOptions",
+ "SoftmaxOptions",
+ "ConcatenationOptions",
+ "AddOptions",
+ "L2NormOptions",
+ "LocalResponseNormalizationOptions",
+ "LSTMOptions",
+ "ResizeBilinearOptions",
+ "CallOptions",
+ "ReshapeOptions",
+ "SkipGramOptions",
+ "SpaceToDepthOptions",
+ "EmbeddingLookupSparseOptions",
+ "MulOptions",
+ "PadOptions",
+ "GatherOptions",
+ "BatchToSpaceNDOptions",
+ "SpaceToBatchNDOptions",
+ "TransposeOptions",
+ "MeanOptions",
+ "SubOptions",
+ "DivOptions",
+ "SqueezeOptions",
+ "SequenceRNNOptions",
+ "StridedSliceOptions",
+ "TFMaximumOptions",
+ nullptr
+ };
return names;
}
@@ -444,206 +458,162 @@ inline const char *EnumNameBuiltinOptions(BuiltinOptions e) {
return EnumNamesBuiltinOptions()[index];
}
-template <typename T>
-struct BuiltinOptionsTraits {
+template<typename T> struct BuiltinOptionsTraits {
static const BuiltinOptions enum_value = BuiltinOptions_NONE;
};
-template <>
-struct BuiltinOptionsTraits<Conv2DOptions> {
+template<> struct BuiltinOptionsTraits<Conv2DOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
};
-template <>
-struct BuiltinOptionsTraits<DepthwiseConv2DOptions> {
- static const BuiltinOptions enum_value =
- BuiltinOptions_DepthwiseConv2DOptions;
+template<> struct BuiltinOptionsTraits<DepthwiseConv2DOptions> {
+ static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
};
-template <>
-struct BuiltinOptionsTraits<ConcatEmbeddingsOptions> {
- static const BuiltinOptions enum_value =
- BuiltinOptions_ConcatEmbeddingsOptions;
+template<> struct BuiltinOptionsTraits<ConcatEmbeddingsOptions> {
+ static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
};
-template <>
-struct BuiltinOptionsTraits<LSHProjectionOptions> {
+template<> struct BuiltinOptionsTraits<LSHProjectionOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
};
-template <>
-struct BuiltinOptionsTraits<Pool2DOptions> {
+template<> struct BuiltinOptionsTraits<Pool2DOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
};
-template <>
-struct BuiltinOptionsTraits<SVDFOptions> {
+template<> struct BuiltinOptionsTraits<SVDFOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
};
-template <>
-struct BuiltinOptionsTraits<RNNOptions> {
+template<> struct BuiltinOptionsTraits<RNNOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
};
-template <>
-struct BuiltinOptionsTraits<FullyConnectedOptions> {
+template<> struct BuiltinOptionsTraits<FullyConnectedOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
};
-template <>
-struct BuiltinOptionsTraits<SoftmaxOptions> {
+template<> struct BuiltinOptionsTraits<SoftmaxOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
};
-template <>
-struct BuiltinOptionsTraits<ConcatenationOptions> {
+template<> struct BuiltinOptionsTraits<ConcatenationOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
};
-template <>
-struct BuiltinOptionsTraits<AddOptions> {
+template<> struct BuiltinOptionsTraits<AddOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
};
-template <>
-struct BuiltinOptionsTraits<L2NormOptions> {
+template<> struct BuiltinOptionsTraits<L2NormOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
};
-template <>
-struct BuiltinOptionsTraits<LocalResponseNormalizationOptions> {
- static const BuiltinOptions enum_value =
- BuiltinOptions_LocalResponseNormalizationOptions;
+template<> struct BuiltinOptionsTraits<LocalResponseNormalizationOptions> {
+ static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
};
-template <>
-struct BuiltinOptionsTraits<LSTMOptions> {
+template<> struct BuiltinOptionsTraits<LSTMOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
};
-template <>
-struct BuiltinOptionsTraits<ResizeBilinearOptions> {
+template<> struct BuiltinOptionsTraits<ResizeBilinearOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
};
-template <>
-struct BuiltinOptionsTraits<CallOptions> {
+template<> struct BuiltinOptionsTraits<CallOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
};
-template <>
-struct BuiltinOptionsTraits<ReshapeOptions> {
+template<> struct BuiltinOptionsTraits<ReshapeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
};
-template <>
-struct BuiltinOptionsTraits<SkipGramOptions> {
+template<> struct BuiltinOptionsTraits<SkipGramOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
};
-template <>
-struct BuiltinOptionsTraits<SpaceToDepthOptions> {
+template<> struct BuiltinOptionsTraits<SpaceToDepthOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
};
-template <>
-struct BuiltinOptionsTraits<EmbeddingLookupSparseOptions> {
- static const BuiltinOptions enum_value =
- BuiltinOptions_EmbeddingLookupSparseOptions;
+template<> struct BuiltinOptionsTraits<EmbeddingLookupSparseOptions> {
+ static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
};
-template <>
-struct BuiltinOptionsTraits<MulOptions> {
+template<> struct BuiltinOptionsTraits<MulOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
};
-template <>
-struct BuiltinOptionsTraits<PadOptions> {
+template<> struct BuiltinOptionsTraits<PadOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
};
-template <>
-struct BuiltinOptionsTraits<GatherOptions> {
+template<> struct BuiltinOptionsTraits<GatherOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
};
-template <>
-struct BuiltinOptionsTraits<BatchToSpaceNDOptions> {
+template<> struct BuiltinOptionsTraits<BatchToSpaceNDOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
};
-template <>
-struct BuiltinOptionsTraits<SpaceToBatchNDOptions> {
+template<> struct BuiltinOptionsTraits<SpaceToBatchNDOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
};
-template <>
-struct BuiltinOptionsTraits<TransposeOptions> {
+template<> struct BuiltinOptionsTraits<TransposeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
};
-template <>
-struct BuiltinOptionsTraits<MeanOptions> {
+template<> struct BuiltinOptionsTraits<MeanOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_MeanOptions;
};
-template <>
-struct BuiltinOptionsTraits<SubOptions> {
+template<> struct BuiltinOptionsTraits<SubOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
};
-template <>
-struct BuiltinOptionsTraits<DivOptions> {
+template<> struct BuiltinOptionsTraits<DivOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
};
-template <>
-struct BuiltinOptionsTraits<SqueezeOptions> {
+template<> struct BuiltinOptionsTraits<SqueezeOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
};
-template <>
-struct BuiltinOptionsTraits<SequenceRNNOptions> {
+template<> struct BuiltinOptionsTraits<SequenceRNNOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
};
-template <>
-struct BuiltinOptionsTraits<StridedSliceOptions> {
+template<> struct BuiltinOptionsTraits<StridedSliceOptions> {
static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
};
+template<> struct BuiltinOptionsTraits<TFMaximumOptions> {
+ static const BuiltinOptions enum_value = BuiltinOptions_TFMaximumOptions;
+};
+
struct BuiltinOptionsUnion {
BuiltinOptions type;
void *value;
BuiltinOptionsUnion() : type(BuiltinOptions_NONE), value(nullptr) {}
- BuiltinOptionsUnion(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
- : type(BuiltinOptions_NONE),
- value(nullptr) {
- std::swap(type, u.type);
- std::swap(value, u.value);
- }
+ BuiltinOptionsUnion(BuiltinOptionsUnion&& u) FLATBUFFERS_NOEXCEPT :
+ type(BuiltinOptions_NONE), value(nullptr)
+ { std::swap(type, u.type); std::swap(value, u.value); }
BuiltinOptionsUnion(const BuiltinOptionsUnion &) FLATBUFFERS_NOEXCEPT;
- BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u)
- FLATBUFFERS_NOEXCEPT {
- BuiltinOptionsUnion t(u);
- std::swap(type, t.type);
- std::swap(value, t.value);
- return *this;
- }
- BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT {
- std::swap(type, u.type);
- std::swap(value, u.value);
- return *this;
- }
+ BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT
+ { BuiltinOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
+ BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
+ { std::swap(type, u.type); std::swap(value, u.value); return *this; }
~BuiltinOptionsUnion() { Reset(); }
void Reset();
#ifndef FLATBUFFERS_CPP98_STL
template <typename T>
- void Set(T &&val) {
+ void Set(T&& val) {
Reset();
type = BuiltinOptionsTraits<typename T::TableType>::enum_value;
if (type != BuiltinOptions_NONE) {
@@ -652,342 +622,277 @@ struct BuiltinOptionsUnion {
}
#endif // FLATBUFFERS_CPP98_STL
- 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;
Conv2DOptionsT *AsConv2DOptions() {
- return type == BuiltinOptions_Conv2DOptions
- ? reinterpret_cast<Conv2DOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_Conv2DOptions ?
+ reinterpret_cast<Conv2DOptionsT *>(value) : nullptr;
}
const Conv2DOptionsT *AsConv2DOptions() const {
- return type == BuiltinOptions_Conv2DOptions
- ? reinterpret_cast<const Conv2DOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_Conv2DOptions ?
+ reinterpret_cast<const Conv2DOptionsT *>(value) : nullptr;
}
DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() {
- return type == BuiltinOptions_DepthwiseConv2DOptions
- ? reinterpret_cast<DepthwiseConv2DOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_DepthwiseConv2DOptions ?
+ reinterpret_cast<DepthwiseConv2DOptionsT *>(value) : nullptr;
}
const DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() const {
- return type == BuiltinOptions_DepthwiseConv2DOptions
- ? reinterpret_cast<const DepthwiseConv2DOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_DepthwiseConv2DOptions ?
+ reinterpret_cast<const DepthwiseConv2DOptionsT *>(value) : nullptr;
}
ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() {
- return type == BuiltinOptions_ConcatEmbeddingsOptions
- ? reinterpret_cast<ConcatEmbeddingsOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_ConcatEmbeddingsOptions ?
+ reinterpret_cast<ConcatEmbeddingsOptionsT *>(value) : nullptr;
}
const ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() const {
- return type == BuiltinOptions_ConcatEmbeddingsOptions
- ? reinterpret_cast<const ConcatEmbeddingsOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_ConcatEmbeddingsOptions ?
+ reinterpret_cast<const ConcatEmbeddingsOptionsT *>(value) : nullptr;
}
LSHProjectionOptionsT *AsLSHProjectionOptions() {
- return type == BuiltinOptions_LSHProjectionOptions
- ? reinterpret_cast<LSHProjectionOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_LSHProjectionOptions ?
+ reinterpret_cast<LSHProjectionOptionsT *>(value) : nullptr;
}
const LSHProjectionOptionsT *AsLSHProjectionOptions() const {
- return type == BuiltinOptions_LSHProjectionOptions
- ? reinterpret_cast<const LSHProjectionOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_LSHProjectionOptions ?
+ reinterpret_cast<const LSHProjectionOptionsT *>(value) : nullptr;
}
Pool2DOptionsT *AsPool2DOptions() {
- return type == BuiltinOptions_Pool2DOptions
- ? reinterpret_cast<Pool2DOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_Pool2DOptions ?
+ reinterpret_cast<Pool2DOptionsT *>(value) : nullptr;
}
const Pool2DOptionsT *AsPool2DOptions() const {
- return type == BuiltinOptions_Pool2DOptions
- ? reinterpret_cast<const Pool2DOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_Pool2DOptions ?
+ reinterpret_cast<const Pool2DOptionsT *>(value) : nullptr;
}
SVDFOptionsT *AsSVDFOptions() {
- return type == BuiltinOptions_SVDFOptions
- ? reinterpret_cast<SVDFOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SVDFOptions ?
+ reinterpret_cast<SVDFOptionsT *>(value) : nullptr;
}
const SVDFOptionsT *AsSVDFOptions() const {
- return type == BuiltinOptions_SVDFOptions
- ? reinterpret_cast<const SVDFOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SVDFOptions ?
+ reinterpret_cast<const SVDFOptionsT *>(value) : nullptr;
}
RNNOptionsT *AsRNNOptions() {
- return type == BuiltinOptions_RNNOptions
- ? reinterpret_cast<RNNOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_RNNOptions ?
+ reinterpret_cast<RNNOptionsT *>(value) : nullptr;
}
const RNNOptionsT *AsRNNOptions() const {
- return type == BuiltinOptions_RNNOptions
- ? reinterpret_cast<const RNNOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_RNNOptions ?
+ reinterpret_cast<const RNNOptionsT *>(value) : nullptr;
}
FullyConnectedOptionsT *AsFullyConnectedOptions() {
- return type == BuiltinOptions_FullyConnectedOptions
- ? reinterpret_cast<FullyConnectedOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_FullyConnectedOptions ?
+ reinterpret_cast<FullyConnectedOptionsT *>(value) : nullptr;
}
const FullyConnectedOptionsT *AsFullyConnectedOptions() const {
- return type == BuiltinOptions_FullyConnectedOptions
- ? reinterpret_cast<const FullyConnectedOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_FullyConnectedOptions ?
+ reinterpret_cast<const FullyConnectedOptionsT *>(value) : nullptr;
}
SoftmaxOptionsT *AsSoftmaxOptions() {
- return type == BuiltinOptions_SoftmaxOptions
- ? reinterpret_cast<SoftmaxOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SoftmaxOptions ?
+ reinterpret_cast<SoftmaxOptionsT *>(value) : nullptr;
}
const SoftmaxOptionsT *AsSoftmaxOptions() const {
- return type == BuiltinOptions_SoftmaxOptions
- ? reinterpret_cast<const SoftmaxOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SoftmaxOptions ?
+ reinterpret_cast<const SoftmaxOptionsT *>(value) : nullptr;
}
ConcatenationOptionsT *AsConcatenationOptions() {
- return type == BuiltinOptions_ConcatenationOptions
- ? reinterpret_cast<ConcatenationOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_ConcatenationOptions ?
+ reinterpret_cast<ConcatenationOptionsT *>(value) : nullptr;
}
const ConcatenationOptionsT *AsConcatenationOptions() const {
- return type == BuiltinOptions_ConcatenationOptions
- ? reinterpret_cast<const ConcatenationOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_ConcatenationOptions ?
+ reinterpret_cast<const ConcatenationOptionsT *>(value) : nullptr;
}
AddOptionsT *AsAddOptions() {
- return type == BuiltinOptions_AddOptions
- ? reinterpret_cast<AddOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_AddOptions ?
+ reinterpret_cast<AddOptionsT *>(value) : nullptr;
}
const AddOptionsT *AsAddOptions() const {
- return type == BuiltinOptions_AddOptions
- ? reinterpret_cast<const AddOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_AddOptions ?
+ reinterpret_cast<const AddOptionsT *>(value) : nullptr;
}
L2NormOptionsT *AsL2NormOptions() {
- return type == BuiltinOptions_L2NormOptions
- ? reinterpret_cast<L2NormOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_L2NormOptions ?
+ reinterpret_cast<L2NormOptionsT *>(value) : nullptr;
}
const L2NormOptionsT *AsL2NormOptions() const {
- return type == BuiltinOptions_L2NormOptions
- ? reinterpret_cast<const L2NormOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_L2NormOptions ?
+ reinterpret_cast<const L2NormOptionsT *>(value) : nullptr;
}
LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() {
- return type == BuiltinOptions_LocalResponseNormalizationOptions
- ? reinterpret_cast<LocalResponseNormalizationOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_LocalResponseNormalizationOptions ?
+ reinterpret_cast<LocalResponseNormalizationOptionsT *>(value) : nullptr;
}
- const LocalResponseNormalizationOptionsT *
- AsLocalResponseNormalizationOptions() const {
- return type == BuiltinOptions_LocalResponseNormalizationOptions
- ? reinterpret_cast<const LocalResponseNormalizationOptionsT *>(
- value)
- : nullptr;
+ const LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() const {
+ return type == BuiltinOptions_LocalResponseNormalizationOptions ?
+ reinterpret_cast<const LocalResponseNormalizationOptionsT *>(value) : nullptr;
}
LSTMOptionsT *AsLSTMOptions() {
- return type == BuiltinOptions_LSTMOptions
- ? reinterpret_cast<LSTMOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_LSTMOptions ?
+ reinterpret_cast<LSTMOptionsT *>(value) : nullptr;
}
const LSTMOptionsT *AsLSTMOptions() const {
- return type == BuiltinOptions_LSTMOptions
- ? reinterpret_cast<const LSTMOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_LSTMOptions ?
+ reinterpret_cast<const LSTMOptionsT *>(value) : nullptr;
}
ResizeBilinearOptionsT *AsResizeBilinearOptions() {
- return type == BuiltinOptions_ResizeBilinearOptions
- ? reinterpret_cast<ResizeBilinearOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_ResizeBilinearOptions ?
+ reinterpret_cast<ResizeBilinearOptionsT *>(value) : nullptr;
}
const ResizeBilinearOptionsT *AsResizeBilinearOptions() const {
- return type == BuiltinOptions_ResizeBilinearOptions
- ? reinterpret_cast<const ResizeBilinearOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_ResizeBilinearOptions ?
+ reinterpret_cast<const ResizeBilinearOptionsT *>(value) : nullptr;
}
CallOptionsT *AsCallOptions() {
- return type == BuiltinOptions_CallOptions
- ? reinterpret_cast<CallOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_CallOptions ?
+ reinterpret_cast<CallOptionsT *>(value) : nullptr;
}
const CallOptionsT *AsCallOptions() const {
- return type == BuiltinOptions_CallOptions
- ? reinterpret_cast<const CallOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_CallOptions ?
+ reinterpret_cast<const CallOptionsT *>(value) : nullptr;
}
ReshapeOptionsT *AsReshapeOptions() {
- return type == BuiltinOptions_ReshapeOptions
- ? reinterpret_cast<ReshapeOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_ReshapeOptions ?
+ reinterpret_cast<ReshapeOptionsT *>(value) : nullptr;
}
const ReshapeOptionsT *AsReshapeOptions() const {
- return type == BuiltinOptions_ReshapeOptions
- ? reinterpret_cast<const ReshapeOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_ReshapeOptions ?
+ reinterpret_cast<const ReshapeOptionsT *>(value) : nullptr;
}
SkipGramOptionsT *AsSkipGramOptions() {
- return type == BuiltinOptions_SkipGramOptions
- ? reinterpret_cast<SkipGramOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SkipGramOptions ?
+ reinterpret_cast<SkipGramOptionsT *>(value) : nullptr;
}
const SkipGramOptionsT *AsSkipGramOptions() const {
- return type == BuiltinOptions_SkipGramOptions
- ? reinterpret_cast<const SkipGramOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SkipGramOptions ?
+ reinterpret_cast<const SkipGramOptionsT *>(value) : nullptr;
}
SpaceToDepthOptionsT *AsSpaceToDepthOptions() {
- return type == BuiltinOptions_SpaceToDepthOptions
- ? reinterpret_cast<SpaceToDepthOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SpaceToDepthOptions ?
+ reinterpret_cast<SpaceToDepthOptionsT *>(value) : nullptr;
}
const SpaceToDepthOptionsT *AsSpaceToDepthOptions() const {
- return type == BuiltinOptions_SpaceToDepthOptions
- ? reinterpret_cast<const SpaceToDepthOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SpaceToDepthOptions ?
+ reinterpret_cast<const SpaceToDepthOptionsT *>(value) : nullptr;
}
EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() {
- return type == BuiltinOptions_EmbeddingLookupSparseOptions
- ? reinterpret_cast<EmbeddingLookupSparseOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
+ reinterpret_cast<EmbeddingLookupSparseOptionsT *>(value) : nullptr;
}
const EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() const {
- return type == BuiltinOptions_EmbeddingLookupSparseOptions
- ? reinterpret_cast<const EmbeddingLookupSparseOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
+ reinterpret_cast<const EmbeddingLookupSparseOptionsT *>(value) : nullptr;
}
MulOptionsT *AsMulOptions() {
- return type == BuiltinOptions_MulOptions
- ? reinterpret_cast<MulOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_MulOptions ?
+ reinterpret_cast<MulOptionsT *>(value) : nullptr;
}
const MulOptionsT *AsMulOptions() const {
- return type == BuiltinOptions_MulOptions
- ? reinterpret_cast<const MulOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_MulOptions ?
+ reinterpret_cast<const MulOptionsT *>(value) : nullptr;
}
PadOptionsT *AsPadOptions() {
- return type == BuiltinOptions_PadOptions
- ? reinterpret_cast<PadOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_PadOptions ?
+ reinterpret_cast<PadOptionsT *>(value) : nullptr;
}
const PadOptionsT *AsPadOptions() const {
- return type == BuiltinOptions_PadOptions
- ? reinterpret_cast<const PadOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_PadOptions ?
+ reinterpret_cast<const PadOptionsT *>(value) : nullptr;
}
GatherOptionsT *AsGatherOptions() {
- return type == BuiltinOptions_GatherOptions
- ? reinterpret_cast<GatherOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_GatherOptions ?
+ reinterpret_cast<GatherOptionsT *>(value) : nullptr;
}
const GatherOptionsT *AsGatherOptions() const {
- return type == BuiltinOptions_GatherOptions
- ? reinterpret_cast<const GatherOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_GatherOptions ?
+ reinterpret_cast<const GatherOptionsT *>(value) : nullptr;
}
BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() {
- return type == BuiltinOptions_BatchToSpaceNDOptions
- ? reinterpret_cast<BatchToSpaceNDOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_BatchToSpaceNDOptions ?
+ reinterpret_cast<BatchToSpaceNDOptionsT *>(value) : nullptr;
}
const BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() const {
- return type == BuiltinOptions_BatchToSpaceNDOptions
- ? reinterpret_cast<const BatchToSpaceNDOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_BatchToSpaceNDOptions ?
+ reinterpret_cast<const BatchToSpaceNDOptionsT *>(value) : nullptr;
}
SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() {
- return type == BuiltinOptions_SpaceToBatchNDOptions
- ? reinterpret_cast<SpaceToBatchNDOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SpaceToBatchNDOptions ?
+ reinterpret_cast<SpaceToBatchNDOptionsT *>(value) : nullptr;
}
const SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() const {
- return type == BuiltinOptions_SpaceToBatchNDOptions
- ? reinterpret_cast<const SpaceToBatchNDOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SpaceToBatchNDOptions ?
+ reinterpret_cast<const SpaceToBatchNDOptionsT *>(value) : nullptr;
}
TransposeOptionsT *AsTransposeOptions() {
- return type == BuiltinOptions_TransposeOptions
- ? reinterpret_cast<TransposeOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_TransposeOptions ?
+ reinterpret_cast<TransposeOptionsT *>(value) : nullptr;
}
const TransposeOptionsT *AsTransposeOptions() const {
- return type == BuiltinOptions_TransposeOptions
- ? reinterpret_cast<const TransposeOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_TransposeOptions ?
+ reinterpret_cast<const TransposeOptionsT *>(value) : nullptr;
}
MeanOptionsT *AsMeanOptions() {
- return type == BuiltinOptions_MeanOptions
- ? reinterpret_cast<MeanOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_MeanOptions ?
+ reinterpret_cast<MeanOptionsT *>(value) : nullptr;
}
const MeanOptionsT *AsMeanOptions() const {
- return type == BuiltinOptions_MeanOptions
- ? reinterpret_cast<const MeanOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_MeanOptions ?
+ reinterpret_cast<const MeanOptionsT *>(value) : nullptr;
}
SubOptionsT *AsSubOptions() {
- return type == BuiltinOptions_SubOptions
- ? reinterpret_cast<SubOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SubOptions ?
+ reinterpret_cast<SubOptionsT *>(value) : nullptr;
}
const SubOptionsT *AsSubOptions() const {
- return type == BuiltinOptions_SubOptions
- ? reinterpret_cast<const SubOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SubOptions ?
+ reinterpret_cast<const SubOptionsT *>(value) : nullptr;
}
DivOptionsT *AsDivOptions() {
- return type == BuiltinOptions_DivOptions
- ? reinterpret_cast<DivOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_DivOptions ?
+ reinterpret_cast<DivOptionsT *>(value) : nullptr;
}
const DivOptionsT *AsDivOptions() const {
- return type == BuiltinOptions_DivOptions
- ? reinterpret_cast<const DivOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_DivOptions ?
+ reinterpret_cast<const DivOptionsT *>(value) : nullptr;
}
SqueezeOptionsT *AsSqueezeOptions() {
- return type == BuiltinOptions_SqueezeOptions
- ? reinterpret_cast<SqueezeOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SqueezeOptions ?
+ reinterpret_cast<SqueezeOptionsT *>(value) : nullptr;
}
const SqueezeOptionsT *AsSqueezeOptions() const {
- return type == BuiltinOptions_SqueezeOptions
- ? reinterpret_cast<const SqueezeOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SqueezeOptions ?
+ reinterpret_cast<const SqueezeOptionsT *>(value) : nullptr;
}
SequenceRNNOptionsT *AsSequenceRNNOptions() {
- return type == BuiltinOptions_SequenceRNNOptions
- ? reinterpret_cast<SequenceRNNOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SequenceRNNOptions ?
+ reinterpret_cast<SequenceRNNOptionsT *>(value) : nullptr;
}
const SequenceRNNOptionsT *AsSequenceRNNOptions() const {
- return type == BuiltinOptions_SequenceRNNOptions
- ? reinterpret_cast<const SequenceRNNOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_SequenceRNNOptions ?
+ reinterpret_cast<const SequenceRNNOptionsT *>(value) : nullptr;
}
StridedSliceOptionsT *AsStridedSliceOptions() {
- return type == BuiltinOptions_StridedSliceOptions
- ? reinterpret_cast<StridedSliceOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_StridedSliceOptions ?
+ reinterpret_cast<StridedSliceOptionsT *>(value) : nullptr;
}
const StridedSliceOptionsT *AsStridedSliceOptions() const {
- return type == BuiltinOptions_StridedSliceOptions
- ? reinterpret_cast<const StridedSliceOptionsT *>(value)
- : nullptr;
+ return type == BuiltinOptions_StridedSliceOptions ?
+ reinterpret_cast<const StridedSliceOptionsT *>(value) : nullptr;
+ }
+ TFMaximumOptionsT *AsTFMaximumOptions() {
+ return type == BuiltinOptions_TFMaximumOptions ?
+ reinterpret_cast<TFMaximumOptionsT *>(value) : nullptr;
+ }
+ const TFMaximumOptionsT *AsTFMaximumOptions() const {
+ return type == BuiltinOptions_TFMaximumOptions ?
+ reinterpret_cast<const TFMaximumOptionsT *>(value) : nullptr;
}
};
-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 Padding {
Padding_SAME = 0,
@@ -997,12 +902,19 @@ enum Padding {
};
inline Padding (&EnumValuesPadding())[2] {
- static Padding values[] = {Padding_SAME, Padding_VALID};
+ static Padding values[] = {
+ Padding_SAME,
+ Padding_VALID
+ };
return values;
}
inline const char **EnumNamesPadding() {
- static const char *names[] = {"SAME", "VALID", nullptr};
+ static const char *names[] = {
+ "SAME",
+ "VALID",
+ nullptr
+ };
return names;
}
@@ -1024,15 +936,26 @@ enum ActivationFunctionType {
inline ActivationFunctionType (&EnumValuesActivationFunctionType())[6] {
static ActivationFunctionType values[] = {
- ActivationFunctionType_NONE, ActivationFunctionType_RELU,
- ActivationFunctionType_RELU_N1_TO_1, ActivationFunctionType_RELU6,
- ActivationFunctionType_TANH, ActivationFunctionType_SIGN_BIT};
+ ActivationFunctionType_NONE,
+ ActivationFunctionType_RELU,
+ ActivationFunctionType_RELU_N1_TO_1,
+ ActivationFunctionType_RELU6,
+ ActivationFunctionType_TANH,
+ ActivationFunctionType_SIGN_BIT
+ };
return values;
}
inline const char **EnumNamesActivationFunctionType() {
- static const char *names[] = {"NONE", "RELU", "RELU_N1_TO_1", "RELU6",
- "TANH", "SIGN_BIT", nullptr};
+ static const char *names[] = {
+ "NONE",
+ "RELU",
+ "RELU_N1_TO_1",
+ "RELU6",
+ "TANH",
+ "SIGN_BIT",
+ nullptr
+ };
return names;
}
@@ -1050,14 +973,21 @@ enum LSHProjectionType {
};
inline LSHProjectionType (&EnumValuesLSHProjectionType())[3] {
- static LSHProjectionType values[] = {LSHProjectionType_UNKNOWN,
- LSHProjectionType_SPARSE,
- LSHProjectionType_DENSE};
+ static LSHProjectionType values[] = {
+ LSHProjectionType_UNKNOWN,
+ LSHProjectionType_SPARSE,
+ LSHProjectionType_DENSE
+ };
return values;
}
inline const char **EnumNamesLSHProjectionType() {
- static const char *names[] = {"UNKNOWN", "SPARSE", "DENSE", nullptr};
+ static const char *names[] = {
+ "UNKNOWN",
+ "SPARSE",
+ "DENSE",
+ nullptr
+ };
return names;
}
@@ -1075,13 +1005,21 @@ enum CombinerType {
};
inline CombinerType (&EnumValuesCombinerType())[3] {
- static CombinerType values[] = {CombinerType_SUM, CombinerType_MEAN,
- CombinerType_SQRTN};
+ static CombinerType values[] = {
+ CombinerType_SUM,
+ CombinerType_MEAN,
+ CombinerType_SQRTN
+ };
return values;
}
inline const char **EnumNamesCombinerType() {
- static const char *names[] = {"SUM", "MEAN", "SQRTN", nullptr};
+ static const char *names[] = {
+ "SUM",
+ "MEAN",
+ "SQRTN",
+ nullptr
+ };
return names;
}
@@ -1097,12 +1035,17 @@ enum CustomOptionsFormat {
};
inline CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1] {
- static CustomOptionsFormat values[] = {CustomOptionsFormat_FLEXBUFFERS};
+ static CustomOptionsFormat values[] = {
+ CustomOptionsFormat_FLEXBUFFERS
+ };
return values;
}
inline const char **EnumNamesCustomOptionsFormat() {
- static const char *names[] = {"FLEXBUFFERS", nullptr};
+ static const char *names[] = {
+ "FLEXBUFFERS",
+ nullptr
+ };
return names;
}
@@ -1117,13 +1060,18 @@ struct QuantizationParametersT : public flatbuffers::NativeTable {
std::vector<float> max;
std::vector<float> scale;
std::vector<int64_t> zero_point;
- QuantizationParametersT() {}
+ QuantizationParametersT() {
+ }
};
-struct QuantizationParameters FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef QuantizationParametersT NativeTableType;
- enum { VT_MIN = 4, VT_MAX = 6, VT_SCALE = 8, VT_ZERO_POINT = 10 };
+ enum {
+ VT_MIN = 4,
+ VT_MAX = 6,
+ VT_SCALE = 8,
+ VT_ZERO_POINT = 10
+ };
const flatbuffers::Vector<float> *min() const {
return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
}
@@ -1137,20 +1085,20 @@ struct QuantizationParameters FLATBUFFERS_FINAL_CLASS
return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
}
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_MIN) &&
- verifier.Verify(min()) && VerifyOffset(verifier, VT_MAX) &&
- verifier.Verify(max()) && VerifyOffset(verifier, VT_SCALE) &&
- verifier.Verify(scale()) && VerifyOffset(verifier, VT_ZERO_POINT) &&
- verifier.Verify(zero_point()) && 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);
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_MIN) &&
+ verifier.Verify(min()) &&
+ VerifyOffset(verifier, VT_MAX) &&
+ verifier.Verify(max()) &&
+ VerifyOffset(verifier, VT_SCALE) &&
+ verifier.Verify(scale()) &&
+ VerifyOffset(verifier, VT_ZERO_POINT) &&
+ verifier.Verify(zero_point()) &&
+ 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);
};
struct QuantizationParametersBuilder {
@@ -1165,16 +1113,14 @@ struct QuantizationParametersBuilder {
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);
}
- explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- QuantizationParametersBuilder &operator=(
- const QuantizationParametersBuilder &);
+ QuantizationParametersBuilder &operator=(const QuantizationParametersBuilder &);
flatbuffers::Offset<QuantizationParameters> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<QuantizationParameters>(end);
@@ -1196,23 +1142,21 @@ inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
return builder_.Finish();
}
-inline flatbuffers::Offset<QuantizationParameters>
-CreateQuantizationParametersDirect(
+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) {
return tflite::CreateQuantizationParameters(
- _fbb, min ? _fbb.CreateVector<float>(*min) : 0,
+ _fbb,
+ min ? _fbb.CreateVector<float>(*min) : 0,
max ? _fbb.CreateVector<float>(*max) : 0,
scale ? _fbb.CreateVector<float>(*scale) : 0,
zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0);
}
-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 TensorT : public flatbuffers::NativeTable {
typedef Tensor TableType;
@@ -1221,7 +1165,10 @@ struct TensorT : public flatbuffers::NativeTable {
uint32_t buffer;
std::string name;
std::unique_ptr<QuantizationParametersT> quantization;
- TensorT() : type(TensorType_FLOAT32), buffer(0) {}
+ TensorT()
+ : type(TensorType_FLOAT32),
+ buffer(0) {
+ }
};
struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1239,7 +1186,9 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
TensorType type() const {
return static_cast<TensorType>(GetField<int8_t>(VT_TYPE, 0));
}
- uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
+ uint32_t buffer() const {
+ return GetField<uint32_t>(VT_BUFFER, 0);
+ }
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
}
@@ -1247,20 +1196,20 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return GetPointer<const QuantizationParameters *>(VT_QUANTIZATION);
}
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SHAPE) &&
- verifier.Verify(shape()) && VerifyField<int8_t>(verifier, VT_TYPE) &&
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_SHAPE) &&
+ verifier.Verify(shape()) &&
+ VerifyField<int8_t>(verifier, VT_TYPE) &&
VerifyField<uint32_t>(verifier, VT_BUFFER) &&
- VerifyOffset(verifier, VT_NAME) && verifier.Verify(name()) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.Verify(name()) &&
VerifyOffset(verifier, VT_QUANTIZATION) &&
- verifier.VerifyTable(quantization()) && verifier.EndTable();
+ verifier.VerifyTable(quantization()) &&
+ 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 {
@@ -1278,11 +1227,11 @@ struct TensorBuilder {
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(Tensor::VT_NAME, name);
}
- void add_quantization(
- flatbuffers::Offset<QuantizationParameters> quantization) {
+ void add_quantization(flatbuffers::Offset<QuantizationParameters> quantization) {
fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
}
- explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+ TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
TensorBuilder &operator=(const TensorBuilder &);
@@ -1296,7 +1245,8 @@ struct TensorBuilder {
inline flatbuffers::Offset<Tensor> CreateTensor(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
- TensorType type = TensorType_FLOAT32, uint32_t buffer = 0,
+ TensorType type = TensorType_FLOAT32,
+ uint32_t buffer = 0,
flatbuffers::Offset<flatbuffers::String> name = 0,
flatbuffers::Offset<QuantizationParameters> quantization = 0) {
TensorBuilder builder_(_fbb);
@@ -1311,17 +1261,20 @@ inline flatbuffers::Offset<Tensor> CreateTensor(
inline flatbuffers::Offset<Tensor> CreateTensorDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *shape = nullptr,
- TensorType type = TensorType_FLOAT32, uint32_t buffer = 0,
+ TensorType type = TensorType_FLOAT32,
+ uint32_t buffer = 0,
const char *name = nullptr,
flatbuffers::Offset<QuantizationParameters> quantization = 0) {
return tflite::CreateTensor(
- _fbb, shape ? _fbb.CreateVector<int32_t>(*shape) : 0, type, buffer,
- name ? _fbb.CreateString(name) : 0, quantization);
+ _fbb,
+ shape ? _fbb.CreateVector<int32_t>(*shape) : 0,
+ type,
+ buffer,
+ name ? _fbb.CreateString(name) : 0,
+ quantization);
}
-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 Conv2DOptionsT : public flatbuffers::NativeTable {
typedef Conv2DOptions TableType;
@@ -1333,7 +1286,8 @@ struct Conv2DOptionsT : public flatbuffers::NativeTable {
: padding(Padding_SAME),
stride_w(0),
stride_h(0),
- fused_activation_function(ActivationFunctionType_NONE) {}
+ fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1347,11 +1301,14 @@ struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
Padding padding() const {
return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0));
}
- int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
- int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
+ int32_t stride_w() const {
+ return GetField<int32_t>(VT_STRIDE_W, 0);
+ }
+ int32_t stride_h() const {
+ return GetField<int32_t>(VT_STRIDE_H, 0);
+ }
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -1361,22 +1318,16 @@ struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_padding(Padding padding) {
- fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING,
- static_cast<int8_t>(padding), 0);
+ fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
void add_stride_w(int32_t stride_w) {
fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
@@ -1384,13 +1335,11 @@ struct Conv2DOptionsBuilder {
void add_stride_h(int32_t stride_h) {
fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
}
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Conv2DOptionsBuilder &operator=(const Conv2DOptionsBuilder &);
@@ -1402,10 +1351,11 @@ struct Conv2DOptionsBuilder {
};
inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
- flatbuffers::FlatBufferBuilder &_fbb, Padding padding = Padding_SAME,
- int32_t stride_w = 0, int32_t stride_h = 0,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ flatbuffers::FlatBufferBuilder &_fbb,
+ Padding padding = Padding_SAME,
+ int32_t stride_w = 0,
+ int32_t stride_h = 0,
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
Conv2DOptionsBuilder builder_(_fbb);
builder_.add_stride_h(stride_h);
builder_.add_stride_w(stride_w);
@@ -1414,9 +1364,7 @@ inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
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 Pool2DOptionsT : public flatbuffers::NativeTable {
typedef Pool2DOptions TableType;
@@ -1432,7 +1380,8 @@ struct Pool2DOptionsT : public flatbuffers::NativeTable {
stride_h(0),
filter_width(0),
filter_height(0),
- fused_activation_function(ActivationFunctionType_NONE) {}
+ fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1448,15 +1397,20 @@ struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
Padding padding() const {
return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0));
}
- int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
- int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
- int32_t filter_width() const { return GetField<int32_t>(VT_FILTER_WIDTH, 0); }
+ int32_t stride_w() const {
+ return GetField<int32_t>(VT_STRIDE_W, 0);
+ }
+ int32_t stride_h() const {
+ return GetField<int32_t>(VT_STRIDE_H, 0);
+ }
+ int32_t filter_width() const {
+ return GetField<int32_t>(VT_FILTER_WIDTH, 0);
+ }
int32_t filter_height() const {
return GetField<int32_t>(VT_FILTER_HEIGHT, 0);
}
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -1468,22 +1422,16 @@ struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_padding(Padding padding) {
- fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING,
- static_cast<int8_t>(padding), 0);
+ fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
void add_stride_w(int32_t stride_w) {
fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
@@ -1497,13 +1445,11 @@ struct Pool2DOptionsBuilder {
void add_filter_height(int32_t filter_height) {
fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
}
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(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)
- : fbb_(_fbb) {
+ Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Pool2DOptionsBuilder &operator=(const Pool2DOptionsBuilder &);
@@ -1515,11 +1461,13 @@ struct Pool2DOptionsBuilder {
};
inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
- flatbuffers::FlatBufferBuilder &_fbb, Padding padding = Padding_SAME,
- int32_t stride_w = 0, int32_t stride_h = 0, int32_t filter_width = 0,
+ flatbuffers::FlatBufferBuilder &_fbb,
+ Padding padding = Padding_SAME,
+ int32_t stride_w = 0,
+ int32_t stride_h = 0,
+ int32_t filter_width = 0,
int32_t filter_height = 0,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
Pool2DOptionsBuilder builder_(_fbb);
builder_.add_filter_height(filter_height);
builder_.add_filter_width(filter_width);
@@ -1530,9 +1478,7 @@ inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
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 {
typedef DepthwiseConv2DOptions TableType;
@@ -1546,11 +1492,11 @@ struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable {
stride_w(0),
stride_h(0),
depth_multiplier(0),
- fused_activation_function(ActivationFunctionType_NONE) {}
+ fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
-struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef DepthwiseConv2DOptionsT NativeTableType;
enum {
VT_PADDING = 4,
@@ -1562,14 +1508,17 @@ struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS
Padding padding() const {
return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0));
}
- int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
- int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
+ int32_t stride_w() const {
+ return GetField<int32_t>(VT_STRIDE_W, 0);
+ }
+ int32_t stride_h() const {
+ return GetField<int32_t>(VT_STRIDE_H, 0);
+ }
int32_t depth_multiplier() const {
return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0);
}
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -1580,22 +1529,16 @@ struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_padding(Padding padding) {
- fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING,
- static_cast<int8_t>(padding), 0);
+ fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
}
void add_stride_w(int32_t stride_w) {
fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
@@ -1604,21 +1547,16 @@ struct DepthwiseConv2DOptionsBuilder {
fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
}
void add_depth_multiplier(int32_t depth_multiplier) {
- fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER,
- depth_multiplier, 0);
+ fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
}
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(
- DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- DepthwiseConv2DOptionsBuilder &operator=(
- const DepthwiseConv2DOptionsBuilder &);
+ DepthwiseConv2DOptionsBuilder &operator=(const DepthwiseConv2DOptionsBuilder &);
flatbuffers::Offset<DepthwiseConv2DOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
@@ -1627,10 +1565,12 @@ struct DepthwiseConv2DOptionsBuilder {
};
inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
- flatbuffers::FlatBufferBuilder &_fbb, Padding padding = Padding_SAME,
- int32_t stride_w = 0, int32_t stride_h = 0, int32_t depth_multiplier = 0,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ flatbuffers::FlatBufferBuilder &_fbb,
+ Padding padding = Padding_SAME,
+ int32_t stride_w = 0,
+ int32_t stride_h = 0,
+ int32_t depth_multiplier = 0,
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
DepthwiseConv2DOptionsBuilder builder_(_fbb);
builder_.add_depth_multiplier(depth_multiplier);
builder_.add_stride_h(stride_h);
@@ -1640,34 +1580,33 @@ inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
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 {
typedef ConcatEmbeddingsOptions TableType;
int32_t num_channels;
std::vector<int32_t> num_columns_per_channel;
std::vector<int32_t> embedding_dim_per_channel;
- ConcatEmbeddingsOptionsT() : num_channels(0) {}
+ ConcatEmbeddingsOptionsT()
+ : num_channels(0) {
+ }
};
-struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ConcatEmbeddingsOptionsT NativeTableType;
enum {
VT_NUM_CHANNELS = 4,
VT_NUM_COLUMNS_PER_CHANNEL = 6,
VT_EMBEDDING_DIM_PER_CHANNEL = 8
};
- int32_t num_channels() const { return GetField<int32_t>(VT_NUM_CHANNELS, 0); }
+ 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);
+ 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);
+ return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -1675,43 +1614,31 @@ struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS
VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
verifier.Verify(num_columns_per_channel()) &&
VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
- verifier.Verify(embedding_dim_per_channel()) && verifier.EndTable();
+ verifier.Verify(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 {
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) {
- 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) {
- fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL,
- embedding_dim_per_channel);
- }
- explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ 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) {
+ 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) {
+ fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel);
+ }
+ ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- ConcatEmbeddingsOptionsBuilder &operator=(
- const ConcatEmbeddingsOptionsBuilder &);
+ ConcatEmbeddingsOptionsBuilder &operator=(const ConcatEmbeddingsOptionsBuilder &);
flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
@@ -1719,13 +1646,11 @@ struct ConcatEmbeddingsOptionsBuilder {
}
};
-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) {
+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) {
ConcatEmbeddingsOptionsBuilder builder_(_fbb);
builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
builder_.add_num_columns_per_channel(num_columns_per_channel);
@@ -1733,61 +1658,54 @@ CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb,
return builder_.Finish();
}
-inline flatbuffers::Offset<ConcatEmbeddingsOptions>
-CreateConcatEmbeddingsOptionsDirect(
- flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
+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) {
return tflite::CreateConcatEmbeddingsOptions(
- _fbb, num_channels,
- num_columns_per_channel
- ? _fbb.CreateVector<int32_t>(*num_columns_per_channel)
- : 0,
- embedding_dim_per_channel
- ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel)
- : 0);
+ _fbb,
+ num_channels,
+ num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0,
+ embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0);
}
-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 {
typedef LSHProjectionOptions TableType;
LSHProjectionType type;
- LSHProjectionOptionsT() : type(LSHProjectionType_UNKNOWN) {}
+ LSHProjectionOptionsT()
+ : type(LSHProjectionType_UNKNOWN) {
+ }
};
-struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LSHProjectionOptionsT NativeTableType;
- enum { VT_TYPE = 4 };
+ enum {
+ VT_TYPE = 4
+ };
LSHProjectionType type() const {
return static_cast<LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
- VerifyField<int8_t>(verifier, VT_TYPE) && verifier.EndTable();
+ VerifyField<int8_t>(verifier, VT_TYPE) &&
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_type(LSHProjectionType type) {
- fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE,
- static_cast<int8_t>(type), 0);
+ fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
}
- explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LSHProjectionOptionsBuilder &operator=(const LSHProjectionOptionsBuilder &);
@@ -1806,25 +1724,29 @@ inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
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 {
typedef SVDFOptions TableType;
int32_t rank;
ActivationFunctionType fused_activation_function;
SVDFOptionsT()
- : rank(0), fused_activation_function(ActivationFunctionType_NONE) {}
+ : rank(0),
+ fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SVDFOptionsT NativeTableType;
- enum { VT_RANK = 4, VT_FUSED_ACTIVATION_FUNCTION = 6 };
- int32_t rank() const { return GetField<int32_t>(VT_RANK, 0); }
+ enum {
+ VT_RANK = 4,
+ VT_FUSED_ACTIVATION_FUNCTION = 6
+ };
+ int32_t rank() const {
+ return GetField<int32_t>(VT_RANK, 0);
+ }
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -1832,14 +1754,9 @@ struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
@@ -1848,13 +1765,11 @@ struct SVDFOptionsBuilder {
void add_rank(int32_t rank) {
fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0);
}
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SVDFOptionsBuilder &operator=(const SVDFOptionsBuilder &);
@@ -1866,57 +1781,51 @@ struct SVDFOptionsBuilder {
};
inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
- flatbuffers::FlatBufferBuilder &_fbb, int32_t rank = 0,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int32_t rank = 0,
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
SVDFOptionsBuilder builder_(_fbb);
builder_.add_rank(rank);
builder_.add_fused_activation_function(fused_activation_function);
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 {
typedef RNNOptions TableType;
ActivationFunctionType fused_activation_function;
- RNNOptionsT() : fused_activation_function(ActivationFunctionType_NONE) {}
+ RNNOptionsT()
+ : fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RNNOptionsT NativeTableType;
- enum { VT_FUSED_ACTIVATION_FUNCTION = 4 };
+ enum {
+ VT_FUSED_ACTIVATION_FUNCTION = 4
+ };
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
RNNOptionsBuilder &operator=(const RNNOptionsBuilder &);
@@ -1929,16 +1838,13 @@ struct RNNOptionsBuilder {
inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
flatbuffers::FlatBufferBuilder &_fbb,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
RNNOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
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 {
typedef SequenceRNNOptions TableType;
@@ -1946,16 +1852,21 @@ struct SequenceRNNOptionsT : public flatbuffers::NativeTable {
ActivationFunctionType fused_activation_function;
SequenceRNNOptionsT()
: time_major(false),
- fused_activation_function(ActivationFunctionType_NONE) {}
+ fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SequenceRNNOptionsT NativeTableType;
- enum { VT_TIME_MAJOR = 4, VT_FUSED_ACTIVATION_FUNCTION = 6 };
- bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
+ enum {
+ VT_TIME_MAJOR = 4,
+ VT_FUSED_ACTIVATION_FUNCTION = 6
+ };
+ bool time_major() const {
+ return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
+ }
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -1963,30 +1874,22 @@ struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
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);
+ fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
}
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SequenceRNNOptionsBuilder &operator=(const SequenceRNNOptionsBuilder &);
@@ -1998,18 +1901,16 @@ struct SequenceRNNOptionsBuilder {
};
inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
- flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ flatbuffers::FlatBufferBuilder &_fbb,
+ bool time_major = false,
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
SequenceRNNOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
builder_.add_time_major(time_major);
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 {
typedef BidirectionalSequenceRNNOptions TableType;
@@ -2017,17 +1918,21 @@ struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable {
ActivationFunctionType fused_activation_function;
BidirectionalSequenceRNNOptionsT()
: time_major(false),
- fused_activation_function(ActivationFunctionType_NONE) {}
+ fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
-struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef BidirectionalSequenceRNNOptionsT NativeTableType;
- enum { VT_TIME_MAJOR = 4, VT_FUSED_ACTIVATION_FUNCTION = 6 };
- bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
+ enum {
+ VT_TIME_MAJOR = 4,
+ VT_FUSED_ACTIVATION_FUNCTION = 6
+ };
+ bool time_major() const {
+ return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
+ }
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -2035,37 +1940,25 @@ struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
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);
- }
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(
- BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
- }
- explicit BidirectionalSequenceRNNOptionsBuilder(
- flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
+ }
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
+ }
+ BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- BidirectionalSequenceRNNOptionsBuilder &operator=(
- const BidirectionalSequenceRNNOptionsBuilder &);
+ BidirectionalSequenceRNNOptionsBuilder &operator=(const BidirectionalSequenceRNNOptionsBuilder &);
flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
@@ -2073,63 +1966,52 @@ struct BidirectionalSequenceRNNOptionsBuilder {
}
};
-inline flatbuffers::Offset<BidirectionalSequenceRNNOptions>
-CreateBidirectionalSequenceRNNOptions(
- flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ bool time_major = false,
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
builder_.add_time_major(time_major);
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 {
typedef FullyConnectedOptions TableType;
ActivationFunctionType fused_activation_function;
FullyConnectedOptionsT()
- : fused_activation_function(ActivationFunctionType_NONE) {}
+ : fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
-struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FullyConnectedOptionsT NativeTableType;
- enum { VT_FUSED_ACTIVATION_FUNCTION = 4 };
+ enum {
+ VT_FUSED_ACTIVATION_FUNCTION = 4
+ };
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
FullyConnectedOptionsBuilder &operator=(const FullyConnectedOptionsBuilder &);
@@ -2142,39 +2024,38 @@ struct FullyConnectedOptionsBuilder {
inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
flatbuffers::FlatBufferBuilder &_fbb,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
FullyConnectedOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
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 {
typedef SoftmaxOptions TableType;
float beta;
- SoftmaxOptionsT() : beta(0.0f) {}
+ SoftmaxOptionsT()
+ : beta(0.0f) {
+ }
};
struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SoftmaxOptionsT NativeTableType;
- enum { VT_BETA = 4 };
- float beta() const { return GetField<float>(VT_BETA, 0.0f); }
+ enum {
+ VT_BETA = 4
+ };
+ float beta() const {
+ return GetField<float>(VT_BETA, 0.0f);
+ }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
- VerifyField<float>(verifier, VT_BETA) && verifier.EndTable();
+ VerifyField<float>(verifier, VT_BETA) &&
+ 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 {
@@ -2183,8 +2064,8 @@ struct SoftmaxOptionsBuilder {
void add_beta(float beta) {
fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f);
}
- explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SoftmaxOptionsBuilder &operator=(const SoftmaxOptionsBuilder &);
@@ -2196,32 +2077,36 @@ struct SoftmaxOptionsBuilder {
};
inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
- flatbuffers::FlatBufferBuilder &_fbb, float beta = 0.0f) {
+ 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 {
typedef ConcatenationOptions TableType;
int32_t axis;
ActivationFunctionType fused_activation_function;
ConcatenationOptionsT()
- : axis(0), fused_activation_function(ActivationFunctionType_NONE) {}
+ : axis(0),
+ fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
-struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ConcatenationOptionsT NativeTableType;
- enum { VT_AXIS = 4, VT_FUSED_ACTIVATION_FUNCTION = 6 };
- int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
+ enum {
+ VT_AXIS = 4,
+ VT_FUSED_ACTIVATION_FUNCTION = 6
+ };
+ int32_t axis() const {
+ return GetField<int32_t>(VT_AXIS, 0);
+ }
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -2229,14 +2114,9 @@ struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
@@ -2245,13 +2125,11 @@ struct ConcatenationOptionsBuilder {
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0);
}
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(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)
- : fbb_(_fbb) {
+ ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ConcatenationOptionsBuilder &operator=(const ConcatenationOptionsBuilder &);
@@ -2263,57 +2141,51 @@ struct ConcatenationOptionsBuilder {
};
inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
- flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int32_t axis = 0,
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
ConcatenationOptionsBuilder builder_(_fbb);
builder_.add_axis(axis);
builder_.add_fused_activation_function(fused_activation_function);
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 {
typedef AddOptions TableType;
ActivationFunctionType fused_activation_function;
- AddOptionsT() : fused_activation_function(ActivationFunctionType_NONE) {}
+ AddOptionsT()
+ : fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef AddOptionsT NativeTableType;
- enum { VT_FUSED_ACTIVATION_FUNCTION = 4 };
+ enum {
+ VT_FUSED_ACTIVATION_FUNCTION = 4
+ };
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
AddOptionsBuilder &operator=(const AddOptionsBuilder &);
@@ -2326,55 +2198,48 @@ struct AddOptionsBuilder {
inline flatbuffers::Offset<AddOptions> CreateAddOptions(
flatbuffers::FlatBufferBuilder &_fbb,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
AddOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
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 {
typedef MulOptions TableType;
ActivationFunctionType fused_activation_function;
- MulOptionsT() : fused_activation_function(ActivationFunctionType_NONE) {}
+ MulOptionsT()
+ : fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MulOptionsT NativeTableType;
- enum { VT_FUSED_ACTIVATION_FUNCTION = 4 };
+ enum {
+ VT_FUSED_ACTIVATION_FUNCTION = 4
+ };
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(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)
- : fbb_(_fbb) {
+ MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MulOptionsBuilder &operator=(const MulOptionsBuilder &);
@@ -2387,55 +2252,48 @@ struct MulOptionsBuilder {
inline flatbuffers::Offset<MulOptions> CreateMulOptions(
flatbuffers::FlatBufferBuilder &_fbb,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ ActivationFunctionType fused_activation_function = 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 {
typedef L2NormOptions TableType;
ActivationFunctionType fused_activation_function;
- L2NormOptionsT() : fused_activation_function(ActivationFunctionType_NONE) {}
+ L2NormOptionsT()
+ : fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef L2NormOptionsT NativeTableType;
- enum { VT_FUSED_ACTIVATION_FUNCTION = 4 };
+ enum {
+ VT_FUSED_ACTIVATION_FUNCTION = 4
+ };
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(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)
- : fbb_(_fbb) {
+ L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
L2NormOptionsBuilder &operator=(const L2NormOptionsBuilder &);
@@ -2448,16 +2306,13 @@ struct L2NormOptionsBuilder {
inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
flatbuffers::FlatBufferBuilder &_fbb,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ ActivationFunctionType fused_activation_function = 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 {
typedef LocalResponseNormalizationOptions TableType;
@@ -2466,61 +2321,66 @@ struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable {
float alpha;
float beta;
LocalResponseNormalizationOptionsT()
- : radius(0), bias(0.0f), alpha(0.0f), beta(0.0f) {}
+ : radius(0),
+ bias(0.0f),
+ alpha(0.0f),
+ beta(0.0f) {
+ }
};
-struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LocalResponseNormalizationOptionsT NativeTableType;
- enum { VT_RADIUS = 4, VT_BIAS = 6, VT_ALPHA = 8, VT_BETA = 10 };
- int32_t radius() const { return GetField<int32_t>(VT_RADIUS, 0); }
- float bias() const { return GetField<float>(VT_BIAS, 0.0f); }
- float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
- float beta() const { return GetField<float>(VT_BETA, 0.0f); }
+ enum {
+ VT_RADIUS = 4,
+ VT_BIAS = 6,
+ VT_ALPHA = 8,
+ VT_BETA = 10
+ };
+ int32_t radius() const {
+ return GetField<int32_t>(VT_RADIUS, 0);
+ }
+ float bias() const {
+ return GetField<float>(VT_BIAS, 0.0f);
+ }
+ float alpha() const {
+ return GetField<float>(VT_ALPHA, 0.0f);
+ }
+ float beta() const {
+ return GetField<float>(VT_BETA, 0.0f);
+ }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_RADIUS) &&
VerifyField<float>(verifier, VT_BIAS) &&
VerifyField<float>(verifier, VT_ALPHA) &&
- VerifyField<float>(verifier, VT_BETA) && verifier.EndTable();
+ VerifyField<float>(verifier, VT_BETA) &&
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_radius(int32_t radius) {
- fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS,
- radius, 0);
+ fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
}
void add_bias(float bias) {
- fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias,
- 0.0f);
+ fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
}
void add_alpha(float alpha) {
- fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha,
- 0.0f);
+ fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
}
void add_beta(float beta) {
- fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta,
- 0.0f);
+ fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
}
- explicit LocalResponseNormalizationOptionsBuilder(
- flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- LocalResponseNormalizationOptionsBuilder &operator=(
- const LocalResponseNormalizationOptionsBuilder &);
+ LocalResponseNormalizationOptionsBuilder &operator=(const LocalResponseNormalizationOptionsBuilder &);
flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
@@ -2528,10 +2388,12 @@ struct LocalResponseNormalizationOptionsBuilder {
}
};
-inline flatbuffers::Offset<LocalResponseNormalizationOptions>
-CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb,
- int32_t radius = 0, float bias = 0.0f,
- float alpha = 0.0f, float beta = 0.0f) {
+inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int32_t radius = 0,
+ float bias = 0.0f,
+ float alpha = 0.0f,
+ float beta = 0.0f) {
LocalResponseNormalizationOptionsBuilder builder_(_fbb);
builder_.add_beta(beta);
builder_.add_alpha(alpha);
@@ -2540,11 +2402,7 @@ CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb,
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 {
typedef LSTMOptions TableType;
@@ -2554,41 +2412,43 @@ struct LSTMOptionsT : public flatbuffers::NativeTable {
LSTMOptionsT()
: fused_activation_function(ActivationFunctionType_NONE),
cell_clip(0.0f),
- proj_clip(0.0f) {}
+ proj_clip(0.0f) {
+ }
};
struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LSTMOptionsT NativeTableType;
- enum { VT_FUSED_ACTIVATION_FUNCTION = 4, VT_CELL_CLIP = 6, VT_PROJ_CLIP = 8 };
+ enum {
+ VT_FUSED_ACTIVATION_FUNCTION = 4,
+ VT_CELL_CLIP = 6,
+ VT_PROJ_CLIP = 8
+ };
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ }
+ float cell_clip() const {
+ return GetField<float>(VT_CELL_CLIP, 0.0f);
+ }
+ float proj_clip() const {
+ return GetField<float>(VT_PROJ_CLIP, 0.0f);
}
- float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
- float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
VerifyField<float>(verifier, VT_CELL_CLIP) &&
- VerifyField<float>(verifier, VT_PROJ_CLIP) && verifier.EndTable();
+ VerifyField<float>(verifier, VT_PROJ_CLIP) &&
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
void add_cell_clip(float cell_clip) {
fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
@@ -2596,8 +2456,8 @@ struct LSTMOptionsBuilder {
void add_proj_clip(float proj_clip) {
fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
}
- explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
LSTMOptionsBuilder &operator=(const LSTMOptionsBuilder &);
@@ -2610,9 +2470,9 @@ struct LSTMOptionsBuilder {
inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
flatbuffers::FlatBufferBuilder &_fbb,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE,
- float cell_clip = 0.0f, float proj_clip = 0.0f) {
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
+ float cell_clip = 0.0f,
+ float proj_clip = 0.0f) {
LSTMOptionsBuilder builder_(_fbb);
builder_.add_proj_clip(proj_clip);
builder_.add_cell_clip(cell_clip);
@@ -2620,9 +2480,7 @@ inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
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 ResizeBilinearOptionsT : public flatbuffers::NativeTable {
typedef ResizeBilinearOptions TableType;
@@ -2656,8 +2514,8 @@ struct ResizeBilinearOptionsBuilder {
void add_align_corners(bool align_corners) {
fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
}
- explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ResizeBilinearOptionsBuilder &operator=(const ResizeBilinearOptionsBuilder &);
@@ -2681,25 +2539,27 @@ flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffe
struct CallOptionsT : public flatbuffers::NativeTable {
typedef CallOptions TableType;
uint32_t subgraph;
- CallOptionsT() : subgraph(0) {}
+ CallOptionsT()
+ : subgraph(0) {
+ }
};
struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef CallOptionsT NativeTableType;
- enum { VT_SUBGRAPH = 4 };
- uint32_t subgraph() const { return GetField<uint32_t>(VT_SUBGRAPH, 0); }
+ enum {
+ VT_SUBGRAPH = 4
+ };
+ uint32_t subgraph() const {
+ return GetField<uint32_t>(VT_SUBGRAPH, 0);
+ }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
- VerifyField<uint32_t>(verifier, VT_SUBGRAPH) && verifier.EndTable();
+ VerifyField<uint32_t>(verifier, VT_SUBGRAPH) &&
+ 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 {
@@ -2708,8 +2568,8 @@ struct CallOptionsBuilder {
void add_subgraph(uint32_t subgraph) {
fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
}
- explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
CallOptionsBuilder &operator=(const CallOptionsBuilder &);
@@ -2721,41 +2581,37 @@ struct CallOptionsBuilder {
};
inline flatbuffers::Offset<CallOptions> CreateCallOptions(
- flatbuffers::FlatBufferBuilder &_fbb, uint32_t subgraph = 0) {
+ 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 {
typedef PadOptions TableType;
- PadOptionsT() {}
+ PadOptionsT() {
+ }
};
struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef PadOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && verifier.EndTable();
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
PadOptionsBuilder &operator=(const PadOptionsBuilder &);
@@ -2772,45 +2628,42 @@ inline flatbuffers::Offset<PadOptions> CreatePadOptions(
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 ReshapeOptionsT : public flatbuffers::NativeTable {
typedef ReshapeOptions TableType;
std::vector<int32_t> new_shape;
- ReshapeOptionsT() {}
+ ReshapeOptionsT() {
+ }
};
struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ReshapeOptionsT NativeTableType;
- enum { VT_NEW_SHAPE = 4 };
+ enum {
+ VT_NEW_SHAPE = 4
+ };
const flatbuffers::Vector<int32_t> *new_shape() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
}
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NEW_SHAPE) &&
- verifier.Verify(new_shape()) && verifier.EndTable();
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_NEW_SHAPE) &&
+ verifier.Verify(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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_new_shape(
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape) {
+ 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)
- : fbb_(_fbb) {
+ ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ReshapeOptionsBuilder &operator=(const ReshapeOptionsBuilder &);
@@ -2833,39 +2686,34 @@ inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *new_shape = nullptr) {
return tflite::CreateReshapeOptions(
- _fbb, new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0);
+ _fbb,
+ new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0);
}
-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 {
typedef SpaceToBatchNDOptions TableType;
- SpaceToBatchNDOptionsT() {}
+ SpaceToBatchNDOptionsT() {
+ }
};
-struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SpaceToBatchNDOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && verifier.EndTable();
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SpaceToBatchNDOptionsBuilder &operator=(const SpaceToBatchNDOptionsBuilder &);
@@ -2882,36 +2730,30 @@ inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
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 {
typedef BatchToSpaceNDOptions TableType;
- BatchToSpaceNDOptionsT() {}
+ BatchToSpaceNDOptionsT() {
+ }
};
-struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef BatchToSpaceNDOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && verifier.EndTable();
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
BatchToSpaceNDOptionsBuilder &operator=(const BatchToSpaceNDOptionsBuilder &);
@@ -2928,9 +2770,7 @@ inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
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 {
typedef SkipGramOptions TableType;
@@ -2938,13 +2778,22 @@ struct SkipGramOptionsT : public flatbuffers::NativeTable {
int32_t max_skip_size;
bool include_all_ngrams;
SkipGramOptionsT()
- : ngram_size(0), max_skip_size(0), include_all_ngrams(false) {}
+ : ngram_size(0),
+ max_skip_size(0),
+ include_all_ngrams(false) {
+ }
};
struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SkipGramOptionsT NativeTableType;
- enum { VT_NGRAM_SIZE = 4, VT_MAX_SKIP_SIZE = 6, VT_INCLUDE_ALL_NGRAMS = 8 };
- int32_t ngram_size() const { return GetField<int32_t>(VT_NGRAM_SIZE, 0); }
+ enum {
+ VT_NGRAM_SIZE = 4,
+ VT_MAX_SKIP_SIZE = 6,
+ VT_INCLUDE_ALL_NGRAMS = 8
+ };
+ int32_t ngram_size() const {
+ return GetField<int32_t>(VT_NGRAM_SIZE, 0);
+ }
int32_t max_skip_size() const {
return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0);
}
@@ -2958,14 +2807,9 @@ struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) &&
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 {
@@ -2975,15 +2819,13 @@ struct SkipGramOptionsBuilder {
fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
}
void add_max_skip_size(int32_t max_skip_size) {
- fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size,
- 0);
+ fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
}
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);
+ fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), 0);
}
- explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SkipGramOptionsBuilder &operator=(const SkipGramOptionsBuilder &);
@@ -2995,8 +2837,10 @@ struct SkipGramOptionsBuilder {
};
inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
- flatbuffers::FlatBufferBuilder &_fbb, int32_t ngram_size = 0,
- int32_t max_skip_size = 0, bool include_all_ngrams = false) {
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int32_t ngram_size = 0,
+ int32_t max_skip_size = 0,
+ bool include_all_ngrams = false) {
SkipGramOptionsBuilder builder_(_fbb);
builder_.add_max_skip_size(max_skip_size);
builder_.add_ngram_size(ngram_size);
@@ -3004,33 +2848,32 @@ inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
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 {
typedef SpaceToDepthOptions TableType;
int32_t block_size;
- SpaceToDepthOptionsT() : block_size(0) {}
+ SpaceToDepthOptionsT()
+ : block_size(0) {
+ }
};
-struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SpaceToDepthOptionsT NativeTableType;
- enum { VT_BLOCK_SIZE = 4 };
- int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
+ enum {
+ VT_BLOCK_SIZE = 4
+ };
+ int32_t block_size() const {
+ return GetField<int32_t>(VT_BLOCK_SIZE, 0);
+ }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
- VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) && verifier.EndTable();
+ VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
+ 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 {
@@ -3039,8 +2882,8 @@ struct SpaceToDepthOptionsBuilder {
void add_block_size(int32_t block_size) {
fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
}
- explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SpaceToDepthOptionsBuilder &operator=(const SpaceToDepthOptionsBuilder &);
@@ -3052,54 +2895,49 @@ struct SpaceToDepthOptionsBuilder {
};
inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
- flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0) {
+ 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 SubOptionsT : public flatbuffers::NativeTable {
typedef SubOptions TableType;
ActivationFunctionType fused_activation_function;
- SubOptionsT() : fused_activation_function(ActivationFunctionType_NONE) {}
+ SubOptionsT()
+ : fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SubOptionsT NativeTableType;
- enum { VT_FUSED_ACTIVATION_FUNCTION = 4 };
+ enum {
+ VT_FUSED_ACTIVATION_FUNCTION = 4
+ };
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(ActivationFunctionType fused_activation_function) {
+ fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
}
- explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SubOptionsBuilder &operator=(const SubOptionsBuilder &);
@@ -3112,55 +2950,48 @@ struct SubOptionsBuilder {
inline flatbuffers::Offset<SubOptions> CreateSubOptions(
flatbuffers::FlatBufferBuilder &_fbb,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) {
SubOptionsBuilder builder_(_fbb);
builder_.add_fused_activation_function(fused_activation_function);
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 {
typedef DivOptions TableType;
ActivationFunctionType fused_activation_function;
- DivOptionsT() : fused_activation_function(ActivationFunctionType_NONE) {}
+ DivOptionsT()
+ : fused_activation_function(ActivationFunctionType_NONE) {
+ }
};
struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef DivOptionsT NativeTableType;
- enum { VT_FUSED_ACTIVATION_FUNCTION = 4 };
+ enum {
+ VT_FUSED_ACTIVATION_FUNCTION = 4
+ };
ActivationFunctionType fused_activation_function() const {
- return static_cast<ActivationFunctionType>(
- GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+ return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_fused_activation_function(
- ActivationFunctionType fused_activation_function) {
- fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION,
- static_cast<int8_t>(fused_activation_function), 0);
+ void add_fused_activation_function(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)
- : fbb_(_fbb) {
+ DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
DivOptionsBuilder &operator=(const DivOptionsBuilder &);
@@ -3173,59 +3004,51 @@ struct DivOptionsBuilder {
inline flatbuffers::Offset<DivOptions> CreateDivOptions(
flatbuffers::FlatBufferBuilder &_fbb,
- ActivationFunctionType fused_activation_function =
- ActivationFunctionType_NONE) {
+ ActivationFunctionType fused_activation_function = 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 EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable {
typedef EmbeddingLookupSparseOptions TableType;
CombinerType combiner;
- EmbeddingLookupSparseOptionsT() : combiner(CombinerType_SUM) {}
+ EmbeddingLookupSparseOptionsT()
+ : combiner(CombinerType_SUM) {
+ }
};
-struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef EmbeddingLookupSparseOptionsT NativeTableType;
- enum { VT_COMBINER = 4 };
+ enum {
+ VT_COMBINER = 4
+ };
CombinerType combiner() const {
return static_cast<CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
- VerifyField<int8_t>(verifier, VT_COMBINER) && verifier.EndTable();
+ VerifyField<int8_t>(verifier, VT_COMBINER) &&
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_combiner(CombinerType combiner) {
- fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER,
- static_cast<int8_t>(combiner), 0);
+ fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), 0);
}
- explicit EmbeddingLookupSparseOptionsBuilder(
- flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
- EmbeddingLookupSparseOptionsBuilder &operator=(
- const EmbeddingLookupSparseOptionsBuilder &);
+ EmbeddingLookupSparseOptionsBuilder &operator=(const EmbeddingLookupSparseOptionsBuilder &);
flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
@@ -3233,42 +3056,40 @@ struct EmbeddingLookupSparseOptionsBuilder {
}
};
-inline flatbuffers::Offset<EmbeddingLookupSparseOptions>
-CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb,
- CombinerType combiner = CombinerType_SUM) {
+inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ CombinerType combiner = 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 {
typedef GatherOptions TableType;
int32_t axis;
- GatherOptionsT() : axis(0) {}
+ GatherOptionsT()
+ : axis(0) {
+ }
};
struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef GatherOptionsT NativeTableType;
- enum { VT_AXIS = 4 };
- int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
+ enum {
+ VT_AXIS = 4
+ };
+ int32_t axis() const {
+ return GetField<int32_t>(VT_AXIS, 0);
+ }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
- VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
+ VerifyField<int32_t>(verifier, VT_AXIS) &&
+ 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 {
@@ -3277,8 +3098,8 @@ struct GatherOptionsBuilder {
void add_axis(int32_t axis) {
fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0);
}
- explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
GatherOptionsBuilder &operator=(const GatherOptionsBuilder &);
@@ -3290,41 +3111,37 @@ struct GatherOptionsBuilder {
};
inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(
- flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0) {
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int32_t axis = 0) {
GatherOptionsBuilder builder_(_fbb);
builder_.add_axis(axis);
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 {
typedef TransposeOptions TableType;
- TransposeOptionsT() {}
+ TransposeOptionsT() {
+ }
};
struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef TransposeOptionsT NativeTableType;
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && verifier.EndTable();
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
TransposeOptionsBuilder &operator=(const TransposeOptionsBuilder &);
@@ -3341,43 +3158,42 @@ inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
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 MeanOptionsT : public flatbuffers::NativeTable {
typedef MeanOptions TableType;
bool keep_dims;
- MeanOptionsT() : keep_dims(false) {}
+ MeanOptionsT()
+ : keep_dims(false) {
+ }
};
struct MeanOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MeanOptionsT NativeTableType;
- enum { VT_KEEP_DIMS = 4 };
- bool keep_dims() const { return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0; }
+ enum {
+ VT_KEEP_DIMS = 4
+ };
+ bool keep_dims() const {
+ return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0;
+ }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
- VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) && verifier.EndTable();
+ VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) &&
+ verifier.EndTable();
}
- MeanOptionsT *UnPack(
- const flatbuffers::resolver_function_t *_resolver = nullptr) const;
- void UnPackTo(
- MeanOptionsT *_o,
- const flatbuffers::resolver_function_t *_resolver = nullptr) const;
- static flatbuffers::Offset<MeanOptions> Pack(
- flatbuffers::FlatBufferBuilder &_fbb, const MeanOptionsT *_o,
- const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+ MeanOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(MeanOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<MeanOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MeanOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MeanOptionsBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_keep_dims(bool keep_dims) {
- fbb_.AddElement<uint8_t>(MeanOptions::VT_KEEP_DIMS,
- static_cast<uint8_t>(keep_dims), 0);
+ fbb_.AddElement<uint8_t>(MeanOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
}
- explicit MeanOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ MeanOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MeanOptionsBuilder &operator=(const MeanOptionsBuilder &);
@@ -3389,52 +3205,49 @@ struct MeanOptionsBuilder {
};
inline flatbuffers::Offset<MeanOptions> CreateMeanOptions(
- flatbuffers::FlatBufferBuilder &_fbb, bool keep_dims = false) {
+ flatbuffers::FlatBufferBuilder &_fbb,
+ bool keep_dims = false) {
MeanOptionsBuilder builder_(_fbb);
builder_.add_keep_dims(keep_dims);
return builder_.Finish();
}
-flatbuffers::Offset<MeanOptions> CreateMeanOptions(
- flatbuffers::FlatBufferBuilder &_fbb, const MeanOptionsT *_o,
- const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+flatbuffers::Offset<MeanOptions> CreateMeanOptions(flatbuffers::FlatBufferBuilder &_fbb, const MeanOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct SqueezeOptionsT : public flatbuffers::NativeTable {
typedef SqueezeOptions TableType;
std::vector<int32_t> squeeze_dims;
- SqueezeOptionsT() {}
+ SqueezeOptionsT() {
+ }
};
struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SqueezeOptionsT NativeTableType;
- enum { VT_SQUEEZE_DIMS = 4 };
+ enum {
+ VT_SQUEEZE_DIMS = 4
+ };
const flatbuffers::Vector<int32_t> *squeeze_dims() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
- verifier.Verify(squeeze_dims()) && verifier.EndTable();
+ verifier.Verify(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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_squeeze_dims(
- flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims) {
+ 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)
- : fbb_(_fbb) {
+ SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SqueezeOptionsBuilder &operator=(const SqueezeOptionsBuilder &);
@@ -3457,12 +3270,11 @@ inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int32_t> *squeeze_dims = nullptr) {
return tflite::CreateSqueezeOptions(
- _fbb, squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0);
+ _fbb,
+ squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0);
}
-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 StridedSliceOptionsT : public flatbuffers::NativeTable {
typedef StridedSliceOptions TableType;
@@ -3476,11 +3288,11 @@ struct StridedSliceOptionsT : public flatbuffers::NativeTable {
end_mask(0),
ellipsis_mask(0),
new_axis_mask(0),
- shrink_axis_mask(0) {}
+ shrink_axis_mask(0) {
+ }
};
-struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS
- : private flatbuffers::Table {
+struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef StridedSliceOptionsT NativeTableType;
enum {
VT_BEGIN_MASK = 4,
@@ -3489,8 +3301,12 @@ struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS
VT_NEW_AXIS_MASK = 10,
VT_SHRINK_AXIS_MASK = 12
};
- int32_t begin_mask() const { return GetField<int32_t>(VT_BEGIN_MASK, 0); }
- int32_t end_mask() const { return GetField<int32_t>(VT_END_MASK, 0); }
+ int32_t begin_mask() const {
+ return GetField<int32_t>(VT_BEGIN_MASK, 0);
+ }
+ int32_t end_mask() const {
+ return GetField<int32_t>(VT_END_MASK, 0);
+ }
int32_t ellipsis_mask() const {
return GetField<int32_t>(VT_ELLIPSIS_MASK, 0);
}
@@ -3509,14 +3325,9 @@ struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS
VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) &&
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 {
@@ -3529,19 +3340,16 @@ struct StridedSliceOptionsBuilder {
fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
}
void add_ellipsis_mask(int32_t ellipsis_mask) {
- fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK,
- ellipsis_mask, 0);
+ fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
}
void add_new_axis_mask(int32_t new_axis_mask) {
- fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK,
- new_axis_mask, 0);
+ fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
}
void add_shrink_axis_mask(int32_t shrink_axis_mask) {
- fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK,
- shrink_axis_mask, 0);
+ fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
}
- explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
StridedSliceOptionsBuilder &operator=(const StridedSliceOptionsBuilder &);
@@ -3553,8 +3361,11 @@ struct StridedSliceOptionsBuilder {
};
inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
- flatbuffers::FlatBufferBuilder &_fbb, int32_t begin_mask = 0,
- int32_t end_mask = 0, int32_t ellipsis_mask = 0, int32_t new_axis_mask = 0,
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int32_t begin_mask = 0,
+ int32_t end_mask = 0,
+ int32_t ellipsis_mask = 0,
+ int32_t new_axis_mask = 0,
int32_t shrink_axis_mask = 0) {
StridedSliceOptionsBuilder builder_(_fbb);
builder_.add_shrink_axis_mask(shrink_axis_mask);
@@ -3565,20 +3376,63 @@ inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
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 TFMaximumOptionsT : public flatbuffers::NativeTable {
+ typedef TFMaximumOptions TableType;
+ TFMaximumOptionsT() {
+ }
+};
+
+struct TFMaximumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef TFMaximumOptionsT NativeTableType;
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ verifier.EndTable();
+ }
+ TFMaximumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(TFMaximumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<TFMaximumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TFMaximumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct TFMaximumOptionsBuilder {
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ TFMaximumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ TFMaximumOptionsBuilder &operator=(const TFMaximumOptionsBuilder &);
+ flatbuffers::Offset<TFMaximumOptions> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<TFMaximumOptions>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<TFMaximumOptions> CreateTFMaximumOptions(
+ flatbuffers::FlatBufferBuilder &_fbb) {
+ TFMaximumOptionsBuilder builder_(_fbb);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<TFMaximumOptions> CreateTFMaximumOptions(flatbuffers::FlatBufferBuilder &_fbb, const TFMaximumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct OperatorCodeT : public flatbuffers::NativeTable {
typedef OperatorCode TableType;
BuiltinOperator builtin_code;
std::string custom_code;
- OperatorCodeT() : builtin_code(BuiltinOperator_ADD) {}
+ OperatorCodeT()
+ : builtin_code(BuiltinOperator_ADD) {
+ }
};
struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef OperatorCodeT NativeTableType;
- enum { VT_BUILTIN_CODE = 4, VT_CUSTOM_CODE = 6 };
+ enum {
+ VT_BUILTIN_CODE = 4,
+ VT_CUSTOM_CODE = 6
+ };
BuiltinOperator builtin_code() const {
return static_cast<BuiltinOperator>(GetField<int8_t>(VT_BUILTIN_CODE, 0));
}
@@ -3589,30 +3443,25 @@ struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_BUILTIN_CODE) &&
VerifyOffset(verifier, VT_CUSTOM_CODE) &&
- verifier.Verify(custom_code()) && verifier.EndTable();
+ verifier.Verify(custom_code()) &&
+ 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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_builtin_code(BuiltinOperator builtin_code) {
- fbb_.AddElement<int8_t>(OperatorCode::VT_BUILTIN_CODE,
- static_cast<int8_t>(builtin_code), 0);
+ fbb_.AddElement<int8_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int8_t>(builtin_code), 0);
}
void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code) {
fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
}
- explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
- : fbb_(_fbb) {
+ OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
OperatorCodeBuilder &operator=(const OperatorCodeBuilder &);
@@ -3638,12 +3487,12 @@ inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
BuiltinOperator builtin_code = BuiltinOperator_ADD,
const char *custom_code = nullptr) {
return tflite::CreateOperatorCode(
- _fbb, builtin_code, custom_code ? _fbb.CreateString(custom_code) : 0);
+ _fbb,
+ builtin_code,
+ custom_code ? _fbb.CreateString(custom_code) : 0);
}
-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 {
typedef Operator TableType;
@@ -3655,7 +3504,8 @@ struct OperatorT : public flatbuffers::NativeTable {
CustomOptionsFormat custom_options_format;
OperatorT()
: opcode_index(0),
- custom_options_format(CustomOptionsFormat_FLEXBUFFERS) {}
+ custom_options_format(CustomOptionsFormat_FLEXBUFFERS) {
+ }
};
struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -3679,398 +3529,269 @@ struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
}
BuiltinOptions builtin_options_type() const {
- return static_cast<BuiltinOptions>(
- GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
+ return static_cast<BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
}
const void *builtin_options() const {
return GetPointer<const void *>(VT_BUILTIN_OPTIONS);
}
- template <typename T>
- const T *builtin_options_as() const;
+ template<typename T> const T *builtin_options_as() const;
const Conv2DOptions *builtin_options_as_Conv2DOptions() const {
- return builtin_options_type() == BuiltinOptions_Conv2DOptions
- ? static_cast<const Conv2DOptions *>(builtin_options())
- : nullptr;
- }
- const DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions()
- const {
- return builtin_options_type() == BuiltinOptions_DepthwiseConv2DOptions
- ? static_cast<const DepthwiseConv2DOptions *>(builtin_options())
- : nullptr;
- }
- const ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions()
- const {
- return builtin_options_type() == BuiltinOptions_ConcatEmbeddingsOptions
- ? static_cast<const ConcatEmbeddingsOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_Conv2DOptions ? static_cast<const Conv2DOptions *>(builtin_options()) : nullptr;
+ }
+ const DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const {
+ return builtin_options_type() == BuiltinOptions_DepthwiseConv2DOptions ? static_cast<const DepthwiseConv2DOptions *>(builtin_options()) : nullptr;
+ }
+ const ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const {
+ return builtin_options_type() == BuiltinOptions_ConcatEmbeddingsOptions ? static_cast<const ConcatEmbeddingsOptions *>(builtin_options()) : nullptr;
}
const LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const {
- return builtin_options_type() == BuiltinOptions_LSHProjectionOptions
- ? static_cast<const LSHProjectionOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_LSHProjectionOptions ? static_cast<const LSHProjectionOptions *>(builtin_options()) : nullptr;
}
const Pool2DOptions *builtin_options_as_Pool2DOptions() const {
- return builtin_options_type() == BuiltinOptions_Pool2DOptions
- ? static_cast<const Pool2DOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_Pool2DOptions ? static_cast<const Pool2DOptions *>(builtin_options()) : nullptr;
}
const SVDFOptions *builtin_options_as_SVDFOptions() const {
- return builtin_options_type() == BuiltinOptions_SVDFOptions
- ? static_cast<const SVDFOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_SVDFOptions ? static_cast<const SVDFOptions *>(builtin_options()) : nullptr;
}
const RNNOptions *builtin_options_as_RNNOptions() const {
- return builtin_options_type() == BuiltinOptions_RNNOptions
- ? static_cast<const RNNOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_RNNOptions ? static_cast<const RNNOptions *>(builtin_options()) : nullptr;
}
- const FullyConnectedOptions *builtin_options_as_FullyConnectedOptions()
- const {
- return builtin_options_type() == BuiltinOptions_FullyConnectedOptions
- ? static_cast<const FullyConnectedOptions *>(builtin_options())
- : nullptr;
+ const FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const {
+ return builtin_options_type() == BuiltinOptions_FullyConnectedOptions ? static_cast<const FullyConnectedOptions *>(builtin_options()) : nullptr;
}
const SoftmaxOptions *builtin_options_as_SoftmaxOptions() const {
- return builtin_options_type() == BuiltinOptions_SoftmaxOptions
- ? static_cast<const SoftmaxOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_SoftmaxOptions ? static_cast<const SoftmaxOptions *>(builtin_options()) : nullptr;
}
const ConcatenationOptions *builtin_options_as_ConcatenationOptions() const {
- return builtin_options_type() == BuiltinOptions_ConcatenationOptions
- ? static_cast<const ConcatenationOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_ConcatenationOptions ? static_cast<const ConcatenationOptions *>(builtin_options()) : nullptr;
}
const AddOptions *builtin_options_as_AddOptions() const {
- return builtin_options_type() == BuiltinOptions_AddOptions
- ? static_cast<const AddOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_AddOptions ? static_cast<const AddOptions *>(builtin_options()) : nullptr;
}
const L2NormOptions *builtin_options_as_L2NormOptions() const {
- return builtin_options_type() == BuiltinOptions_L2NormOptions
- ? static_cast<const L2NormOptions *>(builtin_options())
- : nullptr;
- }
- const LocalResponseNormalizationOptions *
- builtin_options_as_LocalResponseNormalizationOptions() const {
- return builtin_options_type() ==
- BuiltinOptions_LocalResponseNormalizationOptions
- ? static_cast<const LocalResponseNormalizationOptions *>(
- builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_L2NormOptions ? static_cast<const L2NormOptions *>(builtin_options()) : nullptr;
+ }
+ const LocalResponseNormalizationOptions *builtin_options_as_LocalResponseNormalizationOptions() const {
+ return builtin_options_type() == BuiltinOptions_LocalResponseNormalizationOptions ? static_cast<const LocalResponseNormalizationOptions *>(builtin_options()) : nullptr;
}
const LSTMOptions *builtin_options_as_LSTMOptions() const {
- return builtin_options_type() == BuiltinOptions_LSTMOptions
- ? static_cast<const LSTMOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_LSTMOptions ? static_cast<const LSTMOptions *>(builtin_options()) : nullptr;
}
- const ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions()
- const {
- return builtin_options_type() == BuiltinOptions_ResizeBilinearOptions
- ? static_cast<const ResizeBilinearOptions *>(builtin_options())
- : nullptr;
+ const ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const {
+ return builtin_options_type() == BuiltinOptions_ResizeBilinearOptions ? static_cast<const ResizeBilinearOptions *>(builtin_options()) : nullptr;
}
const CallOptions *builtin_options_as_CallOptions() const {
- return builtin_options_type() == BuiltinOptions_CallOptions
- ? static_cast<const CallOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_CallOptions ? static_cast<const CallOptions *>(builtin_options()) : nullptr;
}
const ReshapeOptions *builtin_options_as_ReshapeOptions() const {
- return builtin_options_type() == BuiltinOptions_ReshapeOptions
- ? static_cast<const ReshapeOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_ReshapeOptions ? static_cast<const ReshapeOptions *>(builtin_options()) : nullptr;
}
const SkipGramOptions *builtin_options_as_SkipGramOptions() const {
- return builtin_options_type() == BuiltinOptions_SkipGramOptions
- ? static_cast<const SkipGramOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_SkipGramOptions ? static_cast<const SkipGramOptions *>(builtin_options()) : nullptr;
}
const SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const {
- return builtin_options_type() == BuiltinOptions_SpaceToDepthOptions
- ? static_cast<const SpaceToDepthOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_SpaceToDepthOptions ? static_cast<const SpaceToDepthOptions *>(builtin_options()) : nullptr;
}
- const EmbeddingLookupSparseOptions *
- builtin_options_as_EmbeddingLookupSparseOptions() const {
- return builtin_options_type() == BuiltinOptions_EmbeddingLookupSparseOptions
- ? static_cast<const EmbeddingLookupSparseOptions *>(
- builtin_options())
- : nullptr;
+ const EmbeddingLookupSparseOptions *builtin_options_as_EmbeddingLookupSparseOptions() const {
+ return builtin_options_type() == BuiltinOptions_EmbeddingLookupSparseOptions ? static_cast<const EmbeddingLookupSparseOptions *>(builtin_options()) : nullptr;
}
const MulOptions *builtin_options_as_MulOptions() const {
- return builtin_options_type() == BuiltinOptions_MulOptions
- ? static_cast<const MulOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_MulOptions ? static_cast<const MulOptions *>(builtin_options()) : nullptr;
}
const PadOptions *builtin_options_as_PadOptions() const {
- return builtin_options_type() == BuiltinOptions_PadOptions
- ? static_cast<const PadOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_PadOptions ? static_cast<const PadOptions *>(builtin_options()) : nullptr;
}
const GatherOptions *builtin_options_as_GatherOptions() const {
- return builtin_options_type() == BuiltinOptions_GatherOptions
- ? static_cast<const GatherOptions *>(builtin_options())
- : nullptr;
- }
- const BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions()
- const {
- return builtin_options_type() == BuiltinOptions_BatchToSpaceNDOptions
- ? static_cast<const BatchToSpaceNDOptions *>(builtin_options())
- : nullptr;
- }
- const SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions()
- const {
- return builtin_options_type() == BuiltinOptions_SpaceToBatchNDOptions
- ? static_cast<const SpaceToBatchNDOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_GatherOptions ? static_cast<const GatherOptions *>(builtin_options()) : nullptr;
+ }
+ const BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const {
+ return builtin_options_type() == BuiltinOptions_BatchToSpaceNDOptions ? static_cast<const BatchToSpaceNDOptions *>(builtin_options()) : nullptr;
+ }
+ const SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const {
+ return builtin_options_type() == BuiltinOptions_SpaceToBatchNDOptions ? static_cast<const SpaceToBatchNDOptions *>(builtin_options()) : nullptr;
}
const TransposeOptions *builtin_options_as_TransposeOptions() const {
- return builtin_options_type() == BuiltinOptions_TransposeOptions
- ? static_cast<const TransposeOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_TransposeOptions ? static_cast<const TransposeOptions *>(builtin_options()) : nullptr;
}
const MeanOptions *builtin_options_as_MeanOptions() const {
- return builtin_options_type() == BuiltinOptions_MeanOptions
- ? static_cast<const MeanOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_MeanOptions ? static_cast<const MeanOptions *>(builtin_options()) : nullptr;
}
const SubOptions *builtin_options_as_SubOptions() const {
- return builtin_options_type() == BuiltinOptions_SubOptions
- ? static_cast<const SubOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_SubOptions ? static_cast<const SubOptions *>(builtin_options()) : nullptr;
}
const DivOptions *builtin_options_as_DivOptions() const {
- return builtin_options_type() == BuiltinOptions_DivOptions
- ? static_cast<const DivOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_DivOptions ? static_cast<const DivOptions *>(builtin_options()) : nullptr;
}
const SqueezeOptions *builtin_options_as_SqueezeOptions() const {
- return builtin_options_type() == BuiltinOptions_SqueezeOptions
- ? static_cast<const SqueezeOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_SqueezeOptions ? static_cast<const SqueezeOptions *>(builtin_options()) : nullptr;
}
const SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const {
- return builtin_options_type() == BuiltinOptions_SequenceRNNOptions
- ? static_cast<const SequenceRNNOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_SequenceRNNOptions ? static_cast<const SequenceRNNOptions *>(builtin_options()) : nullptr;
}
const StridedSliceOptions *builtin_options_as_StridedSliceOptions() const {
- return builtin_options_type() == BuiltinOptions_StridedSliceOptions
- ? static_cast<const StridedSliceOptions *>(builtin_options())
- : nullptr;
+ return builtin_options_type() == BuiltinOptions_StridedSliceOptions ? static_cast<const StridedSliceOptions *>(builtin_options()) : nullptr;
+ }
+ const TFMaximumOptions *builtin_options_as_TFMaximumOptions() const {
+ return builtin_options_type() == BuiltinOptions_TFMaximumOptions ? static_cast<const TFMaximumOptions *>(builtin_options()) : nullptr;
}
const flatbuffers::Vector<uint8_t> *custom_options() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
}
CustomOptionsFormat custom_options_format() const {
- return static_cast<CustomOptionsFormat>(
- GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
+ return static_cast<CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) &&
- VerifyOffset(verifier, VT_INPUTS) && verifier.Verify(inputs()) &&
- VerifyOffset(verifier, VT_OUTPUTS) && verifier.Verify(outputs()) &&
+ VerifyOffset(verifier, VT_INPUTS) &&
+ verifier.Verify(inputs()) &&
+ VerifyOffset(verifier, VT_OUTPUTS) &&
+ verifier.Verify(outputs()) &&
VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) &&
VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
- VerifyBuiltinOptions(verifier, builtin_options(),
- builtin_options_type()) &&
+ VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
VerifyOffset(verifier, VT_CUSTOM_OPTIONS) &&
verifier.Verify(custom_options()) &&
VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) &&
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 Conv2DOptions *Operator::builtin_options_as<Conv2DOptions>()
- const {
+template<> inline const Conv2DOptions *Operator::builtin_options_as<Conv2DOptions>() const {
return builtin_options_as_Conv2DOptions();
}
-template <>
-inline const DepthwiseConv2DOptions *
-Operator::builtin_options_as<DepthwiseConv2DOptions>() const {
+template<> inline const DepthwiseConv2DOptions *Operator::builtin_options_as<DepthwiseConv2DOptions>() const {
return builtin_options_as_DepthwiseConv2DOptions();
}
-template <>
-inline const ConcatEmbeddingsOptions *
-Operator::builtin_options_as<ConcatEmbeddingsOptions>() const {
+template<> inline const ConcatEmbeddingsOptions *Operator::builtin_options_as<ConcatEmbeddingsOptions>() const {
return builtin_options_as_ConcatEmbeddingsOptions();
}
-template <>
-inline const LSHProjectionOptions *
-Operator::builtin_options_as<LSHProjectionOptions>() const {
+template<> inline const LSHProjectionOptions *Operator::builtin_options_as<LSHProjectionOptions>() const {
return builtin_options_as_LSHProjectionOptions();
}
-template <>
-inline const Pool2DOptions *Operator::builtin_options_as<Pool2DOptions>()
- const {
+template<> inline const Pool2DOptions *Operator::builtin_options_as<Pool2DOptions>() const {
return builtin_options_as_Pool2DOptions();
}
-template <>
-inline const SVDFOptions *Operator::builtin_options_as<SVDFOptions>() const {
+template<> inline const SVDFOptions *Operator::builtin_options_as<SVDFOptions>() const {
return builtin_options_as_SVDFOptions();
}
-template <>
-inline const RNNOptions *Operator::builtin_options_as<RNNOptions>() const {
+template<> inline const RNNOptions *Operator::builtin_options_as<RNNOptions>() const {
return builtin_options_as_RNNOptions();
}
-template <>
-inline const FullyConnectedOptions *
-Operator::builtin_options_as<FullyConnectedOptions>() const {
+template<> inline const FullyConnectedOptions *Operator::builtin_options_as<FullyConnectedOptions>() const {
return builtin_options_as_FullyConnectedOptions();
}
-template <>
-inline const SoftmaxOptions *Operator::builtin_options_as<SoftmaxOptions>()
- const {
+template<> inline const SoftmaxOptions *Operator::builtin_options_as<SoftmaxOptions>() const {
return builtin_options_as_SoftmaxOptions();
}
-template <>
-inline const ConcatenationOptions *
-Operator::builtin_options_as<ConcatenationOptions>() const {
+template<> inline const ConcatenationOptions *Operator::builtin_options_as<ConcatenationOptions>() const {
return builtin_options_as_ConcatenationOptions();
}
-template <>
-inline const AddOptions *Operator::builtin_options_as<AddOptions>() const {
+template<> inline const AddOptions *Operator::builtin_options_as<AddOptions>() const {
return builtin_options_as_AddOptions();
}
-template <>
-inline const L2NormOptions *Operator::builtin_options_as<L2NormOptions>()
- const {
+template<> inline const L2NormOptions *Operator::builtin_options_as<L2NormOptions>() const {
return builtin_options_as_L2NormOptions();
}
-template <>
-inline const LocalResponseNormalizationOptions *
-Operator::builtin_options_as<LocalResponseNormalizationOptions>() const {
+template<> inline const LocalResponseNormalizationOptions *Operator::builtin_options_as<LocalResponseNormalizationOptions>() const {
return builtin_options_as_LocalResponseNormalizationOptions();
}
-template <>
-inline const LSTMOptions *Operator::builtin_options_as<LSTMOptions>() const {
+template<> inline const LSTMOptions *Operator::builtin_options_as<LSTMOptions>() const {
return builtin_options_as_LSTMOptions();
}
-template <>
-inline const ResizeBilinearOptions *
-Operator::builtin_options_as<ResizeBilinearOptions>() const {
+template<> inline const ResizeBilinearOptions *Operator::builtin_options_as<ResizeBilinearOptions>() const {
return builtin_options_as_ResizeBilinearOptions();
}
-template <>
-inline const CallOptions *Operator::builtin_options_as<CallOptions>() const {
+template<> inline const CallOptions *Operator::builtin_options_as<CallOptions>() const {
return builtin_options_as_CallOptions();
}
-template <>
-inline const ReshapeOptions *Operator::builtin_options_as<ReshapeOptions>()
- const {
+template<> inline const ReshapeOptions *Operator::builtin_options_as<ReshapeOptions>() const {
return builtin_options_as_ReshapeOptions();
}
-template <>
-inline const SkipGramOptions *Operator::builtin_options_as<SkipGramOptions>()
- const {
+template<> inline const SkipGramOptions *Operator::builtin_options_as<SkipGramOptions>() const {
return builtin_options_as_SkipGramOptions();
}
-template <>
-inline const SpaceToDepthOptions *
-Operator::builtin_options_as<SpaceToDepthOptions>() const {
+template<> inline const SpaceToDepthOptions *Operator::builtin_options_as<SpaceToDepthOptions>() const {
return builtin_options_as_SpaceToDepthOptions();
}
-template <>
-inline const EmbeddingLookupSparseOptions *
-Operator::builtin_options_as<EmbeddingLookupSparseOptions>() const {
+template<> inline const EmbeddingLookupSparseOptions *Operator::builtin_options_as<EmbeddingLookupSparseOptions>() const {
return builtin_options_as_EmbeddingLookupSparseOptions();
}
-template <>
-inline const MulOptions *Operator::builtin_options_as<MulOptions>() const {
+template<> inline const MulOptions *Operator::builtin_options_as<MulOptions>() const {
return builtin_options_as_MulOptions();
}
-template <>
-inline const PadOptions *Operator::builtin_options_as<PadOptions>() const {
+template<> inline const PadOptions *Operator::builtin_options_as<PadOptions>() const {
return builtin_options_as_PadOptions();
}
-template <>
-inline const GatherOptions *Operator::builtin_options_as<GatherOptions>()
- const {
+template<> inline const GatherOptions *Operator::builtin_options_as<GatherOptions>() const {
return builtin_options_as_GatherOptions();
}
-template <>
-inline const BatchToSpaceNDOptions *
-Operator::builtin_options_as<BatchToSpaceNDOptions>() const {
+template<> inline const BatchToSpaceNDOptions *Operator::builtin_options_as<BatchToSpaceNDOptions>() const {
return builtin_options_as_BatchToSpaceNDOptions();
}
-template <>
-inline const SpaceToBatchNDOptions *
-Operator::builtin_options_as<SpaceToBatchNDOptions>() const {
+template<> inline const SpaceToBatchNDOptions *Operator::builtin_options_as<SpaceToBatchNDOptions>() const {
return builtin_options_as_SpaceToBatchNDOptions();
}
-template <>
-inline const TransposeOptions *Operator::builtin_options_as<TransposeOptions>()
- const {
+template<> inline const TransposeOptions *Operator::builtin_options_as<TransposeOptions>() const {
return builtin_options_as_TransposeOptions();
}
-template <>
-inline const MeanOptions *Operator::builtin_options_as<MeanOptions>() const {
+template<> inline const MeanOptions *Operator::builtin_options_as<MeanOptions>() const {
return builtin_options_as_MeanOptions();
}
-template <>
-inline const SubOptions *Operator::builtin_options_as<SubOptions>() const {
+template<> inline const SubOptions *Operator::builtin_options_as<SubOptions>() const {
return builtin_options_as_SubOptions();
}
-template <>
-inline const DivOptions *Operator::builtin_options_as<DivOptions>() const {
+template<> inline const DivOptions *Operator::builtin_options_as<DivOptions>() const {
return builtin_options_as_DivOptions();
}
-template <>
-inline const SqueezeOptions *Operator::builtin_options_as<SqueezeOptions>()
- const {
+template<> inline const SqueezeOptions *Operator::builtin_options_as<SqueezeOptions>() const {
return builtin_options_as_SqueezeOptions();
}
-template <>
-inline const SequenceRNNOptions *
-Operator::builtin_options_as<SequenceRNNOptions>() const {
+template<> inline const SequenceRNNOptions *Operator::builtin_options_as<SequenceRNNOptions>() const {
return builtin_options_as_SequenceRNNOptions();
}
-template <>
-inline const StridedSliceOptions *
-Operator::builtin_options_as<StridedSliceOptions>() const {
+template<> inline const StridedSliceOptions *Operator::builtin_options_as<StridedSliceOptions>() const {
return builtin_options_as_StridedSliceOptions();
}
+template<> inline const TFMaximumOptions *Operator::builtin_options_as<TFMaximumOptions>() const {
+ return builtin_options_as_TFMaximumOptions();
+}
+
struct OperatorBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
@@ -4084,21 +3805,19 @@ struct OperatorBuilder {
fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
}
void add_builtin_options_type(BuiltinOptions builtin_options_type) {
- fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE,
- static_cast<uint8_t>(builtin_options_type), 0);
+ 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) {
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(CustomOptionsFormat custom_options_format) {
- fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT,
- static_cast<int8_t>(custom_options_format), 0);
+ fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), 0);
}
- explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+ OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
OperatorBuilder &operator=(const OperatorBuilder &);
@@ -4110,14 +3829,14 @@ struct OperatorBuilder {
};
inline flatbuffers::Offset<Operator> CreateOperator(
- flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint32_t opcode_index = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
BuiltinOptions builtin_options_type = BuiltinOptions_NONE,
flatbuffers::Offset<void> builtin_options = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
- CustomOptionsFormat custom_options_format =
- CustomOptionsFormat_FLEXBUFFERS) {
+ CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS) {
OperatorBuilder builder_(_fbb);
builder_.add_custom_options(custom_options);
builder_.add_builtin_options(builtin_options);
@@ -4130,25 +3849,26 @@ inline flatbuffers::Offset<Operator> CreateOperator(
}
inline flatbuffers::Offset<Operator> CreateOperatorDirect(
- flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint32_t opcode_index = 0,
const std::vector<int32_t> *inputs = nullptr,
const std::vector<int32_t> *outputs = nullptr,
BuiltinOptions builtin_options_type = BuiltinOptions_NONE,
flatbuffers::Offset<void> builtin_options = 0,
const std::vector<uint8_t> *custom_options = nullptr,
- CustomOptionsFormat custom_options_format =
- CustomOptionsFormat_FLEXBUFFERS) {
+ CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS) {
return tflite::CreateOperator(
- _fbb, opcode_index, inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0,
- outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0, builtin_options_type,
+ _fbb,
+ opcode_index,
+ inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0,
+ outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0,
+ builtin_options_type,
builtin_options,
custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0,
custom_options_format);
}
-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 {
typedef SubGraph TableType;
@@ -4157,7 +3877,8 @@ struct SubGraphT : public flatbuffers::NativeTable {
std::vector<int32_t> outputs;
std::vector<std::unique_ptr<OperatorT>> operators;
std::string name;
- SubGraphT() {}
+ SubGraphT() {
+ }
};
struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -4170,8 +3891,7 @@ struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_NAME = 12
};
const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *tensors() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *>(
- VT_TENSORS);
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *>(VT_TENSORS);
}
const flatbuffers::Vector<int32_t> *inputs() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
@@ -4180,41 +3900,36 @@ struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
}
const flatbuffers::Vector<flatbuffers::Offset<Operator>> *operators() const {
- return GetPointer<
- const flatbuffers::Vector<flatbuffers::Offset<Operator>> *>(
- VT_OPERATORS);
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Operator>> *>(VT_OPERATORS);
}
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
}
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TENSORS) &&
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_TENSORS) &&
verifier.Verify(tensors()) &&
verifier.VerifyVectorOfTables(tensors()) &&
- VerifyOffset(verifier, VT_INPUTS) && verifier.Verify(inputs()) &&
- VerifyOffset(verifier, VT_OUTPUTS) && verifier.Verify(outputs()) &&
+ VerifyOffset(verifier, VT_INPUTS) &&
+ verifier.Verify(inputs()) &&
+ VerifyOffset(verifier, VT_OUTPUTS) &&
+ verifier.Verify(outputs()) &&
VerifyOffset(verifier, VT_OPERATORS) &&
verifier.Verify(operators()) &&
verifier.VerifyVectorOfTables(operators()) &&
- VerifyOffset(verifier, VT_NAME) && verifier.Verify(name()) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.Verify(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 {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
- void add_tensors(
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>>
- tensors) {
+ void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>> tensors) {
fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
}
void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
@@ -4223,15 +3938,14 @@ struct SubGraphBuilder {
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<Operator>>>
- operators) {
+ void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Operator>>> operators) {
fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
}
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(SubGraph::VT_NAME, name);
}
- explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+ SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
SubGraphBuilder &operator=(const SubGraphBuilder &);
@@ -4244,12 +3958,10 @@ struct SubGraphBuilder {
inline flatbuffers::Offset<SubGraph> CreateSubGraph(
flatbuffers::FlatBufferBuilder &_fbb,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>>
- tensors = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<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<Operator>>>
- operators = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Operator>>> operators = 0,
flatbuffers::Offset<flatbuffers::String> name = 0) {
SubGraphBuilder builder_(_fbb);
builder_.add_name(name);
@@ -4272,38 +3984,36 @@ inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
tensors ? _fbb.CreateVector<flatbuffers::Offset<Tensor>>(*tensors) : 0,
inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0,
outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0,
- operators ? _fbb.CreateVector<flatbuffers::Offset<Operator>>(*operators)
- : 0,
+ operators ? _fbb.CreateVector<flatbuffers::Offset<Operator>>(*operators) : 0,
name ? _fbb.CreateString(name) : 0);
}
-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 {
typedef Buffer TableType;
std::vector<uint8_t> data;
- BufferT() {}
+ BufferT() {
+ }
};
struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef BufferT NativeTableType;
- enum { VT_DATA = 4 };
+ enum {
+ VT_DATA = 4
+ };
const flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(flatbuffers::Verifier &verifier) const {
- return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DATA) &&
- verifier.Verify(data()) && verifier.EndTable();
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_DATA) &&
+ verifier.Verify(data()) &&
+ 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 {
@@ -4312,7 +4022,8 @@ struct BufferBuilder {
void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(Buffer::VT_DATA, data);
}
- explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+ BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
BufferBuilder &operator=(const BufferBuilder &);
@@ -4334,13 +4045,12 @@ inline flatbuffers::Offset<Buffer> CreateBuffer(
inline flatbuffers::Offset<Buffer> CreateBufferDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *data = nullptr) {
- return tflite::CreateBuffer(_fbb,
- data ? _fbb.CreateVector<uint8_t>(*data) : 0);
+ return tflite::CreateBuffer(
+ _fbb,
+ data ? _fbb.CreateVector<uint8_t>(*data) : 0);
}
-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 ModelT : public flatbuffers::NativeTable {
typedef Model TableType;
@@ -4349,7 +4059,9 @@ struct ModelT : public flatbuffers::NativeTable {
std::vector<std::unique_ptr<SubGraphT>> subgraphs;
std::string description;
std::vector<std::unique_ptr<BufferT>> buffers;
- ModelT() : version(0) {}
+ ModelT()
+ : version(0) {
+ }
};
struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -4361,24 +4073,20 @@ struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_DESCRIPTION = 10,
VT_BUFFERS = 12
};
- uint32_t version() const { return GetField<uint32_t>(VT_VERSION, 0); }
- const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *operator_codes()
- const {
- return GetPointer<
- const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *>(
- VT_OPERATOR_CODES);
+ uint32_t version() const {
+ return GetField<uint32_t>(VT_VERSION, 0);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *operator_codes() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *>(VT_OPERATOR_CODES);
}
const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *subgraphs() const {
- return GetPointer<
- const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *>(
- VT_SUBGRAPHS);
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *>(VT_SUBGRAPHS);
}
const flatbuffers::String *description() const {
return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
}
const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *buffers() const {
- return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *>(
- VT_BUFFERS);
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *>(VT_BUFFERS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -4391,16 +4099,14 @@ struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVectorOfTables(subgraphs()) &&
VerifyOffset(verifier, VT_DESCRIPTION) &&
verifier.Verify(description()) &&
- VerifyOffset(verifier, VT_BUFFERS) && verifier.Verify(buffers()) &&
- verifier.VerifyVectorOfTables(buffers()) && verifier.EndTable();
+ VerifyOffset(verifier, VT_BUFFERS) &&
+ verifier.Verify(buffers()) &&
+ verifier.VerifyVectorOfTables(buffers()) &&
+ 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 {
@@ -4409,26 +4115,20 @@ struct ModelBuilder {
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<OperatorCode>>>
- operator_codes) {
+ void add_operator_codes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>> operator_codes) {
fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
}
- void add_subgraphs(
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>>
- subgraphs) {
+ void add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>> subgraphs) {
fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
}
void add_description(flatbuffers::Offset<flatbuffers::String> description) {
fbb_.AddOffset(Model::VT_DESCRIPTION, description);
}
- void add_buffers(
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>>
- buffers) {
+ void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>> buffers) {
fbb_.AddOffset(Model::VT_BUFFERS, buffers);
}
- explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
+ ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ModelBuilder &operator=(const ModelBuilder &);
@@ -4440,14 +4140,12 @@ struct ModelBuilder {
};
inline flatbuffers::Offset<Model> CreateModel(
- flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>>
- operator_codes = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>>
- subgraphs = 0,
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint32_t version = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>> operator_codes = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>> subgraphs = 0,
flatbuffers::Offset<flatbuffers::String> description = 0,
- flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>>
- buffers = 0) {
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>> buffers = 0) {
ModelBuilder builder_(_fbb);
builder_.add_buffers(buffers);
builder_.add_description(description);
@@ -4458,2010 +4156,1228 @@ inline flatbuffers::Offset<Model> CreateModel(
}
inline flatbuffers::Offset<Model> CreateModelDirect(
- flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
- const std::vector<flatbuffers::Offset<OperatorCode>> *operator_codes =
- nullptr,
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint32_t version = 0,
+ const std::vector<flatbuffers::Offset<OperatorCode>> *operator_codes = nullptr,
const std::vector<flatbuffers::Offset<SubGraph>> *subgraphs = nullptr,
const char *description = nullptr,
const std::vector<flatbuffers::Offset<Buffer>> *buffers = nullptr) {
return tflite::CreateModel(
- _fbb, version,
- operator_codes ? _fbb.CreateVector<flatbuffers::Offset<OperatorCode>>(
- *operator_codes)
- : 0,
- subgraphs ? _fbb.CreateVector<flatbuffers::Offset<SubGraph>>(*subgraphs)
- : 0,
+ _fbb,
+ version,
+ operator_codes ? _fbb.CreateVector<flatbuffers::Offset<OperatorCode>>(*operator_codes) : 0,
+ subgraphs ? _fbb.CreateVector<flatbuffers::Offset<SubGraph>>(*subgraphs) : 0,
description ? _fbb.CreateString(description) : 0,
buffers ? _fbb.CreateVector<flatbuffers::Offset<Buffer>>(*buffers) : 0);
}
-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 QuantizationParametersT *QuantizationParameters::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline QuantizationParametersT *QuantizationParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new QuantizationParametersT();
UnPackTo(_o, _resolver);
return _o;
}
-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); } } };
+ { 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); } } };
}
-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;
- auto _zero_point =
- _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : 0;
- return tflite::CreateQuantizationParameters(_fbb, _min, _max, _scale,
- _zero_point);
+ auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : 0;
+ return tflite::CreateQuantizationParameters(
+ _fbb,
+ _min,
+ _max,
+ _scale,
+ _zero_point);
}
-inline TensorT *Tensor::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline TensorT *Tensor::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TensorT();
UnPackTo(_o, _resolver);
return _o;
}
-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 = type();
- _o->type = _e;
- };
- {
- auto _e = buffer();
- _o->buffer = _e;
- };
- {
- auto _e = name();
- if (_e) _o->name = _e->str();
- };
- {
- auto _e = quantization();
- if (_e)
- _o->quantization =
- std::unique_ptr<QuantizationParametersT>(_e->UnPack(_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 = type(); _o->type = _e; };
+ { auto _e = buffer(); _o->buffer = _e; };
+ { auto _e = name(); if (_e) _o->name = _e->str(); };
+ { auto _e = quantization(); if (_e) _o->quantization = std::unique_ptr<QuantizationParametersT>(_e->UnPack(_resolver)); };
}
-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;
auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
- auto _quantization = _o->quantization
- ? CreateQuantizationParameters(
- _fbb, _o->quantization.get(), _rehasher)
- : 0;
- return tflite::CreateTensor(_fbb, _shape, _type, _buffer, _name,
- _quantization);
+ auto _quantization = _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : 0;
+ return tflite::CreateTensor(
+ _fbb,
+ _shape,
+ _type,
+ _buffer,
+ _name,
+ _quantization);
}
-inline Conv2DOptionsT *Conv2DOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline Conv2DOptionsT *Conv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new Conv2DOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = stride_w();
- _o->stride_w = _e;
- };
- {
- auto _e = stride_h();
- _o->stride_h = _e;
- };
- {
- auto _e = fused_activation_function();
- _o->fused_activation_function = _e;
- };
+ { auto _e = padding(); _o->padding = _e; };
+ { auto _e = stride_w(); _o->stride_w = _e; };
+ { auto _e = stride_h(); _o->stride_h = _e; };
+ { auto _e = fused_activation_function(); _o->fused_activation_function = _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;
auto _fused_activation_function = _o->fused_activation_function;
- return tflite::CreateConv2DOptions(_fbb, _padding, _stride_w, _stride_h,
- _fused_activation_function);
+ return tflite::CreateConv2DOptions(
+ _fbb,
+ _padding,
+ _stride_w,
+ _stride_h,
+ _fused_activation_function);
}
-inline Pool2DOptionsT *Pool2DOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline Pool2DOptionsT *Pool2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new Pool2DOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = stride_w();
- _o->stride_w = _e;
- };
- {
- auto _e = stride_h();
- _o->stride_h = _e;
- };
- {
- auto _e = filter_width();
- _o->filter_width = _e;
- };
- {
- auto _e = filter_height();
- _o->filter_height = _e;
- };
- {
- auto _e = fused_activation_function();
- _o->fused_activation_function = _e;
- };
+ { auto _e = padding(); _o->padding = _e; };
+ { auto _e = stride_w(); _o->stride_w = _e; };
+ { auto _e = stride_h(); _o->stride_h = _e; };
+ { auto _e = filter_width(); _o->filter_width = _e; };
+ { auto _e = filter_height(); _o->filter_height = _e; };
+ { 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;
auto _filter_width = _o->filter_width;
auto _filter_height = _o->filter_height;
auto _fused_activation_function = _o->fused_activation_function;
- return tflite::CreatePool2DOptions(_fbb, _padding, _stride_w, _stride_h,
- _filter_width, _filter_height,
- _fused_activation_function);
+ return tflite::CreatePool2DOptions(
+ _fbb,
+ _padding,
+ _stride_w,
+ _stride_h,
+ _filter_width,
+ _filter_height,
+ _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 = new DepthwiseConv2DOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = stride_w();
- _o->stride_w = _e;
- };
- {
- auto _e = stride_h();
- _o->stride_h = _e;
- };
- {
- auto _e = depth_multiplier();
- _o->depth_multiplier = _e;
- };
- {
- auto _e = fused_activation_function();
- _o->fused_activation_function = _e;
- };
+ { auto _e = padding(); _o->padding = _e; };
+ { auto _e = stride_w(); _o->stride_w = _e; };
+ { auto _e = stride_h(); _o->stride_h = _e; };
+ { auto _e = depth_multiplier(); _o->depth_multiplier = _e; };
+ { auto _e = fused_activation_function(); _o->fused_activation_function = _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;
auto _depth_multiplier = _o->depth_multiplier;
auto _fused_activation_function = _o->fused_activation_function;
- return tflite::CreateDepthwiseConv2DOptions(_fbb, _padding, _stride_w,
- _stride_h, _depth_multiplier,
- _fused_activation_function);
+ return tflite::CreateDepthwiseConv2DOptions(
+ _fbb,
+ _padding,
+ _stride_w,
+ _stride_h,
+ _depth_multiplier,
+ _fused_activation_function);
}
-inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ConcatEmbeddingsOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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_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); } } };
}
-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;
- return tflite::CreateConcatEmbeddingsOptions(_fbb, _num_channels,
- _num_columns_per_channel,
- _embedding_dim_per_channel);
-}
-
-inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+ 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;
+ return tflite::CreateConcatEmbeddingsOptions(
+ _fbb,
+ _num_channels,
+ _num_columns_per_channel,
+ _embedding_dim_per_channel);
+}
+
+inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new LSHProjectionOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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);
+ 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 = new SVDFOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = fused_activation_function();
- _o->fused_activation_function = _e;
- };
+ { auto _e = rank(); _o->rank = _e; };
+ { auto _e = fused_activation_function(); _o->fused_activation_function = _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;
- return tflite::CreateSVDFOptions(_fbb, _rank, _fused_activation_function);
+ return tflite::CreateSVDFOptions(
+ _fbb,
+ _rank,
+ _fused_activation_function);
}
-inline RNNOptionsT *RNNOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline RNNOptionsT *RNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new RNNOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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 = fused_activation_function(); _o->fused_activation_function = _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;
- return tflite::CreateRNNOptions(_fbb, _fused_activation_function);
+ return tflite::CreateRNNOptions(
+ _fbb,
+ _fused_activation_function);
}
-inline SequenceRNNOptionsT *SequenceRNNOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline SequenceRNNOptionsT *SequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SequenceRNNOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = fused_activation_function();
- _o->fused_activation_function = _e;
- };
+ { auto _e = time_major(); _o->time_major = _e; };
+ { auto _e = fused_activation_function(); _o->fused_activation_function = _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;
- return tflite::CreateSequenceRNNOptions(_fbb, _time_major,
- _fused_activation_function);
+ return tflite::CreateSequenceRNNOptions(
+ _fbb,
+ _time_major,
+ _fused_activation_function);
}
-inline BidirectionalSequenceRNNOptionsT *
-BidirectionalSequenceRNNOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline BidirectionalSequenceRNNOptionsT *BidirectionalSequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new BidirectionalSequenceRNNOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = fused_activation_function();
- _o->fused_activation_function = _e;
- };
+ { auto _e = time_major(); _o->time_major = _e; };
+ { auto _e = fused_activation_function(); _o->fused_activation_function = _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;
return tflite::CreateBidirectionalSequenceRNNOptions(
- _fbb, _time_major, _fused_activation_function);
+ _fbb,
+ _time_major,
+ _fused_activation_function);
}
-inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new FullyConnectedOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { auto _e = fused_activation_function(); _o->fused_activation_function = _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;
- return tflite::CreateFullyConnectedOptions(_fbb, _fused_activation_function);
+ return tflite::CreateFullyConnectedOptions(
+ _fbb,
+ _fused_activation_function);
}
-inline SoftmaxOptionsT *SoftmaxOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline SoftmaxOptionsT *SoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SoftmaxOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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);
+ 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 = new ConcatenationOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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(_fbb, _axis,
- _fused_activation_function);
+ return tflite::CreateConcatenationOptions(
+ _fbb,
+ _axis,
+ _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 = new AddOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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 = fused_activation_function(); _o->fused_activation_function = _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;
- return tflite::CreateAddOptions(_fbb, _fused_activation_function);
+ return tflite::CreateAddOptions(
+ _fbb,
+ _fused_activation_function);
}
-inline MulOptionsT *MulOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline MulOptionsT *MulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MulOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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);
+ 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 = new L2NormOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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);
+ 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 = new LocalResponseNormalizationOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = bias();
- _o->bias = _e;
- };
- {
- auto _e = alpha();
- _o->alpha = _e;
- };
- {
- auto _e = beta();
- _o->beta = _e;
- };
+ { auto _e = radius(); _o->radius = _e; };
+ { auto _e = bias(); _o->bias = _e; };
+ { auto _e = alpha(); _o->alpha = _e; };
+ { 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;
auto _beta = _o->beta;
- return tflite::CreateLocalResponseNormalizationOptions(_fbb, _radius, _bias,
- _alpha, _beta);
+ return tflite::CreateLocalResponseNormalizationOptions(
+ _fbb,
+ _radius,
+ _bias,
+ _alpha,
+ _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 = new LSTMOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = cell_clip();
- _o->cell_clip = _e;
- };
- {
- auto _e = proj_clip();
- _o->proj_clip = _e;
- };
+ { auto _e = fused_activation_function(); _o->fused_activation_function = _e; };
+ { auto _e = cell_clip(); _o->cell_clip = _e; };
+ { auto _e = proj_clip(); _o->proj_clip = _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;
- return tflite::CreateLSTMOptions(_fbb, _fused_activation_function, _cell_clip,
- _proj_clip);
+ return tflite::CreateLSTMOptions(
+ _fbb,
+ _fused_activation_function,
+ _cell_clip,
+ _proj_clip);
}
-inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ResizeBilinearOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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; };
}
-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;
- return tflite::CreateResizeBilinearOptions(_fbb);
+ 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;
+ return tflite::CreateResizeBilinearOptions(
+ _fbb,
+ _align_corners);
}
-inline CallOptionsT *CallOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline CallOptionsT *CallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new CallOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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);
+ 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 = new PadOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- return tflite::CreatePadOptions(_fbb);
+ 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 ReshapeOptionsT *ReshapeOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline ReshapeOptionsT *ReshapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ReshapeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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); } } };
}
-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);
+ 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 = new SpaceToBatchNDOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- return tflite::CreateSpaceToBatchNDOptions(_fbb);
+ 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 = new BatchToSpaceNDOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- return tflite::CreateBatchToSpaceNDOptions(_fbb);
+ 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 = new SkipGramOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = max_skip_size();
- _o->max_skip_size = _e;
- };
- {
- auto _e = include_all_ngrams();
- _o->include_all_ngrams = _e;
- };
+ { auto _e = ngram_size(); _o->ngram_size = _e; };
+ { auto _e = max_skip_size(); _o->max_skip_size = _e; };
+ { 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;
- return tflite::CreateSkipGramOptions(_fbb, _ngram_size, _max_skip_size,
- _include_all_ngrams);
+ return tflite::CreateSkipGramOptions(
+ _fbb,
+ _ngram_size,
+ _max_skip_size,
+ _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 = new SpaceToDepthOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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);
+ return tflite::CreateSpaceToDepthOptions(
+ _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 = new SubOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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 = fused_activation_function(); _o->fused_activation_function = _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;
- return tflite::CreateSubOptions(_fbb, _fused_activation_function);
+ return tflite::CreateSubOptions(
+ _fbb,
+ _fused_activation_function);
}
-inline DivOptionsT *DivOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline DivOptionsT *DivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new DivOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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);
+ return tflite::CreateDivOptions(
+ _fbb,
+ _fused_activation_function);
}
-inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new EmbeddingLookupSparseOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
+ { 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);
+ 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 = new GatherOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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 = axis(); _o->axis = _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;
- return tflite::CreateGatherOptions(_fbb, _axis);
+ return tflite::CreateGatherOptions(
+ _fbb,
+ _axis);
}
-inline TransposeOptionsT *TransposeOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline TransposeOptionsT *TransposeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TransposeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- return tflite::CreateTransposeOptions(_fbb);
+ 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 MeanOptionsT *MeanOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline MeanOptionsT *MeanOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MeanOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-inline void MeanOptions::UnPackTo(
- MeanOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+inline void MeanOptions::UnPackTo(MeanOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
- {
- auto _e = keep_dims();
- _o->keep_dims = _e;
- };
+ { auto _e = keep_dims(); _o->keep_dims = _e; };
}
-inline flatbuffers::Offset<MeanOptions> MeanOptions::Pack(
- flatbuffers::FlatBufferBuilder &_fbb, const MeanOptionsT *_o,
- const flatbuffers::rehasher_function_t *_rehasher) {
+inline flatbuffers::Offset<MeanOptions> MeanOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MeanOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateMeanOptions(_fbb, _o, _rehasher);
}
-inline flatbuffers::Offset<MeanOptions> CreateMeanOptions(
- flatbuffers::FlatBufferBuilder &_fbb, const MeanOptionsT *_o,
- const flatbuffers::rehasher_function_t *_rehasher) {
+inline flatbuffers::Offset<MeanOptions> CreateMeanOptions(flatbuffers::FlatBufferBuilder &_fbb, const MeanOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
- struct _VectorArgs {
- flatbuffers::FlatBufferBuilder *__fbb;
- const MeanOptionsT *__o;
- const flatbuffers::rehasher_function_t *__rehasher;
- } _va = {&_fbb, _o, _rehasher};
- (void)_va;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MeanOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _keep_dims = _o->keep_dims;
- return tflite::CreateMeanOptions(_fbb, _keep_dims);
+ return tflite::CreateMeanOptions(
+ _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 = new SqueezeOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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); } } };
}
-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;
- auto _squeeze_dims =
- _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : 0;
- return tflite::CreateSqueezeOptions(_fbb, _squeeze_dims);
-}
-
-inline StridedSliceOptionsT *StridedSliceOptions::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+ 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 StridedSliceOptionsT *StridedSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new StridedSliceOptionsT();
UnPackTo(_o, _resolver);
return _o;
}
-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;
- };
- {
- auto _e = end_mask();
- _o->end_mask = _e;
- };
- {
- auto _e = ellipsis_mask();
- _o->ellipsis_mask = _e;
- };
- {
- auto _e = new_axis_mask();
- _o->new_axis_mask = _e;
- };
- {
- auto _e = shrink_axis_mask();
- _o->shrink_axis_mask = _e;
- };
+ { auto _e = begin_mask(); _o->begin_mask = _e; };
+ { auto _e = end_mask(); _o->end_mask = _e; };
+ { auto _e = ellipsis_mask(); _o->ellipsis_mask = _e; };
+ { auto _e = new_axis_mask(); _o->new_axis_mask = _e; };
+ { auto _e = shrink_axis_mask(); _o->shrink_axis_mask = _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;
auto _new_axis_mask = _o->new_axis_mask;
auto _shrink_axis_mask = _o->shrink_axis_mask;
- return tflite::CreateStridedSliceOptions(_fbb, _begin_mask, _end_mask,
- _ellipsis_mask, _new_axis_mask,
- _shrink_axis_mask);
+ return tflite::CreateStridedSliceOptions(
+ _fbb,
+ _begin_mask,
+ _end_mask,
+ _ellipsis_mask,
+ _new_axis_mask,
+ _shrink_axis_mask);
+}
+
+inline TFMaximumOptionsT *TFMaximumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new TFMaximumOptionsT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void TFMaximumOptions::UnPackTo(TFMaximumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+}
+
+inline flatbuffers::Offset<TFMaximumOptions> TFMaximumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TFMaximumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateTFMaximumOptions(_fbb, _o, _rehasher);
}
-inline OperatorCodeT *OperatorCode::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline flatbuffers::Offset<TFMaximumOptions> CreateTFMaximumOptions(flatbuffers::FlatBufferBuilder &_fbb, const TFMaximumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TFMaximumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ return tflite::CreateTFMaximumOptions(
+ _fbb);
+}
+
+inline OperatorCodeT *OperatorCode::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new OperatorCodeT();
UnPackTo(_o, _resolver);
return _o;
}
-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 = builtin_code();
- _o->builtin_code = _e;
- };
- {
- auto _e = custom_code();
- if (_e) _o->custom_code = _e->str();
- };
+ { auto _e = builtin_code(); _o->builtin_code = _e; };
+ { auto _e = custom_code(); if (_e) _o->custom_code = _e->str(); };
}
-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 _builtin_code = _o->builtin_code;
- auto _custom_code =
- _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code);
- return tflite::CreateOperatorCode(_fbb, _builtin_code, _custom_code);
+ auto _custom_code = _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code);
+ return tflite::CreateOperatorCode(
+ _fbb,
+ _builtin_code,
+ _custom_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 = new OperatorT();
UnPackTo(_o, _resolver);
return _o;
}
-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 = builtin_options_type();
- _o->builtin_options.type = _e;
- };
- {
- auto _e = builtin_options();
- if (_e)
- _o->builtin_options.value =
- BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver);
- };
- {
- auto _e = custom_options();
- if (_e) {
- _o->custom_options.resize(_e->size());
- for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) {
- _o->custom_options[_i] = _e->Get(_i);
- }
- }
- };
- {
- auto _e = custom_options_format();
- _o->custom_options_format = _e;
- };
+ { 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 = builtin_options_type(); _o->builtin_options.type = _e; };
+ { auto _e = builtin_options(); if (_e) _o->builtin_options.value = BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); };
+ { auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->custom_options[_i] = _e->Get(_i); } } };
+ { auto _e = custom_options_format(); _o->custom_options_format = _e; };
}
-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;
auto _builtin_options_type = _o->builtin_options.type;
auto _builtin_options = _o->builtin_options.Pack(_fbb);
- auto _custom_options =
- _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : 0;
+ auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : 0;
auto _custom_options_format = _o->custom_options_format;
- return tflite::CreateOperator(_fbb, _opcode_index, _inputs, _outputs,
- _builtin_options_type, _builtin_options,
- _custom_options, _custom_options_format);
+ return tflite::CreateOperator(
+ _fbb,
+ _opcode_index,
+ _inputs,
+ _outputs,
+ _builtin_options_type,
+ _builtin_options,
+ _custom_options,
+ _custom_options_format);
}
-inline SubGraphT *SubGraph::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline SubGraphT *SubGraph::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SubGraphT();
UnPackTo(_o, _resolver);
return _o;
}
-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++) {
- _o->tensors[_i] =
- std::unique_ptr<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++) {
- _o->operators[_i] =
- std::unique_ptr<OperatorT>(_e->Get(_i)->UnPack(_resolver));
- }
- }
- };
- {
- auto _e = name();
- if (_e) _o->name = _e->str();
- };
+ { auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tensors[_i] = std::unique_ptr<TensorT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { 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++) { _o->operators[_i] = std::unique_ptr<OperatorT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { 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<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<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<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<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, _tensors, _inputs, _outputs, _operators,
- _name);
+ return tflite::CreateSubGraph(
+ _fbb,
+ _tensors,
+ _inputs,
+ _outputs,
+ _operators,
+ _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 = new BufferT();
UnPackTo(_o, _resolver);
return _o;
}
-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());
- for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) {
- _o->data[_i] = _e->Get(_i);
- }
- }
- };
+ { auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->data[_i] = _e->Get(_i); } } };
}
-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;
auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
- return tflite::CreateBuffer(_fbb, _data);
+ return tflite::CreateBuffer(
+ _fbb,
+ _data);
}
-inline ModelT *Model::UnPack(
- const flatbuffers::resolver_function_t *_resolver) const {
+inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new ModelT();
UnPackTo(_o, _resolver);
return _o;
}
-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++) {
- _o->operator_codes[_i] =
- std::unique_ptr<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++) {
- _o->subgraphs[_i] =
- std::unique_ptr<SubGraphT>(_e->Get(_i)->UnPack(_resolver));
- }
- }
- };
- {
- 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++) {
- _o->buffers[_i] =
- std::unique_ptr<BufferT>(_e->Get(_i)->UnPack(_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++) { _o->operator_codes[_i] = std::unique_ptr<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++) { _o->subgraphs[_i] = std::unique_ptr<SubGraphT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { 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++) { _o->buffers[_i] = std::unique_ptr<BufferT>(_e->Get(_i)->UnPack(_resolver)); } } };
}
-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<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<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<Buffer>>(
- _o->buffers.size(),
- [](size_t i, _VectorArgs *__va) {
- return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(),
- __va->__rehasher);
- },
- &_va)
- : 0;
- return tflite::CreateModel(_fbb, _version, _operator_codes, _subgraphs,
- _description, _buffers);
-}
-
-inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier,
- const void *obj, BuiltinOptions type) {
+ auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector<flatbuffers::Offset<OperatorCode>> (_o->operator_codes.size(), [](size_t i, _VectorArgs *__va) { return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector<flatbuffers::Offset<SubGraph>> (_o->subgraphs.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
+ auto _buffers = _o->buffers.size() ? _fbb.CreateVector<flatbuffers::Offset<Buffer>> (_o->buffers.size(), [](size_t i, _VectorArgs *__va) { return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : 0;
+ return tflite::CreateModel(
+ _fbb,
+ _version,
+ _operator_codes,
+ _subgraphs,
+ _description,
+ _buffers);
+}
+
+inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) {
switch (type) {
case BuiltinOptions_NONE: {
return true;
@@ -6515,8 +5431,7 @@ inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier,
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
- auto ptr =
- reinterpret_cast<const LocalResponseNormalizationOptions *>(obj);
+ auto ptr = reinterpret_cast<const LocalResponseNormalizationOptions *>(obj);
return verifier.VerifyTable(ptr);
}
case BuiltinOptions_LSTMOptions: {
@@ -6595,28 +5510,26 @@ inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier,
auto ptr = reinterpret_cast<const StridedSliceOptions *>(obj);
return verifier.VerifyTable(ptr);
}
- default:
- return false;
+ case BuiltinOptions_TFMaximumOptions: {
+ auto ptr = reinterpret_cast<const TFMaximumOptions *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ default: return false;
}
}
-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->size() != types->size()) return false;
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
- if (!VerifyBuiltinOptions(verifier, values->Get(i),
- types->GetEnum<BuiltinOptions>(i))) {
+ if (!VerifyBuiltinOptions(
+ verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i))) {
return false;
}
}
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) {
switch (type) {
case BuiltinOptions_Conv2DOptions: {
auto ptr = reinterpret_cast<const Conv2DOptions *>(obj);
@@ -6667,8 +5580,7 @@ inline void *BuiltinOptionsUnion::UnPack(
return ptr->UnPack(resolver);
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
- auto ptr =
- reinterpret_cast<const LocalResponseNormalizationOptions *>(obj);
+ auto ptr = reinterpret_cast<const LocalResponseNormalizationOptions *>(obj);
return ptr->UnPack(resolver);
}
case BuiltinOptions_LSTMOptions: {
@@ -6747,14 +5659,15 @@ inline void *BuiltinOptionsUnion::UnPack(
auto ptr = reinterpret_cast<const StridedSliceOptions *>(obj);
return ptr->UnPack(resolver);
}
- default:
- return nullptr;
+ case BuiltinOptions_TFMaximumOptions: {
+ auto ptr = reinterpret_cast<const TFMaximumOptions *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ default: return nullptr;
}
}
-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 {
switch (type) {
case BuiltinOptions_Conv2DOptions: {
auto ptr = reinterpret_cast<const Conv2DOptionsT *>(value);
@@ -6805,10 +5718,8 @@ inline flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(
return CreateL2NormOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
- auto ptr =
- reinterpret_cast<const LocalResponseNormalizationOptionsT *>(value);
- return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher)
- .Union();
+ auto ptr = reinterpret_cast<const LocalResponseNormalizationOptionsT *>(value);
+ return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union();
}
case BuiltinOptions_LSTMOptions: {
auto ptr = reinterpret_cast<const LSTMOptionsT *>(value);
@@ -6886,32 +5797,30 @@ inline flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(
auto ptr = reinterpret_cast<const StridedSliceOptionsT *>(value);
return CreateStridedSliceOptions(_fbb, ptr, _rehasher).Union();
}
- default:
- return 0;
+ case BuiltinOptions_TFMaximumOptions: {
+ auto ptr = reinterpret_cast<const TFMaximumOptionsT *>(value);
+ return CreateTFMaximumOptions(_fbb, ptr, _rehasher).Union();
+ }
+ default: return 0;
}
}
-inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u)
- FLATBUFFERS_NOEXCEPT : type(u.type),
- value(nullptr) {
+inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
switch (type) {
case BuiltinOptions_Conv2DOptions: {
value = new Conv2DOptionsT(*reinterpret_cast<Conv2DOptionsT *>(u.value));
break;
}
case BuiltinOptions_DepthwiseConv2DOptions: {
- value = new DepthwiseConv2DOptionsT(
- *reinterpret_cast<DepthwiseConv2DOptionsT *>(u.value));
+ value = new DepthwiseConv2DOptionsT(*reinterpret_cast<DepthwiseConv2DOptionsT *>(u.value));
break;
}
case BuiltinOptions_ConcatEmbeddingsOptions: {
- value = new ConcatEmbeddingsOptionsT(
- *reinterpret_cast<ConcatEmbeddingsOptionsT *>(u.value));
+ value = new ConcatEmbeddingsOptionsT(*reinterpret_cast<ConcatEmbeddingsOptionsT *>(u.value));
break;
}
case BuiltinOptions_LSHProjectionOptions: {
- value = new LSHProjectionOptionsT(
- *reinterpret_cast<LSHProjectionOptionsT *>(u.value));
+ value = new LSHProjectionOptionsT(*reinterpret_cast<LSHProjectionOptionsT *>(u.value));
break;
}
case BuiltinOptions_Pool2DOptions: {
@@ -6927,18 +5836,15 @@ inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u)
break;
}
case BuiltinOptions_FullyConnectedOptions: {
- value = new FullyConnectedOptionsT(
- *reinterpret_cast<FullyConnectedOptionsT *>(u.value));
+ value = new FullyConnectedOptionsT(*reinterpret_cast<FullyConnectedOptionsT *>(u.value));
break;
}
case BuiltinOptions_SoftmaxOptions: {
- value =
- new SoftmaxOptionsT(*reinterpret_cast<SoftmaxOptionsT *>(u.value));
+ value = new SoftmaxOptionsT(*reinterpret_cast<SoftmaxOptionsT *>(u.value));
break;
}
case BuiltinOptions_ConcatenationOptions: {
- value = new ConcatenationOptionsT(
- *reinterpret_cast<ConcatenationOptionsT *>(u.value));
+ value = new ConcatenationOptionsT(*reinterpret_cast<ConcatenationOptionsT *>(u.value));
break;
}
case BuiltinOptions_AddOptions: {
@@ -6950,8 +5856,7 @@ inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u)
break;
}
case BuiltinOptions_LocalResponseNormalizationOptions: {
- value = new LocalResponseNormalizationOptionsT(
- *reinterpret_cast<LocalResponseNormalizationOptionsT *>(u.value));
+ value = new LocalResponseNormalizationOptionsT(*reinterpret_cast<LocalResponseNormalizationOptionsT *>(u.value));
break;
}
case BuiltinOptions_LSTMOptions: {
@@ -6959,8 +5864,7 @@ inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u)
break;
}
case BuiltinOptions_ResizeBilinearOptions: {
- value = new ResizeBilinearOptionsT(
- *reinterpret_cast<ResizeBilinearOptionsT *>(u.value));
+ value = new ResizeBilinearOptionsT(*reinterpret_cast<ResizeBilinearOptionsT *>(u.value));
break;
}
case BuiltinOptions_CallOptions: {
@@ -6968,23 +5872,19 @@ inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u)
break;
}
case BuiltinOptions_ReshapeOptions: {
- value =
- new ReshapeOptionsT(*reinterpret_cast<ReshapeOptionsT *>(u.value));
+ value = new ReshapeOptionsT(*reinterpret_cast<ReshapeOptionsT *>(u.value));
break;
}
case BuiltinOptions_SkipGramOptions: {
- value =
- new SkipGramOptionsT(*reinterpret_cast<SkipGramOptionsT *>(u.value));
+ value = new SkipGramOptionsT(*reinterpret_cast<SkipGramOptionsT *>(u.value));
break;
}
case BuiltinOptions_SpaceToDepthOptions: {
- value = new SpaceToDepthOptionsT(
- *reinterpret_cast<SpaceToDepthOptionsT *>(u.value));
+ value = new SpaceToDepthOptionsT(*reinterpret_cast<SpaceToDepthOptionsT *>(u.value));
break;
}
case BuiltinOptions_EmbeddingLookupSparseOptions: {
- value = new EmbeddingLookupSparseOptionsT(
- *reinterpret_cast<EmbeddingLookupSparseOptionsT *>(u.value));
+ value = new EmbeddingLookupSparseOptionsT(*reinterpret_cast<EmbeddingLookupSparseOptionsT *>(u.value));
break;
}
case BuiltinOptions_MulOptions: {
@@ -7000,18 +5900,15 @@ inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u)
break;
}
case BuiltinOptions_BatchToSpaceNDOptions: {
- value = new BatchToSpaceNDOptionsT(
- *reinterpret_cast<BatchToSpaceNDOptionsT *>(u.value));
+ value = new BatchToSpaceNDOptionsT(*reinterpret_cast<BatchToSpaceNDOptionsT *>(u.value));
break;
}
case BuiltinOptions_SpaceToBatchNDOptions: {
- value = new SpaceToBatchNDOptionsT(
- *reinterpret_cast<SpaceToBatchNDOptionsT *>(u.value));
+ value = new SpaceToBatchNDOptionsT(*reinterpret_cast<SpaceToBatchNDOptionsT *>(u.value));
break;
}
case BuiltinOptions_TransposeOptions: {
- value = new TransposeOptionsT(
- *reinterpret_cast<TransposeOptionsT *>(u.value));
+ value = new TransposeOptionsT(*reinterpret_cast<TransposeOptionsT *>(u.value));
break;
}
case BuiltinOptions_MeanOptions: {
@@ -7027,18 +5924,19 @@ inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u)
break;
}
case BuiltinOptions_SqueezeOptions: {
- value =
- new SqueezeOptionsT(*reinterpret_cast<SqueezeOptionsT *>(u.value));
+ value = new SqueezeOptionsT(*reinterpret_cast<SqueezeOptionsT *>(u.value));
break;
}
case BuiltinOptions_SequenceRNNOptions: {
- value = new SequenceRNNOptionsT(
- *reinterpret_cast<SequenceRNNOptionsT *>(u.value));
+ value = new SequenceRNNOptionsT(*reinterpret_cast<SequenceRNNOptionsT *>(u.value));
break;
}
case BuiltinOptions_StridedSliceOptions: {
- value = new StridedSliceOptionsT(
- *reinterpret_cast<StridedSliceOptionsT *>(u.value));
+ value = new StridedSliceOptionsT(*reinterpret_cast<StridedSliceOptionsT *>(u.value));
+ break;
+ }
+ case BuiltinOptions_TFMaximumOptions: {
+ value = new TFMaximumOptionsT(*reinterpret_cast<TFMaximumOptionsT *>(u.value));
break;
}
default:
@@ -7208,8 +6106,12 @@ inline void BuiltinOptionsUnion::Reset() {
delete ptr;
break;
}
- default:
+ case BuiltinOptions_TFMaximumOptions: {
+ auto ptr = reinterpret_cast<TFMaximumOptionsT *>(value);
+ delete ptr;
break;
+ }
+ default: break;
}
value = nullptr;
type = BuiltinOptions_NONE;
@@ -7219,25 +6121,33 @@ inline const tflite::Model *GetModel(const void *buf) {
return flatbuffers::GetRoot<tflite::Model>(buf);
}
-inline const char *ModelIdentifier() { return "TFL3"; }
+inline const char *ModelIdentifier() {
+ return "TFL3";
+}
inline bool ModelBufferHasIdentifier(const void *buf) {
- return flatbuffers::BufferHasIdentifier(buf, ModelIdentifier());
+ return flatbuffers::BufferHasIdentifier(
+ buf, ModelIdentifier());
}
-inline bool VerifyModelBuffer(flatbuffers::Verifier &verifier) {
+inline bool VerifyModelBuffer(
+ flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<tflite::Model>(ModelIdentifier());
}
-inline const char *ModelExtension() { return "tflite"; }
+inline const char *ModelExtension() {
+ return "tflite";
+}
-inline void FinishModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
- flatbuffers::Offset<tflite::Model> root) {
+inline void FinishModelBuffer(
+ flatbuffers::FlatBufferBuilder &fbb,
+ flatbuffers::Offset<tflite::Model> root) {
fbb.Finish(root, ModelIdentifier());
}
inline std::unique_ptr<ModelT> UnPackModel(
- const void *buf, const flatbuffers::resolver_function_t *res = nullptr) {
+ const void *buf,
+ const flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<ModelT>(GetModel(buf)->UnPack(res));
}
diff --git a/tensorflow/contrib/lite/toco/tflite/operator.cc b/tensorflow/contrib/lite/toco/tflite/operator.cc
index ff54b350bf..d9ee2292e2 100644
--- a/tensorflow/contrib/lite/toco/tflite/operator.cc
+++ b/tensorflow/contrib/lite/toco/tflite/operator.cc
@@ -835,6 +835,9 @@ std::vector<std::unique_ptr<BaseOperator>> BuildOperatorList() {
"LOGISTIC", OperatorType::kLogistic));
ops.emplace_back(
new SimpleOperator<TanhOperator>("TANH", OperatorType::kTanh));
+ ops.emplace_back(
+ new SimpleOperator<TensorFlowMaximumOperator>(
+ "TFMAXIMUM", OperatorType::kTensorFlowMaximum));
return ops;
}
--
2.16.1
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment