From 97bf84f6e162307fc3e8c53045ef0bc60a3e3289 Mon Sep 17 00:00:00 2001 From: Sadik Armagan Date: Wed, 13 Jan 2021 15:06:38 +0000 Subject: IVGCVSW-4417 'Serialise ArmNN Model on android-nn-driver' * Added generated schema file to the source tree * Updated the ANdroid.mk file to pick up the Serializer/Deserializer source Signed-off-by: Sadik Armagan Change-Id: I12c2bf2ae7aa12374c60e671ff3a97eac5b7f161 --- src/armnnSerializer/ArmnnSchema_generated.h | 10053 ++++++++++++++++++++++++++ src/armnnSerializer/Serializer.hpp | 2 +- 2 files changed, 10054 insertions(+), 1 deletion(-) create mode 100644 src/armnnSerializer/ArmnnSchema_generated.h (limited to 'src') diff --git a/src/armnnSerializer/ArmnnSchema_generated.h b/src/armnnSerializer/ArmnnSchema_generated.h new file mode 100644 index 0000000000..031da5d6fa --- /dev/null +++ b/src/armnnSerializer/ArmnnSchema_generated.h @@ -0,0 +1,10053 @@ +// +// Copyright © 2020 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// +// automatically generated by the FlatBuffers compiler, do not modify + +#ifndef FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ +#define FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ + +#include "flatbuffers/flatbuffers.h" + +namespace armnnSerializer { + +struct TensorInfo; +struct TensorInfoBuilder; + +struct Connection; + +struct ByteData; +struct ByteDataBuilder; + +struct ShortData; +struct ShortDataBuilder; + +struct IntData; +struct IntDataBuilder; + +struct LongData; +struct LongDataBuilder; + +struct ConstTensor; +struct ConstTensorBuilder; + +struct InputSlot; +struct InputSlotBuilder; + +struct OutputSlot; +struct OutputSlotBuilder; + +struct LayerBase; +struct LayerBaseBuilder; + +struct BindableLayerBase; +struct BindableLayerBaseBuilder; + +struct AbsLayer; +struct AbsLayerBuilder; + +struct ActivationLayer; +struct ActivationLayerBuilder; + +struct ActivationDescriptor; +struct ActivationDescriptorBuilder; + +struct AdditionLayer; +struct AdditionLayerBuilder; + +struct ArgMinMaxLayer; +struct ArgMinMaxLayerBuilder; + +struct ArgMinMaxDescriptor; +struct ArgMinMaxDescriptorBuilder; + +struct ComparisonDescriptor; +struct ComparisonDescriptorBuilder; + +struct ComparisonLayer; +struct ComparisonLayerBuilder; + +struct ConstantLayer; +struct ConstantLayerBuilder; + +struct Convolution2dLayer; +struct Convolution2dLayerBuilder; + +struct Convolution2dDescriptor; +struct Convolution2dDescriptorBuilder; + +struct DepthToSpaceLayer; +struct DepthToSpaceLayerBuilder; + +struct DepthToSpaceDescriptor; +struct DepthToSpaceDescriptorBuilder; + +struct DivisionLayer; +struct DivisionLayerBuilder; + +struct ElementwiseUnaryDescriptor; +struct ElementwiseUnaryDescriptorBuilder; + +struct ElementwiseUnaryLayer; +struct ElementwiseUnaryLayerBuilder; + +struct EqualLayer; +struct EqualLayerBuilder; + +struct FillLayer; +struct FillLayerBuilder; + +struct FillDescriptor; +struct FillDescriptorBuilder; + +struct FloorLayer; +struct FloorLayerBuilder; + +struct FullyConnectedLayer; +struct FullyConnectedLayerBuilder; + +struct FullyConnectedDescriptor; +struct FullyConnectedDescriptorBuilder; + +struct GatherLayer; +struct GatherLayerBuilder; + +struct GatherDescriptor; +struct GatherDescriptorBuilder; + +struct GreaterLayer; +struct GreaterLayerBuilder; + +struct InputLayer; +struct InputLayerBuilder; + +struct InstanceNormalizationLayer; +struct InstanceNormalizationLayerBuilder; + +struct InstanceNormalizationDescriptor; +struct InstanceNormalizationDescriptorBuilder; + +struct LogSoftmaxLayer; +struct LogSoftmaxLayerBuilder; + +struct LogSoftmaxDescriptor; +struct LogSoftmaxDescriptorBuilder; + +struct L2NormalizationLayer; +struct L2NormalizationLayerBuilder; + +struct L2NormalizationDescriptor; +struct L2NormalizationDescriptorBuilder; + +struct LogicalBinaryDescriptor; +struct LogicalBinaryDescriptorBuilder; + +struct LogicalBinaryLayer; +struct LogicalBinaryLayerBuilder; + +struct MinimumLayer; +struct MinimumLayerBuilder; + +struct MaximumLayer; +struct MaximumLayerBuilder; + +struct MultiplicationLayer; +struct MultiplicationLayerBuilder; + +struct Pooling2dLayer; +struct Pooling2dLayerBuilder; + +struct Pooling2dDescriptor; +struct Pooling2dDescriptorBuilder; + +struct QuantizeLayer; +struct QuantizeLayerBuilder; + +struct SoftmaxLayer; +struct SoftmaxLayerBuilder; + +struct SoftmaxDescriptor; +struct SoftmaxDescriptorBuilder; + +struct DepthwiseConvolution2dLayer; +struct DepthwiseConvolution2dLayerBuilder; + +struct DepthwiseConvolution2dDescriptor; +struct DepthwiseConvolution2dDescriptorBuilder; + +struct OutputLayer; +struct OutputLayerBuilder; + +struct ReshapeLayer; +struct ReshapeLayerBuilder; + +struct ReshapeDescriptor; +struct ReshapeDescriptorBuilder; + +struct PermuteLayer; +struct PermuteLayerBuilder; + +struct PermuteDescriptor; +struct PermuteDescriptorBuilder; + +struct SpaceToBatchNdLayer; +struct SpaceToBatchNdLayerBuilder; + +struct SpaceToBatchNdDescriptor; +struct SpaceToBatchNdDescriptorBuilder; + +struct SpaceToDepthLayer; +struct SpaceToDepthLayerBuilder; + +struct SpaceToDepthDescriptor; +struct SpaceToDepthDescriptorBuilder; + +struct SubtractionLayer; +struct SubtractionLayerBuilder; + +struct BatchToSpaceNdLayer; +struct BatchToSpaceNdLayerBuilder; + +struct BatchToSpaceNdDescriptor; +struct BatchToSpaceNdDescriptorBuilder; + +struct NormalizationLayer; +struct NormalizationLayerBuilder; + +struct NormalizationDescriptor; +struct NormalizationDescriptorBuilder; + +struct MeanLayer; +struct MeanLayerBuilder; + +struct MeanDescriptor; +struct MeanDescriptorBuilder; + +struct PadLayer; +struct PadLayerBuilder; + +struct PadDescriptor; +struct PadDescriptorBuilder; + +struct RsqrtLayer; +struct RsqrtLayerBuilder; + +struct BatchNormalizationLayer; +struct BatchNormalizationLayerBuilder; + +struct BatchNormalizationDescriptor; +struct BatchNormalizationDescriptorBuilder; + +struct ResizeBilinearLayer; +struct ResizeBilinearLayerBuilder; + +struct ResizeBilinearDescriptor; +struct ResizeBilinearDescriptorBuilder; + +struct SliceLayer; +struct SliceLayerBuilder; + +struct SliceDescriptor; +struct SliceDescriptorBuilder; + +struct StridedSliceLayer; +struct StridedSliceLayerBuilder; + +struct StridedSliceDescriptor; +struct StridedSliceDescriptorBuilder; + +struct ConcatLayer; +struct ConcatLayerBuilder; + +struct MergerLayer; +struct MergerLayerBuilder; + +struct UintVector; +struct UintVectorBuilder; + +struct OriginsDescriptor; +struct OriginsDescriptorBuilder; + +struct ViewsDescriptor; +struct ViewsDescriptorBuilder; + +struct SplitterLayer; +struct SplitterLayerBuilder; + +struct DetectionPostProcessLayer; +struct DetectionPostProcessLayerBuilder; + +struct DetectionPostProcessDescriptor; +struct DetectionPostProcessDescriptorBuilder; + +struct LstmInputParams; +struct LstmInputParamsBuilder; + +struct LstmDescriptor; +struct LstmDescriptorBuilder; + +struct LstmLayer; +struct LstmLayerBuilder; + +struct QLstmInputParams; +struct QLstmInputParamsBuilder; + +struct QLstmDescriptor; +struct QLstmDescriptorBuilder; + +struct QLstmLayer; +struct QLstmLayerBuilder; + +struct QuantizedLstmInputParams; +struct QuantizedLstmInputParamsBuilder; + +struct QuantizedLstmLayer; +struct QuantizedLstmLayerBuilder; + +struct DequantizeLayer; +struct DequantizeLayerBuilder; + +struct MergeLayer; +struct MergeLayerBuilder; + +struct SwitchLayer; +struct SwitchLayerBuilder; + +struct PreluLayer; +struct PreluLayerBuilder; + +struct TransposeConvolution2dLayer; +struct TransposeConvolution2dLayerBuilder; + +struct TransposeConvolution2dDescriptor; +struct TransposeConvolution2dDescriptorBuilder; + +struct TransposeLayer; +struct TransposeLayerBuilder; + +struct TransposeDescriptor; +struct TransposeDescriptorBuilder; + +struct ResizeLayer; +struct ResizeLayerBuilder; + +struct ResizeDescriptor; +struct ResizeDescriptorBuilder; + +struct StackLayer; +struct StackLayerBuilder; + +struct StackDescriptor; +struct StackDescriptorBuilder; + +struct StandInDescriptor; +struct StandInDescriptorBuilder; + +struct StandInLayer; +struct StandInLayerBuilder; + +struct RankLayer; +struct RankLayerBuilder; + +struct AnyLayer; +struct AnyLayerBuilder; + +struct FeatureCompatibilityVersions; +struct FeatureCompatibilityVersionsBuilder; + +struct SerializedGraph; +struct SerializedGraphBuilder; + +enum ActivationFunction { + ActivationFunction_Sigmoid = 0, + ActivationFunction_TanH = 1, + ActivationFunction_Linear = 2, + ActivationFunction_ReLu = 3, + ActivationFunction_BoundedReLu = 4, + ActivationFunction_SoftReLu = 5, + ActivationFunction_LeakyReLu = 6, + ActivationFunction_Abs = 7, + ActivationFunction_Sqrt = 8, + ActivationFunction_Square = 9, + ActivationFunction_Elu = 10, + ActivationFunction_HardSwish = 11, + ActivationFunction_MIN = ActivationFunction_Sigmoid, + ActivationFunction_MAX = ActivationFunction_HardSwish +}; + +inline const ActivationFunction (&EnumValuesActivationFunction())[12] { + static const ActivationFunction values[] = { + ActivationFunction_Sigmoid, + ActivationFunction_TanH, + ActivationFunction_Linear, + ActivationFunction_ReLu, + ActivationFunction_BoundedReLu, + ActivationFunction_SoftReLu, + ActivationFunction_LeakyReLu, + ActivationFunction_Abs, + ActivationFunction_Sqrt, + ActivationFunction_Square, + ActivationFunction_Elu, + ActivationFunction_HardSwish + }; + return values; +} + +inline const char * const *EnumNamesActivationFunction() { + static const char * const names[13] = { + "Sigmoid", + "TanH", + "Linear", + "ReLu", + "BoundedReLu", + "SoftReLu", + "LeakyReLu", + "Abs", + "Sqrt", + "Square", + "Elu", + "HardSwish", + nullptr + }; + return names; +} + +inline const char *EnumNameActivationFunction(ActivationFunction e) { + if (flatbuffers::IsOutRange(e, ActivationFunction_Sigmoid, ActivationFunction_HardSwish)) return ""; + const size_t index = static_cast(e); + return EnumNamesActivationFunction()[index]; +} + +enum ArgMinMaxFunction { + ArgMinMaxFunction_Min = 0, + ArgMinMaxFunction_Max = 1, + ArgMinMaxFunction_MIN = ArgMinMaxFunction_Min, + ArgMinMaxFunction_MAX = ArgMinMaxFunction_Max +}; + +inline const ArgMinMaxFunction (&EnumValuesArgMinMaxFunction())[2] { + static const ArgMinMaxFunction values[] = { + ArgMinMaxFunction_Min, + ArgMinMaxFunction_Max + }; + return values; +} + +inline const char * const *EnumNamesArgMinMaxFunction() { + static const char * const names[3] = { + "Min", + "Max", + nullptr + }; + return names; +} + +inline const char *EnumNameArgMinMaxFunction(ArgMinMaxFunction e) { + if (flatbuffers::IsOutRange(e, ArgMinMaxFunction_Min, ArgMinMaxFunction_Max)) return ""; + const size_t index = static_cast(e); + return EnumNamesArgMinMaxFunction()[index]; +} + +enum DataType { + DataType_Float16 = 0, + DataType_Float32 = 1, + DataType_QuantisedAsymm8 = 2, + DataType_Signed32 = 3, + DataType_Boolean = 4, + DataType_QuantisedSymm16 = 5, + DataType_QAsymmU8 = 6, + DataType_QSymmS16 = 7, + DataType_QAsymmS8 = 8, + DataType_QSymmS8 = 9, + DataType_MIN = DataType_Float16, + DataType_MAX = DataType_QSymmS8 +}; + +inline const DataType (&EnumValuesDataType())[10] { + static const DataType values[] = { + DataType_Float16, + DataType_Float32, + DataType_QuantisedAsymm8, + DataType_Signed32, + DataType_Boolean, + DataType_QuantisedSymm16, + DataType_QAsymmU8, + DataType_QSymmS16, + DataType_QAsymmS8, + DataType_QSymmS8 + }; + return values; +} + +inline const char * const *EnumNamesDataType() { + static const char * const names[11] = { + "Float16", + "Float32", + "QuantisedAsymm8", + "Signed32", + "Boolean", + "QuantisedSymm16", + "QAsymmU8", + "QSymmS16", + "QAsymmS8", + "QSymmS8", + nullptr + }; + return names; +} + +inline const char *EnumNameDataType(DataType e) { + if (flatbuffers::IsOutRange(e, DataType_Float16, DataType_QSymmS8)) return ""; + const size_t index = static_cast(e); + return EnumNamesDataType()[index]; +} + +enum DataLayout { + DataLayout_NHWC = 0, + DataLayout_NCHW = 1, + DataLayout_MIN = DataLayout_NHWC, + DataLayout_MAX = DataLayout_NCHW +}; + +inline const DataLayout (&EnumValuesDataLayout())[2] { + static const DataLayout values[] = { + DataLayout_NHWC, + DataLayout_NCHW + }; + return values; +} + +inline const char * const *EnumNamesDataLayout() { + static const char * const names[3] = { + "NHWC", + "NCHW", + nullptr + }; + return names; +} + +inline const char *EnumNameDataLayout(DataLayout e) { + if (flatbuffers::IsOutRange(e, DataLayout_NHWC, DataLayout_NCHW)) return ""; + const size_t index = static_cast(e); + return EnumNamesDataLayout()[index]; +} + +enum ResizeMethod { + ResizeMethod_NearestNeighbor = 0, + ResizeMethod_Bilinear = 1, + ResizeMethod_MIN = ResizeMethod_NearestNeighbor, + ResizeMethod_MAX = ResizeMethod_Bilinear +}; + +inline const ResizeMethod (&EnumValuesResizeMethod())[2] { + static const ResizeMethod values[] = { + ResizeMethod_NearestNeighbor, + ResizeMethod_Bilinear + }; + return values; +} + +inline const char * const *EnumNamesResizeMethod() { + static const char * const names[3] = { + "NearestNeighbor", + "Bilinear", + nullptr + }; + return names; +} + +inline const char *EnumNameResizeMethod(ResizeMethod e) { + if (flatbuffers::IsOutRange(e, ResizeMethod_NearestNeighbor, ResizeMethod_Bilinear)) return ""; + const size_t index = static_cast(e); + return EnumNamesResizeMethod()[index]; +} + +enum ConstTensorData { + ConstTensorData_NONE = 0, + ConstTensorData_ByteData = 1, + ConstTensorData_ShortData = 2, + ConstTensorData_IntData = 3, + ConstTensorData_LongData = 4, + ConstTensorData_MIN = ConstTensorData_NONE, + ConstTensorData_MAX = ConstTensorData_LongData +}; + +inline const ConstTensorData (&EnumValuesConstTensorData())[5] { + static const ConstTensorData values[] = { + ConstTensorData_NONE, + ConstTensorData_ByteData, + ConstTensorData_ShortData, + ConstTensorData_IntData, + ConstTensorData_LongData + }; + return values; +} + +inline const char * const *EnumNamesConstTensorData() { + static const char * const names[6] = { + "NONE", + "ByteData", + "ShortData", + "IntData", + "LongData", + nullptr + }; + return names; +} + +inline const char *EnumNameConstTensorData(ConstTensorData e) { + if (flatbuffers::IsOutRange(e, ConstTensorData_NONE, ConstTensorData_LongData)) return ""; + const size_t index = static_cast(e); + return EnumNamesConstTensorData()[index]; +} + +template struct ConstTensorDataTraits { + static const ConstTensorData enum_value = ConstTensorData_NONE; +}; + +template<> struct ConstTensorDataTraits { + static const ConstTensorData enum_value = ConstTensorData_ByteData; +}; + +template<> struct ConstTensorDataTraits { + static const ConstTensorData enum_value = ConstTensorData_ShortData; +}; + +template<> struct ConstTensorDataTraits { + static const ConstTensorData enum_value = ConstTensorData_IntData; +}; + +template<> struct ConstTensorDataTraits { + static const ConstTensorData enum_value = ConstTensorData_LongData; +}; + +bool VerifyConstTensorData(flatbuffers::Verifier &verifier, const void *obj, ConstTensorData type); +bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum LayerType { + LayerType_Addition = 0, + LayerType_Input = 1, + LayerType_Multiplication = 2, + LayerType_Output = 3, + LayerType_Pooling2d = 4, + LayerType_Reshape = 5, + LayerType_Softmax = 6, + LayerType_Convolution2d = 7, + LayerType_DepthwiseConvolution2d = 8, + LayerType_Activation = 9, + LayerType_Permute = 10, + LayerType_FullyConnected = 11, + LayerType_Constant = 12, + LayerType_SpaceToBatchNd = 13, + LayerType_BatchToSpaceNd = 14, + LayerType_Division = 15, + LayerType_Minimum = 16, + LayerType_Equal = 17, + LayerType_Maximum = 18, + LayerType_Normalization = 19, + LayerType_Pad = 20, + LayerType_Rsqrt = 21, + LayerType_Floor = 22, + LayerType_BatchNormalization = 23, + LayerType_Greater = 24, + LayerType_ResizeBilinear = 25, + LayerType_Subtraction = 26, + LayerType_StridedSlice = 27, + LayerType_Gather = 28, + LayerType_Mean = 29, + LayerType_Merger = 30, + LayerType_L2Normalization = 31, + LayerType_Splitter = 32, + LayerType_DetectionPostProcess = 33, + LayerType_Lstm = 34, + LayerType_Quantize = 35, + LayerType_Dequantize = 36, + LayerType_Merge = 37, + LayerType_Switch = 38, + LayerType_Concat = 39, + LayerType_SpaceToDepth = 40, + LayerType_Prelu = 41, + LayerType_TransposeConvolution2d = 42, + LayerType_Resize = 43, + LayerType_Stack = 44, + LayerType_QuantizedLstm = 45, + LayerType_Abs = 46, + LayerType_ArgMinMax = 47, + LayerType_Slice = 48, + LayerType_DepthToSpace = 49, + LayerType_InstanceNormalization = 50, + LayerType_LogSoftmax = 51, + LayerType_Comparison = 52, + LayerType_StandIn = 53, + LayerType_ElementwiseUnary = 54, + LayerType_Transpose = 55, + LayerType_QLstm = 56, + LayerType_Fill = 57, + LayerType_Rank = 58, + LayerType_LogicalBinary = 59, + LayerType_MIN = LayerType_Addition, + LayerType_MAX = LayerType_LogicalBinary +}; + +inline const LayerType (&EnumValuesLayerType())[60] { + static const LayerType values[] = { + LayerType_Addition, + LayerType_Input, + LayerType_Multiplication, + LayerType_Output, + LayerType_Pooling2d, + LayerType_Reshape, + LayerType_Softmax, + LayerType_Convolution2d, + LayerType_DepthwiseConvolution2d, + LayerType_Activation, + LayerType_Permute, + LayerType_FullyConnected, + LayerType_Constant, + LayerType_SpaceToBatchNd, + LayerType_BatchToSpaceNd, + LayerType_Division, + LayerType_Minimum, + LayerType_Equal, + LayerType_Maximum, + LayerType_Normalization, + LayerType_Pad, + LayerType_Rsqrt, + LayerType_Floor, + LayerType_BatchNormalization, + LayerType_Greater, + LayerType_ResizeBilinear, + LayerType_Subtraction, + LayerType_StridedSlice, + LayerType_Gather, + LayerType_Mean, + LayerType_Merger, + LayerType_L2Normalization, + LayerType_Splitter, + LayerType_DetectionPostProcess, + LayerType_Lstm, + LayerType_Quantize, + LayerType_Dequantize, + LayerType_Merge, + LayerType_Switch, + LayerType_Concat, + LayerType_SpaceToDepth, + LayerType_Prelu, + LayerType_TransposeConvolution2d, + LayerType_Resize, + LayerType_Stack, + LayerType_QuantizedLstm, + LayerType_Abs, + LayerType_ArgMinMax, + LayerType_Slice, + LayerType_DepthToSpace, + LayerType_InstanceNormalization, + LayerType_LogSoftmax, + LayerType_Comparison, + LayerType_StandIn, + LayerType_ElementwiseUnary, + LayerType_Transpose, + LayerType_QLstm, + LayerType_Fill, + LayerType_Rank, + LayerType_LogicalBinary + }; + return values; +} + +inline const char * const *EnumNamesLayerType() { + static const char * const names[61] = { + "Addition", + "Input", + "Multiplication", + "Output", + "Pooling2d", + "Reshape", + "Softmax", + "Convolution2d", + "DepthwiseConvolution2d", + "Activation", + "Permute", + "FullyConnected", + "Constant", + "SpaceToBatchNd", + "BatchToSpaceNd", + "Division", + "Minimum", + "Equal", + "Maximum", + "Normalization", + "Pad", + "Rsqrt", + "Floor", + "BatchNormalization", + "Greater", + "ResizeBilinear", + "Subtraction", + "StridedSlice", + "Gather", + "Mean", + "Merger", + "L2Normalization", + "Splitter", + "DetectionPostProcess", + "Lstm", + "Quantize", + "Dequantize", + "Merge", + "Switch", + "Concat", + "SpaceToDepth", + "Prelu", + "TransposeConvolution2d", + "Resize", + "Stack", + "QuantizedLstm", + "Abs", + "ArgMinMax", + "Slice", + "DepthToSpace", + "InstanceNormalization", + "LogSoftmax", + "Comparison", + "StandIn", + "ElementwiseUnary", + "Transpose", + "QLstm", + "Fill", + "Rank", + "LogicalBinary", + nullptr + }; + return names; +} + +inline const char *EnumNameLayerType(LayerType e) { + if (flatbuffers::IsOutRange(e, LayerType_Addition, LayerType_LogicalBinary)) return ""; + const size_t index = static_cast(e); + return EnumNamesLayerType()[index]; +} + +enum ComparisonOperation { + ComparisonOperation_Equal = 0, + ComparisonOperation_Greater = 1, + ComparisonOperation_GreaterOrEqual = 2, + ComparisonOperation_Less = 3, + ComparisonOperation_LessOrEqual = 4, + ComparisonOperation_NotEqual = 5, + ComparisonOperation_MIN = ComparisonOperation_Equal, + ComparisonOperation_MAX = ComparisonOperation_NotEqual +}; + +inline const ComparisonOperation (&EnumValuesComparisonOperation())[6] { + static const ComparisonOperation values[] = { + ComparisonOperation_Equal, + ComparisonOperation_Greater, + ComparisonOperation_GreaterOrEqual, + ComparisonOperation_Less, + ComparisonOperation_LessOrEqual, + ComparisonOperation_NotEqual + }; + return values; +} + +inline const char * const *EnumNamesComparisonOperation() { + static const char * const names[7] = { + "Equal", + "Greater", + "GreaterOrEqual", + "Less", + "LessOrEqual", + "NotEqual", + nullptr + }; + return names; +} + +inline const char *EnumNameComparisonOperation(ComparisonOperation e) { + if (flatbuffers::IsOutRange(e, ComparisonOperation_Equal, ComparisonOperation_NotEqual)) return ""; + const size_t index = static_cast(e); + return EnumNamesComparisonOperation()[index]; +} + +enum UnaryOperation { + UnaryOperation_Abs = 0, + UnaryOperation_Rsqrt = 1, + UnaryOperation_Sqrt = 2, + UnaryOperation_Exp = 3, + UnaryOperation_Neg = 4, + UnaryOperation_LogicalNot = 5, + UnaryOperation_MIN = UnaryOperation_Abs, + UnaryOperation_MAX = UnaryOperation_LogicalNot +}; + +inline const UnaryOperation (&EnumValuesUnaryOperation())[6] { + static const UnaryOperation values[] = { + UnaryOperation_Abs, + UnaryOperation_Rsqrt, + UnaryOperation_Sqrt, + UnaryOperation_Exp, + UnaryOperation_Neg, + UnaryOperation_LogicalNot + }; + return values; +} + +inline const char * const *EnumNamesUnaryOperation() { + static const char * const names[7] = { + "Abs", + "Rsqrt", + "Sqrt", + "Exp", + "Neg", + "LogicalNot", + nullptr + }; + return names; +} + +inline const char *EnumNameUnaryOperation(UnaryOperation e) { + if (flatbuffers::IsOutRange(e, UnaryOperation_Abs, UnaryOperation_LogicalNot)) return ""; + const size_t index = static_cast(e); + return EnumNamesUnaryOperation()[index]; +} + +enum LogicalBinaryOperation { + LogicalBinaryOperation_LogicalAnd = 0, + LogicalBinaryOperation_LogicalOr = 1, + LogicalBinaryOperation_MIN = LogicalBinaryOperation_LogicalAnd, + LogicalBinaryOperation_MAX = LogicalBinaryOperation_LogicalOr +}; + +inline const LogicalBinaryOperation (&EnumValuesLogicalBinaryOperation())[2] { + static const LogicalBinaryOperation values[] = { + LogicalBinaryOperation_LogicalAnd, + LogicalBinaryOperation_LogicalOr + }; + return values; +} + +inline const char * const *EnumNamesLogicalBinaryOperation() { + static const char * const names[3] = { + "LogicalAnd", + "LogicalOr", + nullptr + }; + return names; +} + +inline const char *EnumNameLogicalBinaryOperation(LogicalBinaryOperation e) { + if (flatbuffers::IsOutRange(e, LogicalBinaryOperation_LogicalAnd, LogicalBinaryOperation_LogicalOr)) return ""; + const size_t index = static_cast(e); + return EnumNamesLogicalBinaryOperation()[index]; +} + +enum PoolingAlgorithm { + PoolingAlgorithm_Max = 0, + PoolingAlgorithm_Average = 1, + PoolingAlgorithm_L2 = 2, + PoolingAlgorithm_MIN = PoolingAlgorithm_Max, + PoolingAlgorithm_MAX = PoolingAlgorithm_L2 +}; + +inline const PoolingAlgorithm (&EnumValuesPoolingAlgorithm())[3] { + static const PoolingAlgorithm values[] = { + PoolingAlgorithm_Max, + PoolingAlgorithm_Average, + PoolingAlgorithm_L2 + }; + return values; +} + +inline const char * const *EnumNamesPoolingAlgorithm() { + static const char * const names[4] = { + "Max", + "Average", + "L2", + nullptr + }; + return names; +} + +inline const char *EnumNamePoolingAlgorithm(PoolingAlgorithm e) { + if (flatbuffers::IsOutRange(e, PoolingAlgorithm_Max, PoolingAlgorithm_L2)) return ""; + const size_t index = static_cast(e); + return EnumNamesPoolingAlgorithm()[index]; +} + +enum OutputShapeRounding { + OutputShapeRounding_Floor = 0, + OutputShapeRounding_Ceiling = 1, + OutputShapeRounding_MIN = OutputShapeRounding_Floor, + OutputShapeRounding_MAX = OutputShapeRounding_Ceiling +}; + +inline const OutputShapeRounding (&EnumValuesOutputShapeRounding())[2] { + static const OutputShapeRounding values[] = { + OutputShapeRounding_Floor, + OutputShapeRounding_Ceiling + }; + return values; +} + +inline const char * const *EnumNamesOutputShapeRounding() { + static const char * const names[3] = { + "Floor", + "Ceiling", + nullptr + }; + return names; +} + +inline const char *EnumNameOutputShapeRounding(OutputShapeRounding e) { + if (flatbuffers::IsOutRange(e, OutputShapeRounding_Floor, OutputShapeRounding_Ceiling)) return ""; + const size_t index = static_cast(e); + return EnumNamesOutputShapeRounding()[index]; +} + +enum PaddingMethod { + PaddingMethod_IgnoreValue = 0, + PaddingMethod_Exclude = 1, + PaddingMethod_MIN = PaddingMethod_IgnoreValue, + PaddingMethod_MAX = PaddingMethod_Exclude +}; + +inline const PaddingMethod (&EnumValuesPaddingMethod())[2] { + static const PaddingMethod values[] = { + PaddingMethod_IgnoreValue, + PaddingMethod_Exclude + }; + return values; +} + +inline const char * const *EnumNamesPaddingMethod() { + static const char * const names[3] = { + "IgnoreValue", + "Exclude", + nullptr + }; + return names; +} + +inline const char *EnumNamePaddingMethod(PaddingMethod e) { + if (flatbuffers::IsOutRange(e, PaddingMethod_IgnoreValue, PaddingMethod_Exclude)) return ""; + const size_t index = static_cast(e); + return EnumNamesPaddingMethod()[index]; +} + +enum NormalizationAlgorithmChannel { + NormalizationAlgorithmChannel_Across = 0, + NormalizationAlgorithmChannel_Within = 1, + NormalizationAlgorithmChannel_MIN = NormalizationAlgorithmChannel_Across, + NormalizationAlgorithmChannel_MAX = NormalizationAlgorithmChannel_Within +}; + +inline const NormalizationAlgorithmChannel (&EnumValuesNormalizationAlgorithmChannel())[2] { + static const NormalizationAlgorithmChannel values[] = { + NormalizationAlgorithmChannel_Across, + NormalizationAlgorithmChannel_Within + }; + return values; +} + +inline const char * const *EnumNamesNormalizationAlgorithmChannel() { + static const char * const names[3] = { + "Across", + "Within", + nullptr + }; + return names; +} + +inline const char *EnumNameNormalizationAlgorithmChannel(NormalizationAlgorithmChannel e) { + if (flatbuffers::IsOutRange(e, NormalizationAlgorithmChannel_Across, NormalizationAlgorithmChannel_Within)) return ""; + const size_t index = static_cast(e); + return EnumNamesNormalizationAlgorithmChannel()[index]; +} + +enum NormalizationAlgorithmMethod { + NormalizationAlgorithmMethod_LocalBrightness = 0, + NormalizationAlgorithmMethod_LocalContrast = 1, + NormalizationAlgorithmMethod_MIN = NormalizationAlgorithmMethod_LocalBrightness, + NormalizationAlgorithmMethod_MAX = NormalizationAlgorithmMethod_LocalContrast +}; + +inline const NormalizationAlgorithmMethod (&EnumValuesNormalizationAlgorithmMethod())[2] { + static const NormalizationAlgorithmMethod values[] = { + NormalizationAlgorithmMethod_LocalBrightness, + NormalizationAlgorithmMethod_LocalContrast + }; + return values; +} + +inline const char * const *EnumNamesNormalizationAlgorithmMethod() { + static const char * const names[3] = { + "LocalBrightness", + "LocalContrast", + nullptr + }; + return names; +} + +inline const char *EnumNameNormalizationAlgorithmMethod(NormalizationAlgorithmMethod e) { + if (flatbuffers::IsOutRange(e, NormalizationAlgorithmMethod_LocalBrightness, NormalizationAlgorithmMethod_LocalContrast)) return ""; + const size_t index = static_cast(e); + return EnumNamesNormalizationAlgorithmMethod()[index]; +} + +enum Layer { + Layer_NONE = 0, + Layer_ActivationLayer = 1, + Layer_AdditionLayer = 2, + Layer_BatchToSpaceNdLayer = 3, + Layer_BatchNormalizationLayer = 4, + Layer_ConstantLayer = 5, + Layer_Convolution2dLayer = 6, + Layer_DepthwiseConvolution2dLayer = 7, + Layer_FullyConnectedLayer = 8, + Layer_InputLayer = 9, + Layer_MultiplicationLayer = 10, + Layer_OutputLayer = 11, + Layer_PermuteLayer = 12, + Layer_Pooling2dLayer = 13, + Layer_ReshapeLayer = 14, + Layer_SoftmaxLayer = 15, + Layer_SpaceToBatchNdLayer = 16, + Layer_DivisionLayer = 17, + Layer_MinimumLayer = 18, + Layer_EqualLayer = 19, + Layer_MaximumLayer = 20, + Layer_NormalizationLayer = 21, + Layer_PadLayer = 22, + Layer_RsqrtLayer = 23, + Layer_FloorLayer = 24, + Layer_GreaterLayer = 25, + Layer_ResizeBilinearLayer = 26, + Layer_SubtractionLayer = 27, + Layer_StridedSliceLayer = 28, + Layer_GatherLayer = 29, + Layer_MeanLayer = 30, + Layer_MergerLayer = 31, + Layer_L2NormalizationLayer = 32, + Layer_SplitterLayer = 33, + Layer_DetectionPostProcessLayer = 34, + Layer_LstmLayer = 35, + Layer_QuantizedLstmLayer = 36, + Layer_QuantizeLayer = 37, + Layer_DequantizeLayer = 38, + Layer_MergeLayer = 39, + Layer_SwitchLayer = 40, + Layer_ConcatLayer = 41, + Layer_SpaceToDepthLayer = 42, + Layer_PreluLayer = 43, + Layer_TransposeConvolution2dLayer = 44, + Layer_ResizeLayer = 45, + Layer_StackLayer = 46, + Layer_AbsLayer = 47, + Layer_ArgMinMaxLayer = 48, + Layer_SliceLayer = 49, + Layer_DepthToSpaceLayer = 50, + Layer_InstanceNormalizationLayer = 51, + Layer_LogSoftmaxLayer = 52, + Layer_ComparisonLayer = 53, + Layer_StandInLayer = 54, + Layer_ElementwiseUnaryLayer = 55, + Layer_TransposeLayer = 56, + Layer_QLstmLayer = 57, + Layer_FillLayer = 58, + Layer_RankLayer = 59, + Layer_LogicalBinaryLayer = 60, + Layer_MIN = Layer_NONE, + Layer_MAX = Layer_LogicalBinaryLayer +}; + +inline const Layer (&EnumValuesLayer())[61] { + static const Layer values[] = { + Layer_NONE, + Layer_ActivationLayer, + Layer_AdditionLayer, + Layer_BatchToSpaceNdLayer, + Layer_BatchNormalizationLayer, + Layer_ConstantLayer, + Layer_Convolution2dLayer, + Layer_DepthwiseConvolution2dLayer, + Layer_FullyConnectedLayer, + Layer_InputLayer, + Layer_MultiplicationLayer, + Layer_OutputLayer, + Layer_PermuteLayer, + Layer_Pooling2dLayer, + Layer_ReshapeLayer, + Layer_SoftmaxLayer, + Layer_SpaceToBatchNdLayer, + Layer_DivisionLayer, + Layer_MinimumLayer, + Layer_EqualLayer, + Layer_MaximumLayer, + Layer_NormalizationLayer, + Layer_PadLayer, + Layer_RsqrtLayer, + Layer_FloorLayer, + Layer_GreaterLayer, + Layer_ResizeBilinearLayer, + Layer_SubtractionLayer, + Layer_StridedSliceLayer, + Layer_GatherLayer, + Layer_MeanLayer, + Layer_MergerLayer, + Layer_L2NormalizationLayer, + Layer_SplitterLayer, + Layer_DetectionPostProcessLayer, + Layer_LstmLayer, + Layer_QuantizedLstmLayer, + Layer_QuantizeLayer, + Layer_DequantizeLayer, + Layer_MergeLayer, + Layer_SwitchLayer, + Layer_ConcatLayer, + Layer_SpaceToDepthLayer, + Layer_PreluLayer, + Layer_TransposeConvolution2dLayer, + Layer_ResizeLayer, + Layer_StackLayer, + Layer_AbsLayer, + Layer_ArgMinMaxLayer, + Layer_SliceLayer, + Layer_DepthToSpaceLayer, + Layer_InstanceNormalizationLayer, + Layer_LogSoftmaxLayer, + Layer_ComparisonLayer, + Layer_StandInLayer, + Layer_ElementwiseUnaryLayer, + Layer_TransposeLayer, + Layer_QLstmLayer, + Layer_FillLayer, + Layer_RankLayer, + Layer_LogicalBinaryLayer + }; + return values; +} + +inline const char * const *EnumNamesLayer() { + static const char * const names[62] = { + "NONE", + "ActivationLayer", + "AdditionLayer", + "BatchToSpaceNdLayer", + "BatchNormalizationLayer", + "ConstantLayer", + "Convolution2dLayer", + "DepthwiseConvolution2dLayer", + "FullyConnectedLayer", + "InputLayer", + "MultiplicationLayer", + "OutputLayer", + "PermuteLayer", + "Pooling2dLayer", + "ReshapeLayer", + "SoftmaxLayer", + "SpaceToBatchNdLayer", + "DivisionLayer", + "MinimumLayer", + "EqualLayer", + "MaximumLayer", + "NormalizationLayer", + "PadLayer", + "RsqrtLayer", + "FloorLayer", + "GreaterLayer", + "ResizeBilinearLayer", + "SubtractionLayer", + "StridedSliceLayer", + "GatherLayer", + "MeanLayer", + "MergerLayer", + "L2NormalizationLayer", + "SplitterLayer", + "DetectionPostProcessLayer", + "LstmLayer", + "QuantizedLstmLayer", + "QuantizeLayer", + "DequantizeLayer", + "MergeLayer", + "SwitchLayer", + "ConcatLayer", + "SpaceToDepthLayer", + "PreluLayer", + "TransposeConvolution2dLayer", + "ResizeLayer", + "StackLayer", + "AbsLayer", + "ArgMinMaxLayer", + "SliceLayer", + "DepthToSpaceLayer", + "InstanceNormalizationLayer", + "LogSoftmaxLayer", + "ComparisonLayer", + "StandInLayer", + "ElementwiseUnaryLayer", + "TransposeLayer", + "QLstmLayer", + "FillLayer", + "RankLayer", + "LogicalBinaryLayer", + nullptr + }; + return names; +} + +inline const char *EnumNameLayer(Layer e) { + if (flatbuffers::IsOutRange(e, Layer_NONE, Layer_LogicalBinaryLayer)) return ""; + const size_t index = static_cast(e); + return EnumNamesLayer()[index]; +} + +template struct LayerTraits { + static const Layer enum_value = Layer_NONE; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ActivationLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_AdditionLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_BatchToSpaceNdLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_BatchNormalizationLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ConstantLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_Convolution2dLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_DepthwiseConvolution2dLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_FullyConnectedLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_InputLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_MultiplicationLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_OutputLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_PermuteLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_Pooling2dLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ReshapeLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_SoftmaxLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_SpaceToBatchNdLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_DivisionLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_MinimumLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_EqualLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_MaximumLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_NormalizationLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_PadLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_RsqrtLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_FloorLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_GreaterLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ResizeBilinearLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_SubtractionLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_StridedSliceLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_GatherLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_MeanLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_MergerLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_L2NormalizationLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_SplitterLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_DetectionPostProcessLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_LstmLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_QuantizedLstmLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_QuantizeLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_DequantizeLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_MergeLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_SwitchLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ConcatLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_SpaceToDepthLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_PreluLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_TransposeConvolution2dLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ResizeLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_StackLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_AbsLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ArgMinMaxLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_SliceLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_DepthToSpaceLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_InstanceNormalizationLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_LogSoftmaxLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ComparisonLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_StandInLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_ElementwiseUnaryLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_TransposeLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_QLstmLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_FillLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_RankLayer; +}; + +template<> struct LayerTraits { + static const Layer enum_value = Layer_LogicalBinaryLayer; +}; + +bool VerifyLayer(flatbuffers::Verifier &verifier, const void *obj, Layer type); +bool VerifyLayerVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Connection FLATBUFFERS_FINAL_CLASS { + private: + uint32_t sourceLayerIndex_; + uint32_t outputSlotIndex_; + + public: + Connection() { + memset(static_cast(this), 0, sizeof(Connection)); + } + Connection(uint32_t _sourceLayerIndex, uint32_t _outputSlotIndex) + : sourceLayerIndex_(flatbuffers::EndianScalar(_sourceLayerIndex)), + outputSlotIndex_(flatbuffers::EndianScalar(_outputSlotIndex)) { + } + uint32_t sourceLayerIndex() const { + return flatbuffers::EndianScalar(sourceLayerIndex_); + } + uint32_t outputSlotIndex() const { + return flatbuffers::EndianScalar(outputSlotIndex_); + } +}; +FLATBUFFERS_STRUCT_END(Connection, 8); + +struct TensorInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TensorInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DIMENSIONS = 4, + VT_DATATYPE = 6, + VT_QUANTIZATIONSCALE = 8, + VT_QUANTIZATIONOFFSET = 10, + VT_QUANTIZATIONSCALES = 12, + VT_QUANTIZATIONDIM = 14, + VT_DIMENSIONALITY = 16 + }; + const flatbuffers::Vector *dimensions() const { + return GetPointer *>(VT_DIMENSIONS); + } + armnnSerializer::DataType dataType() const { + return static_cast(GetField(VT_DATATYPE, 0)); + } + float quantizationScale() const { + return GetField(VT_QUANTIZATIONSCALE, 1.0f); + } + int32_t quantizationOffset() const { + return GetField(VT_QUANTIZATIONOFFSET, 0); + } + const flatbuffers::Vector *quantizationScales() const { + return GetPointer *>(VT_QUANTIZATIONSCALES); + } + uint32_t quantizationDim() const { + return GetField(VT_QUANTIZATIONDIM, 0); + } + uint32_t dimensionality() const { + return GetField(VT_DIMENSIONALITY, 1); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DIMENSIONS) && + verifier.VerifyVector(dimensions()) && + VerifyField(verifier, VT_DATATYPE) && + VerifyField(verifier, VT_QUANTIZATIONSCALE) && + VerifyField(verifier, VT_QUANTIZATIONOFFSET) && + VerifyOffset(verifier, VT_QUANTIZATIONSCALES) && + verifier.VerifyVector(quantizationScales()) && + VerifyField(verifier, VT_QUANTIZATIONDIM) && + VerifyField(verifier, VT_DIMENSIONALITY) && + verifier.EndTable(); + } +}; + +struct TensorInfoBuilder { + typedef TensorInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_dimensions(flatbuffers::Offset> dimensions) { + fbb_.AddOffset(TensorInfo::VT_DIMENSIONS, dimensions); + } + void add_dataType(armnnSerializer::DataType dataType) { + fbb_.AddElement(TensorInfo::VT_DATATYPE, static_cast(dataType), 0); + } + void add_quantizationScale(float quantizationScale) { + fbb_.AddElement(TensorInfo::VT_QUANTIZATIONSCALE, quantizationScale, 1.0f); + } + void add_quantizationOffset(int32_t quantizationOffset) { + fbb_.AddElement(TensorInfo::VT_QUANTIZATIONOFFSET, quantizationOffset, 0); + } + void add_quantizationScales(flatbuffers::Offset> quantizationScales) { + fbb_.AddOffset(TensorInfo::VT_QUANTIZATIONSCALES, quantizationScales); + } + void add_quantizationDim(uint32_t quantizationDim) { + fbb_.AddElement(TensorInfo::VT_QUANTIZATIONDIM, quantizationDim, 0); + } + void add_dimensionality(uint32_t dimensionality) { + fbb_.AddElement(TensorInfo::VT_DIMENSIONALITY, dimensionality, 1); + } + explicit TensorInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TensorInfoBuilder &operator=(const TensorInfoBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTensorInfo( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> dimensions = 0, + armnnSerializer::DataType dataType = armnnSerializer::DataType_Float16, + float quantizationScale = 1.0f, + int32_t quantizationOffset = 0, + flatbuffers::Offset> quantizationScales = 0, + uint32_t quantizationDim = 0, + uint32_t dimensionality = 1) { + TensorInfoBuilder builder_(_fbb); + builder_.add_dimensionality(dimensionality); + builder_.add_quantizationDim(quantizationDim); + builder_.add_quantizationScales(quantizationScales); + builder_.add_quantizationOffset(quantizationOffset); + builder_.add_quantizationScale(quantizationScale); + builder_.add_dimensions(dimensions); + builder_.add_dataType(dataType); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTensorInfoDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *dimensions = nullptr, + armnnSerializer::DataType dataType = armnnSerializer::DataType_Float16, + float quantizationScale = 1.0f, + int32_t quantizationOffset = 0, + const std::vector *quantizationScales = nullptr, + uint32_t quantizationDim = 0, + uint32_t dimensionality = 1) { + auto dimensions__ = dimensions ? _fbb.CreateVector(*dimensions) : 0; + auto quantizationScales__ = quantizationScales ? _fbb.CreateVector(*quantizationScales) : 0; + return armnnSerializer::CreateTensorInfo( + _fbb, + dimensions__, + dataType, + quantizationScale, + quantizationOffset, + quantizationScales__, + quantizationDim, + dimensionality); +} + +struct ByteData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ByteDataBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DATA = 4 + }; + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } +}; + +struct ByteDataBuilder { + typedef ByteData Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(ByteData::VT_DATA, data); + } + explicit ByteDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ByteDataBuilder &operator=(const ByteDataBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateByteData( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> data = 0) { + ByteDataBuilder builder_(_fbb); + builder_.add_data(data); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateByteDataDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return armnnSerializer::CreateByteData( + _fbb, + data__); +} + +struct ShortData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ShortDataBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DATA = 4 + }; + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } +}; + +struct ShortDataBuilder { + typedef ShortData Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(ShortData::VT_DATA, data); + } + explicit ShortDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ShortDataBuilder &operator=(const ShortDataBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateShortData( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> data = 0) { + ShortDataBuilder builder_(_fbb); + builder_.add_data(data); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateShortDataDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return armnnSerializer::CreateShortData( + _fbb, + data__); +} + +struct IntData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef IntDataBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DATA = 4 + }; + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } +}; + +struct IntDataBuilder { + typedef IntData Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(IntData::VT_DATA, data); + } + explicit IntDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + IntDataBuilder &operator=(const IntDataBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateIntData( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> data = 0) { + IntDataBuilder builder_(_fbb); + builder_.add_data(data); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateIntDataDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return armnnSerializer::CreateIntData( + _fbb, + data__); +} + +struct LongData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LongDataBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DATA = 4 + }; + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } +}; + +struct LongDataBuilder { + typedef LongData Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(LongData::VT_DATA, data); + } + explicit LongDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LongDataBuilder &operator=(const LongDataBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLongData( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> data = 0) { + LongDataBuilder builder_(_fbb); + builder_.add_data(data); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateLongDataDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return armnnSerializer::CreateLongData( + _fbb, + data__); +} + +struct ConstTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConstTensorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INFO = 4, + VT_DATA_TYPE = 6, + VT_DATA = 8 + }; + const armnnSerializer::TensorInfo *info() const { + return GetPointer(VT_INFO); + } + armnnSerializer::ConstTensorData data_type() const { + return static_cast(GetField(VT_DATA_TYPE, 0)); + } + const void *data() const { + return GetPointer(VT_DATA); + } + template const T *data_as() const; + const armnnSerializer::ByteData *data_as_ByteData() const { + return data_type() == armnnSerializer::ConstTensorData_ByteData ? static_cast(data()) : nullptr; + } + const armnnSerializer::ShortData *data_as_ShortData() const { + return data_type() == armnnSerializer::ConstTensorData_ShortData ? static_cast(data()) : nullptr; + } + const armnnSerializer::IntData *data_as_IntData() const { + return data_type() == armnnSerializer::ConstTensorData_IntData ? static_cast(data()) : nullptr; + } + const armnnSerializer::LongData *data_as_LongData() const { + return data_type() == armnnSerializer::ConstTensorData_LongData ? static_cast(data()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_INFO) && + verifier.VerifyTable(info()) && + VerifyField(verifier, VT_DATA_TYPE) && + VerifyOffset(verifier, VT_DATA) && + VerifyConstTensorData(verifier, data(), data_type()) && + verifier.EndTable(); + } +}; + +template<> inline const armnnSerializer::ByteData *ConstTensor::data_as() const { + return data_as_ByteData(); +} + +template<> inline const armnnSerializer::ShortData *ConstTensor::data_as() const { + return data_as_ShortData(); +} + +template<> inline const armnnSerializer::IntData *ConstTensor::data_as() const { + return data_as_IntData(); +} + +template<> inline const armnnSerializer::LongData *ConstTensor::data_as() const { + return data_as_LongData(); +} + +struct ConstTensorBuilder { + typedef ConstTensor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_info(flatbuffers::Offset info) { + fbb_.AddOffset(ConstTensor::VT_INFO, info); + } + void add_data_type(armnnSerializer::ConstTensorData data_type) { + fbb_.AddElement(ConstTensor::VT_DATA_TYPE, static_cast(data_type), 0); + } + void add_data(flatbuffers::Offset data) { + fbb_.AddOffset(ConstTensor::VT_DATA, data); + } + explicit ConstTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ConstTensorBuilder &operator=(const ConstTensorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateConstTensor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset info = 0, + armnnSerializer::ConstTensorData data_type = armnnSerializer::ConstTensorData_NONE, + flatbuffers::Offset data = 0) { + ConstTensorBuilder builder_(_fbb); + builder_.add_data(data); + builder_.add_info(info); + builder_.add_data_type(data_type); + return builder_.Finish(); +} + +struct InputSlot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InputSlotBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INDEX = 4, + VT_CONNECTION = 6 + }; + uint32_t index() const { + return GetField(VT_INDEX, 0); + } + const armnnSerializer::Connection *connection() const { + return GetStruct(VT_CONNECTION); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_INDEX) && + VerifyField(verifier, VT_CONNECTION) && + verifier.EndTable(); + } +}; + +struct InputSlotBuilder { + typedef InputSlot Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_index(uint32_t index) { + fbb_.AddElement(InputSlot::VT_INDEX, index, 0); + } + void add_connection(const armnnSerializer::Connection *connection) { + fbb_.AddStruct(InputSlot::VT_CONNECTION, connection); + } + explicit InputSlotBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + InputSlotBuilder &operator=(const InputSlotBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInputSlot( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t index = 0, + const armnnSerializer::Connection *connection = 0) { + InputSlotBuilder builder_(_fbb); + builder_.add_connection(connection); + builder_.add_index(index); + return builder_.Finish(); +} + +struct OutputSlot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OutputSlotBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INDEX = 4, + VT_TENSORINFO = 6 + }; + uint32_t index() const { + return GetField(VT_INDEX, 0); + } + const armnnSerializer::TensorInfo *tensorInfo() const { + return GetPointer(VT_TENSORINFO); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_INDEX) && + VerifyOffset(verifier, VT_TENSORINFO) && + verifier.VerifyTable(tensorInfo()) && + verifier.EndTable(); + } +}; + +struct OutputSlotBuilder { + typedef OutputSlot Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_index(uint32_t index) { + fbb_.AddElement(OutputSlot::VT_INDEX, index, 0); + } + void add_tensorInfo(flatbuffers::Offset tensorInfo) { + fbb_.AddOffset(OutputSlot::VT_TENSORINFO, tensorInfo); + } + explicit OutputSlotBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + OutputSlotBuilder &operator=(const OutputSlotBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateOutputSlot( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t index = 0, + flatbuffers::Offset tensorInfo = 0) { + OutputSlotBuilder builder_(_fbb); + builder_.add_tensorInfo(tensorInfo); + builder_.add_index(index); + return builder_.Finish(); +} + +struct LayerBase FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LayerBaseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INDEX = 4, + VT_LAYERNAME = 6, + VT_LAYERTYPE = 8, + VT_INPUTSLOTS = 10, + VT_OUTPUTSLOTS = 12 + }; + uint32_t index() const { + return GetField(VT_INDEX, 0); + } + const flatbuffers::String *layerName() const { + return GetPointer(VT_LAYERNAME); + } + armnnSerializer::LayerType layerType() const { + return static_cast(GetField(VT_LAYERTYPE, 0)); + } + const flatbuffers::Vector> *inputSlots() const { + return GetPointer> *>(VT_INPUTSLOTS); + } + const flatbuffers::Vector> *outputSlots() const { + return GetPointer> *>(VT_OUTPUTSLOTS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_INDEX) && + VerifyOffset(verifier, VT_LAYERNAME) && + verifier.VerifyString(layerName()) && + VerifyField(verifier, VT_LAYERTYPE) && + VerifyOffset(verifier, VT_INPUTSLOTS) && + verifier.VerifyVector(inputSlots()) && + verifier.VerifyVectorOfTables(inputSlots()) && + VerifyOffset(verifier, VT_OUTPUTSLOTS) && + verifier.VerifyVector(outputSlots()) && + verifier.VerifyVectorOfTables(outputSlots()) && + verifier.EndTable(); + } +}; + +struct LayerBaseBuilder { + typedef LayerBase Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_index(uint32_t index) { + fbb_.AddElement(LayerBase::VT_INDEX, index, 0); + } + void add_layerName(flatbuffers::Offset layerName) { + fbb_.AddOffset(LayerBase::VT_LAYERNAME, layerName); + } + void add_layerType(armnnSerializer::LayerType layerType) { + fbb_.AddElement(LayerBase::VT_LAYERTYPE, static_cast(layerType), 0); + } + void add_inputSlots(flatbuffers::Offset>> inputSlots) { + fbb_.AddOffset(LayerBase::VT_INPUTSLOTS, inputSlots); + } + void add_outputSlots(flatbuffers::Offset>> outputSlots) { + fbb_.AddOffset(LayerBase::VT_OUTPUTSLOTS, outputSlots); + } + explicit LayerBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LayerBaseBuilder &operator=(const LayerBaseBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLayerBase( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t index = 0, + flatbuffers::Offset layerName = 0, + armnnSerializer::LayerType layerType = armnnSerializer::LayerType_Addition, + flatbuffers::Offset>> inputSlots = 0, + flatbuffers::Offset>> outputSlots = 0) { + LayerBaseBuilder builder_(_fbb); + builder_.add_outputSlots(outputSlots); + builder_.add_inputSlots(inputSlots); + builder_.add_layerType(layerType); + builder_.add_layerName(layerName); + builder_.add_index(index); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateLayerBaseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t index = 0, + const char *layerName = nullptr, + armnnSerializer::LayerType layerType = armnnSerializer::LayerType_Addition, + const std::vector> *inputSlots = nullptr, + const std::vector> *outputSlots = nullptr) { + auto layerName__ = layerName ? _fbb.CreateString(layerName) : 0; + auto inputSlots__ = inputSlots ? _fbb.CreateVector>(*inputSlots) : 0; + auto outputSlots__ = outputSlots ? _fbb.CreateVector>(*outputSlots) : 0; + return armnnSerializer::CreateLayerBase( + _fbb, + index, + layerName__, + layerType, + inputSlots__, + outputSlots__); +} + +struct BindableLayerBase FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BindableLayerBaseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_LAYERBINDINGID = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + int32_t layerBindingId() const { + return GetField(VT_LAYERBINDINGID, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyField(verifier, VT_LAYERBINDINGID) && + verifier.EndTable(); + } +}; + +struct BindableLayerBaseBuilder { + typedef BindableLayerBase Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(BindableLayerBase::VT_BASE, base); + } + void add_layerBindingId(int32_t layerBindingId) { + fbb_.AddElement(BindableLayerBase::VT_LAYERBINDINGID, layerBindingId, 0); + } + explicit BindableLayerBaseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + BindableLayerBaseBuilder &operator=(const BindableLayerBaseBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateBindableLayerBase( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + int32_t layerBindingId = 0) { + BindableLayerBaseBuilder builder_(_fbb); + builder_.add_layerBindingId(layerBindingId); + builder_.add_base(base); + return builder_.Finish(); +} + +/// @deprecated Use ElementwiseUnaryLayer instead +struct AbsLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AbsLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct AbsLayerBuilder { + typedef AbsLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(AbsLayer::VT_BASE, base); + } + explicit AbsLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + AbsLayerBuilder &operator=(const AbsLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateAbsLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + AbsLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ActivationLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ActivationLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ActivationDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct ActivationLayerBuilder { + typedef ActivationLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ActivationLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(ActivationLayer::VT_DESCRIPTOR, descriptor); + } + explicit ActivationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ActivationLayerBuilder &operator=(const ActivationLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateActivationLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + ActivationLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ActivationDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ActivationDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ACTIVATIONFUNCTION = 4, + VT_A = 6, + VT_B = 8 + }; + armnnSerializer::ActivationFunction activationFunction() const { + return static_cast(GetField(VT_ACTIVATIONFUNCTION, 0)); + } + float a() const { + return GetField(VT_A, 0.0f); + } + float b() const { + return GetField(VT_B, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ACTIVATIONFUNCTION) && + VerifyField(verifier, VT_A) && + VerifyField(verifier, VT_B) && + verifier.EndTable(); + } +}; + +struct ActivationDescriptorBuilder { + typedef ActivationDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_activationFunction(armnnSerializer::ActivationFunction activationFunction) { + fbb_.AddElement(ActivationDescriptor::VT_ACTIVATIONFUNCTION, static_cast(activationFunction), 0); + } + void add_a(float a) { + fbb_.AddElement(ActivationDescriptor::VT_A, a, 0.0f); + } + void add_b(float b) { + fbb_.AddElement(ActivationDescriptor::VT_B, b, 0.0f); + } + explicit ActivationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ActivationDescriptorBuilder &operator=(const ActivationDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateActivationDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::ActivationFunction activationFunction = armnnSerializer::ActivationFunction_Sigmoid, + float a = 0.0f, + float b = 0.0f) { + ActivationDescriptorBuilder builder_(_fbb); + builder_.add_b(b); + builder_.add_a(a); + builder_.add_activationFunction(activationFunction); + return builder_.Finish(); +} + +struct AdditionLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AdditionLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct AdditionLayerBuilder { + typedef AdditionLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(AdditionLayer::VT_BASE, base); + } + explicit AdditionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + AdditionLayerBuilder &operator=(const AdditionLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateAdditionLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + AdditionLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ArgMinMaxLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ArgMinMaxLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ArgMinMaxDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct ArgMinMaxLayerBuilder { + typedef ArgMinMaxLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ArgMinMaxLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(ArgMinMaxLayer::VT_DESCRIPTOR, descriptor); + } + explicit ArgMinMaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ArgMinMaxLayerBuilder &operator=(const ArgMinMaxLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateArgMinMaxLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + ArgMinMaxLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ArgMinMaxDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ArgMinMaxDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ARGMINMAXFUNCTION = 4, + VT_AXIS = 6 + }; + armnnSerializer::ArgMinMaxFunction argMinMaxFunction() const { + return static_cast(GetField(VT_ARGMINMAXFUNCTION, 0)); + } + int32_t axis() const { + return GetField(VT_AXIS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ARGMINMAXFUNCTION) && + VerifyField(verifier, VT_AXIS) && + verifier.EndTable(); + } +}; + +struct ArgMinMaxDescriptorBuilder { + typedef ArgMinMaxDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_argMinMaxFunction(armnnSerializer::ArgMinMaxFunction argMinMaxFunction) { + fbb_.AddElement(ArgMinMaxDescriptor::VT_ARGMINMAXFUNCTION, static_cast(argMinMaxFunction), 0); + } + void add_axis(int32_t axis) { + fbb_.AddElement(ArgMinMaxDescriptor::VT_AXIS, axis, 0); + } + explicit ArgMinMaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ArgMinMaxDescriptorBuilder &operator=(const ArgMinMaxDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateArgMinMaxDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::ArgMinMaxFunction argMinMaxFunction = armnnSerializer::ArgMinMaxFunction_Min, + int32_t axis = 0) { + ArgMinMaxDescriptorBuilder builder_(_fbb); + builder_.add_axis(axis); + builder_.add_argMinMaxFunction(argMinMaxFunction); + return builder_.Finish(); +} + +struct ComparisonDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ComparisonDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OPERATION = 4 + }; + armnnSerializer::ComparisonOperation operation() const { + return static_cast(GetField(VT_OPERATION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_OPERATION) && + verifier.EndTable(); + } +}; + +struct ComparisonDescriptorBuilder { + typedef ComparisonDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_operation(armnnSerializer::ComparisonOperation operation) { + fbb_.AddElement(ComparisonDescriptor::VT_OPERATION, static_cast(operation), 0); + } + explicit ComparisonDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ComparisonDescriptorBuilder &operator=(const ComparisonDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateComparisonDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::ComparisonOperation operation = armnnSerializer::ComparisonOperation_Equal) { + ComparisonDescriptorBuilder builder_(_fbb); + builder_.add_operation(operation); + return builder_.Finish(); +} + +struct ComparisonLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ComparisonLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ComparisonDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct ComparisonLayerBuilder { + typedef ComparisonLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ComparisonLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(ComparisonLayer::VT_DESCRIPTOR, descriptor); + } + explicit ComparisonLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ComparisonLayerBuilder &operator=(const ComparisonLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateComparisonLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + ComparisonLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ConstantLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConstantLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_INPUT = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ConstTensor *input() const { + return GetPointer(VT_INPUT); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_INPUT) && + verifier.VerifyTable(input()) && + verifier.EndTable(); + } +}; + +struct ConstantLayerBuilder { + typedef ConstantLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ConstantLayer::VT_BASE, base); + } + void add_input(flatbuffers::Offset input) { + fbb_.AddOffset(ConstantLayer::VT_INPUT, input); + } + explicit ConstantLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ConstantLayerBuilder &operator=(const ConstantLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateConstantLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset input = 0) { + ConstantLayerBuilder builder_(_fbb); + builder_.add_input(input); + builder_.add_base(base); + return builder_.Finish(); +} + +struct Convolution2dLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Convolution2dLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6, + VT_WEIGHTS = 8, + VT_BIASES = 10 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::Convolution2dDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + const armnnSerializer::ConstTensor *weights() const { + return GetPointer(VT_WEIGHTS); + } + const armnnSerializer::ConstTensor *biases() const { + return GetPointer(VT_BIASES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + VerifyOffset(verifier, VT_WEIGHTS) && + verifier.VerifyTable(weights()) && + VerifyOffset(verifier, VT_BIASES) && + verifier.VerifyTable(biases()) && + verifier.EndTable(); + } +}; + +struct Convolution2dLayerBuilder { + typedef Convolution2dLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(Convolution2dLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(Convolution2dLayer::VT_DESCRIPTOR, descriptor); + } + void add_weights(flatbuffers::Offset weights) { + fbb_.AddOffset(Convolution2dLayer::VT_WEIGHTS, weights); + } + void add_biases(flatbuffers::Offset biases) { + fbb_.AddOffset(Convolution2dLayer::VT_BIASES, biases); + } + explicit Convolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Convolution2dLayerBuilder &operator=(const Convolution2dLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateConvolution2dLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0, + flatbuffers::Offset weights = 0, + flatbuffers::Offset biases = 0) { + Convolution2dLayerBuilder builder_(_fbb); + builder_.add_biases(biases); + builder_.add_weights(weights); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct Convolution2dDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Convolution2dDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PADLEFT = 4, + VT_PADRIGHT = 6, + VT_PADTOP = 8, + VT_PADBOTTOM = 10, + VT_STRIDEX = 12, + VT_STRIDEY = 14, + VT_DILATIONX = 16, + VT_DILATIONY = 18, + VT_BIASENABLED = 20, + VT_DATALAYOUT = 22 + }; + uint32_t padLeft() const { + return GetField(VT_PADLEFT, 0); + } + uint32_t padRight() const { + return GetField(VT_PADRIGHT, 0); + } + uint32_t padTop() const { + return GetField(VT_PADTOP, 0); + } + uint32_t padBottom() const { + return GetField(VT_PADBOTTOM, 0); + } + uint32_t strideX() const { + return GetField(VT_STRIDEX, 0); + } + uint32_t strideY() const { + return GetField(VT_STRIDEY, 0); + } + uint32_t dilationX() const { + return GetField(VT_DILATIONX, 1); + } + uint32_t dilationY() const { + return GetField(VT_DILATIONY, 1); + } + bool biasEnabled() const { + return GetField(VT_BIASENABLED, 0) != 0; + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 1)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_PADLEFT) && + VerifyField(verifier, VT_PADRIGHT) && + VerifyField(verifier, VT_PADTOP) && + VerifyField(verifier, VT_PADBOTTOM) && + VerifyField(verifier, VT_STRIDEX) && + VerifyField(verifier, VT_STRIDEY) && + VerifyField(verifier, VT_DILATIONX) && + VerifyField(verifier, VT_DILATIONY) && + VerifyField(verifier, VT_BIASENABLED) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct Convolution2dDescriptorBuilder { + typedef Convolution2dDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padLeft(uint32_t padLeft) { + fbb_.AddElement(Convolution2dDescriptor::VT_PADLEFT, padLeft, 0); + } + void add_padRight(uint32_t padRight) { + fbb_.AddElement(Convolution2dDescriptor::VT_PADRIGHT, padRight, 0); + } + void add_padTop(uint32_t padTop) { + fbb_.AddElement(Convolution2dDescriptor::VT_PADTOP, padTop, 0); + } + void add_padBottom(uint32_t padBottom) { + fbb_.AddElement(Convolution2dDescriptor::VT_PADBOTTOM, padBottom, 0); + } + void add_strideX(uint32_t strideX) { + fbb_.AddElement(Convolution2dDescriptor::VT_STRIDEX, strideX, 0); + } + void add_strideY(uint32_t strideY) { + fbb_.AddElement(Convolution2dDescriptor::VT_STRIDEY, strideY, 0); + } + void add_dilationX(uint32_t dilationX) { + fbb_.AddElement(Convolution2dDescriptor::VT_DILATIONX, dilationX, 1); + } + void add_dilationY(uint32_t dilationY) { + fbb_.AddElement(Convolution2dDescriptor::VT_DILATIONY, dilationY, 1); + } + void add_biasEnabled(bool biasEnabled) { + fbb_.AddElement(Convolution2dDescriptor::VT_BIASENABLED, static_cast(biasEnabled), 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(Convolution2dDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 1); + } + explicit Convolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Convolution2dDescriptorBuilder &operator=(const Convolution2dDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateConvolution2dDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t padLeft = 0, + uint32_t padRight = 0, + uint32_t padTop = 0, + uint32_t padBottom = 0, + uint32_t strideX = 0, + uint32_t strideY = 0, + uint32_t dilationX = 1, + uint32_t dilationY = 1, + bool biasEnabled = false, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NCHW) { + Convolution2dDescriptorBuilder builder_(_fbb); + builder_.add_dilationY(dilationY); + builder_.add_dilationX(dilationX); + builder_.add_strideY(strideY); + builder_.add_strideX(strideX); + builder_.add_padBottom(padBottom); + builder_.add_padTop(padTop); + builder_.add_padRight(padRight); + builder_.add_padLeft(padLeft); + builder_.add_dataLayout(dataLayout); + builder_.add_biasEnabled(biasEnabled); + return builder_.Finish(); +} + +struct DepthToSpaceLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DepthToSpaceLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::DepthToSpaceDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct DepthToSpaceLayerBuilder { + typedef DepthToSpaceLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(DepthToSpaceLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(DepthToSpaceLayer::VT_DESCRIPTOR, descriptor); + } + explicit DepthToSpaceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DepthToSpaceLayerBuilder &operator=(const DepthToSpaceLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDepthToSpaceLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + DepthToSpaceLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct DepthToSpaceDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DepthToSpaceDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BLOCKSIZE = 4, + VT_DATALAYOUT = 6 + }; + uint32_t blockSize() const { + return GetField(VT_BLOCKSIZE, 0); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BLOCKSIZE) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct DepthToSpaceDescriptorBuilder { + typedef DepthToSpaceDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_blockSize(uint32_t blockSize) { + fbb_.AddElement(DepthToSpaceDescriptor::VT_BLOCKSIZE, blockSize, 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(DepthToSpaceDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + explicit DepthToSpaceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DepthToSpaceDescriptorBuilder &operator=(const DepthToSpaceDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDepthToSpaceDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t blockSize = 0, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + DepthToSpaceDescriptorBuilder builder_(_fbb); + builder_.add_blockSize(blockSize); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +struct DivisionLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DivisionLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct DivisionLayerBuilder { + typedef DivisionLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(DivisionLayer::VT_BASE, base); + } + explicit DivisionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DivisionLayerBuilder &operator=(const DivisionLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDivisionLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + DivisionLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ElementwiseUnaryDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ElementwiseUnaryDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OPERATION = 4 + }; + armnnSerializer::UnaryOperation operation() const { + return static_cast(GetField(VT_OPERATION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_OPERATION) && + verifier.EndTable(); + } +}; + +struct ElementwiseUnaryDescriptorBuilder { + typedef ElementwiseUnaryDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_operation(armnnSerializer::UnaryOperation operation) { + fbb_.AddElement(ElementwiseUnaryDescriptor::VT_OPERATION, static_cast(operation), 0); + } + explicit ElementwiseUnaryDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ElementwiseUnaryDescriptorBuilder &operator=(const ElementwiseUnaryDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateElementwiseUnaryDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::UnaryOperation operation = armnnSerializer::UnaryOperation_Abs) { + ElementwiseUnaryDescriptorBuilder builder_(_fbb); + builder_.add_operation(operation); + return builder_.Finish(); +} + +struct ElementwiseUnaryLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ElementwiseUnaryLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ElementwiseUnaryDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct ElementwiseUnaryLayerBuilder { + typedef ElementwiseUnaryLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ElementwiseUnaryLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(ElementwiseUnaryLayer::VT_DESCRIPTOR, descriptor); + } + explicit ElementwiseUnaryLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ElementwiseUnaryLayerBuilder &operator=(const ElementwiseUnaryLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateElementwiseUnaryLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + ElementwiseUnaryLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +/// @deprecated Use ComparisonLayer instead +struct EqualLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef EqualLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct EqualLayerBuilder { + typedef EqualLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(EqualLayer::VT_BASE, base); + } + explicit EqualLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + EqualLayerBuilder &operator=(const EqualLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateEqualLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + EqualLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct FillLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FillLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::FillDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct FillLayerBuilder { + typedef FillLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(FillLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(FillLayer::VT_DESCRIPTOR, descriptor); + } + explicit FillLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FillLayerBuilder &operator=(const FillLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFillLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + FillLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct FillDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FillDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VALUE = 4 + }; + float value() const { + return GetField(VT_VALUE, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VALUE) && + verifier.EndTable(); + } +}; + +struct FillDescriptorBuilder { + typedef FillDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_value(float value) { + fbb_.AddElement(FillDescriptor::VT_VALUE, value, 0.0f); + } + explicit FillDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FillDescriptorBuilder &operator=(const FillDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFillDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + float value = 0.0f) { + FillDescriptorBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct FloorLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FloorLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct FloorLayerBuilder { + typedef FloorLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(FloorLayer::VT_BASE, base); + } + explicit FloorLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FloorLayerBuilder &operator=(const FloorLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFloorLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + FloorLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct FullyConnectedLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FullyConnectedLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6, + VT_WEIGHTS = 8, + VT_BIASES = 10 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::FullyConnectedDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + const armnnSerializer::ConstTensor *weights() const { + return GetPointer(VT_WEIGHTS); + } + const armnnSerializer::ConstTensor *biases() const { + return GetPointer(VT_BIASES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + VerifyOffset(verifier, VT_WEIGHTS) && + verifier.VerifyTable(weights()) && + VerifyOffset(verifier, VT_BIASES) && + verifier.VerifyTable(biases()) && + verifier.EndTable(); + } +}; + +struct FullyConnectedLayerBuilder { + typedef FullyConnectedLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(FullyConnectedLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(FullyConnectedLayer::VT_DESCRIPTOR, descriptor); + } + void add_weights(flatbuffers::Offset weights) { + fbb_.AddOffset(FullyConnectedLayer::VT_WEIGHTS, weights); + } + void add_biases(flatbuffers::Offset biases) { + fbb_.AddOffset(FullyConnectedLayer::VT_BIASES, biases); + } + explicit FullyConnectedLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FullyConnectedLayerBuilder &operator=(const FullyConnectedLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFullyConnectedLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0, + flatbuffers::Offset weights = 0, + flatbuffers::Offset biases = 0) { + FullyConnectedLayerBuilder builder_(_fbb); + builder_.add_biases(biases); + builder_.add_weights(weights); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct FullyConnectedDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FullyConnectedDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BIASENABLED = 4, + VT_TRANSPOSEWEIGHTSMATRIX = 6 + }; + bool biasEnabled() const { + return GetField(VT_BIASENABLED, 0) != 0; + } + bool transposeWeightsMatrix() const { + return GetField(VT_TRANSPOSEWEIGHTSMATRIX, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BIASENABLED) && + VerifyField(verifier, VT_TRANSPOSEWEIGHTSMATRIX) && + verifier.EndTable(); + } +}; + +struct FullyConnectedDescriptorBuilder { + typedef FullyConnectedDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_biasEnabled(bool biasEnabled) { + fbb_.AddElement(FullyConnectedDescriptor::VT_BIASENABLED, static_cast(biasEnabled), 0); + } + void add_transposeWeightsMatrix(bool transposeWeightsMatrix) { + fbb_.AddElement(FullyConnectedDescriptor::VT_TRANSPOSEWEIGHTSMATRIX, static_cast(transposeWeightsMatrix), 0); + } + explicit FullyConnectedDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FullyConnectedDescriptorBuilder &operator=(const FullyConnectedDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFullyConnectedDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + bool biasEnabled = false, + bool transposeWeightsMatrix = false) { + FullyConnectedDescriptorBuilder builder_(_fbb); + builder_.add_transposeWeightsMatrix(transposeWeightsMatrix); + builder_.add_biasEnabled(biasEnabled); + return builder_.Finish(); +} + +struct GatherLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef GatherLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::GatherDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct GatherLayerBuilder { + typedef GatherLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(GatherLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(GatherLayer::VT_DESCRIPTOR, descriptor); + } + explicit GatherLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + GatherLayerBuilder &operator=(const GatherLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateGatherLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + GatherLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct GatherDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef GatherDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_AXIS = 4 + }; + int32_t axis() const { + return GetField(VT_AXIS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_AXIS) && + verifier.EndTable(); + } +}; + +struct GatherDescriptorBuilder { + typedef GatherDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_axis(int32_t axis) { + fbb_.AddElement(GatherDescriptor::VT_AXIS, axis, 0); + } + explicit GatherDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + GatherDescriptorBuilder &operator=(const GatherDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateGatherDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t axis = 0) { + GatherDescriptorBuilder builder_(_fbb); + builder_.add_axis(axis); + return builder_.Finish(); +} + +/// @deprecated Use ComparisonLayer instead +struct GreaterLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef GreaterLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct GreaterLayerBuilder { + typedef GreaterLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(GreaterLayer::VT_BASE, base); + } + explicit GreaterLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + GreaterLayerBuilder &operator=(const GreaterLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateGreaterLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + GreaterLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct InputLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InputLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::BindableLayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct InputLayerBuilder { + typedef InputLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(InputLayer::VT_BASE, base); + } + explicit InputLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + InputLayerBuilder &operator=(const InputLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInputLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + InputLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct InstanceNormalizationLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InstanceNormalizationLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::InstanceNormalizationDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct InstanceNormalizationLayerBuilder { + typedef InstanceNormalizationLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(InstanceNormalizationLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(InstanceNormalizationLayer::VT_DESCRIPTOR, descriptor); + } + explicit InstanceNormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + InstanceNormalizationLayerBuilder &operator=(const InstanceNormalizationLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInstanceNormalizationLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + InstanceNormalizationLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct InstanceNormalizationDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InstanceNormalizationDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_GAMMA = 4, + VT_BETA = 6, + VT_EPS = 8, + VT_DATALAYOUT = 10 + }; + float gamma() const { + return GetField(VT_GAMMA, 0.0f); + } + float beta() const { + return GetField(VT_BETA, 0.0f); + } + float eps() const { + return GetField(VT_EPS, 0.0f); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_GAMMA) && + VerifyField(verifier, VT_BETA) && + VerifyField(verifier, VT_EPS) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct InstanceNormalizationDescriptorBuilder { + typedef InstanceNormalizationDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_gamma(float gamma) { + fbb_.AddElement(InstanceNormalizationDescriptor::VT_GAMMA, gamma, 0.0f); + } + void add_beta(float beta) { + fbb_.AddElement(InstanceNormalizationDescriptor::VT_BETA, beta, 0.0f); + } + void add_eps(float eps) { + fbb_.AddElement(InstanceNormalizationDescriptor::VT_EPS, eps, 0.0f); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(InstanceNormalizationDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + explicit InstanceNormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + InstanceNormalizationDescriptorBuilder &operator=(const InstanceNormalizationDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInstanceNormalizationDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + float gamma = 0.0f, + float beta = 0.0f, + float eps = 0.0f, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + InstanceNormalizationDescriptorBuilder builder_(_fbb); + builder_.add_eps(eps); + builder_.add_beta(beta); + builder_.add_gamma(gamma); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +struct LogSoftmaxLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LogSoftmaxLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::LogSoftmaxDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct LogSoftmaxLayerBuilder { + typedef LogSoftmaxLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(LogSoftmaxLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(LogSoftmaxLayer::VT_DESCRIPTOR, descriptor); + } + explicit LogSoftmaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LogSoftmaxLayerBuilder &operator=(const LogSoftmaxLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLogSoftmaxLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + LogSoftmaxLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct LogSoftmaxDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LogSoftmaxDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BETA = 4, + VT_AXIS = 6 + }; + float beta() const { + return GetField(VT_BETA, 1.0f); + } + int32_t axis() const { + return GetField(VT_AXIS, -1); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BETA) && + VerifyField(verifier, VT_AXIS) && + verifier.EndTable(); + } +}; + +struct LogSoftmaxDescriptorBuilder { + typedef LogSoftmaxDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_beta(float beta) { + fbb_.AddElement(LogSoftmaxDescriptor::VT_BETA, beta, 1.0f); + } + void add_axis(int32_t axis) { + fbb_.AddElement(LogSoftmaxDescriptor::VT_AXIS, axis, -1); + } + explicit LogSoftmaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LogSoftmaxDescriptorBuilder &operator=(const LogSoftmaxDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLogSoftmaxDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + float beta = 1.0f, + int32_t axis = -1) { + LogSoftmaxDescriptorBuilder builder_(_fbb); + builder_.add_axis(axis); + builder_.add_beta(beta); + return builder_.Finish(); +} + +struct L2NormalizationLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef L2NormalizationLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::L2NormalizationDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct L2NormalizationLayerBuilder { + typedef L2NormalizationLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(L2NormalizationLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(L2NormalizationLayer::VT_DESCRIPTOR, descriptor); + } + explicit L2NormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + L2NormalizationLayerBuilder &operator=(const L2NormalizationLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateL2NormalizationLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + L2NormalizationLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct L2NormalizationDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef L2NormalizationDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DATALAYOUT = 4, + VT_EPS = 6 + }; + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 1)); + } + float eps() const { + return GetField(VT_EPS, 1e-12f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_DATALAYOUT) && + VerifyField(verifier, VT_EPS) && + verifier.EndTable(); + } +}; + +struct L2NormalizationDescriptorBuilder { + typedef L2NormalizationDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(L2NormalizationDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 1); + } + void add_eps(float eps) { + fbb_.AddElement(L2NormalizationDescriptor::VT_EPS, eps, 1e-12f); + } + explicit L2NormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + L2NormalizationDescriptorBuilder &operator=(const L2NormalizationDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateL2NormalizationDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NCHW, + float eps = 1e-12f) { + L2NormalizationDescriptorBuilder builder_(_fbb); + builder_.add_eps(eps); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +struct LogicalBinaryDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LogicalBinaryDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OPERATION = 4 + }; + armnnSerializer::LogicalBinaryOperation operation() const { + return static_cast(GetField(VT_OPERATION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_OPERATION) && + verifier.EndTable(); + } +}; + +struct LogicalBinaryDescriptorBuilder { + typedef LogicalBinaryDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_operation(armnnSerializer::LogicalBinaryOperation operation) { + fbb_.AddElement(LogicalBinaryDescriptor::VT_OPERATION, static_cast(operation), 0); + } + explicit LogicalBinaryDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LogicalBinaryDescriptorBuilder &operator=(const LogicalBinaryDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLogicalBinaryDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::LogicalBinaryOperation operation = armnnSerializer::LogicalBinaryOperation_LogicalAnd) { + LogicalBinaryDescriptorBuilder builder_(_fbb); + builder_.add_operation(operation); + return builder_.Finish(); +} + +struct LogicalBinaryLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LogicalBinaryLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::LogicalBinaryDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct LogicalBinaryLayerBuilder { + typedef LogicalBinaryLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(LogicalBinaryLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(LogicalBinaryLayer::VT_DESCRIPTOR, descriptor); + } + explicit LogicalBinaryLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LogicalBinaryLayerBuilder &operator=(const LogicalBinaryLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLogicalBinaryLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + LogicalBinaryLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct MinimumLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MinimumLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct MinimumLayerBuilder { + typedef MinimumLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(MinimumLayer::VT_BASE, base); + } + explicit MinimumLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MinimumLayerBuilder &operator=(const MinimumLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMinimumLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + MinimumLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct MaximumLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MaximumLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct MaximumLayerBuilder { + typedef MaximumLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(MaximumLayer::VT_BASE, base); + } + explicit MaximumLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MaximumLayerBuilder &operator=(const MaximumLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMaximumLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + MaximumLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct MultiplicationLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MultiplicationLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct MultiplicationLayerBuilder { + typedef MultiplicationLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(MultiplicationLayer::VT_BASE, base); + } + explicit MultiplicationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MultiplicationLayerBuilder &operator=(const MultiplicationLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMultiplicationLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + MultiplicationLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct Pooling2dLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Pooling2dLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::Pooling2dDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct Pooling2dLayerBuilder { + typedef Pooling2dLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(Pooling2dLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(Pooling2dLayer::VT_DESCRIPTOR, descriptor); + } + explicit Pooling2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Pooling2dLayerBuilder &operator=(const Pooling2dLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePooling2dLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + Pooling2dLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct Pooling2dDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Pooling2dDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POOLTYPE = 4, + VT_PADLEFT = 6, + VT_PADRIGHT = 8, + VT_PADTOP = 10, + VT_PADBOTTOM = 12, + VT_POOLWIDTH = 14, + VT_POOLHEIGHT = 16, + VT_STRIDEX = 18, + VT_STRIDEY = 20, + VT_OUTPUTSHAPEROUNDING = 22, + VT_PADDINGMETHOD = 24, + VT_DATALAYOUT = 26 + }; + armnnSerializer::PoolingAlgorithm poolType() const { + return static_cast(GetField(VT_POOLTYPE, 0)); + } + uint32_t padLeft() const { + return GetField(VT_PADLEFT, 0); + } + uint32_t padRight() const { + return GetField(VT_PADRIGHT, 0); + } + uint32_t padTop() const { + return GetField(VT_PADTOP, 0); + } + uint32_t padBottom() const { + return GetField(VT_PADBOTTOM, 0); + } + uint32_t poolWidth() const { + return GetField(VT_POOLWIDTH, 0); + } + uint32_t poolHeight() const { + return GetField(VT_POOLHEIGHT, 0); + } + uint32_t strideX() const { + return GetField(VT_STRIDEX, 0); + } + uint32_t strideY() const { + return GetField(VT_STRIDEY, 0); + } + armnnSerializer::OutputShapeRounding outputShapeRounding() const { + return static_cast(GetField(VT_OUTPUTSHAPEROUNDING, 0)); + } + armnnSerializer::PaddingMethod paddingMethod() const { + return static_cast(GetField(VT_PADDINGMETHOD, 0)); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POOLTYPE) && + VerifyField(verifier, VT_PADLEFT) && + VerifyField(verifier, VT_PADRIGHT) && + VerifyField(verifier, VT_PADTOP) && + VerifyField(verifier, VT_PADBOTTOM) && + VerifyField(verifier, VT_POOLWIDTH) && + VerifyField(verifier, VT_POOLHEIGHT) && + VerifyField(verifier, VT_STRIDEX) && + VerifyField(verifier, VT_STRIDEY) && + VerifyField(verifier, VT_OUTPUTSHAPEROUNDING) && + VerifyField(verifier, VT_PADDINGMETHOD) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct Pooling2dDescriptorBuilder { + typedef Pooling2dDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_poolType(armnnSerializer::PoolingAlgorithm poolType) { + fbb_.AddElement(Pooling2dDescriptor::VT_POOLTYPE, static_cast(poolType), 0); + } + void add_padLeft(uint32_t padLeft) { + fbb_.AddElement(Pooling2dDescriptor::VT_PADLEFT, padLeft, 0); + } + void add_padRight(uint32_t padRight) { + fbb_.AddElement(Pooling2dDescriptor::VT_PADRIGHT, padRight, 0); + } + void add_padTop(uint32_t padTop) { + fbb_.AddElement(Pooling2dDescriptor::VT_PADTOP, padTop, 0); + } + void add_padBottom(uint32_t padBottom) { + fbb_.AddElement(Pooling2dDescriptor::VT_PADBOTTOM, padBottom, 0); + } + void add_poolWidth(uint32_t poolWidth) { + fbb_.AddElement(Pooling2dDescriptor::VT_POOLWIDTH, poolWidth, 0); + } + void add_poolHeight(uint32_t poolHeight) { + fbb_.AddElement(Pooling2dDescriptor::VT_POOLHEIGHT, poolHeight, 0); + } + void add_strideX(uint32_t strideX) { + fbb_.AddElement(Pooling2dDescriptor::VT_STRIDEX, strideX, 0); + } + void add_strideY(uint32_t strideY) { + fbb_.AddElement(Pooling2dDescriptor::VT_STRIDEY, strideY, 0); + } + void add_outputShapeRounding(armnnSerializer::OutputShapeRounding outputShapeRounding) { + fbb_.AddElement(Pooling2dDescriptor::VT_OUTPUTSHAPEROUNDING, static_cast(outputShapeRounding), 0); + } + void add_paddingMethod(armnnSerializer::PaddingMethod paddingMethod) { + fbb_.AddElement(Pooling2dDescriptor::VT_PADDINGMETHOD, static_cast(paddingMethod), 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(Pooling2dDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + explicit Pooling2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Pooling2dDescriptorBuilder &operator=(const Pooling2dDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePooling2dDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::PoolingAlgorithm poolType = armnnSerializer::PoolingAlgorithm_Max, + uint32_t padLeft = 0, + uint32_t padRight = 0, + uint32_t padTop = 0, + uint32_t padBottom = 0, + uint32_t poolWidth = 0, + uint32_t poolHeight = 0, + uint32_t strideX = 0, + uint32_t strideY = 0, + armnnSerializer::OutputShapeRounding outputShapeRounding = armnnSerializer::OutputShapeRounding_Floor, + armnnSerializer::PaddingMethod paddingMethod = armnnSerializer::PaddingMethod_IgnoreValue, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + Pooling2dDescriptorBuilder builder_(_fbb); + builder_.add_strideY(strideY); + builder_.add_strideX(strideX); + builder_.add_poolHeight(poolHeight); + builder_.add_poolWidth(poolWidth); + builder_.add_padBottom(padBottom); + builder_.add_padTop(padTop); + builder_.add_padRight(padRight); + builder_.add_padLeft(padLeft); + builder_.add_dataLayout(dataLayout); + builder_.add_paddingMethod(paddingMethod); + builder_.add_outputShapeRounding(outputShapeRounding); + builder_.add_poolType(poolType); + return builder_.Finish(); +} + +struct QuantizeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef QuantizeLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct QuantizeLayerBuilder { + typedef QuantizeLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(QuantizeLayer::VT_BASE, base); + } + explicit QuantizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + QuantizeLayerBuilder &operator=(const QuantizeLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateQuantizeLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + QuantizeLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct SoftmaxLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SoftmaxLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::SoftmaxDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct SoftmaxLayerBuilder { + typedef SoftmaxLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(SoftmaxLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(SoftmaxLayer::VT_DESCRIPTOR, descriptor); + } + explicit SoftmaxLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SoftmaxLayerBuilder &operator=(const SoftmaxLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSoftmaxLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + SoftmaxLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct SoftmaxDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SoftmaxDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BETA = 4 + }; + float beta() const { + return GetField(VT_BETA, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BETA) && + verifier.EndTable(); + } +}; + +struct SoftmaxDescriptorBuilder { + typedef SoftmaxDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_beta(float beta) { + fbb_.AddElement(SoftmaxDescriptor::VT_BETA, beta, 0.0f); + } + explicit SoftmaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SoftmaxDescriptorBuilder &operator=(const SoftmaxDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSoftmaxDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + float beta = 0.0f) { + SoftmaxDescriptorBuilder builder_(_fbb); + builder_.add_beta(beta); + return builder_.Finish(); +} + +struct DepthwiseConvolution2dLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DepthwiseConvolution2dLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6, + VT_WEIGHTS = 8, + VT_BIASES = 10 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::DepthwiseConvolution2dDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + const armnnSerializer::ConstTensor *weights() const { + return GetPointer(VT_WEIGHTS); + } + const armnnSerializer::ConstTensor *biases() const { + return GetPointer(VT_BIASES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + VerifyOffset(verifier, VT_WEIGHTS) && + verifier.VerifyTable(weights()) && + VerifyOffset(verifier, VT_BIASES) && + verifier.VerifyTable(biases()) && + verifier.EndTable(); + } +}; + +struct DepthwiseConvolution2dLayerBuilder { + typedef DepthwiseConvolution2dLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_DESCRIPTOR, descriptor); + } + void add_weights(flatbuffers::Offset weights) { + fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_WEIGHTS, weights); + } + void add_biases(flatbuffers::Offset biases) { + fbb_.AddOffset(DepthwiseConvolution2dLayer::VT_BIASES, biases); + } + explicit DepthwiseConvolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DepthwiseConvolution2dLayerBuilder &operator=(const DepthwiseConvolution2dLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDepthwiseConvolution2dLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0, + flatbuffers::Offset weights = 0, + flatbuffers::Offset biases = 0) { + DepthwiseConvolution2dLayerBuilder builder_(_fbb); + builder_.add_biases(biases); + builder_.add_weights(weights); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct DepthwiseConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DepthwiseConvolution2dDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PADLEFT = 4, + VT_PADRIGHT = 6, + VT_PADTOP = 8, + VT_PADBOTTOM = 10, + VT_STRIDEX = 12, + VT_STRIDEY = 14, + VT_DILATIONX = 16, + VT_DILATIONY = 18, + VT_BIASENABLED = 20, + VT_DATALAYOUT = 22 + }; + uint32_t padLeft() const { + return GetField(VT_PADLEFT, 0); + } + uint32_t padRight() const { + return GetField(VT_PADRIGHT, 0); + } + uint32_t padTop() const { + return GetField(VT_PADTOP, 0); + } + uint32_t padBottom() const { + return GetField(VT_PADBOTTOM, 0); + } + uint32_t strideX() const { + return GetField(VT_STRIDEX, 0); + } + uint32_t strideY() const { + return GetField(VT_STRIDEY, 0); + } + uint32_t dilationX() const { + return GetField(VT_DILATIONX, 1); + } + uint32_t dilationY() const { + return GetField(VT_DILATIONY, 1); + } + bool biasEnabled() const { + return GetField(VT_BIASENABLED, 0) != 0; + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 1)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_PADLEFT) && + VerifyField(verifier, VT_PADRIGHT) && + VerifyField(verifier, VT_PADTOP) && + VerifyField(verifier, VT_PADBOTTOM) && + VerifyField(verifier, VT_STRIDEX) && + VerifyField(verifier, VT_STRIDEY) && + VerifyField(verifier, VT_DILATIONX) && + VerifyField(verifier, VT_DILATIONY) && + VerifyField(verifier, VT_BIASENABLED) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct DepthwiseConvolution2dDescriptorBuilder { + typedef DepthwiseConvolution2dDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padLeft(uint32_t padLeft) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_PADLEFT, padLeft, 0); + } + void add_padRight(uint32_t padRight) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_PADRIGHT, padRight, 0); + } + void add_padTop(uint32_t padTop) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_PADTOP, padTop, 0); + } + void add_padBottom(uint32_t padBottom) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_PADBOTTOM, padBottom, 0); + } + void add_strideX(uint32_t strideX) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_STRIDEX, strideX, 0); + } + void add_strideY(uint32_t strideY) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_STRIDEY, strideY, 0); + } + void add_dilationX(uint32_t dilationX) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_DILATIONX, dilationX, 1); + } + void add_dilationY(uint32_t dilationY) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_DILATIONY, dilationY, 1); + } + void add_biasEnabled(bool biasEnabled) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_BIASENABLED, static_cast(biasEnabled), 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(DepthwiseConvolution2dDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 1); + } + explicit DepthwiseConvolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DepthwiseConvolution2dDescriptorBuilder &operator=(const DepthwiseConvolution2dDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDepthwiseConvolution2dDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t padLeft = 0, + uint32_t padRight = 0, + uint32_t padTop = 0, + uint32_t padBottom = 0, + uint32_t strideX = 0, + uint32_t strideY = 0, + uint32_t dilationX = 1, + uint32_t dilationY = 1, + bool biasEnabled = false, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NCHW) { + DepthwiseConvolution2dDescriptorBuilder builder_(_fbb); + builder_.add_dilationY(dilationY); + builder_.add_dilationX(dilationX); + builder_.add_strideY(strideY); + builder_.add_strideX(strideX); + builder_.add_padBottom(padBottom); + builder_.add_padTop(padTop); + builder_.add_padRight(padRight); + builder_.add_padLeft(padLeft); + builder_.add_dataLayout(dataLayout); + builder_.add_biasEnabled(biasEnabled); + return builder_.Finish(); +} + +struct OutputLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OutputLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::BindableLayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct OutputLayerBuilder { + typedef OutputLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(OutputLayer::VT_BASE, base); + } + explicit OutputLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + OutputLayerBuilder &operator=(const OutputLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateOutputLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + OutputLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ReshapeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ReshapeLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ReshapeDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct ReshapeLayerBuilder { + typedef ReshapeLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ReshapeLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(ReshapeLayer::VT_DESCRIPTOR, descriptor); + } + explicit ReshapeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ReshapeLayerBuilder &operator=(const ReshapeLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateReshapeLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + ReshapeLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ReshapeDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ReshapeDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TARGETSHAPE = 4 + }; + const flatbuffers::Vector *targetShape() const { + return GetPointer *>(VT_TARGETSHAPE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TARGETSHAPE) && + verifier.VerifyVector(targetShape()) && + verifier.EndTable(); + } +}; + +struct ReshapeDescriptorBuilder { + typedef ReshapeDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_targetShape(flatbuffers::Offset> targetShape) { + fbb_.AddOffset(ReshapeDescriptor::VT_TARGETSHAPE, targetShape); + } + explicit ReshapeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ReshapeDescriptorBuilder &operator=(const ReshapeDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateReshapeDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> targetShape = 0) { + ReshapeDescriptorBuilder builder_(_fbb); + builder_.add_targetShape(targetShape); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateReshapeDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *targetShape = nullptr) { + auto targetShape__ = targetShape ? _fbb.CreateVector(*targetShape) : 0; + return armnnSerializer::CreateReshapeDescriptor( + _fbb, + targetShape__); +} + +struct PermuteLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PermuteLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::PermuteDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct PermuteLayerBuilder { + typedef PermuteLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(PermuteLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(PermuteLayer::VT_DESCRIPTOR, descriptor); + } + explicit PermuteLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PermuteLayerBuilder &operator=(const PermuteLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePermuteLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + PermuteLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct PermuteDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PermuteDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DIMMAPPINGS = 4 + }; + const flatbuffers::Vector *dimMappings() const { + return GetPointer *>(VT_DIMMAPPINGS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DIMMAPPINGS) && + verifier.VerifyVector(dimMappings()) && + verifier.EndTable(); + } +}; + +struct PermuteDescriptorBuilder { + typedef PermuteDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_dimMappings(flatbuffers::Offset> dimMappings) { + fbb_.AddOffset(PermuteDescriptor::VT_DIMMAPPINGS, dimMappings); + } + explicit PermuteDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PermuteDescriptorBuilder &operator=(const PermuteDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePermuteDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> dimMappings = 0) { + PermuteDescriptorBuilder builder_(_fbb); + builder_.add_dimMappings(dimMappings); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreatePermuteDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *dimMappings = nullptr) { + auto dimMappings__ = dimMappings ? _fbb.CreateVector(*dimMappings) : 0; + return armnnSerializer::CreatePermuteDescriptor( + _fbb, + dimMappings__); +} + +struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SpaceToBatchNdLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::SpaceToBatchNdDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct SpaceToBatchNdLayerBuilder { + typedef SpaceToBatchNdLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(SpaceToBatchNdLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(SpaceToBatchNdLayer::VT_DESCRIPTOR, descriptor); + } + explicit SpaceToBatchNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SpaceToBatchNdLayerBuilder &operator=(const SpaceToBatchNdLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSpaceToBatchNdLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + SpaceToBatchNdLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct SpaceToBatchNdDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SpaceToBatchNdDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BLOCKSHAPE = 4, + VT_PADLIST = 6, + VT_DATALAYOUT = 8 + }; + const flatbuffers::Vector *blockShape() const { + return GetPointer *>(VT_BLOCKSHAPE); + } + const flatbuffers::Vector *padList() const { + return GetPointer *>(VT_PADLIST); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BLOCKSHAPE) && + verifier.VerifyVector(blockShape()) && + VerifyOffset(verifier, VT_PADLIST) && + verifier.VerifyVector(padList()) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct SpaceToBatchNdDescriptorBuilder { + typedef SpaceToBatchNdDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_blockShape(flatbuffers::Offset> blockShape) { + fbb_.AddOffset(SpaceToBatchNdDescriptor::VT_BLOCKSHAPE, blockShape); + } + void add_padList(flatbuffers::Offset> padList) { + fbb_.AddOffset(SpaceToBatchNdDescriptor::VT_PADLIST, padList); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(SpaceToBatchNdDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + explicit SpaceToBatchNdDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SpaceToBatchNdDescriptorBuilder &operator=(const SpaceToBatchNdDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSpaceToBatchNdDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> blockShape = 0, + flatbuffers::Offset> padList = 0, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + SpaceToBatchNdDescriptorBuilder builder_(_fbb); + builder_.add_padList(padList); + builder_.add_blockShape(blockShape); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSpaceToBatchNdDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *blockShape = nullptr, + const std::vector *padList = nullptr, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + auto blockShape__ = blockShape ? _fbb.CreateVector(*blockShape) : 0; + auto padList__ = padList ? _fbb.CreateVector(*padList) : 0; + return armnnSerializer::CreateSpaceToBatchNdDescriptor( + _fbb, + blockShape__, + padList__, + dataLayout); +} + +struct SpaceToDepthLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SpaceToDepthLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::SpaceToDepthDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct SpaceToDepthLayerBuilder { + typedef SpaceToDepthLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(SpaceToDepthLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(SpaceToDepthLayer::VT_DESCRIPTOR, descriptor); + } + explicit SpaceToDepthLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SpaceToDepthLayerBuilder &operator=(const SpaceToDepthLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSpaceToDepthLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + SpaceToDepthLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct SpaceToDepthDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SpaceToDepthDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BLOCKSIZE = 4, + VT_DATALAYOUT = 6 + }; + uint32_t blockSize() const { + return GetField(VT_BLOCKSIZE, 0); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BLOCKSIZE) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct SpaceToDepthDescriptorBuilder { + typedef SpaceToDepthDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_blockSize(uint32_t blockSize) { + fbb_.AddElement(SpaceToDepthDescriptor::VT_BLOCKSIZE, blockSize, 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(SpaceToDepthDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + explicit SpaceToDepthDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SpaceToDepthDescriptorBuilder &operator=(const SpaceToDepthDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSpaceToDepthDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t blockSize = 0, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + SpaceToDepthDescriptorBuilder builder_(_fbb); + builder_.add_blockSize(blockSize); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +struct SubtractionLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SubtractionLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct SubtractionLayerBuilder { + typedef SubtractionLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(SubtractionLayer::VT_BASE, base); + } + explicit SubtractionLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SubtractionLayerBuilder &operator=(const SubtractionLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSubtractionLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + SubtractionLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct BatchToSpaceNdLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BatchToSpaceNdLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::BatchToSpaceNdDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct BatchToSpaceNdLayerBuilder { + typedef BatchToSpaceNdLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(BatchToSpaceNdLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(BatchToSpaceNdLayer::VT_DESCRIPTOR, descriptor); + } + explicit BatchToSpaceNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + BatchToSpaceNdLayerBuilder &operator=(const BatchToSpaceNdLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateBatchToSpaceNdLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + BatchToSpaceNdLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct BatchToSpaceNdDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BatchToSpaceNdDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BLOCKSHAPE = 4, + VT_CROPS = 6, + VT_DATALAYOUT = 8 + }; + const flatbuffers::Vector *blockShape() const { + return GetPointer *>(VT_BLOCKSHAPE); + } + const flatbuffers::Vector *crops() const { + return GetPointer *>(VT_CROPS); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BLOCKSHAPE) && + verifier.VerifyVector(blockShape()) && + VerifyOffset(verifier, VT_CROPS) && + verifier.VerifyVector(crops()) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct BatchToSpaceNdDescriptorBuilder { + typedef BatchToSpaceNdDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_blockShape(flatbuffers::Offset> blockShape) { + fbb_.AddOffset(BatchToSpaceNdDescriptor::VT_BLOCKSHAPE, blockShape); + } + void add_crops(flatbuffers::Offset> crops) { + fbb_.AddOffset(BatchToSpaceNdDescriptor::VT_CROPS, crops); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(BatchToSpaceNdDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + explicit BatchToSpaceNdDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + BatchToSpaceNdDescriptorBuilder &operator=(const BatchToSpaceNdDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateBatchToSpaceNdDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> blockShape = 0, + flatbuffers::Offset> crops = 0, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + BatchToSpaceNdDescriptorBuilder builder_(_fbb); + builder_.add_crops(crops); + builder_.add_blockShape(blockShape); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateBatchToSpaceNdDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *blockShape = nullptr, + const std::vector *crops = nullptr, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + auto blockShape__ = blockShape ? _fbb.CreateVector(*blockShape) : 0; + auto crops__ = crops ? _fbb.CreateVector(*crops) : 0; + return armnnSerializer::CreateBatchToSpaceNdDescriptor( + _fbb, + blockShape__, + crops__, + dataLayout); +} + +struct NormalizationLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef NormalizationLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::NormalizationDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct NormalizationLayerBuilder { + typedef NormalizationLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(NormalizationLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(NormalizationLayer::VT_DESCRIPTOR, descriptor); + } + explicit NormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + NormalizationLayerBuilder &operator=(const NormalizationLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateNormalizationLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + NormalizationLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct NormalizationDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef NormalizationDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NORMCHANNELTYPE = 4, + VT_NORMMETHODTYPE = 6, + VT_NORMSIZE = 8, + VT_ALPHA = 10, + VT_BETA = 12, + VT_K = 14, + VT_DATALAYOUT = 16 + }; + armnnSerializer::NormalizationAlgorithmChannel normChannelType() const { + return static_cast(GetField(VT_NORMCHANNELTYPE, 0)); + } + armnnSerializer::NormalizationAlgorithmMethod normMethodType() const { + return static_cast(GetField(VT_NORMMETHODTYPE, 0)); + } + uint32_t normSize() const { + return GetField(VT_NORMSIZE, 0); + } + float alpha() const { + return GetField(VT_ALPHA, 0.0f); + } + float beta() const { + return GetField(VT_BETA, 0.0f); + } + float k() const { + return GetField(VT_K, 0.0f); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 1)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NORMCHANNELTYPE) && + VerifyField(verifier, VT_NORMMETHODTYPE) && + VerifyField(verifier, VT_NORMSIZE) && + VerifyField(verifier, VT_ALPHA) && + VerifyField(verifier, VT_BETA) && + VerifyField(verifier, VT_K) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct NormalizationDescriptorBuilder { + typedef NormalizationDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_normChannelType(armnnSerializer::NormalizationAlgorithmChannel normChannelType) { + fbb_.AddElement(NormalizationDescriptor::VT_NORMCHANNELTYPE, static_cast(normChannelType), 0); + } + void add_normMethodType(armnnSerializer::NormalizationAlgorithmMethod normMethodType) { + fbb_.AddElement(NormalizationDescriptor::VT_NORMMETHODTYPE, static_cast(normMethodType), 0); + } + void add_normSize(uint32_t normSize) { + fbb_.AddElement(NormalizationDescriptor::VT_NORMSIZE, normSize, 0); + } + void add_alpha(float alpha) { + fbb_.AddElement(NormalizationDescriptor::VT_ALPHA, alpha, 0.0f); + } + void add_beta(float beta) { + fbb_.AddElement(NormalizationDescriptor::VT_BETA, beta, 0.0f); + } + void add_k(float k) { + fbb_.AddElement(NormalizationDescriptor::VT_K, k, 0.0f); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(NormalizationDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 1); + } + explicit NormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + NormalizationDescriptorBuilder &operator=(const NormalizationDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateNormalizationDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::NormalizationAlgorithmChannel normChannelType = armnnSerializer::NormalizationAlgorithmChannel_Across, + armnnSerializer::NormalizationAlgorithmMethod normMethodType = armnnSerializer::NormalizationAlgorithmMethod_LocalBrightness, + uint32_t normSize = 0, + float alpha = 0.0f, + float beta = 0.0f, + float k = 0.0f, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NCHW) { + NormalizationDescriptorBuilder builder_(_fbb); + builder_.add_k(k); + builder_.add_beta(beta); + builder_.add_alpha(alpha); + builder_.add_normSize(normSize); + builder_.add_dataLayout(dataLayout); + builder_.add_normMethodType(normMethodType); + builder_.add_normChannelType(normChannelType); + return builder_.Finish(); +} + +struct MeanLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MeanLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::MeanDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct MeanLayerBuilder { + typedef MeanLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(MeanLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(MeanLayer::VT_DESCRIPTOR, descriptor); + } + explicit MeanLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MeanLayerBuilder &operator=(const MeanLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMeanLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + MeanLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct MeanDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MeanDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_AXIS = 4, + VT_KEEPDIMS = 6 + }; + const flatbuffers::Vector *axis() const { + return GetPointer *>(VT_AXIS); + } + bool keepDims() const { + return GetField(VT_KEEPDIMS, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_AXIS) && + verifier.VerifyVector(axis()) && + VerifyField(verifier, VT_KEEPDIMS) && + verifier.EndTable(); + } +}; + +struct MeanDescriptorBuilder { + typedef MeanDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_axis(flatbuffers::Offset> axis) { + fbb_.AddOffset(MeanDescriptor::VT_AXIS, axis); + } + void add_keepDims(bool keepDims) { + fbb_.AddElement(MeanDescriptor::VT_KEEPDIMS, static_cast(keepDims), 0); + } + explicit MeanDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MeanDescriptorBuilder &operator=(const MeanDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMeanDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> axis = 0, + bool keepDims = false) { + MeanDescriptorBuilder builder_(_fbb); + builder_.add_axis(axis); + builder_.add_keepDims(keepDims); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateMeanDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *axis = nullptr, + bool keepDims = false) { + auto axis__ = axis ? _fbb.CreateVector(*axis) : 0; + return armnnSerializer::CreateMeanDescriptor( + _fbb, + axis__, + keepDims); +} + +struct PadLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PadLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::PadDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct PadLayerBuilder { + typedef PadLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(PadLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(PadLayer::VT_DESCRIPTOR, descriptor); + } + explicit PadLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PadLayerBuilder &operator=(const PadLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePadLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + PadLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct PadDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PadDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PADLIST = 4, + VT_PADVALUE = 6 + }; + const flatbuffers::Vector *padList() const { + return GetPointer *>(VT_PADLIST); + } + float padValue() const { + return GetField(VT_PADVALUE, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PADLIST) && + verifier.VerifyVector(padList()) && + VerifyField(verifier, VT_PADVALUE) && + verifier.EndTable(); + } +}; + +struct PadDescriptorBuilder { + typedef PadDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padList(flatbuffers::Offset> padList) { + fbb_.AddOffset(PadDescriptor::VT_PADLIST, padList); + } + void add_padValue(float padValue) { + fbb_.AddElement(PadDescriptor::VT_PADVALUE, padValue, 0.0f); + } + explicit PadDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PadDescriptorBuilder &operator=(const PadDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePadDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> padList = 0, + float padValue = 0.0f) { + PadDescriptorBuilder builder_(_fbb); + builder_.add_padValue(padValue); + builder_.add_padList(padList); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreatePadDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *padList = nullptr, + float padValue = 0.0f) { + auto padList__ = padList ? _fbb.CreateVector(*padList) : 0; + return armnnSerializer::CreatePadDescriptor( + _fbb, + padList__, + padValue); +} + +/// @deprecated Use ElementwiseUnaryLayer instead +struct RsqrtLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RsqrtLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct RsqrtLayerBuilder { + typedef RsqrtLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(RsqrtLayer::VT_BASE, base); + } + explicit RsqrtLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RsqrtLayerBuilder &operator=(const RsqrtLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateRsqrtLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + RsqrtLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct BatchNormalizationLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BatchNormalizationLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6, + VT_MEAN = 8, + VT_VARIANCE = 10, + VT_BETA = 12, + VT_GAMMA = 14 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::BatchNormalizationDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + const armnnSerializer::ConstTensor *mean() const { + return GetPointer(VT_MEAN); + } + const armnnSerializer::ConstTensor *variance() const { + return GetPointer(VT_VARIANCE); + } + const armnnSerializer::ConstTensor *beta() const { + return GetPointer(VT_BETA); + } + const armnnSerializer::ConstTensor *gamma() const { + return GetPointer(VT_GAMMA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + VerifyOffset(verifier, VT_MEAN) && + verifier.VerifyTable(mean()) && + VerifyOffset(verifier, VT_VARIANCE) && + verifier.VerifyTable(variance()) && + VerifyOffset(verifier, VT_BETA) && + verifier.VerifyTable(beta()) && + VerifyOffset(verifier, VT_GAMMA) && + verifier.VerifyTable(gamma()) && + verifier.EndTable(); + } +}; + +struct BatchNormalizationLayerBuilder { + typedef BatchNormalizationLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(BatchNormalizationLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(BatchNormalizationLayer::VT_DESCRIPTOR, descriptor); + } + void add_mean(flatbuffers::Offset mean) { + fbb_.AddOffset(BatchNormalizationLayer::VT_MEAN, mean); + } + void add_variance(flatbuffers::Offset variance) { + fbb_.AddOffset(BatchNormalizationLayer::VT_VARIANCE, variance); + } + void add_beta(flatbuffers::Offset beta) { + fbb_.AddOffset(BatchNormalizationLayer::VT_BETA, beta); + } + void add_gamma(flatbuffers::Offset gamma) { + fbb_.AddOffset(BatchNormalizationLayer::VT_GAMMA, gamma); + } + explicit BatchNormalizationLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + BatchNormalizationLayerBuilder &operator=(const BatchNormalizationLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateBatchNormalizationLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0, + flatbuffers::Offset mean = 0, + flatbuffers::Offset variance = 0, + flatbuffers::Offset beta = 0, + flatbuffers::Offset gamma = 0) { + BatchNormalizationLayerBuilder builder_(_fbb); + builder_.add_gamma(gamma); + builder_.add_beta(beta); + builder_.add_variance(variance); + builder_.add_mean(mean); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct BatchNormalizationDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BatchNormalizationDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_EPS = 4, + VT_DATALAYOUT = 6 + }; + float eps() const { + return GetField(VT_EPS, 0.0f); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_EPS) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct BatchNormalizationDescriptorBuilder { + typedef BatchNormalizationDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_eps(float eps) { + fbb_.AddElement(BatchNormalizationDescriptor::VT_EPS, eps, 0.0f); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(BatchNormalizationDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + explicit BatchNormalizationDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + BatchNormalizationDescriptorBuilder &operator=(const BatchNormalizationDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateBatchNormalizationDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + float eps = 0.0f, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + BatchNormalizationDescriptorBuilder builder_(_fbb); + builder_.add_eps(eps); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +/// @deprecated Use ResizeLayer instead +struct ResizeBilinearLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResizeBilinearLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ResizeBilinearDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct ResizeBilinearLayerBuilder { + typedef ResizeBilinearLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ResizeBilinearLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(ResizeBilinearLayer::VT_DESCRIPTOR, descriptor); + } + explicit ResizeBilinearLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ResizeBilinearLayerBuilder &operator=(const ResizeBilinearLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateResizeBilinearLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + ResizeBilinearLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ResizeBilinearDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResizeBilinearDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TARGETWIDTH = 4, + VT_TARGETHEIGHT = 6, + VT_DATALAYOUT = 8, + VT_ALIGNCORNERS = 10, + VT_HALFPIXELCENTERS = 12 + }; + uint32_t targetWidth() const { + return GetField(VT_TARGETWIDTH, 0); + } + uint32_t targetHeight() const { + return GetField(VT_TARGETHEIGHT, 0); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool alignCorners() const { + return GetField(VT_ALIGNCORNERS, 0) != 0; + } + bool halfPixelCenters() const { + return GetField(VT_HALFPIXELCENTERS, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_TARGETWIDTH) && + VerifyField(verifier, VT_TARGETHEIGHT) && + VerifyField(verifier, VT_DATALAYOUT) && + VerifyField(verifier, VT_ALIGNCORNERS) && + VerifyField(verifier, VT_HALFPIXELCENTERS) && + verifier.EndTable(); + } +}; + +struct ResizeBilinearDescriptorBuilder { + typedef ResizeBilinearDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_targetWidth(uint32_t targetWidth) { + fbb_.AddElement(ResizeBilinearDescriptor::VT_TARGETWIDTH, targetWidth, 0); + } + void add_targetHeight(uint32_t targetHeight) { + fbb_.AddElement(ResizeBilinearDescriptor::VT_TARGETHEIGHT, targetHeight, 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(ResizeBilinearDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + void add_alignCorners(bool alignCorners) { + fbb_.AddElement(ResizeBilinearDescriptor::VT_ALIGNCORNERS, static_cast(alignCorners), 0); + } + void add_halfPixelCenters(bool halfPixelCenters) { + fbb_.AddElement(ResizeBilinearDescriptor::VT_HALFPIXELCENTERS, static_cast(halfPixelCenters), 0); + } + explicit ResizeBilinearDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ResizeBilinearDescriptorBuilder &operator=(const ResizeBilinearDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateResizeBilinearDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t targetWidth = 0, + uint32_t targetHeight = 0, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC, + bool alignCorners = false, + bool halfPixelCenters = false) { + ResizeBilinearDescriptorBuilder builder_(_fbb); + builder_.add_targetHeight(targetHeight); + builder_.add_targetWidth(targetWidth); + builder_.add_halfPixelCenters(halfPixelCenters); + builder_.add_alignCorners(alignCorners); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +struct SliceLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SliceLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::SliceDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct SliceLayerBuilder { + typedef SliceLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(SliceLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(SliceLayer::VT_DESCRIPTOR, descriptor); + } + explicit SliceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SliceLayerBuilder &operator=(const SliceLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSliceLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + SliceLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct SliceDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SliceDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BEGIN = 4, + VT_SIZE = 6 + }; + const flatbuffers::Vector *begin() const { + return GetPointer *>(VT_BEGIN); + } + const flatbuffers::Vector *size() const { + return GetPointer *>(VT_SIZE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BEGIN) && + verifier.VerifyVector(begin()) && + VerifyOffset(verifier, VT_SIZE) && + verifier.VerifyVector(size()) && + verifier.EndTable(); + } +}; + +struct SliceDescriptorBuilder { + typedef SliceDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_begin(flatbuffers::Offset> begin) { + fbb_.AddOffset(SliceDescriptor::VT_BEGIN, begin); + } + void add_size(flatbuffers::Offset> size) { + fbb_.AddOffset(SliceDescriptor::VT_SIZE, size); + } + explicit SliceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SliceDescriptorBuilder &operator=(const SliceDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSliceDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> begin = 0, + flatbuffers::Offset> size = 0) { + SliceDescriptorBuilder builder_(_fbb); + builder_.add_size(size); + builder_.add_begin(begin); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSliceDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *begin = nullptr, + const std::vector *size = nullptr) { + auto begin__ = begin ? _fbb.CreateVector(*begin) : 0; + auto size__ = size ? _fbb.CreateVector(*size) : 0; + return armnnSerializer::CreateSliceDescriptor( + _fbb, + begin__, + size__); +} + +struct StridedSliceLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StridedSliceLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::StridedSliceDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct StridedSliceLayerBuilder { + typedef StridedSliceLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(StridedSliceLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(StridedSliceLayer::VT_DESCRIPTOR, descriptor); + } + explicit StridedSliceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StridedSliceLayerBuilder &operator=(const StridedSliceLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStridedSliceLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + StridedSliceLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct StridedSliceDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StridedSliceDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BEGIN = 4, + VT_END = 6, + VT_STRIDE = 8, + VT_BEGINMASK = 10, + VT_ENDMASK = 12, + VT_SHRINKAXISMASK = 14, + VT_ELLIPSISMASK = 16, + VT_NEWAXISMASK = 18, + VT_DATALAYOUT = 20 + }; + const flatbuffers::Vector *begin() const { + return GetPointer *>(VT_BEGIN); + } + const flatbuffers::Vector *end() const { + return GetPointer *>(VT_END); + } + const flatbuffers::Vector *stride() const { + return GetPointer *>(VT_STRIDE); + } + int32_t beginMask() const { + return GetField(VT_BEGINMASK, 0); + } + int32_t endMask() const { + return GetField(VT_ENDMASK, 0); + } + int32_t shrinkAxisMask() const { + return GetField(VT_SHRINKAXISMASK, 0); + } + int32_t ellipsisMask() const { + return GetField(VT_ELLIPSISMASK, 0); + } + int32_t newAxisMask() const { + return GetField(VT_NEWAXISMASK, 0); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BEGIN) && + verifier.VerifyVector(begin()) && + VerifyOffset(verifier, VT_END) && + verifier.VerifyVector(end()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + VerifyField(verifier, VT_BEGINMASK) && + VerifyField(verifier, VT_ENDMASK) && + VerifyField(verifier, VT_SHRINKAXISMASK) && + VerifyField(verifier, VT_ELLIPSISMASK) && + VerifyField(verifier, VT_NEWAXISMASK) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct StridedSliceDescriptorBuilder { + typedef StridedSliceDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_begin(flatbuffers::Offset> begin) { + fbb_.AddOffset(StridedSliceDescriptor::VT_BEGIN, begin); + } + void add_end(flatbuffers::Offset> end) { + fbb_.AddOffset(StridedSliceDescriptor::VT_END, end); + } + void add_stride(flatbuffers::Offset> stride) { + fbb_.AddOffset(StridedSliceDescriptor::VT_STRIDE, stride); + } + void add_beginMask(int32_t beginMask) { + fbb_.AddElement(StridedSliceDescriptor::VT_BEGINMASK, beginMask, 0); + } + void add_endMask(int32_t endMask) { + fbb_.AddElement(StridedSliceDescriptor::VT_ENDMASK, endMask, 0); + } + void add_shrinkAxisMask(int32_t shrinkAxisMask) { + fbb_.AddElement(StridedSliceDescriptor::VT_SHRINKAXISMASK, shrinkAxisMask, 0); + } + void add_ellipsisMask(int32_t ellipsisMask) { + fbb_.AddElement(StridedSliceDescriptor::VT_ELLIPSISMASK, ellipsisMask, 0); + } + void add_newAxisMask(int32_t newAxisMask) { + fbb_.AddElement(StridedSliceDescriptor::VT_NEWAXISMASK, newAxisMask, 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(StridedSliceDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + explicit StridedSliceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StridedSliceDescriptorBuilder &operator=(const StridedSliceDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStridedSliceDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> begin = 0, + flatbuffers::Offset> end = 0, + flatbuffers::Offset> stride = 0, + int32_t beginMask = 0, + int32_t endMask = 0, + int32_t shrinkAxisMask = 0, + int32_t ellipsisMask = 0, + int32_t newAxisMask = 0, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + StridedSliceDescriptorBuilder builder_(_fbb); + builder_.add_newAxisMask(newAxisMask); + builder_.add_ellipsisMask(ellipsisMask); + builder_.add_shrinkAxisMask(shrinkAxisMask); + builder_.add_endMask(endMask); + builder_.add_beginMask(beginMask); + builder_.add_stride(stride); + builder_.add_end(end); + builder_.add_begin(begin); + builder_.add_dataLayout(dataLayout); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateStridedSliceDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *begin = nullptr, + const std::vector *end = nullptr, + const std::vector *stride = nullptr, + int32_t beginMask = 0, + int32_t endMask = 0, + int32_t shrinkAxisMask = 0, + int32_t ellipsisMask = 0, + int32_t newAxisMask = 0, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { + auto begin__ = begin ? _fbb.CreateVector(*begin) : 0; + auto end__ = end ? _fbb.CreateVector(*end) : 0; + auto stride__ = stride ? _fbb.CreateVector(*stride) : 0; + return armnnSerializer::CreateStridedSliceDescriptor( + _fbb, + begin__, + end__, + stride__, + beginMask, + endMask, + shrinkAxisMask, + ellipsisMask, + newAxisMask, + dataLayout); +} + +struct ConcatLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConcatLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::OriginsDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct ConcatLayerBuilder { + typedef ConcatLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ConcatLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(ConcatLayer::VT_DESCRIPTOR, descriptor); + } + explicit ConcatLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ConcatLayerBuilder &operator=(const ConcatLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateConcatLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + ConcatLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +/// @deprecated Use ConcatLayer instead +struct MergerLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MergerLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::OriginsDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct MergerLayerBuilder { + typedef MergerLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(MergerLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(MergerLayer::VT_DESCRIPTOR, descriptor); + } + explicit MergerLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MergerLayerBuilder &operator=(const MergerLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMergerLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + MergerLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct UintVector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UintVectorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DATA = 4 + }; + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } +}; + +struct UintVectorBuilder { + typedef UintVector Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(UintVector::VT_DATA, data); + } + explicit UintVectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UintVectorBuilder &operator=(const UintVectorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUintVector( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> data = 0) { + UintVectorBuilder builder_(_fbb); + builder_.add_data(data); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateUintVectorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return armnnSerializer::CreateUintVector( + _fbb, + data__); +} + +struct OriginsDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OriginsDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CONCATAXIS = 4, + VT_NUMVIEWS = 6, + VT_NUMDIMENSIONS = 8, + VT_VIEWORIGINS = 10 + }; + uint32_t concatAxis() const { + return GetField(VT_CONCATAXIS, 0); + } + uint32_t numViews() const { + return GetField(VT_NUMVIEWS, 0); + } + uint32_t numDimensions() const { + return GetField(VT_NUMDIMENSIONS, 0); + } + const flatbuffers::Vector> *viewOrigins() const { + return GetPointer> *>(VT_VIEWORIGINS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_CONCATAXIS) && + VerifyField(verifier, VT_NUMVIEWS) && + VerifyField(verifier, VT_NUMDIMENSIONS) && + VerifyOffset(verifier, VT_VIEWORIGINS) && + verifier.VerifyVector(viewOrigins()) && + verifier.VerifyVectorOfTables(viewOrigins()) && + verifier.EndTable(); + } +}; + +struct OriginsDescriptorBuilder { + typedef OriginsDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_concatAxis(uint32_t concatAxis) { + fbb_.AddElement(OriginsDescriptor::VT_CONCATAXIS, concatAxis, 0); + } + void add_numViews(uint32_t numViews) { + fbb_.AddElement(OriginsDescriptor::VT_NUMVIEWS, numViews, 0); + } + void add_numDimensions(uint32_t numDimensions) { + fbb_.AddElement(OriginsDescriptor::VT_NUMDIMENSIONS, numDimensions, 0); + } + void add_viewOrigins(flatbuffers::Offset>> viewOrigins) { + fbb_.AddOffset(OriginsDescriptor::VT_VIEWORIGINS, viewOrigins); + } + explicit OriginsDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + OriginsDescriptorBuilder &operator=(const OriginsDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateOriginsDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t concatAxis = 0, + uint32_t numViews = 0, + uint32_t numDimensions = 0, + flatbuffers::Offset>> viewOrigins = 0) { + OriginsDescriptorBuilder builder_(_fbb); + builder_.add_viewOrigins(viewOrigins); + builder_.add_numDimensions(numDimensions); + builder_.add_numViews(numViews); + builder_.add_concatAxis(concatAxis); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateOriginsDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t concatAxis = 0, + uint32_t numViews = 0, + uint32_t numDimensions = 0, + const std::vector> *viewOrigins = nullptr) { + auto viewOrigins__ = viewOrigins ? _fbb.CreateVector>(*viewOrigins) : 0; + return armnnSerializer::CreateOriginsDescriptor( + _fbb, + concatAxis, + numViews, + numDimensions, + viewOrigins__); +} + +struct ViewsDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ViewsDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ORIGINS = 4, + VT_VIEWSIZES = 6 + }; + const armnnSerializer::OriginsDescriptor *origins() const { + return GetPointer(VT_ORIGINS); + } + const flatbuffers::Vector> *viewSizes() const { + return GetPointer> *>(VT_VIEWSIZES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ORIGINS) && + verifier.VerifyTable(origins()) && + VerifyOffset(verifier, VT_VIEWSIZES) && + verifier.VerifyVector(viewSizes()) && + verifier.VerifyVectorOfTables(viewSizes()) && + verifier.EndTable(); + } +}; + +struct ViewsDescriptorBuilder { + typedef ViewsDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_origins(flatbuffers::Offset origins) { + fbb_.AddOffset(ViewsDescriptor::VT_ORIGINS, origins); + } + void add_viewSizes(flatbuffers::Offset>> viewSizes) { + fbb_.AddOffset(ViewsDescriptor::VT_VIEWSIZES, viewSizes); + } + explicit ViewsDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ViewsDescriptorBuilder &operator=(const ViewsDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateViewsDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset origins = 0, + flatbuffers::Offset>> viewSizes = 0) { + ViewsDescriptorBuilder builder_(_fbb); + builder_.add_viewSizes(viewSizes); + builder_.add_origins(origins); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateViewsDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset origins = 0, + const std::vector> *viewSizes = nullptr) { + auto viewSizes__ = viewSizes ? _fbb.CreateVector>(*viewSizes) : 0; + return armnnSerializer::CreateViewsDescriptor( + _fbb, + origins, + viewSizes__); +} + +struct SplitterLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SplitterLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ViewsDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct SplitterLayerBuilder { + typedef SplitterLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(SplitterLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(SplitterLayer::VT_DESCRIPTOR, descriptor); + } + explicit SplitterLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SplitterLayerBuilder &operator=(const SplitterLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSplitterLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + SplitterLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct DetectionPostProcessLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DetectionPostProcessLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6, + VT_ANCHORS = 8 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::DetectionPostProcessDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + const armnnSerializer::ConstTensor *anchors() const { + return GetPointer(VT_ANCHORS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + VerifyOffset(verifier, VT_ANCHORS) && + verifier.VerifyTable(anchors()) && + verifier.EndTable(); + } +}; + +struct DetectionPostProcessLayerBuilder { + typedef DetectionPostProcessLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(DetectionPostProcessLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(DetectionPostProcessLayer::VT_DESCRIPTOR, descriptor); + } + void add_anchors(flatbuffers::Offset anchors) { + fbb_.AddOffset(DetectionPostProcessLayer::VT_ANCHORS, anchors); + } + explicit DetectionPostProcessLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DetectionPostProcessLayerBuilder &operator=(const DetectionPostProcessLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDetectionPostProcessLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0, + flatbuffers::Offset anchors = 0) { + DetectionPostProcessLayerBuilder builder_(_fbb); + builder_.add_anchors(anchors); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct DetectionPostProcessDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DetectionPostProcessDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MAXDETECTIONS = 4, + VT_MAXCLASSESPERDETECTION = 6, + VT_DETECTIONSPERCLASS = 8, + VT_NMSSCORETHRESHOLD = 10, + VT_NMSIOUTHRESHOLD = 12, + VT_NUMCLASSES = 14, + VT_USEREGULARNMS = 16, + VT_SCALEX = 18, + VT_SCALEY = 20, + VT_SCALEW = 22, + VT_SCALEH = 24 + }; + uint32_t maxDetections() const { + return GetField(VT_MAXDETECTIONS, 0); + } + uint32_t maxClassesPerDetection() const { + return GetField(VT_MAXCLASSESPERDETECTION, 0); + } + uint32_t detectionsPerClass() const { + return GetField(VT_DETECTIONSPERCLASS, 0); + } + float nmsScoreThreshold() const { + return GetField(VT_NMSSCORETHRESHOLD, 0.0f); + } + float nmsIouThreshold() const { + return GetField(VT_NMSIOUTHRESHOLD, 0.0f); + } + uint32_t numClasses() const { + return GetField(VT_NUMCLASSES, 0); + } + bool useRegularNms() const { + return GetField(VT_USEREGULARNMS, 0) != 0; + } + float scaleX() const { + return GetField(VT_SCALEX, 0.0f); + } + float scaleY() const { + return GetField(VT_SCALEY, 0.0f); + } + float scaleW() const { + return GetField(VT_SCALEW, 0.0f); + } + float scaleH() const { + return GetField(VT_SCALEH, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_MAXDETECTIONS) && + VerifyField(verifier, VT_MAXCLASSESPERDETECTION) && + VerifyField(verifier, VT_DETECTIONSPERCLASS) && + VerifyField(verifier, VT_NMSSCORETHRESHOLD) && + VerifyField(verifier, VT_NMSIOUTHRESHOLD) && + VerifyField(verifier, VT_NUMCLASSES) && + VerifyField(verifier, VT_USEREGULARNMS) && + VerifyField(verifier, VT_SCALEX) && + VerifyField(verifier, VT_SCALEY) && + VerifyField(verifier, VT_SCALEW) && + VerifyField(verifier, VT_SCALEH) && + verifier.EndTable(); + } +}; + +struct DetectionPostProcessDescriptorBuilder { + typedef DetectionPostProcessDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_maxDetections(uint32_t maxDetections) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_MAXDETECTIONS, maxDetections, 0); + } + void add_maxClassesPerDetection(uint32_t maxClassesPerDetection) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_MAXCLASSESPERDETECTION, maxClassesPerDetection, 0); + } + void add_detectionsPerClass(uint32_t detectionsPerClass) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_DETECTIONSPERCLASS, detectionsPerClass, 0); + } + void add_nmsScoreThreshold(float nmsScoreThreshold) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_NMSSCORETHRESHOLD, nmsScoreThreshold, 0.0f); + } + void add_nmsIouThreshold(float nmsIouThreshold) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_NMSIOUTHRESHOLD, nmsIouThreshold, 0.0f); + } + void add_numClasses(uint32_t numClasses) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_NUMCLASSES, numClasses, 0); + } + void add_useRegularNms(bool useRegularNms) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_USEREGULARNMS, static_cast(useRegularNms), 0); + } + void add_scaleX(float scaleX) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_SCALEX, scaleX, 0.0f); + } + void add_scaleY(float scaleY) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_SCALEY, scaleY, 0.0f); + } + void add_scaleW(float scaleW) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_SCALEW, scaleW, 0.0f); + } + void add_scaleH(float scaleH) { + fbb_.AddElement(DetectionPostProcessDescriptor::VT_SCALEH, scaleH, 0.0f); + } + explicit DetectionPostProcessDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DetectionPostProcessDescriptorBuilder &operator=(const DetectionPostProcessDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDetectionPostProcessDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t maxDetections = 0, + uint32_t maxClassesPerDetection = 0, + uint32_t detectionsPerClass = 0, + float nmsScoreThreshold = 0.0f, + float nmsIouThreshold = 0.0f, + uint32_t numClasses = 0, + bool useRegularNms = false, + float scaleX = 0.0f, + float scaleY = 0.0f, + float scaleW = 0.0f, + float scaleH = 0.0f) { + DetectionPostProcessDescriptorBuilder builder_(_fbb); + builder_.add_scaleH(scaleH); + builder_.add_scaleW(scaleW); + builder_.add_scaleY(scaleY); + builder_.add_scaleX(scaleX); + builder_.add_numClasses(numClasses); + builder_.add_nmsIouThreshold(nmsIouThreshold); + builder_.add_nmsScoreThreshold(nmsScoreThreshold); + builder_.add_detectionsPerClass(detectionsPerClass); + builder_.add_maxClassesPerDetection(maxClassesPerDetection); + builder_.add_maxDetections(maxDetections); + builder_.add_useRegularNms(useRegularNms); + return builder_.Finish(); +} + +struct LstmInputParams FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LstmInputParamsBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUTTOFORGETWEIGHTS = 4, + VT_INPUTTOCELLWEIGHTS = 6, + VT_INPUTTOOUTPUTWEIGHTS = 8, + VT_RECURRENTTOFORGETWEIGHTS = 10, + VT_RECURRENTTOCELLWEIGHTS = 12, + VT_RECURRENTTOOUTPUTWEIGHTS = 14, + VT_FORGETGATEBIAS = 16, + VT_CELLBIAS = 18, + VT_OUTPUTGATEBIAS = 20, + VT_INPUTTOINPUTWEIGHTS = 22, + VT_RECURRENTTOINPUTWEIGHTS = 24, + VT_CELLTOINPUTWEIGHTS = 26, + VT_INPUTGATEBIAS = 28, + VT_PROJECTIONWEIGHTS = 30, + VT_PROJECTIONBIAS = 32, + VT_CELLTOFORGETWEIGHTS = 34, + VT_CELLTOOUTPUTWEIGHTS = 36, + VT_INPUTLAYERNORMWEIGHTS = 38, + VT_FORGETLAYERNORMWEIGHTS = 40, + VT_CELLLAYERNORMWEIGHTS = 42, + VT_OUTPUTLAYERNORMWEIGHTS = 44 + }; + const armnnSerializer::ConstTensor *inputToForgetWeights() const { + return GetPointer(VT_INPUTTOFORGETWEIGHTS); + } + const armnnSerializer::ConstTensor *inputToCellWeights() const { + return GetPointer(VT_INPUTTOCELLWEIGHTS); + } + const armnnSerializer::ConstTensor *inputToOutputWeights() const { + return GetPointer(VT_INPUTTOOUTPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToForgetWeights() const { + return GetPointer(VT_RECURRENTTOFORGETWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToCellWeights() const { + return GetPointer(VT_RECURRENTTOCELLWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToOutputWeights() const { + return GetPointer(VT_RECURRENTTOOUTPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *forgetGateBias() const { + return GetPointer(VT_FORGETGATEBIAS); + } + const armnnSerializer::ConstTensor *cellBias() const { + return GetPointer(VT_CELLBIAS); + } + const armnnSerializer::ConstTensor *outputGateBias() const { + return GetPointer(VT_OUTPUTGATEBIAS); + } + const armnnSerializer::ConstTensor *inputToInputWeights() const { + return GetPointer(VT_INPUTTOINPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToInputWeights() const { + return GetPointer(VT_RECURRENTTOINPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *cellToInputWeights() const { + return GetPointer(VT_CELLTOINPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *inputGateBias() const { + return GetPointer(VT_INPUTGATEBIAS); + } + const armnnSerializer::ConstTensor *projectionWeights() const { + return GetPointer(VT_PROJECTIONWEIGHTS); + } + const armnnSerializer::ConstTensor *projectionBias() const { + return GetPointer(VT_PROJECTIONBIAS); + } + const armnnSerializer::ConstTensor *cellToForgetWeights() const { + return GetPointer(VT_CELLTOFORGETWEIGHTS); + } + const armnnSerializer::ConstTensor *cellToOutputWeights() const { + return GetPointer(VT_CELLTOOUTPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *inputLayerNormWeights() const { + return GetPointer(VT_INPUTLAYERNORMWEIGHTS); + } + const armnnSerializer::ConstTensor *forgetLayerNormWeights() const { + return GetPointer(VT_FORGETLAYERNORMWEIGHTS); + } + const armnnSerializer::ConstTensor *cellLayerNormWeights() const { + return GetPointer(VT_CELLLAYERNORMWEIGHTS); + } + const armnnSerializer::ConstTensor *outputLayerNormWeights() const { + return GetPointer(VT_OUTPUTLAYERNORMWEIGHTS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_INPUTTOFORGETWEIGHTS) && + verifier.VerifyTable(inputToForgetWeights()) && + VerifyOffset(verifier, VT_INPUTTOCELLWEIGHTS) && + verifier.VerifyTable(inputToCellWeights()) && + VerifyOffset(verifier, VT_INPUTTOOUTPUTWEIGHTS) && + verifier.VerifyTable(inputToOutputWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOFORGETWEIGHTS) && + verifier.VerifyTable(recurrentToForgetWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOCELLWEIGHTS) && + verifier.VerifyTable(recurrentToCellWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOOUTPUTWEIGHTS) && + verifier.VerifyTable(recurrentToOutputWeights()) && + VerifyOffset(verifier, VT_FORGETGATEBIAS) && + verifier.VerifyTable(forgetGateBias()) && + VerifyOffset(verifier, VT_CELLBIAS) && + verifier.VerifyTable(cellBias()) && + VerifyOffset(verifier, VT_OUTPUTGATEBIAS) && + verifier.VerifyTable(outputGateBias()) && + VerifyOffset(verifier, VT_INPUTTOINPUTWEIGHTS) && + verifier.VerifyTable(inputToInputWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOINPUTWEIGHTS) && + verifier.VerifyTable(recurrentToInputWeights()) && + VerifyOffset(verifier, VT_CELLTOINPUTWEIGHTS) && + verifier.VerifyTable(cellToInputWeights()) && + VerifyOffset(verifier, VT_INPUTGATEBIAS) && + verifier.VerifyTable(inputGateBias()) && + VerifyOffset(verifier, VT_PROJECTIONWEIGHTS) && + verifier.VerifyTable(projectionWeights()) && + VerifyOffset(verifier, VT_PROJECTIONBIAS) && + verifier.VerifyTable(projectionBias()) && + VerifyOffset(verifier, VT_CELLTOFORGETWEIGHTS) && + verifier.VerifyTable(cellToForgetWeights()) && + VerifyOffset(verifier, VT_CELLTOOUTPUTWEIGHTS) && + verifier.VerifyTable(cellToOutputWeights()) && + VerifyOffset(verifier, VT_INPUTLAYERNORMWEIGHTS) && + verifier.VerifyTable(inputLayerNormWeights()) && + VerifyOffset(verifier, VT_FORGETLAYERNORMWEIGHTS) && + verifier.VerifyTable(forgetLayerNormWeights()) && + VerifyOffset(verifier, VT_CELLLAYERNORMWEIGHTS) && + verifier.VerifyTable(cellLayerNormWeights()) && + VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) && + verifier.VerifyTable(outputLayerNormWeights()) && + verifier.EndTable(); + } +}; + +struct LstmInputParamsBuilder { + typedef LstmInputParams Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_inputToForgetWeights(flatbuffers::Offset inputToForgetWeights) { + fbb_.AddOffset(LstmInputParams::VT_INPUTTOFORGETWEIGHTS, inputToForgetWeights); + } + void add_inputToCellWeights(flatbuffers::Offset inputToCellWeights) { + fbb_.AddOffset(LstmInputParams::VT_INPUTTOCELLWEIGHTS, inputToCellWeights); + } + void add_inputToOutputWeights(flatbuffers::Offset inputToOutputWeights) { + fbb_.AddOffset(LstmInputParams::VT_INPUTTOOUTPUTWEIGHTS, inputToOutputWeights); + } + void add_recurrentToForgetWeights(flatbuffers::Offset recurrentToForgetWeights) { + fbb_.AddOffset(LstmInputParams::VT_RECURRENTTOFORGETWEIGHTS, recurrentToForgetWeights); + } + void add_recurrentToCellWeights(flatbuffers::Offset recurrentToCellWeights) { + fbb_.AddOffset(LstmInputParams::VT_RECURRENTTOCELLWEIGHTS, recurrentToCellWeights); + } + void add_recurrentToOutputWeights(flatbuffers::Offset recurrentToOutputWeights) { + fbb_.AddOffset(LstmInputParams::VT_RECURRENTTOOUTPUTWEIGHTS, recurrentToOutputWeights); + } + void add_forgetGateBias(flatbuffers::Offset forgetGateBias) { + fbb_.AddOffset(LstmInputParams::VT_FORGETGATEBIAS, forgetGateBias); + } + void add_cellBias(flatbuffers::Offset cellBias) { + fbb_.AddOffset(LstmInputParams::VT_CELLBIAS, cellBias); + } + void add_outputGateBias(flatbuffers::Offset outputGateBias) { + fbb_.AddOffset(LstmInputParams::VT_OUTPUTGATEBIAS, outputGateBias); + } + void add_inputToInputWeights(flatbuffers::Offset inputToInputWeights) { + fbb_.AddOffset(LstmInputParams::VT_INPUTTOINPUTWEIGHTS, inputToInputWeights); + } + void add_recurrentToInputWeights(flatbuffers::Offset recurrentToInputWeights) { + fbb_.AddOffset(LstmInputParams::VT_RECURRENTTOINPUTWEIGHTS, recurrentToInputWeights); + } + void add_cellToInputWeights(flatbuffers::Offset cellToInputWeights) { + fbb_.AddOffset(LstmInputParams::VT_CELLTOINPUTWEIGHTS, cellToInputWeights); + } + void add_inputGateBias(flatbuffers::Offset inputGateBias) { + fbb_.AddOffset(LstmInputParams::VT_INPUTGATEBIAS, inputGateBias); + } + void add_projectionWeights(flatbuffers::Offset projectionWeights) { + fbb_.AddOffset(LstmInputParams::VT_PROJECTIONWEIGHTS, projectionWeights); + } + void add_projectionBias(flatbuffers::Offset projectionBias) { + fbb_.AddOffset(LstmInputParams::VT_PROJECTIONBIAS, projectionBias); + } + void add_cellToForgetWeights(flatbuffers::Offset cellToForgetWeights) { + fbb_.AddOffset(LstmInputParams::VT_CELLTOFORGETWEIGHTS, cellToForgetWeights); + } + void add_cellToOutputWeights(flatbuffers::Offset cellToOutputWeights) { + fbb_.AddOffset(LstmInputParams::VT_CELLTOOUTPUTWEIGHTS, cellToOutputWeights); + } + void add_inputLayerNormWeights(flatbuffers::Offset inputLayerNormWeights) { + fbb_.AddOffset(LstmInputParams::VT_INPUTLAYERNORMWEIGHTS, inputLayerNormWeights); + } + void add_forgetLayerNormWeights(flatbuffers::Offset forgetLayerNormWeights) { + fbb_.AddOffset(LstmInputParams::VT_FORGETLAYERNORMWEIGHTS, forgetLayerNormWeights); + } + void add_cellLayerNormWeights(flatbuffers::Offset cellLayerNormWeights) { + fbb_.AddOffset(LstmInputParams::VT_CELLLAYERNORMWEIGHTS, cellLayerNormWeights); + } + void add_outputLayerNormWeights(flatbuffers::Offset outputLayerNormWeights) { + fbb_.AddOffset(LstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights); + } + explicit LstmInputParamsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LstmInputParamsBuilder &operator=(const LstmInputParamsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLstmInputParams( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset inputToForgetWeights = 0, + flatbuffers::Offset inputToCellWeights = 0, + flatbuffers::Offset inputToOutputWeights = 0, + flatbuffers::Offset recurrentToForgetWeights = 0, + flatbuffers::Offset recurrentToCellWeights = 0, + flatbuffers::Offset recurrentToOutputWeights = 0, + flatbuffers::Offset forgetGateBias = 0, + flatbuffers::Offset cellBias = 0, + flatbuffers::Offset outputGateBias = 0, + flatbuffers::Offset inputToInputWeights = 0, + flatbuffers::Offset recurrentToInputWeights = 0, + flatbuffers::Offset cellToInputWeights = 0, + flatbuffers::Offset inputGateBias = 0, + flatbuffers::Offset projectionWeights = 0, + flatbuffers::Offset projectionBias = 0, + flatbuffers::Offset cellToForgetWeights = 0, + flatbuffers::Offset cellToOutputWeights = 0, + flatbuffers::Offset inputLayerNormWeights = 0, + flatbuffers::Offset forgetLayerNormWeights = 0, + flatbuffers::Offset cellLayerNormWeights = 0, + flatbuffers::Offset outputLayerNormWeights = 0) { + LstmInputParamsBuilder builder_(_fbb); + builder_.add_outputLayerNormWeights(outputLayerNormWeights); + builder_.add_cellLayerNormWeights(cellLayerNormWeights); + builder_.add_forgetLayerNormWeights(forgetLayerNormWeights); + builder_.add_inputLayerNormWeights(inputLayerNormWeights); + builder_.add_cellToOutputWeights(cellToOutputWeights); + builder_.add_cellToForgetWeights(cellToForgetWeights); + builder_.add_projectionBias(projectionBias); + builder_.add_projectionWeights(projectionWeights); + builder_.add_inputGateBias(inputGateBias); + builder_.add_cellToInputWeights(cellToInputWeights); + builder_.add_recurrentToInputWeights(recurrentToInputWeights); + builder_.add_inputToInputWeights(inputToInputWeights); + builder_.add_outputGateBias(outputGateBias); + builder_.add_cellBias(cellBias); + builder_.add_forgetGateBias(forgetGateBias); + builder_.add_recurrentToOutputWeights(recurrentToOutputWeights); + builder_.add_recurrentToCellWeights(recurrentToCellWeights); + builder_.add_recurrentToForgetWeights(recurrentToForgetWeights); + builder_.add_inputToOutputWeights(inputToOutputWeights); + builder_.add_inputToCellWeights(inputToCellWeights); + builder_.add_inputToForgetWeights(inputToForgetWeights); + return builder_.Finish(); +} + +struct LstmDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LstmDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ACTIVATIONFUNC = 4, + VT_CLIPPINGTHRESCELL = 6, + VT_CLIPPINGTHRESPROJ = 8, + VT_CIFGENABLED = 10, + VT_PEEPHOLEENABLED = 12, + VT_PROJECTIONENABLED = 14, + VT_LAYERNORMENABLED = 16 + }; + uint32_t activationFunc() const { + return GetField(VT_ACTIVATIONFUNC, 0); + } + float clippingThresCell() const { + return GetField(VT_CLIPPINGTHRESCELL, 0.0f); + } + float clippingThresProj() const { + return GetField(VT_CLIPPINGTHRESPROJ, 0.0f); + } + bool cifgEnabled() const { + return GetField(VT_CIFGENABLED, 1) != 0; + } + bool peepholeEnabled() const { + return GetField(VT_PEEPHOLEENABLED, 0) != 0; + } + bool projectionEnabled() const { + return GetField(VT_PROJECTIONENABLED, 0) != 0; + } + bool layerNormEnabled() const { + return GetField(VT_LAYERNORMENABLED, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ACTIVATIONFUNC) && + VerifyField(verifier, VT_CLIPPINGTHRESCELL) && + VerifyField(verifier, VT_CLIPPINGTHRESPROJ) && + VerifyField(verifier, VT_CIFGENABLED) && + VerifyField(verifier, VT_PEEPHOLEENABLED) && + VerifyField(verifier, VT_PROJECTIONENABLED) && + VerifyField(verifier, VT_LAYERNORMENABLED) && + verifier.EndTable(); + } +}; + +struct LstmDescriptorBuilder { + typedef LstmDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_activationFunc(uint32_t activationFunc) { + fbb_.AddElement(LstmDescriptor::VT_ACTIVATIONFUNC, activationFunc, 0); + } + void add_clippingThresCell(float clippingThresCell) { + fbb_.AddElement(LstmDescriptor::VT_CLIPPINGTHRESCELL, clippingThresCell, 0.0f); + } + void add_clippingThresProj(float clippingThresProj) { + fbb_.AddElement(LstmDescriptor::VT_CLIPPINGTHRESPROJ, clippingThresProj, 0.0f); + } + void add_cifgEnabled(bool cifgEnabled) { + fbb_.AddElement(LstmDescriptor::VT_CIFGENABLED, static_cast(cifgEnabled), 1); + } + void add_peepholeEnabled(bool peepholeEnabled) { + fbb_.AddElement(LstmDescriptor::VT_PEEPHOLEENABLED, static_cast(peepholeEnabled), 0); + } + void add_projectionEnabled(bool projectionEnabled) { + fbb_.AddElement(LstmDescriptor::VT_PROJECTIONENABLED, static_cast(projectionEnabled), 0); + } + void add_layerNormEnabled(bool layerNormEnabled) { + fbb_.AddElement(LstmDescriptor::VT_LAYERNORMENABLED, static_cast(layerNormEnabled), 0); + } + explicit LstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LstmDescriptorBuilder &operator=(const LstmDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLstmDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t activationFunc = 0, + float clippingThresCell = 0.0f, + float clippingThresProj = 0.0f, + bool cifgEnabled = true, + bool peepholeEnabled = false, + bool projectionEnabled = false, + bool layerNormEnabled = false) { + LstmDescriptorBuilder builder_(_fbb); + builder_.add_clippingThresProj(clippingThresProj); + builder_.add_clippingThresCell(clippingThresCell); + builder_.add_activationFunc(activationFunc); + builder_.add_layerNormEnabled(layerNormEnabled); + builder_.add_projectionEnabled(projectionEnabled); + builder_.add_peepholeEnabled(peepholeEnabled); + builder_.add_cifgEnabled(cifgEnabled); + return builder_.Finish(); +} + +struct LstmLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LstmLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6, + VT_INPUTPARAMS = 8 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::LstmDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + const armnnSerializer::LstmInputParams *inputParams() const { + return GetPointer(VT_INPUTPARAMS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + VerifyOffset(verifier, VT_INPUTPARAMS) && + verifier.VerifyTable(inputParams()) && + verifier.EndTable(); + } +}; + +struct LstmLayerBuilder { + typedef LstmLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(LstmLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(LstmLayer::VT_DESCRIPTOR, descriptor); + } + void add_inputParams(flatbuffers::Offset inputParams) { + fbb_.AddOffset(LstmLayer::VT_INPUTPARAMS, inputParams); + } + explicit LstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LstmLayerBuilder &operator=(const LstmLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLstmLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0, + flatbuffers::Offset inputParams = 0) { + LstmLayerBuilder builder_(_fbb); + builder_.add_inputParams(inputParams); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct QLstmInputParams FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef QLstmInputParamsBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUTTOFORGETWEIGHTS = 4, + VT_INPUTTOCELLWEIGHTS = 6, + VT_INPUTTOOUTPUTWEIGHTS = 8, + VT_RECURRENTTOFORGETWEIGHTS = 10, + VT_RECURRENTTOCELLWEIGHTS = 12, + VT_RECURRENTTOOUTPUTWEIGHTS = 14, + VT_FORGETGATEBIAS = 16, + VT_CELLBIAS = 18, + VT_OUTPUTGATEBIAS = 20, + VT_INPUTTOINPUTWEIGHTS = 22, + VT_RECURRENTTOINPUTWEIGHTS = 24, + VT_INPUTGATEBIAS = 26, + VT_PROJECTIONWEIGHTS = 28, + VT_PROJECTIONBIAS = 30, + VT_CELLTOINPUTWEIGHTS = 32, + VT_CELLTOFORGETWEIGHTS = 34, + VT_CELLTOOUTPUTWEIGHTS = 36, + VT_INPUTLAYERNORMWEIGHTS = 38, + VT_FORGETLAYERNORMWEIGHTS = 40, + VT_CELLLAYERNORMWEIGHTS = 42, + VT_OUTPUTLAYERNORMWEIGHTS = 44 + }; + const armnnSerializer::ConstTensor *inputToForgetWeights() const { + return GetPointer(VT_INPUTTOFORGETWEIGHTS); + } + const armnnSerializer::ConstTensor *inputToCellWeights() const { + return GetPointer(VT_INPUTTOCELLWEIGHTS); + } + const armnnSerializer::ConstTensor *inputToOutputWeights() const { + return GetPointer(VT_INPUTTOOUTPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToForgetWeights() const { + return GetPointer(VT_RECURRENTTOFORGETWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToCellWeights() const { + return GetPointer(VT_RECURRENTTOCELLWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToOutputWeights() const { + return GetPointer(VT_RECURRENTTOOUTPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *forgetGateBias() const { + return GetPointer(VT_FORGETGATEBIAS); + } + const armnnSerializer::ConstTensor *cellBias() const { + return GetPointer(VT_CELLBIAS); + } + const armnnSerializer::ConstTensor *outputGateBias() const { + return GetPointer(VT_OUTPUTGATEBIAS); + } + const armnnSerializer::ConstTensor *inputToInputWeights() const { + return GetPointer(VT_INPUTTOINPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToInputWeights() const { + return GetPointer(VT_RECURRENTTOINPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *inputGateBias() const { + return GetPointer(VT_INPUTGATEBIAS); + } + const armnnSerializer::ConstTensor *projectionWeights() const { + return GetPointer(VT_PROJECTIONWEIGHTS); + } + const armnnSerializer::ConstTensor *projectionBias() const { + return GetPointer(VT_PROJECTIONBIAS); + } + const armnnSerializer::ConstTensor *cellToInputWeights() const { + return GetPointer(VT_CELLTOINPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *cellToForgetWeights() const { + return GetPointer(VT_CELLTOFORGETWEIGHTS); + } + const armnnSerializer::ConstTensor *cellToOutputWeights() const { + return GetPointer(VT_CELLTOOUTPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *inputLayerNormWeights() const { + return GetPointer(VT_INPUTLAYERNORMWEIGHTS); + } + const armnnSerializer::ConstTensor *forgetLayerNormWeights() const { + return GetPointer(VT_FORGETLAYERNORMWEIGHTS); + } + const armnnSerializer::ConstTensor *cellLayerNormWeights() const { + return GetPointer(VT_CELLLAYERNORMWEIGHTS); + } + const armnnSerializer::ConstTensor *outputLayerNormWeights() const { + return GetPointer(VT_OUTPUTLAYERNORMWEIGHTS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_INPUTTOFORGETWEIGHTS) && + verifier.VerifyTable(inputToForgetWeights()) && + VerifyOffset(verifier, VT_INPUTTOCELLWEIGHTS) && + verifier.VerifyTable(inputToCellWeights()) && + VerifyOffset(verifier, VT_INPUTTOOUTPUTWEIGHTS) && + verifier.VerifyTable(inputToOutputWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOFORGETWEIGHTS) && + verifier.VerifyTable(recurrentToForgetWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOCELLWEIGHTS) && + verifier.VerifyTable(recurrentToCellWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOOUTPUTWEIGHTS) && + verifier.VerifyTable(recurrentToOutputWeights()) && + VerifyOffset(verifier, VT_FORGETGATEBIAS) && + verifier.VerifyTable(forgetGateBias()) && + VerifyOffset(verifier, VT_CELLBIAS) && + verifier.VerifyTable(cellBias()) && + VerifyOffset(verifier, VT_OUTPUTGATEBIAS) && + verifier.VerifyTable(outputGateBias()) && + VerifyOffset(verifier, VT_INPUTTOINPUTWEIGHTS) && + verifier.VerifyTable(inputToInputWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOINPUTWEIGHTS) && + verifier.VerifyTable(recurrentToInputWeights()) && + VerifyOffset(verifier, VT_INPUTGATEBIAS) && + verifier.VerifyTable(inputGateBias()) && + VerifyOffset(verifier, VT_PROJECTIONWEIGHTS) && + verifier.VerifyTable(projectionWeights()) && + VerifyOffset(verifier, VT_PROJECTIONBIAS) && + verifier.VerifyTable(projectionBias()) && + VerifyOffset(verifier, VT_CELLTOINPUTWEIGHTS) && + verifier.VerifyTable(cellToInputWeights()) && + VerifyOffset(verifier, VT_CELLTOFORGETWEIGHTS) && + verifier.VerifyTable(cellToForgetWeights()) && + VerifyOffset(verifier, VT_CELLTOOUTPUTWEIGHTS) && + verifier.VerifyTable(cellToOutputWeights()) && + VerifyOffset(verifier, VT_INPUTLAYERNORMWEIGHTS) && + verifier.VerifyTable(inputLayerNormWeights()) && + VerifyOffset(verifier, VT_FORGETLAYERNORMWEIGHTS) && + verifier.VerifyTable(forgetLayerNormWeights()) && + VerifyOffset(verifier, VT_CELLLAYERNORMWEIGHTS) && + verifier.VerifyTable(cellLayerNormWeights()) && + VerifyOffset(verifier, VT_OUTPUTLAYERNORMWEIGHTS) && + verifier.VerifyTable(outputLayerNormWeights()) && + verifier.EndTable(); + } +}; + +struct QLstmInputParamsBuilder { + typedef QLstmInputParams Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_inputToForgetWeights(flatbuffers::Offset inputToForgetWeights) { + fbb_.AddOffset(QLstmInputParams::VT_INPUTTOFORGETWEIGHTS, inputToForgetWeights); + } + void add_inputToCellWeights(flatbuffers::Offset inputToCellWeights) { + fbb_.AddOffset(QLstmInputParams::VT_INPUTTOCELLWEIGHTS, inputToCellWeights); + } + void add_inputToOutputWeights(flatbuffers::Offset inputToOutputWeights) { + fbb_.AddOffset(QLstmInputParams::VT_INPUTTOOUTPUTWEIGHTS, inputToOutputWeights); + } + void add_recurrentToForgetWeights(flatbuffers::Offset recurrentToForgetWeights) { + fbb_.AddOffset(QLstmInputParams::VT_RECURRENTTOFORGETWEIGHTS, recurrentToForgetWeights); + } + void add_recurrentToCellWeights(flatbuffers::Offset recurrentToCellWeights) { + fbb_.AddOffset(QLstmInputParams::VT_RECURRENTTOCELLWEIGHTS, recurrentToCellWeights); + } + void add_recurrentToOutputWeights(flatbuffers::Offset recurrentToOutputWeights) { + fbb_.AddOffset(QLstmInputParams::VT_RECURRENTTOOUTPUTWEIGHTS, recurrentToOutputWeights); + } + void add_forgetGateBias(flatbuffers::Offset forgetGateBias) { + fbb_.AddOffset(QLstmInputParams::VT_FORGETGATEBIAS, forgetGateBias); + } + void add_cellBias(flatbuffers::Offset cellBias) { + fbb_.AddOffset(QLstmInputParams::VT_CELLBIAS, cellBias); + } + void add_outputGateBias(flatbuffers::Offset outputGateBias) { + fbb_.AddOffset(QLstmInputParams::VT_OUTPUTGATEBIAS, outputGateBias); + } + void add_inputToInputWeights(flatbuffers::Offset inputToInputWeights) { + fbb_.AddOffset(QLstmInputParams::VT_INPUTTOINPUTWEIGHTS, inputToInputWeights); + } + void add_recurrentToInputWeights(flatbuffers::Offset recurrentToInputWeights) { + fbb_.AddOffset(QLstmInputParams::VT_RECURRENTTOINPUTWEIGHTS, recurrentToInputWeights); + } + void add_inputGateBias(flatbuffers::Offset inputGateBias) { + fbb_.AddOffset(QLstmInputParams::VT_INPUTGATEBIAS, inputGateBias); + } + void add_projectionWeights(flatbuffers::Offset projectionWeights) { + fbb_.AddOffset(QLstmInputParams::VT_PROJECTIONWEIGHTS, projectionWeights); + } + void add_projectionBias(flatbuffers::Offset projectionBias) { + fbb_.AddOffset(QLstmInputParams::VT_PROJECTIONBIAS, projectionBias); + } + void add_cellToInputWeights(flatbuffers::Offset cellToInputWeights) { + fbb_.AddOffset(QLstmInputParams::VT_CELLTOINPUTWEIGHTS, cellToInputWeights); + } + void add_cellToForgetWeights(flatbuffers::Offset cellToForgetWeights) { + fbb_.AddOffset(QLstmInputParams::VT_CELLTOFORGETWEIGHTS, cellToForgetWeights); + } + void add_cellToOutputWeights(flatbuffers::Offset cellToOutputWeights) { + fbb_.AddOffset(QLstmInputParams::VT_CELLTOOUTPUTWEIGHTS, cellToOutputWeights); + } + void add_inputLayerNormWeights(flatbuffers::Offset inputLayerNormWeights) { + fbb_.AddOffset(QLstmInputParams::VT_INPUTLAYERNORMWEIGHTS, inputLayerNormWeights); + } + void add_forgetLayerNormWeights(flatbuffers::Offset forgetLayerNormWeights) { + fbb_.AddOffset(QLstmInputParams::VT_FORGETLAYERNORMWEIGHTS, forgetLayerNormWeights); + } + void add_cellLayerNormWeights(flatbuffers::Offset cellLayerNormWeights) { + fbb_.AddOffset(QLstmInputParams::VT_CELLLAYERNORMWEIGHTS, cellLayerNormWeights); + } + void add_outputLayerNormWeights(flatbuffers::Offset outputLayerNormWeights) { + fbb_.AddOffset(QLstmInputParams::VT_OUTPUTLAYERNORMWEIGHTS, outputLayerNormWeights); + } + explicit QLstmInputParamsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + QLstmInputParamsBuilder &operator=(const QLstmInputParamsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateQLstmInputParams( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset inputToForgetWeights = 0, + flatbuffers::Offset inputToCellWeights = 0, + flatbuffers::Offset inputToOutputWeights = 0, + flatbuffers::Offset recurrentToForgetWeights = 0, + flatbuffers::Offset recurrentToCellWeights = 0, + flatbuffers::Offset recurrentToOutputWeights = 0, + flatbuffers::Offset forgetGateBias = 0, + flatbuffers::Offset cellBias = 0, + flatbuffers::Offset outputGateBias = 0, + flatbuffers::Offset inputToInputWeights = 0, + flatbuffers::Offset recurrentToInputWeights = 0, + flatbuffers::Offset inputGateBias = 0, + flatbuffers::Offset projectionWeights = 0, + flatbuffers::Offset projectionBias = 0, + flatbuffers::Offset cellToInputWeights = 0, + flatbuffers::Offset cellToForgetWeights = 0, + flatbuffers::Offset cellToOutputWeights = 0, + flatbuffers::Offset inputLayerNormWeights = 0, + flatbuffers::Offset forgetLayerNormWeights = 0, + flatbuffers::Offset cellLayerNormWeights = 0, + flatbuffers::Offset outputLayerNormWeights = 0) { + QLstmInputParamsBuilder builder_(_fbb); + builder_.add_outputLayerNormWeights(outputLayerNormWeights); + builder_.add_cellLayerNormWeights(cellLayerNormWeights); + builder_.add_forgetLayerNormWeights(forgetLayerNormWeights); + builder_.add_inputLayerNormWeights(inputLayerNormWeights); + builder_.add_cellToOutputWeights(cellToOutputWeights); + builder_.add_cellToForgetWeights(cellToForgetWeights); + builder_.add_cellToInputWeights(cellToInputWeights); + builder_.add_projectionBias(projectionBias); + builder_.add_projectionWeights(projectionWeights); + builder_.add_inputGateBias(inputGateBias); + builder_.add_recurrentToInputWeights(recurrentToInputWeights); + builder_.add_inputToInputWeights(inputToInputWeights); + builder_.add_outputGateBias(outputGateBias); + builder_.add_cellBias(cellBias); + builder_.add_forgetGateBias(forgetGateBias); + builder_.add_recurrentToOutputWeights(recurrentToOutputWeights); + builder_.add_recurrentToCellWeights(recurrentToCellWeights); + builder_.add_recurrentToForgetWeights(recurrentToForgetWeights); + builder_.add_inputToOutputWeights(inputToOutputWeights); + builder_.add_inputToCellWeights(inputToCellWeights); + builder_.add_inputToForgetWeights(inputToForgetWeights); + return builder_.Finish(); +} + +struct QLstmDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef QLstmDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CIFGENABLED = 4, + VT_PEEPHOLEENABLED = 6, + VT_PROJECTIONENABLED = 8, + VT_LAYERNORMENABLED = 10, + VT_CELLCLIP = 12, + VT_PROJECTIONCLIP = 14, + VT_INPUTINTERMEDIATESCALE = 16, + VT_FORGETINTERMEDIATESCALE = 18, + VT_CELLINTERMEDIATESCALE = 20, + VT_OUTPUTINTERMEDIATESCALE = 22, + VT_HIDDENSTATEZEROPOINT = 24, + VT_HIDDENSTATESCALE = 26 + }; + bool cifgEnabled() const { + return GetField(VT_CIFGENABLED, 1) != 0; + } + bool peepholeEnabled() const { + return GetField(VT_PEEPHOLEENABLED, 0) != 0; + } + bool projectionEnabled() const { + return GetField(VT_PROJECTIONENABLED, 0) != 0; + } + bool layerNormEnabled() const { + return GetField(VT_LAYERNORMENABLED, 0) != 0; + } + float cellClip() const { + return GetField(VT_CELLCLIP, 0.0f); + } + float projectionClip() const { + return GetField(VT_PROJECTIONCLIP, 0.0f); + } + float inputIntermediateScale() const { + return GetField(VT_INPUTINTERMEDIATESCALE, 0.0f); + } + float forgetIntermediateScale() const { + return GetField(VT_FORGETINTERMEDIATESCALE, 0.0f); + } + float cellIntermediateScale() const { + return GetField(VT_CELLINTERMEDIATESCALE, 0.0f); + } + float outputIntermediateScale() const { + return GetField(VT_OUTPUTINTERMEDIATESCALE, 0.0f); + } + int32_t hiddenStateZeroPoint() const { + return GetField(VT_HIDDENSTATEZEROPOINT, 0); + } + float hiddenStateScale() const { + return GetField(VT_HIDDENSTATESCALE, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_CIFGENABLED) && + VerifyField(verifier, VT_PEEPHOLEENABLED) && + VerifyField(verifier, VT_PROJECTIONENABLED) && + VerifyField(verifier, VT_LAYERNORMENABLED) && + VerifyField(verifier, VT_CELLCLIP) && + VerifyField(verifier, VT_PROJECTIONCLIP) && + VerifyField(verifier, VT_INPUTINTERMEDIATESCALE) && + VerifyField(verifier, VT_FORGETINTERMEDIATESCALE) && + VerifyField(verifier, VT_CELLINTERMEDIATESCALE) && + VerifyField(verifier, VT_OUTPUTINTERMEDIATESCALE) && + VerifyField(verifier, VT_HIDDENSTATEZEROPOINT) && + VerifyField(verifier, VT_HIDDENSTATESCALE) && + verifier.EndTable(); + } +}; + +struct QLstmDescriptorBuilder { + typedef QLstmDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_cifgEnabled(bool cifgEnabled) { + fbb_.AddElement(QLstmDescriptor::VT_CIFGENABLED, static_cast(cifgEnabled), 1); + } + void add_peepholeEnabled(bool peepholeEnabled) { + fbb_.AddElement(QLstmDescriptor::VT_PEEPHOLEENABLED, static_cast(peepholeEnabled), 0); + } + void add_projectionEnabled(bool projectionEnabled) { + fbb_.AddElement(QLstmDescriptor::VT_PROJECTIONENABLED, static_cast(projectionEnabled), 0); + } + void add_layerNormEnabled(bool layerNormEnabled) { + fbb_.AddElement(QLstmDescriptor::VT_LAYERNORMENABLED, static_cast(layerNormEnabled), 0); + } + void add_cellClip(float cellClip) { + fbb_.AddElement(QLstmDescriptor::VT_CELLCLIP, cellClip, 0.0f); + } + void add_projectionClip(float projectionClip) { + fbb_.AddElement(QLstmDescriptor::VT_PROJECTIONCLIP, projectionClip, 0.0f); + } + void add_inputIntermediateScale(float inputIntermediateScale) { + fbb_.AddElement(QLstmDescriptor::VT_INPUTINTERMEDIATESCALE, inputIntermediateScale, 0.0f); + } + void add_forgetIntermediateScale(float forgetIntermediateScale) { + fbb_.AddElement(QLstmDescriptor::VT_FORGETINTERMEDIATESCALE, forgetIntermediateScale, 0.0f); + } + void add_cellIntermediateScale(float cellIntermediateScale) { + fbb_.AddElement(QLstmDescriptor::VT_CELLINTERMEDIATESCALE, cellIntermediateScale, 0.0f); + } + void add_outputIntermediateScale(float outputIntermediateScale) { + fbb_.AddElement(QLstmDescriptor::VT_OUTPUTINTERMEDIATESCALE, outputIntermediateScale, 0.0f); + } + void add_hiddenStateZeroPoint(int32_t hiddenStateZeroPoint) { + fbb_.AddElement(QLstmDescriptor::VT_HIDDENSTATEZEROPOINT, hiddenStateZeroPoint, 0); + } + void add_hiddenStateScale(float hiddenStateScale) { + fbb_.AddElement(QLstmDescriptor::VT_HIDDENSTATESCALE, hiddenStateScale, 0.0f); + } + explicit QLstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + QLstmDescriptorBuilder &operator=(const QLstmDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateQLstmDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + bool cifgEnabled = true, + bool peepholeEnabled = false, + bool projectionEnabled = false, + bool layerNormEnabled = false, + float cellClip = 0.0f, + float projectionClip = 0.0f, + float inputIntermediateScale = 0.0f, + float forgetIntermediateScale = 0.0f, + float cellIntermediateScale = 0.0f, + float outputIntermediateScale = 0.0f, + int32_t hiddenStateZeroPoint = 0, + float hiddenStateScale = 0.0f) { + QLstmDescriptorBuilder builder_(_fbb); + builder_.add_hiddenStateScale(hiddenStateScale); + builder_.add_hiddenStateZeroPoint(hiddenStateZeroPoint); + builder_.add_outputIntermediateScale(outputIntermediateScale); + builder_.add_cellIntermediateScale(cellIntermediateScale); + builder_.add_forgetIntermediateScale(forgetIntermediateScale); + builder_.add_inputIntermediateScale(inputIntermediateScale); + builder_.add_projectionClip(projectionClip); + builder_.add_cellClip(cellClip); + builder_.add_layerNormEnabled(layerNormEnabled); + builder_.add_projectionEnabled(projectionEnabled); + builder_.add_peepholeEnabled(peepholeEnabled); + builder_.add_cifgEnabled(cifgEnabled); + return builder_.Finish(); +} + +struct QLstmLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef QLstmLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6, + VT_INPUTPARAMS = 8 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::QLstmDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + const armnnSerializer::QLstmInputParams *inputParams() const { + return GetPointer(VT_INPUTPARAMS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + VerifyOffset(verifier, VT_INPUTPARAMS) && + verifier.VerifyTable(inputParams()) && + verifier.EndTable(); + } +}; + +struct QLstmLayerBuilder { + typedef QLstmLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(QLstmLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(QLstmLayer::VT_DESCRIPTOR, descriptor); + } + void add_inputParams(flatbuffers::Offset inputParams) { + fbb_.AddOffset(QLstmLayer::VT_INPUTPARAMS, inputParams); + } + explicit QLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + QLstmLayerBuilder &operator=(const QLstmLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateQLstmLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0, + flatbuffers::Offset inputParams = 0) { + QLstmLayerBuilder builder_(_fbb); + builder_.add_inputParams(inputParams); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct QuantizedLstmInputParams FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef QuantizedLstmInputParamsBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUTTOINPUTWEIGHTS = 4, + VT_INPUTTOFORGETWEIGHTS = 6, + VT_INPUTTOCELLWEIGHTS = 8, + VT_INPUTTOOUTPUTWEIGHTS = 10, + VT_RECURRENTTOINPUTWEIGHTS = 12, + VT_RECURRENTTOFORGETWEIGHTS = 14, + VT_RECURRENTTOCELLWEIGHTS = 16, + VT_RECURRENTTOOUTPUTWEIGHTS = 18, + VT_INPUTGATEBIAS = 20, + VT_FORGETGATEBIAS = 22, + VT_CELLBIAS = 24, + VT_OUTPUTGATEBIAS = 26 + }; + const armnnSerializer::ConstTensor *inputToInputWeights() const { + return GetPointer(VT_INPUTTOINPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *inputToForgetWeights() const { + return GetPointer(VT_INPUTTOFORGETWEIGHTS); + } + const armnnSerializer::ConstTensor *inputToCellWeights() const { + return GetPointer(VT_INPUTTOCELLWEIGHTS); + } + const armnnSerializer::ConstTensor *inputToOutputWeights() const { + return GetPointer(VT_INPUTTOOUTPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToInputWeights() const { + return GetPointer(VT_RECURRENTTOINPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToForgetWeights() const { + return GetPointer(VT_RECURRENTTOFORGETWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToCellWeights() const { + return GetPointer(VT_RECURRENTTOCELLWEIGHTS); + } + const armnnSerializer::ConstTensor *recurrentToOutputWeights() const { + return GetPointer(VT_RECURRENTTOOUTPUTWEIGHTS); + } + const armnnSerializer::ConstTensor *inputGateBias() const { + return GetPointer(VT_INPUTGATEBIAS); + } + const armnnSerializer::ConstTensor *forgetGateBias() const { + return GetPointer(VT_FORGETGATEBIAS); + } + const armnnSerializer::ConstTensor *cellBias() const { + return GetPointer(VT_CELLBIAS); + } + const armnnSerializer::ConstTensor *outputGateBias() const { + return GetPointer(VT_OUTPUTGATEBIAS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_INPUTTOINPUTWEIGHTS) && + verifier.VerifyTable(inputToInputWeights()) && + VerifyOffset(verifier, VT_INPUTTOFORGETWEIGHTS) && + verifier.VerifyTable(inputToForgetWeights()) && + VerifyOffset(verifier, VT_INPUTTOCELLWEIGHTS) && + verifier.VerifyTable(inputToCellWeights()) && + VerifyOffset(verifier, VT_INPUTTOOUTPUTWEIGHTS) && + verifier.VerifyTable(inputToOutputWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOINPUTWEIGHTS) && + verifier.VerifyTable(recurrentToInputWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOFORGETWEIGHTS) && + verifier.VerifyTable(recurrentToForgetWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOCELLWEIGHTS) && + verifier.VerifyTable(recurrentToCellWeights()) && + VerifyOffset(verifier, VT_RECURRENTTOOUTPUTWEIGHTS) && + verifier.VerifyTable(recurrentToOutputWeights()) && + VerifyOffset(verifier, VT_INPUTGATEBIAS) && + verifier.VerifyTable(inputGateBias()) && + VerifyOffset(verifier, VT_FORGETGATEBIAS) && + verifier.VerifyTable(forgetGateBias()) && + VerifyOffset(verifier, VT_CELLBIAS) && + verifier.VerifyTable(cellBias()) && + VerifyOffset(verifier, VT_OUTPUTGATEBIAS) && + verifier.VerifyTable(outputGateBias()) && + verifier.EndTable(); + } +}; + +struct QuantizedLstmInputParamsBuilder { + typedef QuantizedLstmInputParams Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_inputToInputWeights(flatbuffers::Offset inputToInputWeights) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_INPUTTOINPUTWEIGHTS, inputToInputWeights); + } + void add_inputToForgetWeights(flatbuffers::Offset inputToForgetWeights) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_INPUTTOFORGETWEIGHTS, inputToForgetWeights); + } + void add_inputToCellWeights(flatbuffers::Offset inputToCellWeights) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_INPUTTOCELLWEIGHTS, inputToCellWeights); + } + void add_inputToOutputWeights(flatbuffers::Offset inputToOutputWeights) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_INPUTTOOUTPUTWEIGHTS, inputToOutputWeights); + } + void add_recurrentToInputWeights(flatbuffers::Offset recurrentToInputWeights) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_RECURRENTTOINPUTWEIGHTS, recurrentToInputWeights); + } + void add_recurrentToForgetWeights(flatbuffers::Offset recurrentToForgetWeights) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_RECURRENTTOFORGETWEIGHTS, recurrentToForgetWeights); + } + void add_recurrentToCellWeights(flatbuffers::Offset recurrentToCellWeights) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_RECURRENTTOCELLWEIGHTS, recurrentToCellWeights); + } + void add_recurrentToOutputWeights(flatbuffers::Offset recurrentToOutputWeights) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_RECURRENTTOOUTPUTWEIGHTS, recurrentToOutputWeights); + } + void add_inputGateBias(flatbuffers::Offset inputGateBias) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_INPUTGATEBIAS, inputGateBias); + } + void add_forgetGateBias(flatbuffers::Offset forgetGateBias) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_FORGETGATEBIAS, forgetGateBias); + } + void add_cellBias(flatbuffers::Offset cellBias) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_CELLBIAS, cellBias); + } + void add_outputGateBias(flatbuffers::Offset outputGateBias) { + fbb_.AddOffset(QuantizedLstmInputParams::VT_OUTPUTGATEBIAS, outputGateBias); + } + explicit QuantizedLstmInputParamsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + QuantizedLstmInputParamsBuilder &operator=(const QuantizedLstmInputParamsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateQuantizedLstmInputParams( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset inputToInputWeights = 0, + flatbuffers::Offset inputToForgetWeights = 0, + flatbuffers::Offset inputToCellWeights = 0, + flatbuffers::Offset inputToOutputWeights = 0, + flatbuffers::Offset recurrentToInputWeights = 0, + flatbuffers::Offset recurrentToForgetWeights = 0, + flatbuffers::Offset recurrentToCellWeights = 0, + flatbuffers::Offset recurrentToOutputWeights = 0, + flatbuffers::Offset inputGateBias = 0, + flatbuffers::Offset forgetGateBias = 0, + flatbuffers::Offset cellBias = 0, + flatbuffers::Offset outputGateBias = 0) { + QuantizedLstmInputParamsBuilder builder_(_fbb); + builder_.add_outputGateBias(outputGateBias); + builder_.add_cellBias(cellBias); + builder_.add_forgetGateBias(forgetGateBias); + builder_.add_inputGateBias(inputGateBias); + builder_.add_recurrentToOutputWeights(recurrentToOutputWeights); + builder_.add_recurrentToCellWeights(recurrentToCellWeights); + builder_.add_recurrentToForgetWeights(recurrentToForgetWeights); + builder_.add_recurrentToInputWeights(recurrentToInputWeights); + builder_.add_inputToOutputWeights(inputToOutputWeights); + builder_.add_inputToCellWeights(inputToCellWeights); + builder_.add_inputToForgetWeights(inputToForgetWeights); + builder_.add_inputToInputWeights(inputToInputWeights); + return builder_.Finish(); +} + +struct QuantizedLstmLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef QuantizedLstmLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_INPUTPARAMS = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::QuantizedLstmInputParams *inputParams() const { + return GetPointer(VT_INPUTPARAMS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_INPUTPARAMS) && + verifier.VerifyTable(inputParams()) && + verifier.EndTable(); + } +}; + +struct QuantizedLstmLayerBuilder { + typedef QuantizedLstmLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(QuantizedLstmLayer::VT_BASE, base); + } + void add_inputParams(flatbuffers::Offset inputParams) { + fbb_.AddOffset(QuantizedLstmLayer::VT_INPUTPARAMS, inputParams); + } + explicit QuantizedLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + QuantizedLstmLayerBuilder &operator=(const QuantizedLstmLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateQuantizedLstmLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset inputParams = 0) { + QuantizedLstmLayerBuilder builder_(_fbb); + builder_.add_inputParams(inputParams); + builder_.add_base(base); + return builder_.Finish(); +} + +struct DequantizeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DequantizeLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct DequantizeLayerBuilder { + typedef DequantizeLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(DequantizeLayer::VT_BASE, base); + } + explicit DequantizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DequantizeLayerBuilder &operator=(const DequantizeLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDequantizeLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + DequantizeLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct MergeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MergeLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct MergeLayerBuilder { + typedef MergeLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(MergeLayer::VT_BASE, base); + } + explicit MergeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MergeLayerBuilder &operator=(const MergeLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMergeLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + MergeLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct SwitchLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SwitchLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct SwitchLayerBuilder { + typedef SwitchLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(SwitchLayer::VT_BASE, base); + } + explicit SwitchLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SwitchLayerBuilder &operator=(const SwitchLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSwitchLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + SwitchLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct PreluLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PreluLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct PreluLayerBuilder { + typedef PreluLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(PreluLayer::VT_BASE, base); + } + explicit PreluLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PreluLayerBuilder &operator=(const PreluLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePreluLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + PreluLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct TransposeConvolution2dLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TransposeConvolution2dLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6, + VT_WEIGHTS = 8, + VT_BIASES = 10 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::TransposeConvolution2dDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + const armnnSerializer::ConstTensor *weights() const { + return GetPointer(VT_WEIGHTS); + } + const armnnSerializer::ConstTensor *biases() const { + return GetPointer(VT_BIASES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + VerifyOffset(verifier, VT_WEIGHTS) && + verifier.VerifyTable(weights()) && + VerifyOffset(verifier, VT_BIASES) && + verifier.VerifyTable(biases()) && + verifier.EndTable(); + } +}; + +struct TransposeConvolution2dLayerBuilder { + typedef TransposeConvolution2dLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(TransposeConvolution2dLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(TransposeConvolution2dLayer::VT_DESCRIPTOR, descriptor); + } + void add_weights(flatbuffers::Offset weights) { + fbb_.AddOffset(TransposeConvolution2dLayer::VT_WEIGHTS, weights); + } + void add_biases(flatbuffers::Offset biases) { + fbb_.AddOffset(TransposeConvolution2dLayer::VT_BIASES, biases); + } + explicit TransposeConvolution2dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TransposeConvolution2dLayerBuilder &operator=(const TransposeConvolution2dLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTransposeConvolution2dLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0, + flatbuffers::Offset weights = 0, + flatbuffers::Offset biases = 0) { + TransposeConvolution2dLayerBuilder builder_(_fbb); + builder_.add_biases(biases); + builder_.add_weights(weights); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct TransposeConvolution2dDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TransposeConvolution2dDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PADLEFT = 4, + VT_PADRIGHT = 6, + VT_PADTOP = 8, + VT_PADBOTTOM = 10, + VT_STRIDEX = 12, + VT_STRIDEY = 14, + VT_BIASENABLED = 16, + VT_DATALAYOUT = 18 + }; + uint32_t padLeft() const { + return GetField(VT_PADLEFT, 0); + } + uint32_t padRight() const { + return GetField(VT_PADRIGHT, 0); + } + uint32_t padTop() const { + return GetField(VT_PADTOP, 0); + } + uint32_t padBottom() const { + return GetField(VT_PADBOTTOM, 0); + } + uint32_t strideX() const { + return GetField(VT_STRIDEX, 0); + } + uint32_t strideY() const { + return GetField(VT_STRIDEY, 0); + } + bool biasEnabled() const { + return GetField(VT_BIASENABLED, 0) != 0; + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 1)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_PADLEFT) && + VerifyField(verifier, VT_PADRIGHT) && + VerifyField(verifier, VT_PADTOP) && + VerifyField(verifier, VT_PADBOTTOM) && + VerifyField(verifier, VT_STRIDEX) && + VerifyField(verifier, VT_STRIDEY) && + VerifyField(verifier, VT_BIASENABLED) && + VerifyField(verifier, VT_DATALAYOUT) && + verifier.EndTable(); + } +}; + +struct TransposeConvolution2dDescriptorBuilder { + typedef TransposeConvolution2dDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padLeft(uint32_t padLeft) { + fbb_.AddElement(TransposeConvolution2dDescriptor::VT_PADLEFT, padLeft, 0); + } + void add_padRight(uint32_t padRight) { + fbb_.AddElement(TransposeConvolution2dDescriptor::VT_PADRIGHT, padRight, 0); + } + void add_padTop(uint32_t padTop) { + fbb_.AddElement(TransposeConvolution2dDescriptor::VT_PADTOP, padTop, 0); + } + void add_padBottom(uint32_t padBottom) { + fbb_.AddElement(TransposeConvolution2dDescriptor::VT_PADBOTTOM, padBottom, 0); + } + void add_strideX(uint32_t strideX) { + fbb_.AddElement(TransposeConvolution2dDescriptor::VT_STRIDEX, strideX, 0); + } + void add_strideY(uint32_t strideY) { + fbb_.AddElement(TransposeConvolution2dDescriptor::VT_STRIDEY, strideY, 0); + } + void add_biasEnabled(bool biasEnabled) { + fbb_.AddElement(TransposeConvolution2dDescriptor::VT_BIASENABLED, static_cast(biasEnabled), 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(TransposeConvolution2dDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 1); + } + explicit TransposeConvolution2dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TransposeConvolution2dDescriptorBuilder &operator=(const TransposeConvolution2dDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTransposeConvolution2dDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t padLeft = 0, + uint32_t padRight = 0, + uint32_t padTop = 0, + uint32_t padBottom = 0, + uint32_t strideX = 0, + uint32_t strideY = 0, + bool biasEnabled = false, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NCHW) { + TransposeConvolution2dDescriptorBuilder builder_(_fbb); + builder_.add_strideY(strideY); + builder_.add_strideX(strideX); + builder_.add_padBottom(padBottom); + builder_.add_padTop(padTop); + builder_.add_padRight(padRight); + builder_.add_padLeft(padLeft); + builder_.add_dataLayout(dataLayout); + builder_.add_biasEnabled(biasEnabled); + return builder_.Finish(); +} + +struct TransposeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TransposeLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::TransposeDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct TransposeLayerBuilder { + typedef TransposeLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(TransposeLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(TransposeLayer::VT_DESCRIPTOR, descriptor); + } + explicit TransposeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TransposeLayerBuilder &operator=(const TransposeLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTransposeLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + TransposeLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct TransposeDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TransposeDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DIMMAPPINGS = 4 + }; + const flatbuffers::Vector *dimMappings() const { + return GetPointer *>(VT_DIMMAPPINGS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DIMMAPPINGS) && + verifier.VerifyVector(dimMappings()) && + verifier.EndTable(); + } +}; + +struct TransposeDescriptorBuilder { + typedef TransposeDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_dimMappings(flatbuffers::Offset> dimMappings) { + fbb_.AddOffset(TransposeDescriptor::VT_DIMMAPPINGS, dimMappings); + } + explicit TransposeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TransposeDescriptorBuilder &operator=(const TransposeDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTransposeDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> dimMappings = 0) { + TransposeDescriptorBuilder builder_(_fbb); + builder_.add_dimMappings(dimMappings); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTransposeDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *dimMappings = nullptr) { + auto dimMappings__ = dimMappings ? _fbb.CreateVector(*dimMappings) : 0; + return armnnSerializer::CreateTransposeDescriptor( + _fbb, + dimMappings__); +} + +struct ResizeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResizeLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::ResizeDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct ResizeLayerBuilder { + typedef ResizeLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ResizeLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(ResizeLayer::VT_DESCRIPTOR, descriptor); + } + explicit ResizeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ResizeLayerBuilder &operator=(const ResizeLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateResizeLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + ResizeLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ResizeDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResizeDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TARGETHEIGHT = 4, + VT_TARGETWIDTH = 6, + VT_METHOD = 8, + VT_DATALAYOUT = 10, + VT_ALIGNCORNERS = 12, + VT_HALFPIXELCENTERS = 14 + }; + uint32_t targetHeight() const { + return GetField(VT_TARGETHEIGHT, 0); + } + uint32_t targetWidth() const { + return GetField(VT_TARGETWIDTH, 0); + } + armnnSerializer::ResizeMethod method() const { + return static_cast(GetField(VT_METHOD, 0)); + } + armnnSerializer::DataLayout dataLayout() const { + return static_cast(GetField(VT_DATALAYOUT, 0)); + } + bool alignCorners() const { + return GetField(VT_ALIGNCORNERS, 0) != 0; + } + bool halfPixelCenters() const { + return GetField(VT_HALFPIXELCENTERS, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_TARGETHEIGHT) && + VerifyField(verifier, VT_TARGETWIDTH) && + VerifyField(verifier, VT_METHOD) && + VerifyField(verifier, VT_DATALAYOUT) && + VerifyField(verifier, VT_ALIGNCORNERS) && + VerifyField(verifier, VT_HALFPIXELCENTERS) && + verifier.EndTable(); + } +}; + +struct ResizeDescriptorBuilder { + typedef ResizeDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_targetHeight(uint32_t targetHeight) { + fbb_.AddElement(ResizeDescriptor::VT_TARGETHEIGHT, targetHeight, 0); + } + void add_targetWidth(uint32_t targetWidth) { + fbb_.AddElement(ResizeDescriptor::VT_TARGETWIDTH, targetWidth, 0); + } + void add_method(armnnSerializer::ResizeMethod method) { + fbb_.AddElement(ResizeDescriptor::VT_METHOD, static_cast(method), 0); + } + void add_dataLayout(armnnSerializer::DataLayout dataLayout) { + fbb_.AddElement(ResizeDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); + } + void add_alignCorners(bool alignCorners) { + fbb_.AddElement(ResizeDescriptor::VT_ALIGNCORNERS, static_cast(alignCorners), 0); + } + void add_halfPixelCenters(bool halfPixelCenters) { + fbb_.AddElement(ResizeDescriptor::VT_HALFPIXELCENTERS, static_cast(halfPixelCenters), 0); + } + explicit ResizeDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ResizeDescriptorBuilder &operator=(const ResizeDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateResizeDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t targetHeight = 0, + uint32_t targetWidth = 0, + armnnSerializer::ResizeMethod method = armnnSerializer::ResizeMethod_NearestNeighbor, + armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC, + bool alignCorners = false, + bool halfPixelCenters = false) { + ResizeDescriptorBuilder builder_(_fbb); + builder_.add_targetWidth(targetWidth); + builder_.add_targetHeight(targetHeight); + builder_.add_halfPixelCenters(halfPixelCenters); + builder_.add_alignCorners(alignCorners); + builder_.add_dataLayout(dataLayout); + builder_.add_method(method); + return builder_.Finish(); +} + +struct StackLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StackLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::StackDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct StackLayerBuilder { + typedef StackLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(StackLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(StackLayer::VT_DESCRIPTOR, descriptor); + } + explicit StackLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StackLayerBuilder &operator=(const StackLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStackLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + StackLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct StackDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StackDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_AXIS = 4, + VT_NUMINPUTS = 6, + VT_INPUTSHAPE = 8 + }; + uint32_t axis() const { + return GetField(VT_AXIS, 0); + } + uint32_t numInputs() const { + return GetField(VT_NUMINPUTS, 0); + } + const flatbuffers::Vector *inputShape() const { + return GetPointer *>(VT_INPUTSHAPE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_AXIS) && + VerifyField(verifier, VT_NUMINPUTS) && + VerifyOffset(verifier, VT_INPUTSHAPE) && + verifier.VerifyVector(inputShape()) && + verifier.EndTable(); + } +}; + +struct StackDescriptorBuilder { + typedef StackDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_axis(uint32_t axis) { + fbb_.AddElement(StackDescriptor::VT_AXIS, axis, 0); + } + void add_numInputs(uint32_t numInputs) { + fbb_.AddElement(StackDescriptor::VT_NUMINPUTS, numInputs, 0); + } + void add_inputShape(flatbuffers::Offset> inputShape) { + fbb_.AddOffset(StackDescriptor::VT_INPUTSHAPE, inputShape); + } + explicit StackDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StackDescriptorBuilder &operator=(const StackDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStackDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t axis = 0, + uint32_t numInputs = 0, + flatbuffers::Offset> inputShape = 0) { + StackDescriptorBuilder builder_(_fbb); + builder_.add_inputShape(inputShape); + builder_.add_numInputs(numInputs); + builder_.add_axis(axis); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateStackDescriptorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t axis = 0, + uint32_t numInputs = 0, + const std::vector *inputShape = nullptr) { + auto inputShape__ = inputShape ? _fbb.CreateVector(*inputShape) : 0; + return armnnSerializer::CreateStackDescriptor( + _fbb, + axis, + numInputs, + inputShape__); +} + +struct StandInDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StandInDescriptorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NUMINPUTS = 4, + VT_NUMOUTPUTS = 6 + }; + uint32_t numInputs() const { + return GetField(VT_NUMINPUTS, 0); + } + uint32_t numOutputs() const { + return GetField(VT_NUMOUTPUTS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NUMINPUTS) && + VerifyField(verifier, VT_NUMOUTPUTS) && + verifier.EndTable(); + } +}; + +struct StandInDescriptorBuilder { + typedef StandInDescriptor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_numInputs(uint32_t numInputs) { + fbb_.AddElement(StandInDescriptor::VT_NUMINPUTS, numInputs, 0); + } + void add_numOutputs(uint32_t numOutputs) { + fbb_.AddElement(StandInDescriptor::VT_NUMOUTPUTS, numOutputs, 0); + } + explicit StandInDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StandInDescriptorBuilder &operator=(const StandInDescriptorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStandInDescriptor( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t numInputs = 0, + uint32_t numOutputs = 0) { + StandInDescriptorBuilder builder_(_fbb); + builder_.add_numOutputs(numOutputs); + builder_.add_numInputs(numInputs); + return builder_.Finish(); +} + +struct StandInLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StandInLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_DESCRIPTOR = 6 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + const armnnSerializer::StandInDescriptor *descriptor() const { + return GetPointer(VT_DESCRIPTOR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DESCRIPTOR) && + verifier.VerifyTable(descriptor()) && + verifier.EndTable(); + } +}; + +struct StandInLayerBuilder { + typedef StandInLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(StandInLayer::VT_BASE, base); + } + void add_descriptor(flatbuffers::Offset descriptor) { + fbb_.AddOffset(StandInLayer::VT_DESCRIPTOR, descriptor); + } + explicit StandInLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + StandInLayerBuilder &operator=(const StandInLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStandInLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0, + flatbuffers::Offset descriptor = 0) { + StandInLayerBuilder builder_(_fbb); + builder_.add_descriptor(descriptor); + builder_.add_base(base); + return builder_.Finish(); +} + +struct RankLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RankLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct RankLayerBuilder { + typedef RankLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(RankLayer::VT_BASE, base); + } + explicit RankLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RankLayerBuilder &operator=(const RankLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateRankLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + RankLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct AnyLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AnyLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_LAYER_TYPE = 4, + VT_LAYER = 6 + }; + armnnSerializer::Layer layer_type() const { + return static_cast(GetField(VT_LAYER_TYPE, 0)); + } + const void *layer() const { + return GetPointer(VT_LAYER); + } + template const T *layer_as() const; + const armnnSerializer::ActivationLayer *layer_as_ActivationLayer() const { + return layer_type() == armnnSerializer::Layer_ActivationLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::AdditionLayer *layer_as_AdditionLayer() const { + return layer_type() == armnnSerializer::Layer_AdditionLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::BatchToSpaceNdLayer *layer_as_BatchToSpaceNdLayer() const { + return layer_type() == armnnSerializer::Layer_BatchToSpaceNdLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::BatchNormalizationLayer *layer_as_BatchNormalizationLayer() const { + return layer_type() == armnnSerializer::Layer_BatchNormalizationLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::ConstantLayer *layer_as_ConstantLayer() const { + return layer_type() == armnnSerializer::Layer_ConstantLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::Convolution2dLayer *layer_as_Convolution2dLayer() const { + return layer_type() == armnnSerializer::Layer_Convolution2dLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::DepthwiseConvolution2dLayer *layer_as_DepthwiseConvolution2dLayer() const { + return layer_type() == armnnSerializer::Layer_DepthwiseConvolution2dLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::FullyConnectedLayer *layer_as_FullyConnectedLayer() const { + return layer_type() == armnnSerializer::Layer_FullyConnectedLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::InputLayer *layer_as_InputLayer() const { + return layer_type() == armnnSerializer::Layer_InputLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::MultiplicationLayer *layer_as_MultiplicationLayer() const { + return layer_type() == armnnSerializer::Layer_MultiplicationLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::OutputLayer *layer_as_OutputLayer() const { + return layer_type() == armnnSerializer::Layer_OutputLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::PermuteLayer *layer_as_PermuteLayer() const { + return layer_type() == armnnSerializer::Layer_PermuteLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::Pooling2dLayer *layer_as_Pooling2dLayer() const { + return layer_type() == armnnSerializer::Layer_Pooling2dLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::ReshapeLayer *layer_as_ReshapeLayer() const { + return layer_type() == armnnSerializer::Layer_ReshapeLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::SoftmaxLayer *layer_as_SoftmaxLayer() const { + return layer_type() == armnnSerializer::Layer_SoftmaxLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::SpaceToBatchNdLayer *layer_as_SpaceToBatchNdLayer() const { + return layer_type() == armnnSerializer::Layer_SpaceToBatchNdLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::DivisionLayer *layer_as_DivisionLayer() const { + return layer_type() == armnnSerializer::Layer_DivisionLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::MinimumLayer *layer_as_MinimumLayer() const { + return layer_type() == armnnSerializer::Layer_MinimumLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::EqualLayer *layer_as_EqualLayer() const { + return layer_type() == armnnSerializer::Layer_EqualLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::MaximumLayer *layer_as_MaximumLayer() const { + return layer_type() == armnnSerializer::Layer_MaximumLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::NormalizationLayer *layer_as_NormalizationLayer() const { + return layer_type() == armnnSerializer::Layer_NormalizationLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::PadLayer *layer_as_PadLayer() const { + return layer_type() == armnnSerializer::Layer_PadLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::RsqrtLayer *layer_as_RsqrtLayer() const { + return layer_type() == armnnSerializer::Layer_RsqrtLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::FloorLayer *layer_as_FloorLayer() const { + return layer_type() == armnnSerializer::Layer_FloorLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::GreaterLayer *layer_as_GreaterLayer() const { + return layer_type() == armnnSerializer::Layer_GreaterLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::ResizeBilinearLayer *layer_as_ResizeBilinearLayer() const { + return layer_type() == armnnSerializer::Layer_ResizeBilinearLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::SubtractionLayer *layer_as_SubtractionLayer() const { + return layer_type() == armnnSerializer::Layer_SubtractionLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::StridedSliceLayer *layer_as_StridedSliceLayer() const { + return layer_type() == armnnSerializer::Layer_StridedSliceLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::GatherLayer *layer_as_GatherLayer() const { + return layer_type() == armnnSerializer::Layer_GatherLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::MeanLayer *layer_as_MeanLayer() const { + return layer_type() == armnnSerializer::Layer_MeanLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::MergerLayer *layer_as_MergerLayer() const { + return layer_type() == armnnSerializer::Layer_MergerLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::L2NormalizationLayer *layer_as_L2NormalizationLayer() const { + return layer_type() == armnnSerializer::Layer_L2NormalizationLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::SplitterLayer *layer_as_SplitterLayer() const { + return layer_type() == armnnSerializer::Layer_SplitterLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::DetectionPostProcessLayer *layer_as_DetectionPostProcessLayer() const { + return layer_type() == armnnSerializer::Layer_DetectionPostProcessLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::LstmLayer *layer_as_LstmLayer() const { + return layer_type() == armnnSerializer::Layer_LstmLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::QuantizedLstmLayer *layer_as_QuantizedLstmLayer() const { + return layer_type() == armnnSerializer::Layer_QuantizedLstmLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::QuantizeLayer *layer_as_QuantizeLayer() const { + return layer_type() == armnnSerializer::Layer_QuantizeLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::DequantizeLayer *layer_as_DequantizeLayer() const { + return layer_type() == armnnSerializer::Layer_DequantizeLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::MergeLayer *layer_as_MergeLayer() const { + return layer_type() == armnnSerializer::Layer_MergeLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::SwitchLayer *layer_as_SwitchLayer() const { + return layer_type() == armnnSerializer::Layer_SwitchLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::ConcatLayer *layer_as_ConcatLayer() const { + return layer_type() == armnnSerializer::Layer_ConcatLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::SpaceToDepthLayer *layer_as_SpaceToDepthLayer() const { + return layer_type() == armnnSerializer::Layer_SpaceToDepthLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::PreluLayer *layer_as_PreluLayer() const { + return layer_type() == armnnSerializer::Layer_PreluLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::TransposeConvolution2dLayer *layer_as_TransposeConvolution2dLayer() const { + return layer_type() == armnnSerializer::Layer_TransposeConvolution2dLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::ResizeLayer *layer_as_ResizeLayer() const { + return layer_type() == armnnSerializer::Layer_ResizeLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::StackLayer *layer_as_StackLayer() const { + return layer_type() == armnnSerializer::Layer_StackLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::AbsLayer *layer_as_AbsLayer() const { + return layer_type() == armnnSerializer::Layer_AbsLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::ArgMinMaxLayer *layer_as_ArgMinMaxLayer() const { + return layer_type() == armnnSerializer::Layer_ArgMinMaxLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::SliceLayer *layer_as_SliceLayer() const { + return layer_type() == armnnSerializer::Layer_SliceLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::DepthToSpaceLayer *layer_as_DepthToSpaceLayer() const { + return layer_type() == armnnSerializer::Layer_DepthToSpaceLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::InstanceNormalizationLayer *layer_as_InstanceNormalizationLayer() const { + return layer_type() == armnnSerializer::Layer_InstanceNormalizationLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::LogSoftmaxLayer *layer_as_LogSoftmaxLayer() const { + return layer_type() == armnnSerializer::Layer_LogSoftmaxLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::ComparisonLayer *layer_as_ComparisonLayer() const { + return layer_type() == armnnSerializer::Layer_ComparisonLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::StandInLayer *layer_as_StandInLayer() const { + return layer_type() == armnnSerializer::Layer_StandInLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::ElementwiseUnaryLayer *layer_as_ElementwiseUnaryLayer() const { + return layer_type() == armnnSerializer::Layer_ElementwiseUnaryLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::TransposeLayer *layer_as_TransposeLayer() const { + return layer_type() == armnnSerializer::Layer_TransposeLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::QLstmLayer *layer_as_QLstmLayer() const { + return layer_type() == armnnSerializer::Layer_QLstmLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::FillLayer *layer_as_FillLayer() const { + return layer_type() == armnnSerializer::Layer_FillLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::RankLayer *layer_as_RankLayer() const { + return layer_type() == armnnSerializer::Layer_RankLayer ? static_cast(layer()) : nullptr; + } + const armnnSerializer::LogicalBinaryLayer *layer_as_LogicalBinaryLayer() const { + return layer_type() == armnnSerializer::Layer_LogicalBinaryLayer ? static_cast(layer()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_LAYER_TYPE) && + VerifyOffset(verifier, VT_LAYER) && + VerifyLayer(verifier, layer(), layer_type()) && + verifier.EndTable(); + } +}; + +template<> inline const armnnSerializer::ActivationLayer *AnyLayer::layer_as() const { + return layer_as_ActivationLayer(); +} + +template<> inline const armnnSerializer::AdditionLayer *AnyLayer::layer_as() const { + return layer_as_AdditionLayer(); +} + +template<> inline const armnnSerializer::BatchToSpaceNdLayer *AnyLayer::layer_as() const { + return layer_as_BatchToSpaceNdLayer(); +} + +template<> inline const armnnSerializer::BatchNormalizationLayer *AnyLayer::layer_as() const { + return layer_as_BatchNormalizationLayer(); +} + +template<> inline const armnnSerializer::ConstantLayer *AnyLayer::layer_as() const { + return layer_as_ConstantLayer(); +} + +template<> inline const armnnSerializer::Convolution2dLayer *AnyLayer::layer_as() const { + return layer_as_Convolution2dLayer(); +} + +template<> inline const armnnSerializer::DepthwiseConvolution2dLayer *AnyLayer::layer_as() const { + return layer_as_DepthwiseConvolution2dLayer(); +} + +template<> inline const armnnSerializer::FullyConnectedLayer *AnyLayer::layer_as() const { + return layer_as_FullyConnectedLayer(); +} + +template<> inline const armnnSerializer::InputLayer *AnyLayer::layer_as() const { + return layer_as_InputLayer(); +} + +template<> inline const armnnSerializer::MultiplicationLayer *AnyLayer::layer_as() const { + return layer_as_MultiplicationLayer(); +} + +template<> inline const armnnSerializer::OutputLayer *AnyLayer::layer_as() const { + return layer_as_OutputLayer(); +} + +template<> inline const armnnSerializer::PermuteLayer *AnyLayer::layer_as() const { + return layer_as_PermuteLayer(); +} + +template<> inline const armnnSerializer::Pooling2dLayer *AnyLayer::layer_as() const { + return layer_as_Pooling2dLayer(); +} + +template<> inline const armnnSerializer::ReshapeLayer *AnyLayer::layer_as() const { + return layer_as_ReshapeLayer(); +} + +template<> inline const armnnSerializer::SoftmaxLayer *AnyLayer::layer_as() const { + return layer_as_SoftmaxLayer(); +} + +template<> inline const armnnSerializer::SpaceToBatchNdLayer *AnyLayer::layer_as() const { + return layer_as_SpaceToBatchNdLayer(); +} + +template<> inline const armnnSerializer::DivisionLayer *AnyLayer::layer_as() const { + return layer_as_DivisionLayer(); +} + +template<> inline const armnnSerializer::MinimumLayer *AnyLayer::layer_as() const { + return layer_as_MinimumLayer(); +} + +template<> inline const armnnSerializer::EqualLayer *AnyLayer::layer_as() const { + return layer_as_EqualLayer(); +} + +template<> inline const armnnSerializer::MaximumLayer *AnyLayer::layer_as() const { + return layer_as_MaximumLayer(); +} + +template<> inline const armnnSerializer::NormalizationLayer *AnyLayer::layer_as() const { + return layer_as_NormalizationLayer(); +} + +template<> inline const armnnSerializer::PadLayer *AnyLayer::layer_as() const { + return layer_as_PadLayer(); +} + +template<> inline const armnnSerializer::RsqrtLayer *AnyLayer::layer_as() const { + return layer_as_RsqrtLayer(); +} + +template<> inline const armnnSerializer::FloorLayer *AnyLayer::layer_as() const { + return layer_as_FloorLayer(); +} + +template<> inline const armnnSerializer::GreaterLayer *AnyLayer::layer_as() const { + return layer_as_GreaterLayer(); +} + +template<> inline const armnnSerializer::ResizeBilinearLayer *AnyLayer::layer_as() const { + return layer_as_ResizeBilinearLayer(); +} + +template<> inline const armnnSerializer::SubtractionLayer *AnyLayer::layer_as() const { + return layer_as_SubtractionLayer(); +} + +template<> inline const armnnSerializer::StridedSliceLayer *AnyLayer::layer_as() const { + return layer_as_StridedSliceLayer(); +} + +template<> inline const armnnSerializer::GatherLayer *AnyLayer::layer_as() const { + return layer_as_GatherLayer(); +} + +template<> inline const armnnSerializer::MeanLayer *AnyLayer::layer_as() const { + return layer_as_MeanLayer(); +} + +template<> inline const armnnSerializer::MergerLayer *AnyLayer::layer_as() const { + return layer_as_MergerLayer(); +} + +template<> inline const armnnSerializer::L2NormalizationLayer *AnyLayer::layer_as() const { + return layer_as_L2NormalizationLayer(); +} + +template<> inline const armnnSerializer::SplitterLayer *AnyLayer::layer_as() const { + return layer_as_SplitterLayer(); +} + +template<> inline const armnnSerializer::DetectionPostProcessLayer *AnyLayer::layer_as() const { + return layer_as_DetectionPostProcessLayer(); +} + +template<> inline const armnnSerializer::LstmLayer *AnyLayer::layer_as() const { + return layer_as_LstmLayer(); +} + +template<> inline const armnnSerializer::QuantizedLstmLayer *AnyLayer::layer_as() const { + return layer_as_QuantizedLstmLayer(); +} + +template<> inline const armnnSerializer::QuantizeLayer *AnyLayer::layer_as() const { + return layer_as_QuantizeLayer(); +} + +template<> inline const armnnSerializer::DequantizeLayer *AnyLayer::layer_as() const { + return layer_as_DequantizeLayer(); +} + +template<> inline const armnnSerializer::MergeLayer *AnyLayer::layer_as() const { + return layer_as_MergeLayer(); +} + +template<> inline const armnnSerializer::SwitchLayer *AnyLayer::layer_as() const { + return layer_as_SwitchLayer(); +} + +template<> inline const armnnSerializer::ConcatLayer *AnyLayer::layer_as() const { + return layer_as_ConcatLayer(); +} + +template<> inline const armnnSerializer::SpaceToDepthLayer *AnyLayer::layer_as() const { + return layer_as_SpaceToDepthLayer(); +} + +template<> inline const armnnSerializer::PreluLayer *AnyLayer::layer_as() const { + return layer_as_PreluLayer(); +} + +template<> inline const armnnSerializer::TransposeConvolution2dLayer *AnyLayer::layer_as() const { + return layer_as_TransposeConvolution2dLayer(); +} + +template<> inline const armnnSerializer::ResizeLayer *AnyLayer::layer_as() const { + return layer_as_ResizeLayer(); +} + +template<> inline const armnnSerializer::StackLayer *AnyLayer::layer_as() const { + return layer_as_StackLayer(); +} + +template<> inline const armnnSerializer::AbsLayer *AnyLayer::layer_as() const { + return layer_as_AbsLayer(); +} + +template<> inline const armnnSerializer::ArgMinMaxLayer *AnyLayer::layer_as() const { + return layer_as_ArgMinMaxLayer(); +} + +template<> inline const armnnSerializer::SliceLayer *AnyLayer::layer_as() const { + return layer_as_SliceLayer(); +} + +template<> inline const armnnSerializer::DepthToSpaceLayer *AnyLayer::layer_as() const { + return layer_as_DepthToSpaceLayer(); +} + +template<> inline const armnnSerializer::InstanceNormalizationLayer *AnyLayer::layer_as() const { + return layer_as_InstanceNormalizationLayer(); +} + +template<> inline const armnnSerializer::LogSoftmaxLayer *AnyLayer::layer_as() const { + return layer_as_LogSoftmaxLayer(); +} + +template<> inline const armnnSerializer::ComparisonLayer *AnyLayer::layer_as() const { + return layer_as_ComparisonLayer(); +} + +template<> inline const armnnSerializer::StandInLayer *AnyLayer::layer_as() const { + return layer_as_StandInLayer(); +} + +template<> inline const armnnSerializer::ElementwiseUnaryLayer *AnyLayer::layer_as() const { + return layer_as_ElementwiseUnaryLayer(); +} + +template<> inline const armnnSerializer::TransposeLayer *AnyLayer::layer_as() const { + return layer_as_TransposeLayer(); +} + +template<> inline const armnnSerializer::QLstmLayer *AnyLayer::layer_as() const { + return layer_as_QLstmLayer(); +} + +template<> inline const armnnSerializer::FillLayer *AnyLayer::layer_as() const { + return layer_as_FillLayer(); +} + +template<> inline const armnnSerializer::RankLayer *AnyLayer::layer_as() const { + return layer_as_RankLayer(); +} + +template<> inline const armnnSerializer::LogicalBinaryLayer *AnyLayer::layer_as() const { + return layer_as_LogicalBinaryLayer(); +} + +struct AnyLayerBuilder { + typedef AnyLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_layer_type(armnnSerializer::Layer layer_type) { + fbb_.AddElement(AnyLayer::VT_LAYER_TYPE, static_cast(layer_type), 0); + } + void add_layer(flatbuffers::Offset layer) { + fbb_.AddOffset(AnyLayer::VT_LAYER, layer); + } + explicit AnyLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + AnyLayerBuilder &operator=(const AnyLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateAnyLayer( + flatbuffers::FlatBufferBuilder &_fbb, + armnnSerializer::Layer layer_type = armnnSerializer::Layer_NONE, + flatbuffers::Offset layer = 0) { + AnyLayerBuilder builder_(_fbb); + builder_.add_layer(layer); + builder_.add_layer_type(layer_type); + return builder_.Finish(); +} + +struct FeatureCompatibilityVersions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FeatureCompatibilityVersionsBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BINDINGIDSSCHEME = 4 + }; + uint32_t bindingIdsScheme() const { + return GetField(VT_BINDINGIDSSCHEME, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BINDINGIDSSCHEME) && + verifier.EndTable(); + } +}; + +struct FeatureCompatibilityVersionsBuilder { + typedef FeatureCompatibilityVersions Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_bindingIdsScheme(uint32_t bindingIdsScheme) { + fbb_.AddElement(FeatureCompatibilityVersions::VT_BINDINGIDSSCHEME, bindingIdsScheme, 0); + } + explicit FeatureCompatibilityVersionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FeatureCompatibilityVersionsBuilder &operator=(const FeatureCompatibilityVersionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFeatureCompatibilityVersions( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t bindingIdsScheme = 0) { + FeatureCompatibilityVersionsBuilder builder_(_fbb); + builder_.add_bindingIdsScheme(bindingIdsScheme); + return builder_.Finish(); +} + +struct SerializedGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerializedGraphBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_LAYERS = 4, + VT_INPUTIDS = 6, + VT_OUTPUTIDS = 8, + VT_FEATUREVERSIONS = 10 + }; + const flatbuffers::Vector> *layers() const { + return GetPointer> *>(VT_LAYERS); + } + const flatbuffers::Vector *inputIds() const { + return GetPointer *>(VT_INPUTIDS); + } + const flatbuffers::Vector *outputIds() const { + return GetPointer *>(VT_OUTPUTIDS); + } + const armnnSerializer::FeatureCompatibilityVersions *featureVersions() const { + return GetPointer(VT_FEATUREVERSIONS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_LAYERS) && + verifier.VerifyVector(layers()) && + verifier.VerifyVectorOfTables(layers()) && + VerifyOffset(verifier, VT_INPUTIDS) && + verifier.VerifyVector(inputIds()) && + VerifyOffset(verifier, VT_OUTPUTIDS) && + verifier.VerifyVector(outputIds()) && + VerifyOffset(verifier, VT_FEATUREVERSIONS) && + verifier.VerifyTable(featureVersions()) && + verifier.EndTable(); + } +}; + +struct SerializedGraphBuilder { + typedef SerializedGraph Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_layers(flatbuffers::Offset>> layers) { + fbb_.AddOffset(SerializedGraph::VT_LAYERS, layers); + } + void add_inputIds(flatbuffers::Offset> inputIds) { + fbb_.AddOffset(SerializedGraph::VT_INPUTIDS, inputIds); + } + void add_outputIds(flatbuffers::Offset> outputIds) { + fbb_.AddOffset(SerializedGraph::VT_OUTPUTIDS, outputIds); + } + void add_featureVersions(flatbuffers::Offset featureVersions) { + fbb_.AddOffset(SerializedGraph::VT_FEATUREVERSIONS, featureVersions); + } + explicit SerializedGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SerializedGraphBuilder &operator=(const SerializedGraphBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSerializedGraph( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> layers = 0, + flatbuffers::Offset> inputIds = 0, + flatbuffers::Offset> outputIds = 0, + flatbuffers::Offset featureVersions = 0) { + SerializedGraphBuilder builder_(_fbb); + builder_.add_featureVersions(featureVersions); + builder_.add_outputIds(outputIds); + builder_.add_inputIds(inputIds); + builder_.add_layers(layers); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSerializedGraphDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *layers = nullptr, + const std::vector *inputIds = nullptr, + const std::vector *outputIds = nullptr, + flatbuffers::Offset featureVersions = 0) { + auto layers__ = layers ? _fbb.CreateVector>(*layers) : 0; + auto inputIds__ = inputIds ? _fbb.CreateVector(*inputIds) : 0; + auto outputIds__ = outputIds ? _fbb.CreateVector(*outputIds) : 0; + return armnnSerializer::CreateSerializedGraph( + _fbb, + layers__, + inputIds__, + outputIds__, + featureVersions); +} + +inline bool VerifyConstTensorData(flatbuffers::Verifier &verifier, const void *obj, ConstTensorData type) { + switch (type) { + case ConstTensorData_NONE: { + return true; + } + case ConstTensorData_ByteData: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ConstTensorData_ShortData: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ConstTensorData_IntData: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ConstTensorData_LongData: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyConstTensorDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyConstTensorData( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyLayer(flatbuffers::Verifier &verifier, const void *obj, Layer type) { + switch (type) { + case Layer_NONE: { + return true; + } + case Layer_ActivationLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_AdditionLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_BatchToSpaceNdLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_BatchNormalizationLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ConstantLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_Convolution2dLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_DepthwiseConvolution2dLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_FullyConnectedLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_InputLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_MultiplicationLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_OutputLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_PermuteLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_Pooling2dLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ReshapeLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_SoftmaxLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_SpaceToBatchNdLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_DivisionLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_MinimumLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_EqualLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_MaximumLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_NormalizationLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_PadLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_RsqrtLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_FloorLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_GreaterLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ResizeBilinearLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_SubtractionLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_StridedSliceLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_GatherLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_MeanLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_MergerLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_L2NormalizationLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_SplitterLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_DetectionPostProcessLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_LstmLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_QuantizedLstmLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_QuantizeLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_DequantizeLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_MergeLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_SwitchLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ConcatLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_SpaceToDepthLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_PreluLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_TransposeConvolution2dLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ResizeLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_StackLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_AbsLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ArgMinMaxLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_SliceLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_DepthToSpaceLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_InstanceNormalizationLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_LogSoftmaxLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ComparisonLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_StandInLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ElementwiseUnaryLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_TransposeLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_QLstmLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_FillLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_RankLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_LogicalBinaryLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyLayerVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyLayer( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline const armnnSerializer::SerializedGraph *GetSerializedGraph(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const armnnSerializer::SerializedGraph *GetSizePrefixedSerializedGraph(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline const char *SerializedGraphIdentifier() { + return "ARMN"; +} + +inline bool SerializedGraphBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, SerializedGraphIdentifier()); +} + +inline bool VerifySerializedGraphBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(SerializedGraphIdentifier()); +} + +inline bool VerifySizePrefixedSerializedGraphBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(SerializedGraphIdentifier()); +} + +inline const char *SerializedGraphExtension() { + return "armnn"; +} + +inline void FinishSerializedGraphBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root, SerializedGraphIdentifier()); +} + +inline void FinishSizePrefixedSerializedGraphBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root, SerializedGraphIdentifier()); +} + +} // namespace armnnSerializer + +#endif // FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ diff --git a/src/armnnSerializer/Serializer.hpp b/src/armnnSerializer/Serializer.hpp index fa3447de21..8c44ced72f 100644 --- a/src/armnnSerializer/Serializer.hpp +++ b/src/armnnSerializer/Serializer.hpp @@ -11,7 +11,7 @@ #include -#include +#include "ArmnnSchema_generated.h" #include -- cgit v1.2.1