chromium/third_party/tflite/src/tensorflow/lite/acceleration/configuration/configuration_generated.h

/* Copyright 2021 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_CONFIGURATION_TFLITE_H_
#define FLATBUFFERS_GENERATED_CONFIGURATION_TFLITE_H_

#include "flatbuffers/flatbuffers.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert …;

namespace tflite {

struct ComputeSettings;
struct ComputeSettingsBuilder;
struct ComputeSettingsT;

struct NNAPISettings;
struct NNAPISettingsBuilder;
struct NNAPISettingsT;

struct GPUSettings;
struct GPUSettingsBuilder;
struct GPUSettingsT;

struct HexagonSettings;
struct HexagonSettingsBuilder;
struct HexagonSettingsT;

struct XNNPackSettings;
struct XNNPackSettingsBuilder;
struct XNNPackSettingsT;

struct CoreMLSettings;
struct CoreMLSettingsBuilder;
struct CoreMLSettingsT;

struct StableDelegateLoaderSettings;
struct StableDelegateLoaderSettingsBuilder;
struct StableDelegateLoaderSettingsT;

struct CompilationCachingSettings;
struct CompilationCachingSettingsBuilder;
struct CompilationCachingSettingsT;

struct EdgeTpuDeviceSpec;
struct EdgeTpuDeviceSpecBuilder;
struct EdgeTpuDeviceSpecT;

struct EdgeTpuInactivePowerConfig;
struct EdgeTpuInactivePowerConfigBuilder;
struct EdgeTpuInactivePowerConfigT;

struct EdgeTpuSettings;
struct EdgeTpuSettingsBuilder;
struct EdgeTpuSettingsT;

struct GoogleEdgeTpuSettings;
struct GoogleEdgeTpuSettingsBuilder;
struct GoogleEdgeTpuSettingsT;

struct CoralSettings;
struct CoralSettingsBuilder;
struct CoralSettingsT;

struct CPUSettings;
struct CPUSettingsBuilder;
struct CPUSettingsT;

struct ArmNNSettings;
struct ArmNNSettingsBuilder;
struct ArmNNSettingsT;

struct MtkNeuronSettings;
struct MtkNeuronSettingsBuilder;
struct MtkNeuronSettingsT;

struct TFLiteSettings;
struct TFLiteSettingsBuilder;
struct TFLiteSettingsT;

struct FallbackSettings;
struct FallbackSettingsBuilder;
struct FallbackSettingsT;

struct BenchmarkMetric;
struct BenchmarkMetricBuilder;
struct BenchmarkMetricT;

struct BenchmarkResult;
struct BenchmarkResultBuilder;
struct BenchmarkResultT;

namespace BenchmarkResult_ {

struct InferenceOutput;
struct InferenceOutputBuilder;
struct InferenceOutputT;

}  // namespace BenchmarkResult_

struct ErrorCode;
struct ErrorCodeBuilder;
struct ErrorCodeT;

struct BenchmarkError;
struct BenchmarkErrorBuilder;
struct BenchmarkErrorT;

struct BenchmarkEvent;
struct BenchmarkEventBuilder;
struct BenchmarkEventT;

struct BestAccelerationDecision;
struct BestAccelerationDecisionBuilder;
struct BestAccelerationDecisionT;

struct BenchmarkInitializationFailure;
struct BenchmarkInitializationFailureBuilder;
struct BenchmarkInitializationFailureT;

struct MiniBenchmarkEvent;
struct MiniBenchmarkEventBuilder;
struct MiniBenchmarkEventT;

struct ModelFile;
struct ModelFileBuilder;
struct ModelFileT;

struct ModelIdGroup;
struct ModelIdGroupBuilder;
struct ModelIdGroupT;

struct BenchmarkStoragePaths;
struct BenchmarkStoragePathsBuilder;
struct BenchmarkStoragePathsT;

struct ValidationSettings;
struct ValidationSettingsBuilder;
struct ValidationSettingsT;

struct MinibenchmarkSettings;
struct MinibenchmarkSettingsBuilder;
struct MinibenchmarkSettingsT;

struct BenchmarkEventStorage;
struct BenchmarkEventStorageBuilder;
struct BenchmarkEventStorageT;

bool operator==(const ComputeSettingsT &lhs, const ComputeSettingsT &rhs);
bool operator!=(const ComputeSettingsT &lhs, const ComputeSettingsT &rhs);
bool operator==(const NNAPISettingsT &lhs, const NNAPISettingsT &rhs);
bool operator!=(const NNAPISettingsT &lhs, const NNAPISettingsT &rhs);
bool operator==(const GPUSettingsT &lhs, const GPUSettingsT &rhs);
bool operator!=(const GPUSettingsT &lhs, const GPUSettingsT &rhs);
bool operator==(const HexagonSettingsT &lhs, const HexagonSettingsT &rhs);
bool operator!=(const HexagonSettingsT &lhs, const HexagonSettingsT &rhs);
bool operator==(const XNNPackSettingsT &lhs, const XNNPackSettingsT &rhs);
bool operator!=(const XNNPackSettingsT &lhs, const XNNPackSettingsT &rhs);
bool operator==(const CoreMLSettingsT &lhs, const CoreMLSettingsT &rhs);
bool operator!=(const CoreMLSettingsT &lhs, const CoreMLSettingsT &rhs);
bool operator==(const StableDelegateLoaderSettingsT &lhs, const StableDelegateLoaderSettingsT &rhs);
bool operator!=(const StableDelegateLoaderSettingsT &lhs, const StableDelegateLoaderSettingsT &rhs);
bool operator==(const CompilationCachingSettingsT &lhs, const CompilationCachingSettingsT &rhs);
bool operator!=(const CompilationCachingSettingsT &lhs, const CompilationCachingSettingsT &rhs);
bool operator==(const EdgeTpuDeviceSpecT &lhs, const EdgeTpuDeviceSpecT &rhs);
bool operator!=(const EdgeTpuDeviceSpecT &lhs, const EdgeTpuDeviceSpecT &rhs);
bool operator==(const EdgeTpuInactivePowerConfigT &lhs, const EdgeTpuInactivePowerConfigT &rhs);
bool operator!=(const EdgeTpuInactivePowerConfigT &lhs, const EdgeTpuInactivePowerConfigT &rhs);
bool operator==(const EdgeTpuSettingsT &lhs, const EdgeTpuSettingsT &rhs);
bool operator!=(const EdgeTpuSettingsT &lhs, const EdgeTpuSettingsT &rhs);
bool operator==(const GoogleEdgeTpuSettingsT &lhs, const GoogleEdgeTpuSettingsT &rhs);
bool operator!=(const GoogleEdgeTpuSettingsT &lhs, const GoogleEdgeTpuSettingsT &rhs);
bool operator==(const CoralSettingsT &lhs, const CoralSettingsT &rhs);
bool operator!=(const CoralSettingsT &lhs, const CoralSettingsT &rhs);
bool operator==(const CPUSettingsT &lhs, const CPUSettingsT &rhs);
bool operator!=(const CPUSettingsT &lhs, const CPUSettingsT &rhs);
bool operator==(const ArmNNSettingsT &lhs, const ArmNNSettingsT &rhs);
bool operator!=(const ArmNNSettingsT &lhs, const ArmNNSettingsT &rhs);
bool operator==(const MtkNeuronSettingsT &lhs, const MtkNeuronSettingsT &rhs);
bool operator!=(const MtkNeuronSettingsT &lhs, const MtkNeuronSettingsT &rhs);
bool operator==(const TFLiteSettingsT &lhs, const TFLiteSettingsT &rhs);
bool operator!=(const TFLiteSettingsT &lhs, const TFLiteSettingsT &rhs);
bool operator==(const FallbackSettingsT &lhs, const FallbackSettingsT &rhs);
bool operator!=(const FallbackSettingsT &lhs, const FallbackSettingsT &rhs);
bool operator==(const BenchmarkMetricT &lhs, const BenchmarkMetricT &rhs);
bool operator!=(const BenchmarkMetricT &lhs, const BenchmarkMetricT &rhs);
bool operator==(const BenchmarkResultT &lhs, const BenchmarkResultT &rhs);
bool operator!=(const BenchmarkResultT &lhs, const BenchmarkResultT &rhs);
namespace BenchmarkResult_ {

bool operator==(const InferenceOutputT &lhs, const InferenceOutputT &rhs);
bool operator!=(const InferenceOutputT &lhs, const InferenceOutputT &rhs);
}  // namespace BenchmarkResult_

bool operator==(const ErrorCodeT &lhs, const ErrorCodeT &rhs);
bool operator!=(const ErrorCodeT &lhs, const ErrorCodeT &rhs);
bool operator==(const BenchmarkErrorT &lhs, const BenchmarkErrorT &rhs);
bool operator!=(const BenchmarkErrorT &lhs, const BenchmarkErrorT &rhs);
bool operator==(const BenchmarkEventT &lhs, const BenchmarkEventT &rhs);
bool operator!=(const BenchmarkEventT &lhs, const BenchmarkEventT &rhs);
bool operator==(const BestAccelerationDecisionT &lhs, const BestAccelerationDecisionT &rhs);
bool operator!=(const BestAccelerationDecisionT &lhs, const BestAccelerationDecisionT &rhs);
bool operator==(const BenchmarkInitializationFailureT &lhs, const BenchmarkInitializationFailureT &rhs);
bool operator!=(const BenchmarkInitializationFailureT &lhs, const BenchmarkInitializationFailureT &rhs);
bool operator==(const MiniBenchmarkEventT &lhs, const MiniBenchmarkEventT &rhs);
bool operator!=(const MiniBenchmarkEventT &lhs, const MiniBenchmarkEventT &rhs);
bool operator==(const ModelFileT &lhs, const ModelFileT &rhs);
bool operator!=(const ModelFileT &lhs, const ModelFileT &rhs);
bool operator==(const ModelIdGroupT &lhs, const ModelIdGroupT &rhs);
bool operator!=(const ModelIdGroupT &lhs, const ModelIdGroupT &rhs);
bool operator==(const BenchmarkStoragePathsT &lhs, const BenchmarkStoragePathsT &rhs);
bool operator!=(const BenchmarkStoragePathsT &lhs, const BenchmarkStoragePathsT &rhs);
bool operator==(const ValidationSettingsT &lhs, const ValidationSettingsT &rhs);
bool operator!=(const ValidationSettingsT &lhs, const ValidationSettingsT &rhs);
bool operator==(const MinibenchmarkSettingsT &lhs, const MinibenchmarkSettingsT &rhs);
bool operator!=(const MinibenchmarkSettingsT &lhs, const MinibenchmarkSettingsT &rhs);
bool operator==(const BenchmarkEventStorageT &lhs, const BenchmarkEventStorageT &rhs);
bool operator!=(const BenchmarkEventStorageT &lhs, const BenchmarkEventStorageT &rhs);

enum ExecutionPreference : int32_t { … };

inline const ExecutionPreference (&EnumValuesExecutionPreference())[4] { … }

inline const char * const *EnumNamesExecutionPreference() { … }

inline const char *EnumNameExecutionPreference(ExecutionPreference e) { … }

enum Delegate : int32_t { … };

inline const Delegate (&EnumValuesDelegate())[10] { … }

inline const char * const *EnumNamesDelegate() { … }

inline const char *EnumNameDelegate(Delegate e) { … }

enum NNAPIExecutionPreference : int32_t { … };

inline const NNAPIExecutionPreference (&EnumValuesNNAPIExecutionPreference())[4] { … }

inline const char * const *EnumNamesNNAPIExecutionPreference() { … }

inline const char *EnumNameNNAPIExecutionPreference(NNAPIExecutionPreference e) { … }

enum NNAPIExecutionPriority : int32_t { … };

inline const NNAPIExecutionPriority (&EnumValuesNNAPIExecutionPriority())[4] { … }

inline const char * const *EnumNamesNNAPIExecutionPriority() { … }

inline const char *EnumNameNNAPIExecutionPriority(NNAPIExecutionPriority e) { … }

enum GPUBackend : int32_t { … };

inline const GPUBackend (&EnumValuesGPUBackend())[3] { … }

inline const char * const *EnumNamesGPUBackend() { … }

inline const char *EnumNameGPUBackend(GPUBackend e) { … }

enum GPUInferencePriority : int32_t { … };

inline const GPUInferencePriority (&EnumValuesGPUInferencePriority())[4] { … }

inline const char * const *EnumNamesGPUInferencePriority() { … }

inline const char *EnumNameGPUInferencePriority(GPUInferencePriority e) { … }

enum GPUInferenceUsage : int32_t { … };

inline const GPUInferenceUsage (&EnumValuesGPUInferenceUsage())[2] { … }

inline const char * const *EnumNamesGPUInferenceUsage() { … }

inline const char *EnumNameGPUInferenceUsage(GPUInferenceUsage e) { … }

enum XNNPackFlags : int32_t { … };

inline const XNNPackFlags (&EnumValuesXNNPackFlags())[10] { … }

inline const char * const *EnumNamesXNNPackFlags() { … }

inline const char *EnumNameXNNPackFlags(XNNPackFlags e) { … }

namespace CoreMLSettings_ {

enum EnabledDevices : int32_t { … };

inline const EnabledDevices (&EnumValuesEnabledDevices())[2] { … }

inline const char * const *EnumNamesEnabledDevices() { … }

inline const char *EnumNameEnabledDevices(EnabledDevices e) { … }

}  // namespace CoreMLSettings_

namespace EdgeTpuDeviceSpec_ {

enum PlatformType : int32_t { … };

inline const PlatformType (&EnumValuesPlatformType())[4] { … }

inline const char * const *EnumNamesPlatformType() { … }

inline const char *EnumNamePlatformType(PlatformType e) { … }

}  // namespace EdgeTpuDeviceSpec_

enum EdgeTpuPowerState : int32_t { … };

inline const EdgeTpuPowerState (&EnumValuesEdgeTpuPowerState())[8] { … }

inline const char * const *EnumNamesEdgeTpuPowerState() { … }

inline const char *EnumNameEdgeTpuPowerState(EdgeTpuPowerState e) { … }

namespace EdgeTpuSettings_ {

enum FloatTruncationType : int32_t { … };

inline const FloatTruncationType (&EnumValuesFloatTruncationType())[4] { … }

inline const char * const *EnumNamesFloatTruncationType() { … }

inline const char *EnumNameFloatTruncationType(FloatTruncationType e) { … }

enum QosClass : int32_t { … };

inline const QosClass (&EnumValuesQosClass())[3] { … }

inline const char * const *EnumNamesQosClass() { … }

inline const char *EnumNameQosClass(QosClass e) { … }

enum UseLayerIrTgcBackend : int32_t { … };

inline const UseLayerIrTgcBackend (&EnumValuesUseLayerIrTgcBackend())[4] { … }

inline const char * const *EnumNamesUseLayerIrTgcBackend() { … }

inline const char *EnumNameUseLayerIrTgcBackend(UseLayerIrTgcBackend e) { … }

}  // namespace EdgeTpuSettings_

namespace GoogleEdgeTpuSettings_ {

enum Priority : int32_t { … };

inline const Priority (&EnumValuesPriority())[4] { … }

inline const char * const *EnumNamesPriority() { … }

inline const char *EnumNamePriority(Priority e) { … }

enum TriState : int32_t { … };

inline const TriState (&EnumValuesTriState())[3] { … }

inline const char * const *EnumNamesTriState() { … }

inline const char *EnumNameTriState(TriState e) { … }

}  // namespace GoogleEdgeTpuSettings_

namespace CoralSettings_ {

enum Performance : int32_t { … };

inline const Performance (&EnumValuesPerformance())[5] { … }

inline const char * const *EnumNamesPerformance() { … }

inline const char *EnumNamePerformance(Performance e) { … }

}  // namespace CoralSettings_

namespace MtkNeuronSettings_ {

enum ExecutionPreference : int32_t { … };

inline const ExecutionPreference (&EnumValuesExecutionPreference())[5] { … }

inline const char * const *EnumNamesExecutionPreference() { … }

inline const char *EnumNameExecutionPreference(ExecutionPreference e) { … }

enum ExecutionPriority : int32_t { … };

inline const ExecutionPriority (&EnumValuesExecutionPriority())[4] { … }

inline const char *EnumNameExecutionPriority(ExecutionPriority e) { … }

enum OptimizationHint : int32_t { … };

inline const OptimizationHint (&EnumValuesOptimizationHint())[4] { … }

inline const char * const *EnumNamesOptimizationHint() { … }

inline const char *EnumNameOptimizationHint(OptimizationHint e) { … }

enum OperationCheckMode : int32_t { … };

inline const OperationCheckMode (&EnumValuesOperationCheckMode())[3] { … }

inline const char * const *EnumNamesOperationCheckMode() { … }

inline const char *EnumNameOperationCheckMode(OperationCheckMode e) { … }

}  // namespace MtkNeuronSettings_

enum BenchmarkEventType : int32_t { … };

inline const BenchmarkEventType (&EnumValuesBenchmarkEventType())[6] { … }

inline const char * const *EnumNamesBenchmarkEventType() { … }

inline const char *EnumNameBenchmarkEventType(BenchmarkEventType e) { … }

enum BenchmarkStage : int32_t { … };

inline const BenchmarkStage (&EnumValuesBenchmarkStage())[3] { … }

inline const char * const *EnumNamesBenchmarkStage() { … }

inline const char *EnumNameBenchmarkStage(BenchmarkStage e) { … }

struct ComputeSettingsT : public ::flatbuffers::NativeTable { … };

struct ComputeSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct ComputeSettingsBuilder { … };

inline ::flatbuffers::Offset<ComputeSettings> CreateComputeSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ExecutionPreference preference = tflite::ExecutionPreference_ANY,
    ::flatbuffers::Offset<tflite::TFLiteSettings> tflite_settings = 0,
    ::flatbuffers::Offset<::flatbuffers::String> model_namespace_for_statistics = 0,
    ::flatbuffers::Offset<::flatbuffers::String> model_identifier_for_statistics = 0,
    ::flatbuffers::Offset<tflite::MinibenchmarkSettings> settings_to_test_locally = 0) { … }

inline ::flatbuffers::Offset<ComputeSettings> CreateComputeSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ExecutionPreference preference = tflite::ExecutionPreference_ANY,
    ::flatbuffers::Offset<tflite::TFLiteSettings> tflite_settings = 0,
    const char *model_namespace_for_statistics = nullptr,
    const char *model_identifier_for_statistics = nullptr,
    ::flatbuffers::Offset<tflite::MinibenchmarkSettings> settings_to_test_locally = 0) { … }

::flatbuffers::Offset<ComputeSettings> CreateComputeSettings(::flatbuffers::FlatBufferBuilder &_fbb, const ComputeSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NNAPISettingsT : public ::flatbuffers::NativeTable { … };

struct NNAPISettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct NNAPISettingsBuilder { … };

inline ::flatbuffers::Offset<NNAPISettings> CreateNNAPISettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> accelerator_name = 0,
    ::flatbuffers::Offset<::flatbuffers::String> cache_directory = 0,
    ::flatbuffers::Offset<::flatbuffers::String> model_token = 0,
    tflite::NNAPIExecutionPreference execution_preference = tflite::NNAPIExecutionPreference_UNDEFINED,
    int32_t no_of_nnapi_instances_to_cache = 0,
    ::flatbuffers::Offset<tflite::FallbackSettings> fallback_settings = 0,
    bool allow_nnapi_cpu_on_android_10_plus = false,
    tflite::NNAPIExecutionPriority execution_priority = tflite::NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED,
    bool allow_dynamic_dimensions = false,
    bool allow_fp16_precision_for_fp32 = false,
    bool use_burst_computation = false,
    int64_t support_library_handle = 0) { … }

inline ::flatbuffers::Offset<NNAPISettings> CreateNNAPISettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *accelerator_name = nullptr,
    const char *cache_directory = nullptr,
    const char *model_token = nullptr,
    tflite::NNAPIExecutionPreference execution_preference = tflite::NNAPIExecutionPreference_UNDEFINED,
    int32_t no_of_nnapi_instances_to_cache = 0,
    ::flatbuffers::Offset<tflite::FallbackSettings> fallback_settings = 0,
    bool allow_nnapi_cpu_on_android_10_plus = false,
    tflite::NNAPIExecutionPriority execution_priority = tflite::NNAPIExecutionPriority_NNAPI_PRIORITY_UNDEFINED,
    bool allow_dynamic_dimensions = false,
    bool allow_fp16_precision_for_fp32 = false,
    bool use_burst_computation = false,
    int64_t support_library_handle = 0) { … }

::flatbuffers::Offset<NNAPISettings> CreateNNAPISettings(::flatbuffers::FlatBufferBuilder &_fbb, const NNAPISettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct GPUSettingsT : public ::flatbuffers::NativeTable { … };

struct GPUSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct GPUSettingsBuilder { … };

inline ::flatbuffers::Offset<GPUSettings> CreateGPUSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool is_precision_loss_allowed = false,
    bool enable_quantized_inference = true,
    tflite::GPUBackend force_backend = tflite::GPUBackend_UNSET,
    tflite::GPUInferencePriority inference_priority1 = tflite::GPUInferencePriority_GPU_PRIORITY_AUTO,
    tflite::GPUInferencePriority inference_priority2 = tflite::GPUInferencePriority_GPU_PRIORITY_AUTO,
    tflite::GPUInferencePriority inference_priority3 = tflite::GPUInferencePriority_GPU_PRIORITY_AUTO,
    tflite::GPUInferenceUsage inference_preference = tflite::GPUInferenceUsage_GPU_INFERENCE_PREFERENCE_FAST_SINGLE_ANSWER,
    ::flatbuffers::Offset<::flatbuffers::String> cache_directory = 0,
    ::flatbuffers::Offset<::flatbuffers::String> model_token = 0) { … }

inline ::flatbuffers::Offset<GPUSettings> CreateGPUSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool is_precision_loss_allowed = false,
    bool enable_quantized_inference = true,
    tflite::GPUBackend force_backend = tflite::GPUBackend_UNSET,
    tflite::GPUInferencePriority inference_priority1 = tflite::GPUInferencePriority_GPU_PRIORITY_AUTO,
    tflite::GPUInferencePriority inference_priority2 = tflite::GPUInferencePriority_GPU_PRIORITY_AUTO,
    tflite::GPUInferencePriority inference_priority3 = tflite::GPUInferencePriority_GPU_PRIORITY_AUTO,
    tflite::GPUInferenceUsage inference_preference = tflite::GPUInferenceUsage_GPU_INFERENCE_PREFERENCE_FAST_SINGLE_ANSWER,
    const char *cache_directory = nullptr,
    const char *model_token = nullptr) { … }

::flatbuffers::Offset<GPUSettings> CreateGPUSettings(::flatbuffers::FlatBufferBuilder &_fbb, const GPUSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct HexagonSettingsT : public ::flatbuffers::NativeTable { … };

struct HexagonSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct HexagonSettingsBuilder { … };

inline ::flatbuffers::Offset<HexagonSettings> CreateHexagonSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t debug_level = 0,
    int32_t powersave_level = 0,
    bool print_graph_profile = false,
    bool print_graph_debug = false) { … }

::flatbuffers::Offset<HexagonSettings> CreateHexagonSettings(::flatbuffers::FlatBufferBuilder &_fbb, const HexagonSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct XNNPackSettingsT : public ::flatbuffers::NativeTable { … };

struct XNNPackSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct XNNPackSettingsBuilder { … };

inline ::flatbuffers::Offset<XNNPackSettings> CreateXNNPackSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t num_threads = 0,
    tflite::XNNPackFlags flags = tflite::XNNPackFlags_TFLITE_XNNPACK_DELEGATE_NO_FLAGS,
    ::flatbuffers::Offset<::flatbuffers::String> weight_cache_file_path = 0) { … }

inline ::flatbuffers::Offset<XNNPackSettings> CreateXNNPackSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t num_threads = 0,
    tflite::XNNPackFlags flags = tflite::XNNPackFlags_TFLITE_XNNPACK_DELEGATE_NO_FLAGS,
    const char *weight_cache_file_path = nullptr) { … }

::flatbuffers::Offset<XNNPackSettings> CreateXNNPackSettings(::flatbuffers::FlatBufferBuilder &_fbb, const XNNPackSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct CoreMLSettingsT : public ::flatbuffers::NativeTable { … };

struct CoreMLSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct CoreMLSettingsBuilder { … };

inline ::flatbuffers::Offset<CoreMLSettings> CreateCoreMLSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::CoreMLSettings_::EnabledDevices enabled_devices = tflite::CoreMLSettings_::EnabledDevices_DEVICES_ALL,
    int32_t coreml_version = 0,
    int32_t max_delegated_partitions = 0,
    int32_t min_nodes_per_partition = 2) { … }

::flatbuffers::Offset<CoreMLSettings> CreateCoreMLSettings(::flatbuffers::FlatBufferBuilder &_fbb, const CoreMLSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct StableDelegateLoaderSettingsT : public ::flatbuffers::NativeTable { … };

struct StableDelegateLoaderSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct StableDelegateLoaderSettingsBuilder { … };

inline ::flatbuffers::Offset<StableDelegateLoaderSettings> CreateStableDelegateLoaderSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> delegate_path = 0,
    ::flatbuffers::Offset<::flatbuffers::String> delegate_name = 0) { … }

inline ::flatbuffers::Offset<StableDelegateLoaderSettings> CreateStableDelegateLoaderSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *delegate_path = nullptr,
    const char *delegate_name = nullptr) { … }

::flatbuffers::Offset<StableDelegateLoaderSettings> CreateStableDelegateLoaderSettings(::flatbuffers::FlatBufferBuilder &_fbb, const StableDelegateLoaderSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct CompilationCachingSettingsT : public ::flatbuffers::NativeTable { … };

struct CompilationCachingSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct CompilationCachingSettingsBuilder { … };

inline ::flatbuffers::Offset<CompilationCachingSettings> CreateCompilationCachingSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> cache_dir = 0,
    ::flatbuffers::Offset<::flatbuffers::String> model_token = 0) { … }

inline ::flatbuffers::Offset<CompilationCachingSettings> CreateCompilationCachingSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *cache_dir = nullptr,
    const char *model_token = nullptr) { … }

::flatbuffers::Offset<CompilationCachingSettings> CreateCompilationCachingSettings(::flatbuffers::FlatBufferBuilder &_fbb, const CompilationCachingSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct EdgeTpuDeviceSpecT : public ::flatbuffers::NativeTable { … };

struct EdgeTpuDeviceSpec FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct EdgeTpuDeviceSpecBuilder { … };

inline ::flatbuffers::Offset<EdgeTpuDeviceSpec> CreateEdgeTpuDeviceSpec(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::EdgeTpuDeviceSpec_::PlatformType platform_type = tflite::EdgeTpuDeviceSpec_::PlatformType_MMIO,
    int32_t num_chips = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> device_paths = 0,
    int32_t chip_family = 0) { … }

inline ::flatbuffers::Offset<EdgeTpuDeviceSpec> CreateEdgeTpuDeviceSpecDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::EdgeTpuDeviceSpec_::PlatformType platform_type = tflite::EdgeTpuDeviceSpec_::PlatformType_MMIO,
    int32_t num_chips = 0,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *device_paths = nullptr,
    int32_t chip_family = 0) { … }

::flatbuffers::Offset<EdgeTpuDeviceSpec> CreateEdgeTpuDeviceSpec(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuDeviceSpecT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct EdgeTpuInactivePowerConfigT : public ::flatbuffers::NativeTable { … };

struct EdgeTpuInactivePowerConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct EdgeTpuInactivePowerConfigBuilder { … };

inline ::flatbuffers::Offset<EdgeTpuInactivePowerConfig> CreateEdgeTpuInactivePowerConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::EdgeTpuPowerState inactive_power_state = tflite::EdgeTpuPowerState_UNDEFINED_POWERSTATE,
    int64_t inactive_timeout_us = 0) { … }

::flatbuffers::Offset<EdgeTpuInactivePowerConfig> CreateEdgeTpuInactivePowerConfig(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuInactivePowerConfigT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct EdgeTpuSettingsT : public ::flatbuffers::NativeTable { … };

struct EdgeTpuSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct EdgeTpuSettingsBuilder { … };

inline ::flatbuffers::Offset<EdgeTpuSettings> CreateEdgeTpuSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::EdgeTpuPowerState inference_power_state = tflite::EdgeTpuPowerState_UNDEFINED_POWERSTATE,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::EdgeTpuInactivePowerConfig>>> inactive_power_configs = 0,
    int32_t inference_priority = -1,
    ::flatbuffers::Offset<tflite::EdgeTpuDeviceSpec> edgetpu_device_spec = 0,
    ::flatbuffers::Offset<::flatbuffers::String> model_token = 0,
    tflite::EdgeTpuSettings_::FloatTruncationType float_truncation_type = tflite::EdgeTpuSettings_::FloatTruncationType_UNSPECIFIED,
    tflite::EdgeTpuSettings_::QosClass qos_class = tflite::EdgeTpuSettings_::QosClass_QOS_UNDEFINED,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> hardware_cluster_ids = 0,
    ::flatbuffers::Offset<::flatbuffers::String> public_model_id = 0,
    tflite::EdgeTpuSettings_::UseLayerIrTgcBackend use_layer_ir_tgc_backend = tflite::EdgeTpuSettings_::UseLayerIrTgcBackend_USE_LAYER_IR_TGC_BACKEND_UNSPECIFIED) { … }

inline ::flatbuffers::Offset<EdgeTpuSettings> CreateEdgeTpuSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::EdgeTpuPowerState inference_power_state = tflite::EdgeTpuPowerState_UNDEFINED_POWERSTATE,
    const std::vector<::flatbuffers::Offset<tflite::EdgeTpuInactivePowerConfig>> *inactive_power_configs = nullptr,
    int32_t inference_priority = -1,
    ::flatbuffers::Offset<tflite::EdgeTpuDeviceSpec> edgetpu_device_spec = 0,
    const char *model_token = nullptr,
    tflite::EdgeTpuSettings_::FloatTruncationType float_truncation_type = tflite::EdgeTpuSettings_::FloatTruncationType_UNSPECIFIED,
    tflite::EdgeTpuSettings_::QosClass qos_class = tflite::EdgeTpuSettings_::QosClass_QOS_UNDEFINED,
    const std::vector<int32_t> *hardware_cluster_ids = nullptr,
    const char *public_model_id = nullptr,
    tflite::EdgeTpuSettings_::UseLayerIrTgcBackend use_layer_ir_tgc_backend = tflite::EdgeTpuSettings_::UseLayerIrTgcBackend_USE_LAYER_IR_TGC_BACKEND_UNSPECIFIED) { … }

::flatbuffers::Offset<EdgeTpuSettings> CreateEdgeTpuSettings(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct GoogleEdgeTpuSettingsT : public ::flatbuffers::NativeTable { … };

struct GoogleEdgeTpuSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct GoogleEdgeTpuSettingsBuilder { … };

inline ::flatbuffers::Offset<GoogleEdgeTpuSettings> CreateGoogleEdgeTpuSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t log_verbosity = -1,
    bool enable_tracing = false,
    tflite::GoogleEdgeTpuSettings_::Priority priority = tflite::GoogleEdgeTpuSettings_::Priority_PRIORITY_UNDEFINED,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> extension_data = 0,
    ::flatbuffers::Offset<::flatbuffers::String> model_identifier = 0,
    bool use_async_api = false,
    bool delegate_should_manage_cache_for_inputs = true,
    bool delegate_should_manage_cache_for_outputs = true,
    tflite::GoogleEdgeTpuSettings_::TriState prefer_cache_coherency_for_inputs = tflite::GoogleEdgeTpuSettings_::TriState_TRISTATE_UNDEFINED,
    tflite::GoogleEdgeTpuSettings_::TriState prefer_cache_coherency_for_outputs = tflite::GoogleEdgeTpuSettings_::TriState_TRISTATE_UNDEFINED,
    bool allow_fp16_precision_for_fp32 = false) { … }

inline ::flatbuffers::Offset<GoogleEdgeTpuSettings> CreateGoogleEdgeTpuSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t log_verbosity = -1,
    bool enable_tracing = false,
    tflite::GoogleEdgeTpuSettings_::Priority priority = tflite::GoogleEdgeTpuSettings_::Priority_PRIORITY_UNDEFINED,
    const std::vector<uint8_t> *extension_data = nullptr,
    const char *model_identifier = nullptr,
    bool use_async_api = false,
    bool delegate_should_manage_cache_for_inputs = true,
    bool delegate_should_manage_cache_for_outputs = true,
    tflite::GoogleEdgeTpuSettings_::TriState prefer_cache_coherency_for_inputs = tflite::GoogleEdgeTpuSettings_::TriState_TRISTATE_UNDEFINED,
    tflite::GoogleEdgeTpuSettings_::TriState prefer_cache_coherency_for_outputs = tflite::GoogleEdgeTpuSettings_::TriState_TRISTATE_UNDEFINED,
    bool allow_fp16_precision_for_fp32 = false) { … }

::flatbuffers::Offset<GoogleEdgeTpuSettings> CreateGoogleEdgeTpuSettings(::flatbuffers::FlatBufferBuilder &_fbb, const GoogleEdgeTpuSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct CoralSettingsT : public ::flatbuffers::NativeTable { … };

struct CoralSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct CoralSettingsBuilder { … };

inline ::flatbuffers::Offset<CoralSettings> CreateCoralSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> device = 0,
    tflite::CoralSettings_::Performance performance = tflite::CoralSettings_::Performance_UNDEFINED,
    bool usb_always_dfu = false,
    int32_t usb_max_bulk_in_queue_length = 0) { … }

inline ::flatbuffers::Offset<CoralSettings> CreateCoralSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *device = nullptr,
    tflite::CoralSettings_::Performance performance = tflite::CoralSettings_::Performance_UNDEFINED,
    bool usb_always_dfu = false,
    int32_t usb_max_bulk_in_queue_length = 0) { … }

::flatbuffers::Offset<CoralSettings> CreateCoralSettings(::flatbuffers::FlatBufferBuilder &_fbb, const CoralSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct CPUSettingsT : public ::flatbuffers::NativeTable { … };

struct CPUSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct CPUSettingsBuilder { … };

inline ::flatbuffers::Offset<CPUSettings> CreateCPUSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t num_threads = -1) { … }

::flatbuffers::Offset<CPUSettings> CreateCPUSettings(::flatbuffers::FlatBufferBuilder &_fbb, const CPUSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ArmNNSettingsT : public ::flatbuffers::NativeTable { … };

struct ArmNNSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct ArmNNSettingsBuilder { … };

inline ::flatbuffers::Offset<ArmNNSettings> CreateArmNNSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> backends = 0,
    bool fastmath = false,
    ::flatbuffers::Offset<::flatbuffers::String> additional_parameters = 0) { … }

inline ::flatbuffers::Offset<ArmNNSettings> CreateArmNNSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *backends = nullptr,
    bool fastmath = false,
    const char *additional_parameters = nullptr) { … }

::flatbuffers::Offset<ArmNNSettings> CreateArmNNSettings(::flatbuffers::FlatBufferBuilder &_fbb, const ArmNNSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MtkNeuronSettingsT : public ::flatbuffers::NativeTable { … };

struct MtkNeuronSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct MtkNeuronSettingsBuilder { … };

inline ::flatbuffers::Offset<MtkNeuronSettings> CreateMtkNeuronSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::MtkNeuronSettings_::ExecutionPreference execution_preference = tflite::MtkNeuronSettings_::ExecutionPreference_PREFERENCE_UNDEFINED,
    tflite::MtkNeuronSettings_::ExecutionPriority execution_priority = tflite::MtkNeuronSettings_::ExecutionPriority_PRIORITY_UNDEFINED,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> optimization_hints = 0,
    tflite::MtkNeuronSettings_::OperationCheckMode operation_check_mode = tflite::MtkNeuronSettings_::OperationCheckMode_NO_OPERATION_CHECK,
    bool allow_fp16_precision_for_fp32 = false,
    bool use_ahwb = false,
    bool use_cacheable_buffer = true,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> compile_options = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> accelerator_names = 0,
    ::flatbuffers::Offset<::flatbuffers::String> neuron_config_path = 0) { … }

inline ::flatbuffers::Offset<MtkNeuronSettings> CreateMtkNeuronSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::MtkNeuronSettings_::ExecutionPreference execution_preference = tflite::MtkNeuronSettings_::ExecutionPreference_PREFERENCE_UNDEFINED,
    tflite::MtkNeuronSettings_::ExecutionPriority execution_priority = tflite::MtkNeuronSettings_::ExecutionPriority_PRIORITY_UNDEFINED,
    const std::vector<int32_t> *optimization_hints = nullptr,
    tflite::MtkNeuronSettings_::OperationCheckMode operation_check_mode = tflite::MtkNeuronSettings_::OperationCheckMode_NO_OPERATION_CHECK,
    bool allow_fp16_precision_for_fp32 = false,
    bool use_ahwb = false,
    bool use_cacheable_buffer = true,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *compile_options = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *accelerator_names = nullptr,
    const char *neuron_config_path = nullptr) { … }

::flatbuffers::Offset<MtkNeuronSettings> CreateMtkNeuronSettings(::flatbuffers::FlatBufferBuilder &_fbb, const MtkNeuronSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct TFLiteSettingsT : public ::flatbuffers::NativeTable { … };

struct TFLiteSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct TFLiteSettingsBuilder { … };

inline ::flatbuffers::Offset<TFLiteSettings> CreateTFLiteSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::Delegate delegate = tflite::Delegate_NONE,
    ::flatbuffers::Offset<tflite::NNAPISettings> nnapi_settings = 0,
    ::flatbuffers::Offset<tflite::GPUSettings> gpu_settings = 0,
    ::flatbuffers::Offset<tflite::HexagonSettings> hexagon_settings = 0,
    ::flatbuffers::Offset<tflite::XNNPackSettings> xnnpack_settings = 0,
    ::flatbuffers::Offset<tflite::CoreMLSettings> coreml_settings = 0,
    ::flatbuffers::Offset<tflite::CPUSettings> cpu_settings = 0,
    int32_t max_delegated_partitions = 0,
    ::flatbuffers::Offset<tflite::EdgeTpuSettings> edgetpu_settings = 0,
    ::flatbuffers::Offset<tflite::CoralSettings> coral_settings = 0,
    ::flatbuffers::Offset<tflite::FallbackSettings> fallback_settings = 0,
    bool disable_default_delegates = false,
    ::flatbuffers::Offset<tflite::StableDelegateLoaderSettings> stable_delegate_loader_settings = 0,
    ::flatbuffers::Offset<tflite::GoogleEdgeTpuSettings> google_edgetpu_settings = 0,
    ::flatbuffers::Offset<tflite::CompilationCachingSettings> compilation_caching_settings = 0,
    ::flatbuffers::Offset<tflite::ArmNNSettings> armnn_settings = 0,
    ::flatbuffers::Offset<tflite::MtkNeuronSettings> mtk_neuron_settings = 0) { … }

::flatbuffers::Offset<TFLiteSettings> CreateTFLiteSettings(::flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct FallbackSettingsT : public ::flatbuffers::NativeTable { … };

struct FallbackSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct FallbackSettingsBuilder { … };

inline ::flatbuffers::Offset<FallbackSettings> CreateFallbackSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool allow_automatic_fallback_on_compilation_error = false,
    bool allow_automatic_fallback_on_execution_error = false) { … }

::flatbuffers::Offset<FallbackSettings> CreateFallbackSettings(::flatbuffers::FlatBufferBuilder &_fbb, const FallbackSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BenchmarkMetricT : public ::flatbuffers::NativeTable { … };

struct BenchmarkMetric FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct BenchmarkMetricBuilder { … };

inline ::flatbuffers::Offset<BenchmarkMetric> CreateBenchmarkMetric(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<float>> values = 0) { … }

inline ::flatbuffers::Offset<BenchmarkMetric> CreateBenchmarkMetricDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    const std::vector<float> *values = nullptr) { … }

::flatbuffers::Offset<BenchmarkMetric> CreateBenchmarkMetric(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkMetricT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BenchmarkResultT : public ::flatbuffers::NativeTable { … };

struct BenchmarkResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct BenchmarkResultBuilder { … };

inline ::flatbuffers::Offset<BenchmarkResult> CreateBenchmarkResult(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> initialization_time_us = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> inference_time_us = 0,
    int32_t max_memory_kb = 0,
    bool ok = false,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::BenchmarkMetric>>> metrics = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>>> actual_output = 0) { … }

inline ::flatbuffers::Offset<BenchmarkResult> CreateBenchmarkResultDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *initialization_time_us = nullptr,
    const std::vector<int64_t> *inference_time_us = nullptr,
    int32_t max_memory_kb = 0,
    bool ok = false,
    const std::vector<::flatbuffers::Offset<tflite::BenchmarkMetric>> *metrics = nullptr,
    const std::vector<::flatbuffers::Offset<tflite::BenchmarkResult_::InferenceOutput>> *actual_output = nullptr) { … }

::flatbuffers::Offset<BenchmarkResult> CreateBenchmarkResult(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkResultT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

namespace BenchmarkResult_ {

struct InferenceOutputT : public ::flatbuffers::NativeTable { … };

struct InferenceOutput FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct InferenceOutputBuilder { … };

inline ::flatbuffers::Offset<InferenceOutput> CreateInferenceOutput(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> value = 0) { … }

inline ::flatbuffers::Offset<InferenceOutput> CreateInferenceOutputDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *value = nullptr) { … }

::flatbuffers::Offset<InferenceOutput> CreateInferenceOutput(::flatbuffers::FlatBufferBuilder &_fbb, const InferenceOutputT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

}  // namespace BenchmarkResult_

struct ErrorCodeT : public ::flatbuffers::NativeTable { … };

struct ErrorCode FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct ErrorCodeBuilder { … };

inline ::flatbuffers::Offset<ErrorCode> CreateErrorCode(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::Delegate source = tflite::Delegate_NONE,
    int32_t tflite_error = 0,
    int64_t underlying_api_error = 0) { … }

::flatbuffers::Offset<ErrorCode> CreateErrorCode(::flatbuffers::FlatBufferBuilder &_fbb, const ErrorCodeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BenchmarkErrorT : public ::flatbuffers::NativeTable { … };

struct BenchmarkError FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct BenchmarkErrorBuilder { … };

inline ::flatbuffers::Offset<BenchmarkError> CreateBenchmarkError(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::BenchmarkStage stage = tflite::BenchmarkStage_UNKNOWN,
    int32_t exit_code = 0,
    int32_t signal = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::ErrorCode>>> error_code = 0,
    int32_t mini_benchmark_error_code = 0) { … }

inline ::flatbuffers::Offset<BenchmarkError> CreateBenchmarkErrorDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::BenchmarkStage stage = tflite::BenchmarkStage_UNKNOWN,
    int32_t exit_code = 0,
    int32_t signal = 0,
    const std::vector<::flatbuffers::Offset<tflite::ErrorCode>> *error_code = nullptr,
    int32_t mini_benchmark_error_code = 0) { … }

::flatbuffers::Offset<BenchmarkError> CreateBenchmarkError(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkErrorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BenchmarkEventT : public ::flatbuffers::NativeTable { … };

struct BenchmarkEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct BenchmarkEventBuilder { … };

inline ::flatbuffers::Offset<BenchmarkEvent> CreateBenchmarkEvent(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tflite::TFLiteSettings> tflite_settings = 0,
    tflite::BenchmarkEventType event_type = tflite::BenchmarkEventType_UNDEFINED_BENCHMARK_EVENT_TYPE,
    ::flatbuffers::Offset<tflite::BenchmarkResult> result = 0,
    ::flatbuffers::Offset<tflite::BenchmarkError> error = 0,
    int64_t boottime_us = 0,
    int64_t wallclock_us = 0) { … }

::flatbuffers::Offset<BenchmarkEvent> CreateBenchmarkEvent(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BestAccelerationDecisionT : public ::flatbuffers::NativeTable { … };

struct BestAccelerationDecision FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct BestAccelerationDecisionBuilder { … };

inline ::flatbuffers::Offset<BestAccelerationDecision> CreateBestAccelerationDecision(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t number_of_source_events = 0,
    ::flatbuffers::Offset<tflite::BenchmarkEvent> min_latency_event = 0,
    int64_t min_inference_time_us = 0) { … }

::flatbuffers::Offset<BestAccelerationDecision> CreateBestAccelerationDecision(::flatbuffers::FlatBufferBuilder &_fbb, const BestAccelerationDecisionT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BenchmarkInitializationFailureT : public ::flatbuffers::NativeTable { … };

struct BenchmarkInitializationFailure FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct BenchmarkInitializationFailureBuilder { … };

inline ::flatbuffers::Offset<BenchmarkInitializationFailure> CreateBenchmarkInitializationFailure(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t initialization_status = 0) { … }

::flatbuffers::Offset<BenchmarkInitializationFailure> CreateBenchmarkInitializationFailure(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkInitializationFailureT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MiniBenchmarkEventT : public ::flatbuffers::NativeTable { … };

struct MiniBenchmarkEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct MiniBenchmarkEventBuilder { … };

inline ::flatbuffers::Offset<MiniBenchmarkEvent> CreateMiniBenchmarkEvent(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool is_log_flushing_event = false,
    ::flatbuffers::Offset<tflite::BestAccelerationDecision> best_acceleration_decision = 0,
    ::flatbuffers::Offset<tflite::BenchmarkInitializationFailure> initialization_failure = 0,
    ::flatbuffers::Offset<tflite::BenchmarkEvent> benchmark_event = 0) { … }

::flatbuffers::Offset<MiniBenchmarkEvent> CreateMiniBenchmarkEvent(::flatbuffers::FlatBufferBuilder &_fbb, const MiniBenchmarkEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ModelFileT : public ::flatbuffers::NativeTable { … };

struct ModelFile FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct ModelFileBuilder { … };

inline ::flatbuffers::Offset<ModelFile> CreateModelFile(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> filename = 0,
    int64_t fd = 0,
    int64_t offset = 0,
    int64_t length = 0,
    ::flatbuffers::Offset<tflite::ModelIdGroup> model_id_group = 0,
    int64_t buffer_handle = 0) { … }

inline ::flatbuffers::Offset<ModelFile> CreateModelFileDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *filename = nullptr,
    int64_t fd = 0,
    int64_t offset = 0,
    int64_t length = 0,
    ::flatbuffers::Offset<tflite::ModelIdGroup> model_id_group = 0,
    int64_t buffer_handle = 0) { … }

::flatbuffers::Offset<ModelFile> CreateModelFile(::flatbuffers::FlatBufferBuilder &_fbb, const ModelFileT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ModelIdGroupT : public ::flatbuffers::NativeTable { … };

struct ModelIdGroup FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct ModelIdGroupBuilder { … };

inline ::flatbuffers::Offset<ModelIdGroup> CreateModelIdGroup(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> model_namespace = 0,
    ::flatbuffers::Offset<::flatbuffers::String> model_id = 0) { … }

inline ::flatbuffers::Offset<ModelIdGroup> CreateModelIdGroupDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *model_namespace = nullptr,
    const char *model_id = nullptr) { … }

::flatbuffers::Offset<ModelIdGroup> CreateModelIdGroup(::flatbuffers::FlatBufferBuilder &_fbb, const ModelIdGroupT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BenchmarkStoragePathsT : public ::flatbuffers::NativeTable { … };

struct BenchmarkStoragePaths FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct BenchmarkStoragePathsBuilder { … };

inline ::flatbuffers::Offset<BenchmarkStoragePaths> CreateBenchmarkStoragePaths(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> storage_file_path = 0,
    ::flatbuffers::Offset<::flatbuffers::String> data_directory_path = 0) { … }

inline ::flatbuffers::Offset<BenchmarkStoragePaths> CreateBenchmarkStoragePathsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *storage_file_path = nullptr,
    const char *data_directory_path = nullptr) { … }

::flatbuffers::Offset<BenchmarkStoragePaths> CreateBenchmarkStoragePaths(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkStoragePathsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ValidationSettingsT : public ::flatbuffers::NativeTable { … };

struct ValidationSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct ValidationSettingsBuilder { … };

inline ::flatbuffers::Offset<ValidationSettings> CreateValidationSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int64_t per_test_timeout_ms = 0) { … }

::flatbuffers::Offset<ValidationSettings> CreateValidationSettings(::flatbuffers::FlatBufferBuilder &_fbb, const ValidationSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MinibenchmarkSettingsT : public ::flatbuffers::NativeTable { … };

struct MinibenchmarkSettings FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct MinibenchmarkSettingsBuilder { … };

inline ::flatbuffers::Offset<MinibenchmarkSettings> CreateMinibenchmarkSettings(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TFLiteSettings>>> settings_to_test = 0,
    ::flatbuffers::Offset<tflite::ModelFile> model_file = 0,
    ::flatbuffers::Offset<tflite::BenchmarkStoragePaths> storage_paths = 0,
    ::flatbuffers::Offset<tflite::ValidationSettings> validation_settings = 0) { … }

inline ::flatbuffers::Offset<MinibenchmarkSettings> CreateMinibenchmarkSettingsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tflite::TFLiteSettings>> *settings_to_test = nullptr,
    ::flatbuffers::Offset<tflite::ModelFile> model_file = 0,
    ::flatbuffers::Offset<tflite::BenchmarkStoragePaths> storage_paths = 0,
    ::flatbuffers::Offset<tflite::ValidationSettings> validation_settings = 0) { … }

::flatbuffers::Offset<MinibenchmarkSettings> CreateMinibenchmarkSettings(::flatbuffers::FlatBufferBuilder &_fbb, const MinibenchmarkSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BenchmarkEventStorageT : public ::flatbuffers::NativeTable { … };

struct BenchmarkEventStorage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct BenchmarkEventStorageBuilder { … };

inline ::flatbuffers::Offset<BenchmarkEventStorage> CreateBenchmarkEventStorage(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tflite::ModelIdGroup> model_id_group = 0,
    ::flatbuffers::Offset<tflite::BenchmarkEvent> benchmark_event = 0) { … }

::flatbuffers::Offset<BenchmarkEventStorage> CreateBenchmarkEventStorage(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkEventStorageT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);


inline bool operator==(const ComputeSettingsT &lhs, const ComputeSettingsT &rhs) { … }

inline bool operator!=(const ComputeSettingsT &lhs, const ComputeSettingsT &rhs) { … }


inline ComputeSettingsT::ComputeSettingsT(const ComputeSettingsT &o)
      : … { … }

inline ComputeSettingsT &ComputeSettingsT::operator=(ComputeSettingsT o) FLATBUFFERS_NOEXCEPT { … }

inline ComputeSettingsT *ComputeSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void ComputeSettings::UnPackTo(ComputeSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<ComputeSettings> ComputeSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ComputeSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<ComputeSettings> CreateComputeSettings(::flatbuffers::FlatBufferBuilder &_fbb, const ComputeSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const NNAPISettingsT &lhs, const NNAPISettingsT &rhs) { … }

inline bool operator!=(const NNAPISettingsT &lhs, const NNAPISettingsT &rhs) { … }


inline NNAPISettingsT::NNAPISettingsT(const NNAPISettingsT &o)
      : … { … }

inline NNAPISettingsT &NNAPISettingsT::operator=(NNAPISettingsT o) FLATBUFFERS_NOEXCEPT { … }

inline NNAPISettingsT *NNAPISettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void NNAPISettings::UnPackTo(NNAPISettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<NNAPISettings> NNAPISettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NNAPISettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<NNAPISettings> CreateNNAPISettings(::flatbuffers::FlatBufferBuilder &_fbb, const NNAPISettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const GPUSettingsT &lhs, const GPUSettingsT &rhs) { … }

inline bool operator!=(const GPUSettingsT &lhs, const GPUSettingsT &rhs) { … }


inline GPUSettingsT *GPUSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void GPUSettings::UnPackTo(GPUSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<GPUSettings> GPUSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GPUSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<GPUSettings> CreateGPUSettings(::flatbuffers::FlatBufferBuilder &_fbb, const GPUSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const HexagonSettingsT &lhs, const HexagonSettingsT &rhs) { … }

inline bool operator!=(const HexagonSettingsT &lhs, const HexagonSettingsT &rhs) { … }


inline HexagonSettingsT *HexagonSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void HexagonSettings::UnPackTo(HexagonSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<HexagonSettings> HexagonSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HexagonSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<HexagonSettings> CreateHexagonSettings(::flatbuffers::FlatBufferBuilder &_fbb, const HexagonSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const XNNPackSettingsT &lhs, const XNNPackSettingsT &rhs) { … }

inline bool operator!=(const XNNPackSettingsT &lhs, const XNNPackSettingsT &rhs) { … }


inline XNNPackSettingsT *XNNPackSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void XNNPackSettings::UnPackTo(XNNPackSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<XNNPackSettings> XNNPackSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const XNNPackSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<XNNPackSettings> CreateXNNPackSettings(::flatbuffers::FlatBufferBuilder &_fbb, const XNNPackSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const CoreMLSettingsT &lhs, const CoreMLSettingsT &rhs) { … }

inline bool operator!=(const CoreMLSettingsT &lhs, const CoreMLSettingsT &rhs) { … }


inline CoreMLSettingsT *CoreMLSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void CoreMLSettings::UnPackTo(CoreMLSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<CoreMLSettings> CoreMLSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CoreMLSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<CoreMLSettings> CreateCoreMLSettings(::flatbuffers::FlatBufferBuilder &_fbb, const CoreMLSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const StableDelegateLoaderSettingsT &lhs, const StableDelegateLoaderSettingsT &rhs) { … }

inline bool operator!=(const StableDelegateLoaderSettingsT &lhs, const StableDelegateLoaderSettingsT &rhs) { … }


inline StableDelegateLoaderSettingsT *StableDelegateLoaderSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void StableDelegateLoaderSettings::UnPackTo(StableDelegateLoaderSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<StableDelegateLoaderSettings> StableDelegateLoaderSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StableDelegateLoaderSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<StableDelegateLoaderSettings> CreateStableDelegateLoaderSettings(::flatbuffers::FlatBufferBuilder &_fbb, const StableDelegateLoaderSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const CompilationCachingSettingsT &lhs, const CompilationCachingSettingsT &rhs) { … }

inline bool operator!=(const CompilationCachingSettingsT &lhs, const CompilationCachingSettingsT &rhs) { … }


inline CompilationCachingSettingsT *CompilationCachingSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void CompilationCachingSettings::UnPackTo(CompilationCachingSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<CompilationCachingSettings> CompilationCachingSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CompilationCachingSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<CompilationCachingSettings> CreateCompilationCachingSettings(::flatbuffers::FlatBufferBuilder &_fbb, const CompilationCachingSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const EdgeTpuDeviceSpecT &lhs, const EdgeTpuDeviceSpecT &rhs) { … }

inline bool operator!=(const EdgeTpuDeviceSpecT &lhs, const EdgeTpuDeviceSpecT &rhs) { … }


inline EdgeTpuDeviceSpecT *EdgeTpuDeviceSpec::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void EdgeTpuDeviceSpec::UnPackTo(EdgeTpuDeviceSpecT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<EdgeTpuDeviceSpec> EdgeTpuDeviceSpec::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuDeviceSpecT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<EdgeTpuDeviceSpec> CreateEdgeTpuDeviceSpec(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuDeviceSpecT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const EdgeTpuInactivePowerConfigT &lhs, const EdgeTpuInactivePowerConfigT &rhs) { … }

inline bool operator!=(const EdgeTpuInactivePowerConfigT &lhs, const EdgeTpuInactivePowerConfigT &rhs) { … }


inline EdgeTpuInactivePowerConfigT *EdgeTpuInactivePowerConfig::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void EdgeTpuInactivePowerConfig::UnPackTo(EdgeTpuInactivePowerConfigT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<EdgeTpuInactivePowerConfig> EdgeTpuInactivePowerConfig::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuInactivePowerConfigT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<EdgeTpuInactivePowerConfig> CreateEdgeTpuInactivePowerConfig(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuInactivePowerConfigT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const EdgeTpuSettingsT &lhs, const EdgeTpuSettingsT &rhs) { … }

inline bool operator!=(const EdgeTpuSettingsT &lhs, const EdgeTpuSettingsT &rhs) { … }


inline EdgeTpuSettingsT::EdgeTpuSettingsT(const EdgeTpuSettingsT &o)
      : … { … }

inline EdgeTpuSettingsT &EdgeTpuSettingsT::operator=(EdgeTpuSettingsT o) FLATBUFFERS_NOEXCEPT { … }

inline EdgeTpuSettingsT *EdgeTpuSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void EdgeTpuSettings::UnPackTo(EdgeTpuSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<EdgeTpuSettings> EdgeTpuSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<EdgeTpuSettings> CreateEdgeTpuSettings(::flatbuffers::FlatBufferBuilder &_fbb, const EdgeTpuSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const GoogleEdgeTpuSettingsT &lhs, const GoogleEdgeTpuSettingsT &rhs) { … }

inline bool operator!=(const GoogleEdgeTpuSettingsT &lhs, const GoogleEdgeTpuSettingsT &rhs) { … }


inline GoogleEdgeTpuSettingsT *GoogleEdgeTpuSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void GoogleEdgeTpuSettings::UnPackTo(GoogleEdgeTpuSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<GoogleEdgeTpuSettings> GoogleEdgeTpuSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GoogleEdgeTpuSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<GoogleEdgeTpuSettings> CreateGoogleEdgeTpuSettings(::flatbuffers::FlatBufferBuilder &_fbb, const GoogleEdgeTpuSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const CoralSettingsT &lhs, const CoralSettingsT &rhs) { … }

inline bool operator!=(const CoralSettingsT &lhs, const CoralSettingsT &rhs) { … }


inline CoralSettingsT *CoralSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void CoralSettings::UnPackTo(CoralSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<CoralSettings> CoralSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CoralSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<CoralSettings> CreateCoralSettings(::flatbuffers::FlatBufferBuilder &_fbb, const CoralSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const CPUSettingsT &lhs, const CPUSettingsT &rhs) { … }

inline bool operator!=(const CPUSettingsT &lhs, const CPUSettingsT &rhs) { … }


inline CPUSettingsT *CPUSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void CPUSettings::UnPackTo(CPUSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<CPUSettings> CPUSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CPUSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<CPUSettings> CreateCPUSettings(::flatbuffers::FlatBufferBuilder &_fbb, const CPUSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const ArmNNSettingsT &lhs, const ArmNNSettingsT &rhs) { … }

inline bool operator!=(const ArmNNSettingsT &lhs, const ArmNNSettingsT &rhs) { … }


inline ArmNNSettingsT *ArmNNSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void ArmNNSettings::UnPackTo(ArmNNSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<ArmNNSettings> ArmNNSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArmNNSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<ArmNNSettings> CreateArmNNSettings(::flatbuffers::FlatBufferBuilder &_fbb, const ArmNNSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const MtkNeuronSettingsT &lhs, const MtkNeuronSettingsT &rhs) { … }

inline bool operator!=(const MtkNeuronSettingsT &lhs, const MtkNeuronSettingsT &rhs) { … }


inline MtkNeuronSettingsT *MtkNeuronSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void MtkNeuronSettings::UnPackTo(MtkNeuronSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<MtkNeuronSettings> MtkNeuronSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MtkNeuronSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<MtkNeuronSettings> CreateMtkNeuronSettings(::flatbuffers::FlatBufferBuilder &_fbb, const MtkNeuronSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const TFLiteSettingsT &lhs, const TFLiteSettingsT &rhs) { … }

inline bool operator!=(const TFLiteSettingsT &lhs, const TFLiteSettingsT &rhs) { … }


inline TFLiteSettingsT::TFLiteSettingsT(const TFLiteSettingsT &o)
      : … { … }

inline TFLiteSettingsT &TFLiteSettingsT::operator=(TFLiteSettingsT o) FLATBUFFERS_NOEXCEPT { … }

inline TFLiteSettingsT *TFLiteSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void TFLiteSettings::UnPackTo(TFLiteSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<TFLiteSettings> TFLiteSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<TFLiteSettings> CreateTFLiteSettings(::flatbuffers::FlatBufferBuilder &_fbb, const TFLiteSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const FallbackSettingsT &lhs, const FallbackSettingsT &rhs) { … }

inline bool operator!=(const FallbackSettingsT &lhs, const FallbackSettingsT &rhs) { … }


inline FallbackSettingsT *FallbackSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void FallbackSettings::UnPackTo(FallbackSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<FallbackSettings> FallbackSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FallbackSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<FallbackSettings> CreateFallbackSettings(::flatbuffers::FlatBufferBuilder &_fbb, const FallbackSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const BenchmarkMetricT &lhs, const BenchmarkMetricT &rhs) { … }

inline bool operator!=(const BenchmarkMetricT &lhs, const BenchmarkMetricT &rhs) { … }


inline BenchmarkMetricT *BenchmarkMetric::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void BenchmarkMetric::UnPackTo(BenchmarkMetricT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<BenchmarkMetric> BenchmarkMetric::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkMetricT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<BenchmarkMetric> CreateBenchmarkMetric(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkMetricT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const BenchmarkResultT &lhs, const BenchmarkResultT &rhs) { … }

inline bool operator!=(const BenchmarkResultT &lhs, const BenchmarkResultT &rhs) { … }


inline BenchmarkResultT::BenchmarkResultT(const BenchmarkResultT &o)
      : … { … }

inline BenchmarkResultT &BenchmarkResultT::operator=(BenchmarkResultT o) FLATBUFFERS_NOEXCEPT { … }

inline BenchmarkResultT *BenchmarkResult::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void BenchmarkResult::UnPackTo(BenchmarkResultT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<BenchmarkResult> BenchmarkResult::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkResultT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<BenchmarkResult> CreateBenchmarkResult(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkResultT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

namespace BenchmarkResult_ {


inline bool operator==(const InferenceOutputT &lhs, const InferenceOutputT &rhs) { … }

inline bool operator!=(const InferenceOutputT &lhs, const InferenceOutputT &rhs) { … }


inline InferenceOutputT *InferenceOutput::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void InferenceOutput::UnPackTo(InferenceOutputT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<InferenceOutput> InferenceOutput::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InferenceOutputT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<InferenceOutput> CreateInferenceOutput(::flatbuffers::FlatBufferBuilder &_fbb, const InferenceOutputT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

}  // namespace BenchmarkResult_


inline bool operator==(const ErrorCodeT &lhs, const ErrorCodeT &rhs) { … }

inline bool operator!=(const ErrorCodeT &lhs, const ErrorCodeT &rhs) { … }


inline ErrorCodeT *ErrorCode::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void ErrorCode::UnPackTo(ErrorCodeT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<ErrorCode> ErrorCode::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ErrorCodeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<ErrorCode> CreateErrorCode(::flatbuffers::FlatBufferBuilder &_fbb, const ErrorCodeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const BenchmarkErrorT &lhs, const BenchmarkErrorT &rhs) { … }

inline bool operator!=(const BenchmarkErrorT &lhs, const BenchmarkErrorT &rhs) { … }


inline BenchmarkErrorT::BenchmarkErrorT(const BenchmarkErrorT &o)
      : … { … }

inline BenchmarkErrorT &BenchmarkErrorT::operator=(BenchmarkErrorT o) FLATBUFFERS_NOEXCEPT { … }

inline BenchmarkErrorT *BenchmarkError::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void BenchmarkError::UnPackTo(BenchmarkErrorT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<BenchmarkError> BenchmarkError::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkErrorT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<BenchmarkError> CreateBenchmarkError(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkErrorT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const BenchmarkEventT &lhs, const BenchmarkEventT &rhs) { … }

inline bool operator!=(const BenchmarkEventT &lhs, const BenchmarkEventT &rhs) { … }


inline BenchmarkEventT::BenchmarkEventT(const BenchmarkEventT &o)
      : … { … }

inline BenchmarkEventT &BenchmarkEventT::operator=(BenchmarkEventT o) FLATBUFFERS_NOEXCEPT { … }

inline BenchmarkEventT *BenchmarkEvent::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void BenchmarkEvent::UnPackTo(BenchmarkEventT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<BenchmarkEvent> BenchmarkEvent::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkEventT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<BenchmarkEvent> CreateBenchmarkEvent(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const BestAccelerationDecisionT &lhs, const BestAccelerationDecisionT &rhs) { … }

inline bool operator!=(const BestAccelerationDecisionT &lhs, const BestAccelerationDecisionT &rhs) { … }


inline BestAccelerationDecisionT::BestAccelerationDecisionT(const BestAccelerationDecisionT &o)
      : … { … }

inline BestAccelerationDecisionT &BestAccelerationDecisionT::operator=(BestAccelerationDecisionT o) FLATBUFFERS_NOEXCEPT { … }

inline BestAccelerationDecisionT *BestAccelerationDecision::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void BestAccelerationDecision::UnPackTo(BestAccelerationDecisionT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<BestAccelerationDecision> BestAccelerationDecision::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BestAccelerationDecisionT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<BestAccelerationDecision> CreateBestAccelerationDecision(::flatbuffers::FlatBufferBuilder &_fbb, const BestAccelerationDecisionT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const BenchmarkInitializationFailureT &lhs, const BenchmarkInitializationFailureT &rhs) { … }

inline bool operator!=(const BenchmarkInitializationFailureT &lhs, const BenchmarkInitializationFailureT &rhs) { … }


inline BenchmarkInitializationFailureT *BenchmarkInitializationFailure::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void BenchmarkInitializationFailure::UnPackTo(BenchmarkInitializationFailureT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<BenchmarkInitializationFailure> BenchmarkInitializationFailure::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkInitializationFailureT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<BenchmarkInitializationFailure> CreateBenchmarkInitializationFailure(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkInitializationFailureT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const MiniBenchmarkEventT &lhs, const MiniBenchmarkEventT &rhs) { … }

inline bool operator!=(const MiniBenchmarkEventT &lhs, const MiniBenchmarkEventT &rhs) { … }


inline MiniBenchmarkEventT::MiniBenchmarkEventT(const MiniBenchmarkEventT &o)
      : … { … }

inline MiniBenchmarkEventT &MiniBenchmarkEventT::operator=(MiniBenchmarkEventT o) FLATBUFFERS_NOEXCEPT { … }

inline MiniBenchmarkEventT *MiniBenchmarkEvent::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void MiniBenchmarkEvent::UnPackTo(MiniBenchmarkEventT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<MiniBenchmarkEvent> MiniBenchmarkEvent::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MiniBenchmarkEventT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<MiniBenchmarkEvent> CreateMiniBenchmarkEvent(::flatbuffers::FlatBufferBuilder &_fbb, const MiniBenchmarkEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const ModelFileT &lhs, const ModelFileT &rhs) { … }

inline bool operator!=(const ModelFileT &lhs, const ModelFileT &rhs) { … }


inline ModelFileT::ModelFileT(const ModelFileT &o)
      : … { … }

inline ModelFileT &ModelFileT::operator=(ModelFileT o) FLATBUFFERS_NOEXCEPT { … }

inline ModelFileT *ModelFile::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void ModelFile::UnPackTo(ModelFileT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<ModelFile> ModelFile::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ModelFileT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<ModelFile> CreateModelFile(::flatbuffers::FlatBufferBuilder &_fbb, const ModelFileT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const ModelIdGroupT &lhs, const ModelIdGroupT &rhs) { … }

inline bool operator!=(const ModelIdGroupT &lhs, const ModelIdGroupT &rhs) { … }


inline ModelIdGroupT *ModelIdGroup::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void ModelIdGroup::UnPackTo(ModelIdGroupT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<ModelIdGroup> ModelIdGroup::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ModelIdGroupT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<ModelIdGroup> CreateModelIdGroup(::flatbuffers::FlatBufferBuilder &_fbb, const ModelIdGroupT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const BenchmarkStoragePathsT &lhs, const BenchmarkStoragePathsT &rhs) { … }

inline bool operator!=(const BenchmarkStoragePathsT &lhs, const BenchmarkStoragePathsT &rhs) { … }


inline BenchmarkStoragePathsT *BenchmarkStoragePaths::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void BenchmarkStoragePaths::UnPackTo(BenchmarkStoragePathsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<BenchmarkStoragePaths> BenchmarkStoragePaths::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkStoragePathsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<BenchmarkStoragePaths> CreateBenchmarkStoragePaths(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkStoragePathsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const ValidationSettingsT &lhs, const ValidationSettingsT &rhs) { … }

inline bool operator!=(const ValidationSettingsT &lhs, const ValidationSettingsT &rhs) { … }


inline ValidationSettingsT *ValidationSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void ValidationSettings::UnPackTo(ValidationSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<ValidationSettings> ValidationSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ValidationSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<ValidationSettings> CreateValidationSettings(::flatbuffers::FlatBufferBuilder &_fbb, const ValidationSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const MinibenchmarkSettingsT &lhs, const MinibenchmarkSettingsT &rhs) { … }

inline bool operator!=(const MinibenchmarkSettingsT &lhs, const MinibenchmarkSettingsT &rhs) { … }


inline MinibenchmarkSettingsT::MinibenchmarkSettingsT(const MinibenchmarkSettingsT &o)
      : … { … }

inline MinibenchmarkSettingsT &MinibenchmarkSettingsT::operator=(MinibenchmarkSettingsT o) FLATBUFFERS_NOEXCEPT { … }

inline MinibenchmarkSettingsT *MinibenchmarkSettings::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void MinibenchmarkSettings::UnPackTo(MinibenchmarkSettingsT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<MinibenchmarkSettings> MinibenchmarkSettings::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MinibenchmarkSettingsT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<MinibenchmarkSettings> CreateMinibenchmarkSettings(::flatbuffers::FlatBufferBuilder &_fbb, const MinibenchmarkSettingsT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const BenchmarkEventStorageT &lhs, const BenchmarkEventStorageT &rhs) { … }

inline bool operator!=(const BenchmarkEventStorageT &lhs, const BenchmarkEventStorageT &rhs) { … }


inline BenchmarkEventStorageT::BenchmarkEventStorageT(const BenchmarkEventStorageT &o)
      : … { … }

inline BenchmarkEventStorageT &BenchmarkEventStorageT::operator=(BenchmarkEventStorageT o) FLATBUFFERS_NOEXCEPT { … }

inline BenchmarkEventStorageT *BenchmarkEventStorage::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void BenchmarkEventStorage::UnPackTo(BenchmarkEventStorageT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<BenchmarkEventStorage> BenchmarkEventStorage::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkEventStorageT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<BenchmarkEventStorage> CreateBenchmarkEventStorage(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkEventStorageT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

}  // namespace tflite

#endif  // FLATBUFFERS_GENERATED_CONFIGURATION_TFLITE_H_