// 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" // Ensure the included flatbuffers.h is the same version as when this file was // generated, otherwise it may not be compatible. static_assert(FLATBUFFERS_VERSION_MAJOR == 2 && FLATBUFFERS_VERSION_MINOR == 0 && FLATBUFFERS_VERSION_REVISION == 7, "Non-compatible flatbuffers version included"); 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 CastLayer; struct CastLayerBuilder; struct ChannelShuffleLayer; struct ChannelShuffleLayerBuilder; struct ChannelShuffleDescriptor; struct ChannelShuffleDescriptorBuilder; struct ComparisonDescriptor; struct ComparisonDescriptorBuilder; struct ComparisonLayer; struct ComparisonLayerBuilder; struct ConstantLayer; struct ConstantLayerBuilder; struct Convolution2dLayer; struct Convolution2dLayerBuilder; struct Convolution2dDescriptor; struct Convolution2dDescriptorBuilder; struct Convolution3dLayer; struct Convolution3dLayerBuilder; struct Convolution3dDescriptor; struct Convolution3dDescriptorBuilder; struct DepthToSpaceLayer; struct DepthToSpaceLayerBuilder; struct DepthToSpaceDescriptor; struct DepthToSpaceDescriptorBuilder; struct DivisionLayer; struct DivisionLayerBuilder; struct ElementwiseBinaryDescriptor; struct ElementwiseBinaryDescriptorBuilder; struct ElementwiseBinaryLayer; struct ElementwiseBinaryLayerBuilder; 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 GatherNdLayer; struct GatherNdLayerBuilder; 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 Pooling3dLayer; struct Pooling3dLayerBuilder; struct Pooling2dDescriptor; struct Pooling2dDescriptorBuilder; struct Pooling3dDescriptor; struct Pooling3dDescriptorBuilder; 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 ShapeLayer; struct ShapeLayerBuilder; 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 ReduceLayer; struct ReduceLayerBuilder; struct ReduceDescriptor; struct ReduceDescriptorBuilder; struct UnidirectionalSequenceLstmDescriptor; struct UnidirectionalSequenceLstmDescriptorBuilder; struct UnidirectionalSequenceLstmLayer; struct UnidirectionalSequenceLstmLayerBuilder; struct BatchMatMulDescriptor; struct BatchMatMulDescriptorBuilder; struct BatchMatMulLayer; struct BatchMatMulLayerBuilder; struct AnyLayer; struct AnyLayerBuilder; struct FeatureCompatibilityVersions; struct FeatureCompatibilityVersionsBuilder; struct SerializedGraph; struct SerializedGraphBuilder; enum ActivationFunction : int8_t { 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 : int8_t { 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 : int8_t { 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_Signed64 = 10, DataType_MIN = DataType_Float16, DataType_MAX = DataType_Signed64 }; inline const DataType (&EnumValuesDataType())[11] { static const DataType values[] = { DataType_Float16, DataType_Float32, DataType_QuantisedAsymm8, DataType_Signed32, DataType_Boolean, DataType_QuantisedSymm16, DataType_QAsymmU8, DataType_QSymmS16, DataType_QAsymmS8, DataType_QSymmS8, DataType_Signed64 }; return values; } inline const char * const *EnumNamesDataType() { static const char * const names[12] = { "Float16", "Float32", "QuantisedAsymm8", "Signed32", "Boolean", "QuantisedSymm16", "QAsymmU8", "QSymmS16", "QAsymmS8", "QSymmS8", "Signed64", nullptr }; return names; } inline const char *EnumNameDataType(DataType e) { if (flatbuffers::IsOutRange(e, DataType_Float16, DataType_Signed64)) return ""; const size_t index = static_cast(e); return EnumNamesDataType()[index]; } enum DataLayout : int8_t { DataLayout_NHWC = 0, DataLayout_NCHW = 1, DataLayout_NDHWC = 2, DataLayout_NCDHW = 3, DataLayout_MIN = DataLayout_NHWC, DataLayout_MAX = DataLayout_NCDHW }; inline const DataLayout (&EnumValuesDataLayout())[4] { static const DataLayout values[] = { DataLayout_NHWC, DataLayout_NCHW, DataLayout_NDHWC, DataLayout_NCDHW }; return values; } inline const char * const *EnumNamesDataLayout() { static const char * const names[5] = { "NHWC", "NCHW", "NDHWC", "NCDHW", nullptr }; return names; } inline const char *EnumNameDataLayout(DataLayout e) { if (flatbuffers::IsOutRange(e, DataLayout_NHWC, DataLayout_NCDHW)) return ""; const size_t index = static_cast(e); return EnumNamesDataLayout()[index]; } enum ReduceOperation : int8_t { ReduceOperation_Sum = 0, ReduceOperation_Max = 1, ReduceOperation_Mean = 2, ReduceOperation_Min = 3, ReduceOperation_Prod = 4, ReduceOperation_MIN = ReduceOperation_Sum, ReduceOperation_MAX = ReduceOperation_Prod }; inline const ReduceOperation (&EnumValuesReduceOperation())[5] { static const ReduceOperation values[] = { ReduceOperation_Sum, ReduceOperation_Max, ReduceOperation_Mean, ReduceOperation_Min, ReduceOperation_Prod }; return values; } inline const char * const *EnumNamesReduceOperation() { static const char * const names[6] = { "Sum", "Max", "Mean", "Min", "Prod", nullptr }; return names; } inline const char *EnumNameReduceOperation(ReduceOperation e) { if (flatbuffers::IsOutRange(e, ReduceOperation_Sum, ReduceOperation_Prod)) return ""; const size_t index = static_cast(e); return EnumNamesReduceOperation()[index]; } enum ResizeMethod : int8_t { 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 : uint8_t { 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 : uint32_t { 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_Reduce = 60, LayerType_Cast = 61, LayerType_Shape = 62, LayerType_UnidirectionalSequenceLstm = 63, LayerType_ChannelShuffle = 64, LayerType_Convolution3d = 65, LayerType_Pooling3d = 66, LayerType_GatherNd = 67, LayerType_BatchMatMul = 68, LayerType_ElementwiseBinary = 69, LayerType_MIN = LayerType_Addition, LayerType_MAX = LayerType_ElementwiseBinary }; inline const LayerType (&EnumValuesLayerType())[70] { 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, LayerType_Reduce, LayerType_Cast, LayerType_Shape, LayerType_UnidirectionalSequenceLstm, LayerType_ChannelShuffle, LayerType_Convolution3d, LayerType_Pooling3d, LayerType_GatherNd, LayerType_BatchMatMul, LayerType_ElementwiseBinary }; return values; } inline const char * const *EnumNamesLayerType() { static const char * const names[71] = { "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", "Reduce", "Cast", "Shape", "UnidirectionalSequenceLstm", "ChannelShuffle", "Convolution3d", "Pooling3d", "GatherNd", "BatchMatMul", "ElementwiseBinary", nullptr }; return names; } inline const char *EnumNameLayerType(LayerType e) { if (flatbuffers::IsOutRange(e, LayerType_Addition, LayerType_ElementwiseBinary)) return ""; const size_t index = static_cast(e); return EnumNamesLayerType()[index]; } enum ComparisonOperation : int8_t { 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 BinaryOperation : int8_t { BinaryOperation_Add = 0, BinaryOperation_Div = 1, BinaryOperation_Maximum = 2, BinaryOperation_Minimum = 3, BinaryOperation_Mul = 4, BinaryOperation_Sub = 5, BinaryOperation_MIN = BinaryOperation_Add, BinaryOperation_MAX = BinaryOperation_Sub }; inline const BinaryOperation (&EnumValuesBinaryOperation())[6] { static const BinaryOperation values[] = { BinaryOperation_Add, BinaryOperation_Div, BinaryOperation_Maximum, BinaryOperation_Minimum, BinaryOperation_Mul, BinaryOperation_Sub }; return values; } inline const char * const *EnumNamesBinaryOperation() { static const char * const names[7] = { "Add", "Div", "Maximum", "Minimum", "Mul", "Sub", nullptr }; return names; } inline const char *EnumNameBinaryOperation(BinaryOperation e) { if (flatbuffers::IsOutRange(e, BinaryOperation_Add, BinaryOperation_Sub)) return ""; const size_t index = static_cast(e); return EnumNamesBinaryOperation()[index]; } enum UnaryOperation : int8_t { UnaryOperation_Abs = 0, UnaryOperation_Rsqrt = 1, UnaryOperation_Sqrt = 2, UnaryOperation_Exp = 3, UnaryOperation_Neg = 4, UnaryOperation_LogicalNot = 5, UnaryOperation_Log = 6, UnaryOperation_Sin = 7, UnaryOperation_Ceil = 8, UnaryOperation_MIN = UnaryOperation_Abs, UnaryOperation_MAX = UnaryOperation_Ceil }; inline const UnaryOperation (&EnumValuesUnaryOperation())[9] { static const UnaryOperation values[] = { UnaryOperation_Abs, UnaryOperation_Rsqrt, UnaryOperation_Sqrt, UnaryOperation_Exp, UnaryOperation_Neg, UnaryOperation_LogicalNot, UnaryOperation_Log, UnaryOperation_Sin, UnaryOperation_Ceil }; return values; } inline const char * const *EnumNamesUnaryOperation() { static const char * const names[10] = { "Abs", "Rsqrt", "Sqrt", "Exp", "Neg", "LogicalNot", "Log", "Sin", "Ceil", nullptr }; return names; } inline const char *EnumNameUnaryOperation(UnaryOperation e) { if (flatbuffers::IsOutRange(e, UnaryOperation_Abs, UnaryOperation_Ceil)) return ""; const size_t index = static_cast(e); return EnumNamesUnaryOperation()[index]; } enum LogicalBinaryOperation : int8_t { 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 : int8_t { 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 : int8_t { 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 : int8_t { 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 : int8_t { 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 : int8_t { 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 PaddingMode : int8_t { PaddingMode_Constant = 0, PaddingMode_Reflect = 1, PaddingMode_Symmetric = 2, PaddingMode_MIN = PaddingMode_Constant, PaddingMode_MAX = PaddingMode_Symmetric }; inline const PaddingMode (&EnumValuesPaddingMode())[3] { static const PaddingMode values[] = { PaddingMode_Constant, PaddingMode_Reflect, PaddingMode_Symmetric }; return values; } inline const char * const *EnumNamesPaddingMode() { static const char * const names[4] = { "Constant", "Reflect", "Symmetric", nullptr }; return names; } inline const char *EnumNamePaddingMode(PaddingMode e) { if (flatbuffers::IsOutRange(e, PaddingMode_Constant, PaddingMode_Symmetric)) return ""; const size_t index = static_cast(e); return EnumNamesPaddingMode()[index]; } enum Layer : uint8_t { 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_ReduceLayer = 61, Layer_CastLayer = 62, Layer_ShapeLayer = 63, Layer_UnidirectionalSequenceLstmLayer = 64, Layer_ChannelShuffleLayer = 65, Layer_Convolution3dLayer = 66, Layer_Pooling3dLayer = 67, Layer_GatherNdLayer = 68, Layer_BatchMatMulLayer = 69, Layer_ElementwiseBinaryLayer = 70, Layer_MIN = Layer_NONE, Layer_MAX = Layer_ElementwiseBinaryLayer }; inline const Layer (&EnumValuesLayer())[71] { 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, Layer_ReduceLayer, Layer_CastLayer, Layer_ShapeLayer, Layer_UnidirectionalSequenceLstmLayer, Layer_ChannelShuffleLayer, Layer_Convolution3dLayer, Layer_Pooling3dLayer, Layer_GatherNdLayer, Layer_BatchMatMulLayer, Layer_ElementwiseBinaryLayer }; return values; } inline const char * const *EnumNamesLayer() { static const char * const names[72] = { "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", "ReduceLayer", "CastLayer", "ShapeLayer", "UnidirectionalSequenceLstmLayer", "ChannelShuffleLayer", "Convolution3dLayer", "Pooling3dLayer", "GatherNdLayer", "BatchMatMulLayer", "ElementwiseBinaryLayer", nullptr }; return names; } inline const char *EnumNameLayer(Layer e) { if (flatbuffers::IsOutRange(e, Layer_NONE, Layer_ElementwiseBinaryLayer)) 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; }; template<> struct LayerTraits { static const Layer enum_value = Layer_ReduceLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_CastLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_ShapeLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_UnidirectionalSequenceLstmLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_ChannelShuffleLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_Convolution3dLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_Pooling3dLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_GatherNdLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_BatchMatMulLayer; }; template<> struct LayerTraits { static const Layer enum_value = Layer_ElementwiseBinaryLayer; }; 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() : sourceLayerIndex_(0), outputSlotIndex_(0) { } 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, VT_DIMENSIONSPECIFICITY = 18, VT_ISCONSTANT = 20 }; 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); } const flatbuffers::Vector *dimensionSpecificity() const { return GetPointer *>(VT_DIMENSIONSPECIFICITY); } bool isConstant() const { return GetField(VT_ISCONSTANT, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DIMENSIONS) && verifier.VerifyVector(dimensions()) && VerifyField(verifier, VT_DATATYPE, 1) && VerifyField(verifier, VT_QUANTIZATIONSCALE, 4) && VerifyField(verifier, VT_QUANTIZATIONOFFSET, 4) && VerifyOffset(verifier, VT_QUANTIZATIONSCALES) && verifier.VerifyVector(quantizationScales()) && VerifyField(verifier, VT_QUANTIZATIONDIM, 4) && VerifyField(verifier, VT_DIMENSIONALITY, 4) && VerifyOffset(verifier, VT_DIMENSIONSPECIFICITY) && verifier.VerifyVector(dimensionSpecificity()) && VerifyField(verifier, VT_ISCONSTANT, 1) && 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); } void add_dimensionSpecificity(flatbuffers::Offset> dimensionSpecificity) { fbb_.AddOffset(TensorInfo::VT_DIMENSIONSPECIFICITY, dimensionSpecificity); } void add_isConstant(bool isConstant) { fbb_.AddElement(TensorInfo::VT_ISCONSTANT, static_cast(isConstant), 0); } explicit TensorInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } 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, flatbuffers::Offset> dimensionSpecificity = 0, bool isConstant = false) { TensorInfoBuilder builder_(_fbb); builder_.add_dimensionSpecificity(dimensionSpecificity); 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_isConstant(isConstant); 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, const std::vector *dimensionSpecificity = nullptr, bool isConstant = false) { auto dimensions__ = dimensions ? _fbb.CreateVector(*dimensions) : 0; auto quantizationScales__ = quantizationScales ? _fbb.CreateVector(*quantizationScales) : 0; auto dimensionSpecificity__ = dimensionSpecificity ? _fbb.CreateVector(*dimensionSpecificity) : 0; return armnnSerializer::CreateTensorInfo( _fbb, dimensions__, dataType, quantizationScale, quantizationOffset, quantizationScales__, quantizationDim, dimensionality, dimensionSpecificity__, isConstant); } 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(); } 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(); } 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(); } 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(); } 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, 1) && 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(); } 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, 4) && VerifyField(verifier, VT_CONNECTION, 4) && 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(); } 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 = nullptr) { 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, 4) && 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(); } 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, 4) && VerifyOffset(verifier, VT_LAYERNAME) && verifier.VerifyString(layerName()) && VerifyField(verifier, VT_LAYERTYPE, 4) && 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(); } 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, 4) && 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(); } 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(); } 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(); } 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, 1) && VerifyField(verifier, VT_A, 4) && VerifyField(verifier, VT_B, 4) && 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(); } 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(); } 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(); } 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, 1) && VerifyField(verifier, VT_AXIS, 4) && 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(); } 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 CastLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef CastLayerBuilder 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 CastLayerBuilder { typedef CastLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(CastLayer::VT_BASE, base); } explicit CastLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateCastLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0) { CastLayerBuilder builder_(_fbb); builder_.add_base(base); return builder_.Finish(); } struct ChannelShuffleLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ChannelShuffleLayerBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_DESCRIPTOR = 6 }; const armnnSerializer::LayerBase *base() const { return GetPointer(VT_BASE); } const armnnSerializer::ChannelShuffleDescriptor *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 ChannelShuffleLayerBuilder { typedef ChannelShuffleLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(ChannelShuffleLayer::VT_BASE, base); } void add_descriptor(flatbuffers::Offset descriptor) { fbb_.AddOffset(ChannelShuffleLayer::VT_DESCRIPTOR, descriptor); } explicit ChannelShuffleLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateChannelShuffleLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0, flatbuffers::Offset descriptor = 0) { ChannelShuffleLayerBuilder builder_(_fbb); builder_.add_descriptor(descriptor); builder_.add_base(base); return builder_.Finish(); } struct ChannelShuffleDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ChannelShuffleDescriptorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_AXIS = 4, VT_NUMGROUPS = 6 }; uint32_t axis() const { return GetField(VT_AXIS, 0); } uint32_t numGroups() const { return GetField(VT_NUMGROUPS, 0); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_AXIS, 4) && VerifyField(verifier, VT_NUMGROUPS, 4) && verifier.EndTable(); } }; struct ChannelShuffleDescriptorBuilder { typedef ChannelShuffleDescriptor Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_axis(uint32_t axis) { fbb_.AddElement(ChannelShuffleDescriptor::VT_AXIS, axis, 0); } void add_numGroups(uint32_t numGroups) { fbb_.AddElement(ChannelShuffleDescriptor::VT_NUMGROUPS, numGroups, 0); } explicit ChannelShuffleDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateChannelShuffleDescriptor( flatbuffers::FlatBufferBuilder &_fbb, uint32_t axis = 0, uint32_t numGroups = 0) { ChannelShuffleDescriptorBuilder builder_(_fbb); builder_.add_numGroups(numGroups); builder_.add_axis(axis); 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, 1) && 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(); } 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(); } 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_PADRIGHT, 4) && VerifyField(verifier, VT_PADTOP, 4) && VerifyField(verifier, VT_PADBOTTOM, 4) && VerifyField(verifier, VT_STRIDEX, 4) && VerifyField(verifier, VT_STRIDEY, 4) && VerifyField(verifier, VT_DILATIONX, 4) && VerifyField(verifier, VT_DILATIONY, 4) && VerifyField(verifier, VT_BIASENABLED, 1) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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 Convolution3dLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef Convolution3dLayerBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_DESCRIPTOR = 6 }; const armnnSerializer::LayerBase *base() const { return GetPointer(VT_BASE); } const armnnSerializer::Convolution3dDescriptor *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 Convolution3dLayerBuilder { typedef Convolution3dLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(Convolution3dLayer::VT_BASE, base); } void add_descriptor(flatbuffers::Offset descriptor) { fbb_.AddOffset(Convolution3dLayer::VT_DESCRIPTOR, descriptor); } explicit Convolution3dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateConvolution3dLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0, flatbuffers::Offset descriptor = 0) { Convolution3dLayerBuilder builder_(_fbb); builder_.add_descriptor(descriptor); builder_.add_base(base); return builder_.Finish(); } struct Convolution3dDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef Convolution3dDescriptorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_PADLEFT = 4, VT_PADRIGHT = 6, VT_PADTOP = 8, VT_PADBOTTOM = 10, VT_PADFRONT = 12, VT_PADBACK = 14, VT_STRIDEX = 16, VT_STRIDEY = 18, VT_STRIDEZ = 20, VT_DILATIONX = 22, VT_DILATIONY = 24, VT_DILATIONZ = 26, VT_BIASENABLED = 28, VT_DATALAYOUT = 30 }; 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 padFront() const { return GetField(VT_PADFRONT, 0); } uint32_t padBack() const { return GetField(VT_PADBACK, 0); } uint32_t strideX() const { return GetField(VT_STRIDEX, 0); } uint32_t strideY() const { return GetField(VT_STRIDEY, 0); } uint32_t strideZ() const { return GetField(VT_STRIDEZ, 0); } uint32_t dilationX() const { return GetField(VT_DILATIONX, 1); } uint32_t dilationY() const { return GetField(VT_DILATIONY, 1); } uint32_t dilationZ() const { return GetField(VT_DILATIONZ, 1); } bool biasEnabled() const { return GetField(VT_BIASENABLED, 0) != 0; } armnnSerializer::DataLayout dataLayout() const { return static_cast(GetField(VT_DATALAYOUT, 2)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_PADLEFT, 4) && VerifyField(verifier, VT_PADRIGHT, 4) && VerifyField(verifier, VT_PADTOP, 4) && VerifyField(verifier, VT_PADBOTTOM, 4) && VerifyField(verifier, VT_PADFRONT, 4) && VerifyField(verifier, VT_PADBACK, 4) && VerifyField(verifier, VT_STRIDEX, 4) && VerifyField(verifier, VT_STRIDEY, 4) && VerifyField(verifier, VT_STRIDEZ, 4) && VerifyField(verifier, VT_DILATIONX, 4) && VerifyField(verifier, VT_DILATIONY, 4) && VerifyField(verifier, VT_DILATIONZ, 4) && VerifyField(verifier, VT_BIASENABLED, 1) && VerifyField(verifier, VT_DATALAYOUT, 1) && verifier.EndTable(); } }; struct Convolution3dDescriptorBuilder { typedef Convolution3dDescriptor Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_padLeft(uint32_t padLeft) { fbb_.AddElement(Convolution3dDescriptor::VT_PADLEFT, padLeft, 0); } void add_padRight(uint32_t padRight) { fbb_.AddElement(Convolution3dDescriptor::VT_PADRIGHT, padRight, 0); } void add_padTop(uint32_t padTop) { fbb_.AddElement(Convolution3dDescriptor::VT_PADTOP, padTop, 0); } void add_padBottom(uint32_t padBottom) { fbb_.AddElement(Convolution3dDescriptor::VT_PADBOTTOM, padBottom, 0); } void add_padFront(uint32_t padFront) { fbb_.AddElement(Convolution3dDescriptor::VT_PADFRONT, padFront, 0); } void add_padBack(uint32_t padBack) { fbb_.AddElement(Convolution3dDescriptor::VT_PADBACK, padBack, 0); } void add_strideX(uint32_t strideX) { fbb_.AddElement(Convolution3dDescriptor::VT_STRIDEX, strideX, 0); } void add_strideY(uint32_t strideY) { fbb_.AddElement(Convolution3dDescriptor::VT_STRIDEY, strideY, 0); } void add_strideZ(uint32_t strideZ) { fbb_.AddElement(Convolution3dDescriptor::VT_STRIDEZ, strideZ, 0); } void add_dilationX(uint32_t dilationX) { fbb_.AddElement(Convolution3dDescriptor::VT_DILATIONX, dilationX, 1); } void add_dilationY(uint32_t dilationY) { fbb_.AddElement(Convolution3dDescriptor::VT_DILATIONY, dilationY, 1); } void add_dilationZ(uint32_t dilationZ) { fbb_.AddElement(Convolution3dDescriptor::VT_DILATIONZ, dilationZ, 1); } void add_biasEnabled(bool biasEnabled) { fbb_.AddElement(Convolution3dDescriptor::VT_BIASENABLED, static_cast(biasEnabled), 0); } void add_dataLayout(armnnSerializer::DataLayout dataLayout) { fbb_.AddElement(Convolution3dDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 2); } explicit Convolution3dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateConvolution3dDescriptor( flatbuffers::FlatBufferBuilder &_fbb, uint32_t padLeft = 0, uint32_t padRight = 0, uint32_t padTop = 0, uint32_t padBottom = 0, uint32_t padFront = 0, uint32_t padBack = 0, uint32_t strideX = 0, uint32_t strideY = 0, uint32_t strideZ = 0, uint32_t dilationX = 1, uint32_t dilationY = 1, uint32_t dilationZ = 1, bool biasEnabled = false, armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NDHWC) { Convolution3dDescriptorBuilder builder_(_fbb); builder_.add_dilationZ(dilationZ); builder_.add_dilationY(dilationY); builder_.add_dilationX(dilationX); builder_.add_strideZ(strideZ); builder_.add_strideY(strideY); builder_.add_strideX(strideX); builder_.add_padBack(padBack); builder_.add_padFront(padFront); 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(); } 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, 4) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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(); } 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 ElementwiseBinaryDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ElementwiseBinaryDescriptorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_OPERATION = 4 }; armnnSerializer::BinaryOperation operation() const { return static_cast(GetField(VT_OPERATION, 0)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_OPERATION, 1) && verifier.EndTable(); } }; struct ElementwiseBinaryDescriptorBuilder { typedef ElementwiseBinaryDescriptor Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_operation(armnnSerializer::BinaryOperation operation) { fbb_.AddElement(ElementwiseBinaryDescriptor::VT_OPERATION, static_cast(operation), 0); } explicit ElementwiseBinaryDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateElementwiseBinaryDescriptor( flatbuffers::FlatBufferBuilder &_fbb, armnnSerializer::BinaryOperation operation = armnnSerializer::BinaryOperation_Add) { ElementwiseBinaryDescriptorBuilder builder_(_fbb); builder_.add_operation(operation); return builder_.Finish(); } struct ElementwiseBinaryLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ElementwiseBinaryLayerBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_DESCRIPTOR = 6 }; const armnnSerializer::LayerBase *base() const { return GetPointer(VT_BASE); } const armnnSerializer::ElementwiseBinaryDescriptor *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 ElementwiseBinaryLayerBuilder { typedef ElementwiseBinaryLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(ElementwiseBinaryLayer::VT_BASE, base); } void add_descriptor(flatbuffers::Offset descriptor) { fbb_.AddOffset(ElementwiseBinaryLayer::VT_DESCRIPTOR, descriptor); } explicit ElementwiseBinaryLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateElementwiseBinaryLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0, flatbuffers::Offset descriptor = 0) { ElementwiseBinaryLayerBuilder builder_(_fbb); builder_.add_descriptor(descriptor); 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, 1) && 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(); } 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(); } 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(); } 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(); } 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, 4) && 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(); } 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(); } 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(); } 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, VT_CONSTANTWEIGHTS = 8 }; bool biasEnabled() const { return GetField(VT_BIASENABLED, 0) != 0; } bool transposeWeightsMatrix() const { return GetField(VT_TRANSPOSEWEIGHTSMATRIX, 0) != 0; } bool constantWeights() const { return GetField(VT_CONSTANTWEIGHTS, 1) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_BIASENABLED, 1) && VerifyField(verifier, VT_TRANSPOSEWEIGHTSMATRIX, 1) && VerifyField(verifier, VT_CONSTANTWEIGHTS, 1) && 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); } void add_constantWeights(bool constantWeights) { fbb_.AddElement(FullyConnectedDescriptor::VT_CONSTANTWEIGHTS, static_cast(constantWeights), 1); } explicit FullyConnectedDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } 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, bool constantWeights = true) { FullyConnectedDescriptorBuilder builder_(_fbb); builder_.add_constantWeights(constantWeights); 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(); } 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, 4) && 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(); } 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(); } struct GatherNdLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef GatherNdLayerBuilder 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 GatherNdLayerBuilder { typedef GatherNdLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(GatherNdLayer::VT_BASE, base); } explicit GatherNdLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateGatherNdLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0) { GatherNdLayerBuilder builder_(_fbb); builder_.add_base(base); 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(); } 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_BETA, 4) && VerifyField(verifier, VT_EPS, 4) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_AXIS, 4) && 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(); } 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(); } 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, 1) && VerifyField(verifier, VT_EPS, 4) && 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(); } 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, 1) && 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(); } 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(); } 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(); } 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(); } 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(); } 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(); } 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 Pooling3dLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef Pooling3dLayerBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_DESCRIPTOR = 6 }; const armnnSerializer::LayerBase *base() const { return GetPointer(VT_BASE); } const armnnSerializer::Pooling3dDescriptor *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 Pooling3dLayerBuilder { typedef Pooling3dLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(Pooling3dLayer::VT_BASE, base); } void add_descriptor(flatbuffers::Offset descriptor) { fbb_.AddOffset(Pooling3dLayer::VT_DESCRIPTOR, descriptor); } explicit Pooling3dLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreatePooling3dLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0, flatbuffers::Offset descriptor = 0) { Pooling3dLayerBuilder 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, 1) && VerifyField(verifier, VT_PADLEFT, 4) && VerifyField(verifier, VT_PADRIGHT, 4) && VerifyField(verifier, VT_PADTOP, 4) && VerifyField(verifier, VT_PADBOTTOM, 4) && VerifyField(verifier, VT_POOLWIDTH, 4) && VerifyField(verifier, VT_POOLHEIGHT, 4) && VerifyField(verifier, VT_STRIDEX, 4) && VerifyField(verifier, VT_STRIDEY, 4) && VerifyField(verifier, VT_OUTPUTSHAPEROUNDING, 1) && VerifyField(verifier, VT_PADDINGMETHOD, 1) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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 Pooling3dDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef Pooling3dDescriptorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_POOLTYPE = 4, VT_PADLEFT = 6, VT_PADRIGHT = 8, VT_PADTOP = 10, VT_PADBOTTOM = 12, VT_PADFRONT = 14, VT_PADBACK = 16, VT_POOLWIDTH = 18, VT_POOLHEIGHT = 20, VT_POOLDEPTH = 22, VT_STRIDEX = 24, VT_STRIDEY = 26, VT_STRIDEZ = 28, VT_OUTPUTSHAPEROUNDING = 30, VT_PADDINGMETHOD = 32, VT_DATALAYOUT = 34 }; 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 padFront() const { return GetField(VT_PADFRONT, 0); } uint32_t padBack() const { return GetField(VT_PADBACK, 0); } uint32_t poolWidth() const { return GetField(VT_POOLWIDTH, 0); } uint32_t poolHeight() const { return GetField(VT_POOLHEIGHT, 0); } uint32_t poolDepth() const { return GetField(VT_POOLDEPTH, 0); } uint32_t strideX() const { return GetField(VT_STRIDEX, 0); } uint32_t strideY() const { return GetField(VT_STRIDEY, 0); } uint32_t strideZ() const { return GetField(VT_STRIDEZ, 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, 1) && VerifyField(verifier, VT_PADLEFT, 4) && VerifyField(verifier, VT_PADRIGHT, 4) && VerifyField(verifier, VT_PADTOP, 4) && VerifyField(verifier, VT_PADBOTTOM, 4) && VerifyField(verifier, VT_PADFRONT, 4) && VerifyField(verifier, VT_PADBACK, 4) && VerifyField(verifier, VT_POOLWIDTH, 4) && VerifyField(verifier, VT_POOLHEIGHT, 4) && VerifyField(verifier, VT_POOLDEPTH, 4) && VerifyField(verifier, VT_STRIDEX, 4) && VerifyField(verifier, VT_STRIDEY, 4) && VerifyField(verifier, VT_STRIDEZ, 4) && VerifyField(verifier, VT_OUTPUTSHAPEROUNDING, 1) && VerifyField(verifier, VT_PADDINGMETHOD, 1) && VerifyField(verifier, VT_DATALAYOUT, 1) && verifier.EndTable(); } }; struct Pooling3dDescriptorBuilder { typedef Pooling3dDescriptor Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_poolType(armnnSerializer::PoolingAlgorithm poolType) { fbb_.AddElement(Pooling3dDescriptor::VT_POOLTYPE, static_cast(poolType), 0); } void add_padLeft(uint32_t padLeft) { fbb_.AddElement(Pooling3dDescriptor::VT_PADLEFT, padLeft, 0); } void add_padRight(uint32_t padRight) { fbb_.AddElement(Pooling3dDescriptor::VT_PADRIGHT, padRight, 0); } void add_padTop(uint32_t padTop) { fbb_.AddElement(Pooling3dDescriptor::VT_PADTOP, padTop, 0); } void add_padBottom(uint32_t padBottom) { fbb_.AddElement(Pooling3dDescriptor::VT_PADBOTTOM, padBottom, 0); } void add_padFront(uint32_t padFront) { fbb_.AddElement(Pooling3dDescriptor::VT_PADFRONT, padFront, 0); } void add_padBack(uint32_t padBack) { fbb_.AddElement(Pooling3dDescriptor::VT_PADBACK, padBack, 0); } void add_poolWidth(uint32_t poolWidth) { fbb_.AddElement(Pooling3dDescriptor::VT_POOLWIDTH, poolWidth, 0); } void add_poolHeight(uint32_t poolHeight) { fbb_.AddElement(Pooling3dDescriptor::VT_POOLHEIGHT, poolHeight, 0); } void add_poolDepth(uint32_t poolDepth) { fbb_.AddElement(Pooling3dDescriptor::VT_POOLDEPTH, poolDepth, 0); } void add_strideX(uint32_t strideX) { fbb_.AddElement(Pooling3dDescriptor::VT_STRIDEX, strideX, 0); } void add_strideY(uint32_t strideY) { fbb_.AddElement(Pooling3dDescriptor::VT_STRIDEY, strideY, 0); } void add_strideZ(uint32_t strideZ) { fbb_.AddElement(Pooling3dDescriptor::VT_STRIDEZ, strideZ, 0); } void add_outputShapeRounding(armnnSerializer::OutputShapeRounding outputShapeRounding) { fbb_.AddElement(Pooling3dDescriptor::VT_OUTPUTSHAPEROUNDING, static_cast(outputShapeRounding), 0); } void add_paddingMethod(armnnSerializer::PaddingMethod paddingMethod) { fbb_.AddElement(Pooling3dDescriptor::VT_PADDINGMETHOD, static_cast(paddingMethod), 0); } void add_dataLayout(armnnSerializer::DataLayout dataLayout) { fbb_.AddElement(Pooling3dDescriptor::VT_DATALAYOUT, static_cast(dataLayout), 0); } explicit Pooling3dDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreatePooling3dDescriptor( 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 padFront = 0, uint32_t padBack = 0, uint32_t poolWidth = 0, uint32_t poolHeight = 0, uint32_t poolDepth = 0, uint32_t strideX = 0, uint32_t strideY = 0, uint32_t strideZ = 0, armnnSerializer::OutputShapeRounding outputShapeRounding = armnnSerializer::OutputShapeRounding_Floor, armnnSerializer::PaddingMethod paddingMethod = armnnSerializer::PaddingMethod_IgnoreValue, armnnSerializer::DataLayout dataLayout = armnnSerializer::DataLayout_NHWC) { Pooling3dDescriptorBuilder builder_(_fbb); builder_.add_strideZ(strideZ); builder_.add_strideY(strideY); builder_.add_strideX(strideX); builder_.add_poolDepth(poolDepth); builder_.add_poolHeight(poolHeight); builder_.add_poolWidth(poolWidth); builder_.add_padBack(padBack); builder_.add_padFront(padFront); 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(); } 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(); } 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, VT_AXIS = 6 }; float beta() const { return GetField(VT_BETA, 0.0f); } int32_t axis() const { return GetField(VT_AXIS, -1); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_BETA, 4) && VerifyField(verifier, VT_AXIS, 4) && 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); } void add_axis(int32_t axis) { fbb_.AddElement(SoftmaxDescriptor::VT_AXIS, axis, -1); } explicit SoftmaxDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } 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, int32_t axis = -1) { SoftmaxDescriptorBuilder builder_(_fbb); builder_.add_axis(axis); 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(); } 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, 4) && VerifyField(verifier, VT_PADRIGHT, 4) && VerifyField(verifier, VT_PADTOP, 4) && VerifyField(verifier, VT_PADBOTTOM, 4) && VerifyField(verifier, VT_STRIDEX, 4) && VerifyField(verifier, VT_STRIDEY, 4) && VerifyField(verifier, VT_DILATIONX, 4) && VerifyField(verifier, VT_DILATIONY, 4) && VerifyField(verifier, VT_BIASENABLED, 1) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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(); } 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(); } 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(); } 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(); } 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(); } 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 ShapeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ShapeLayerBuilder 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 ShapeLayerBuilder { typedef ShapeLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(ShapeLayer::VT_BASE, base); } explicit ShapeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateShapeLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0) { ShapeLayerBuilder builder_(_fbb); builder_.add_base(base); return builder_.Finish(); } 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(); } 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, 1) && 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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(); } 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(); } 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, 1) && 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(); } 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(); } 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, 1) && VerifyField(verifier, VT_NORMMETHODTYPE, 1) && VerifyField(verifier, VT_NORMSIZE, 4) && VerifyField(verifier, VT_ALPHA, 4) && VerifyField(verifier, VT_BETA, 4) && VerifyField(verifier, VT_K, 4) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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(); } 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, 1) && 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(); } 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(); } 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, VT_PADDINGMODE = 8 }; const flatbuffers::Vector *padList() const { return GetPointer *>(VT_PADLIST); } float padValue() const { return GetField(VT_PADVALUE, 0.0f); } armnnSerializer::PaddingMode paddingMode() const { return static_cast(GetField(VT_PADDINGMODE, 0)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_PADLIST) && verifier.VerifyVector(padList()) && VerifyField(verifier, VT_PADVALUE, 4) && VerifyField(verifier, VT_PADDINGMODE, 1) && 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); } void add_paddingMode(armnnSerializer::PaddingMode paddingMode) { fbb_.AddElement(PadDescriptor::VT_PADDINGMODE, static_cast(paddingMode), 0); } explicit PadDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } 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, armnnSerializer::PaddingMode paddingMode = armnnSerializer::PaddingMode_Constant) { PadDescriptorBuilder builder_(_fbb); builder_.add_padValue(padValue); builder_.add_padList(padList); builder_.add_paddingMode(paddingMode); return builder_.Finish(); } inline flatbuffers::Offset CreatePadDescriptorDirect( flatbuffers::FlatBufferBuilder &_fbb, const std::vector *padList = nullptr, float padValue = 0.0f, armnnSerializer::PaddingMode paddingMode = armnnSerializer::PaddingMode_Constant) { auto padList__ = padList ? _fbb.CreateVector(*padList) : 0; return armnnSerializer::CreatePadDescriptor( _fbb, padList__, padValue, paddingMode); } /// @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(); } 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(); } 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, 4) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_TARGETHEIGHT, 4) && VerifyField(verifier, VT_DATALAYOUT, 1) && VerifyField(verifier, VT_ALIGNCORNERS, 1) && VerifyField(verifier, VT_HALFPIXELCENTERS, 1) && 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(); } 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(); } 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_ENDMASK, 4) && VerifyField(verifier, VT_SHRINKAXISMASK, 4) && VerifyField(verifier, VT_ELLIPSISMASK, 4) && VerifyField(verifier, VT_NEWAXISMASK, 4) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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(); } 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_NUMVIEWS, 4) && VerifyField(verifier, VT_NUMDIMENSIONS, 4) && 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(); } 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(); } 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_MAXCLASSESPERDETECTION, 4) && VerifyField(verifier, VT_DETECTIONSPERCLASS, 4) && VerifyField(verifier, VT_NMSSCORETHRESHOLD, 4) && VerifyField(verifier, VT_NMSIOUTHRESHOLD, 4) && VerifyField(verifier, VT_NUMCLASSES, 4) && VerifyField(verifier, VT_USEREGULARNMS, 1) && VerifyField(verifier, VT_SCALEX, 4) && VerifyField(verifier, VT_SCALEY, 4) && VerifyField(verifier, VT_SCALEW, 4) && VerifyField(verifier, VT_SCALEH, 4) && 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_CLIPPINGTHRESCELL, 4) && VerifyField(verifier, VT_CLIPPINGTHRESPROJ, 4) && VerifyField(verifier, VT_CIFGENABLED, 1) && VerifyField(verifier, VT_PEEPHOLEENABLED, 1) && VerifyField(verifier, VT_PROJECTIONENABLED, 1) && VerifyField(verifier, VT_LAYERNORMENABLED, 1) && 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(); } 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(); } 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(); } 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, 1) && VerifyField(verifier, VT_PEEPHOLEENABLED, 1) && VerifyField(verifier, VT_PROJECTIONENABLED, 1) && VerifyField(verifier, VT_LAYERNORMENABLED, 1) && VerifyField(verifier, VT_CELLCLIP, 4) && VerifyField(verifier, VT_PROJECTIONCLIP, 4) && VerifyField(verifier, VT_INPUTINTERMEDIATESCALE, 4) && VerifyField(verifier, VT_FORGETINTERMEDIATESCALE, 4) && VerifyField(verifier, VT_CELLINTERMEDIATESCALE, 4) && VerifyField(verifier, VT_OUTPUTINTERMEDIATESCALE, 4) && VerifyField(verifier, VT_HIDDENSTATEZEROPOINT, 4) && VerifyField(verifier, VT_HIDDENSTATESCALE, 4) && 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(); } 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(); } 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(); } 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(); } 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(); } 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(); } 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(); } 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_PADRIGHT, 4) && VerifyField(verifier, VT_PADTOP, 4) && VerifyField(verifier, VT_PADBOTTOM, 4) && VerifyField(verifier, VT_STRIDEX, 4) && VerifyField(verifier, VT_STRIDEY, 4) && VerifyField(verifier, VT_BIASENABLED, 1) && VerifyField(verifier, VT_DATALAYOUT, 1) && 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(); } 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(); } 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_TARGETWIDTH, 4) && VerifyField(verifier, VT_METHOD, 1) && VerifyField(verifier, VT_DATALAYOUT, 1) && VerifyField(verifier, VT_ALIGNCORNERS, 1) && VerifyField(verifier, VT_HALFPIXELCENTERS, 1) && 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(); } 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(); } 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, 4) && VerifyField(verifier, VT_NUMINPUTS, 4) && 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(); } 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, 4) && VerifyField(verifier, VT_NUMOUTPUTS, 4) && 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(); } 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(); } 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(); } 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 ReduceLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ReduceLayerBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_DESCRIPTOR = 6 }; const armnnSerializer::LayerBase *base() const { return GetPointer(VT_BASE); } const armnnSerializer::ReduceDescriptor *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 ReduceLayerBuilder { typedef ReduceLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(ReduceLayer::VT_BASE, base); } void add_descriptor(flatbuffers::Offset descriptor) { fbb_.AddOffset(ReduceLayer::VT_DESCRIPTOR, descriptor); } explicit ReduceLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateReduceLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0, flatbuffers::Offset descriptor = 0) { ReduceLayerBuilder builder_(_fbb); builder_.add_descriptor(descriptor); builder_.add_base(base); return builder_.Finish(); } struct ReduceDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ReduceDescriptorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_KEEPDIMS = 4, VT_AXIS = 6, VT_REDUCEOPERATION = 8 }; bool keepDims() const { return GetField(VT_KEEPDIMS, 0) != 0; } const flatbuffers::Vector *axis() const { return GetPointer *>(VT_AXIS); } armnnSerializer::ReduceOperation reduceOperation() const { return static_cast(GetField(VT_REDUCEOPERATION, 0)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_KEEPDIMS, 1) && VerifyOffset(verifier, VT_AXIS) && verifier.VerifyVector(axis()) && VerifyField(verifier, VT_REDUCEOPERATION, 1) && verifier.EndTable(); } }; struct ReduceDescriptorBuilder { typedef ReduceDescriptor Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_keepDims(bool keepDims) { fbb_.AddElement(ReduceDescriptor::VT_KEEPDIMS, static_cast(keepDims), 0); } void add_axis(flatbuffers::Offset> axis) { fbb_.AddOffset(ReduceDescriptor::VT_AXIS, axis); } void add_reduceOperation(armnnSerializer::ReduceOperation reduceOperation) { fbb_.AddElement(ReduceDescriptor::VT_REDUCEOPERATION, static_cast(reduceOperation), 0); } explicit ReduceDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateReduceDescriptor( flatbuffers::FlatBufferBuilder &_fbb, bool keepDims = false, flatbuffers::Offset> axis = 0, armnnSerializer::ReduceOperation reduceOperation = armnnSerializer::ReduceOperation_Sum) { ReduceDescriptorBuilder builder_(_fbb); builder_.add_axis(axis); builder_.add_reduceOperation(reduceOperation); builder_.add_keepDims(keepDims); return builder_.Finish(); } inline flatbuffers::Offset CreateReduceDescriptorDirect( flatbuffers::FlatBufferBuilder &_fbb, bool keepDims = false, const std::vector *axis = nullptr, armnnSerializer::ReduceOperation reduceOperation = armnnSerializer::ReduceOperation_Sum) { auto axis__ = axis ? _fbb.CreateVector(*axis) : 0; return armnnSerializer::CreateReduceDescriptor( _fbb, keepDims, axis__, reduceOperation); } struct UnidirectionalSequenceLstmDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef UnidirectionalSequenceLstmDescriptorBuilder 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, VT_TIMEMAJOR = 18 }; 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 timeMajor() const { return GetField(VT_TIMEMAJOR, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_ACTIVATIONFUNC, 4) && VerifyField(verifier, VT_CLIPPINGTHRESCELL, 4) && VerifyField(verifier, VT_CLIPPINGTHRESPROJ, 4) && VerifyField(verifier, VT_CIFGENABLED, 1) && VerifyField(verifier, VT_PEEPHOLEENABLED, 1) && VerifyField(verifier, VT_PROJECTIONENABLED, 1) && VerifyField(verifier, VT_LAYERNORMENABLED, 1) && VerifyField(verifier, VT_TIMEMAJOR, 1) && verifier.EndTable(); } }; struct UnidirectionalSequenceLstmDescriptorBuilder { typedef UnidirectionalSequenceLstmDescriptor Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_activationFunc(uint32_t activationFunc) { fbb_.AddElement(UnidirectionalSequenceLstmDescriptor::VT_ACTIVATIONFUNC, activationFunc, 0); } void add_clippingThresCell(float clippingThresCell) { fbb_.AddElement(UnidirectionalSequenceLstmDescriptor::VT_CLIPPINGTHRESCELL, clippingThresCell, 0.0f); } void add_clippingThresProj(float clippingThresProj) { fbb_.AddElement(UnidirectionalSequenceLstmDescriptor::VT_CLIPPINGTHRESPROJ, clippingThresProj, 0.0f); } void add_cifgEnabled(bool cifgEnabled) { fbb_.AddElement(UnidirectionalSequenceLstmDescriptor::VT_CIFGENABLED, static_cast(cifgEnabled), 1); } void add_peepholeEnabled(bool peepholeEnabled) { fbb_.AddElement(UnidirectionalSequenceLstmDescriptor::VT_PEEPHOLEENABLED, static_cast(peepholeEnabled), 0); } void add_projectionEnabled(bool projectionEnabled) { fbb_.AddElement(UnidirectionalSequenceLstmDescriptor::VT_PROJECTIONENABLED, static_cast(projectionEnabled), 0); } void add_layerNormEnabled(bool layerNormEnabled) { fbb_.AddElement(UnidirectionalSequenceLstmDescriptor::VT_LAYERNORMENABLED, static_cast(layerNormEnabled), 0); } void add_timeMajor(bool timeMajor) { fbb_.AddElement(UnidirectionalSequenceLstmDescriptor::VT_TIMEMAJOR, static_cast(timeMajor), 0); } explicit UnidirectionalSequenceLstmDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateUnidirectionalSequenceLstmDescriptor( 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, bool timeMajor = false) { UnidirectionalSequenceLstmDescriptorBuilder builder_(_fbb); builder_.add_clippingThresProj(clippingThresProj); builder_.add_clippingThresCell(clippingThresCell); builder_.add_activationFunc(activationFunc); builder_.add_timeMajor(timeMajor); builder_.add_layerNormEnabled(layerNormEnabled); builder_.add_projectionEnabled(projectionEnabled); builder_.add_peepholeEnabled(peepholeEnabled); builder_.add_cifgEnabled(cifgEnabled); return builder_.Finish(); } struct UnidirectionalSequenceLstmLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef UnidirectionalSequenceLstmLayerBuilder 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::UnidirectionalSequenceLstmDescriptor *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 UnidirectionalSequenceLstmLayerBuilder { typedef UnidirectionalSequenceLstmLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(UnidirectionalSequenceLstmLayer::VT_BASE, base); } void add_descriptor(flatbuffers::Offset descriptor) { fbb_.AddOffset(UnidirectionalSequenceLstmLayer::VT_DESCRIPTOR, descriptor); } void add_inputParams(flatbuffers::Offset inputParams) { fbb_.AddOffset(UnidirectionalSequenceLstmLayer::VT_INPUTPARAMS, inputParams); } explicit UnidirectionalSequenceLstmLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateUnidirectionalSequenceLstmLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0, flatbuffers::Offset descriptor = 0, flatbuffers::Offset inputParams = 0) { UnidirectionalSequenceLstmLayerBuilder builder_(_fbb); builder_.add_inputParams(inputParams); builder_.add_descriptor(descriptor); builder_.add_base(base); return builder_.Finish(); } struct BatchMatMulDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef BatchMatMulDescriptorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TRANSPOSEX = 4, VT_TRANSPOSEY = 6, VT_ADJOINTX = 8, VT_ADJOINTY = 10, VT_DATALAYOUTX = 12, VT_DATALAYOUTY = 14 }; bool transposeX() const { return GetField(VT_TRANSPOSEX, 0) != 0; } bool transposeY() const { return GetField(VT_TRANSPOSEY, 0) != 0; } bool adjointX() const { return GetField(VT_ADJOINTX, 0) != 0; } bool adjointY() const { return GetField(VT_ADJOINTY, 0) != 0; } armnnSerializer::DataLayout dataLayoutX() const { return static_cast(GetField(VT_DATALAYOUTX, 1)); } armnnSerializer::DataLayout dataLayoutY() const { return static_cast(GetField(VT_DATALAYOUTY, 1)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TRANSPOSEX, 1) && VerifyField(verifier, VT_TRANSPOSEY, 1) && VerifyField(verifier, VT_ADJOINTX, 1) && VerifyField(verifier, VT_ADJOINTY, 1) && VerifyField(verifier, VT_DATALAYOUTX, 1) && VerifyField(verifier, VT_DATALAYOUTY, 1) && verifier.EndTable(); } }; struct BatchMatMulDescriptorBuilder { typedef BatchMatMulDescriptor Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_transposeX(bool transposeX) { fbb_.AddElement(BatchMatMulDescriptor::VT_TRANSPOSEX, static_cast(transposeX), 0); } void add_transposeY(bool transposeY) { fbb_.AddElement(BatchMatMulDescriptor::VT_TRANSPOSEY, static_cast(transposeY), 0); } void add_adjointX(bool adjointX) { fbb_.AddElement(BatchMatMulDescriptor::VT_ADJOINTX, static_cast(adjointX), 0); } void add_adjointY(bool adjointY) { fbb_.AddElement(BatchMatMulDescriptor::VT_ADJOINTY, static_cast(adjointY), 0); } void add_dataLayoutX(armnnSerializer::DataLayout dataLayoutX) { fbb_.AddElement(BatchMatMulDescriptor::VT_DATALAYOUTX, static_cast(dataLayoutX), 1); } void add_dataLayoutY(armnnSerializer::DataLayout dataLayoutY) { fbb_.AddElement(BatchMatMulDescriptor::VT_DATALAYOUTY, static_cast(dataLayoutY), 1); } explicit BatchMatMulDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateBatchMatMulDescriptor( flatbuffers::FlatBufferBuilder &_fbb, bool transposeX = false, bool transposeY = false, bool adjointX = false, bool adjointY = false, armnnSerializer::DataLayout dataLayoutX = armnnSerializer::DataLayout_NCHW, armnnSerializer::DataLayout dataLayoutY = armnnSerializer::DataLayout_NCHW) { BatchMatMulDescriptorBuilder builder_(_fbb); builder_.add_dataLayoutY(dataLayoutY); builder_.add_dataLayoutX(dataLayoutX); builder_.add_adjointY(adjointY); builder_.add_adjointX(adjointX); builder_.add_transposeY(transposeY); builder_.add_transposeX(transposeX); return builder_.Finish(); } struct BatchMatMulLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef BatchMatMulLayerBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_DESCRIPTOR = 6 }; const armnnSerializer::LayerBase *base() const { return GetPointer(VT_BASE); } const armnnSerializer::BatchMatMulDescriptor *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 BatchMatMulLayerBuilder { typedef BatchMatMulLayer Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_base(flatbuffers::Offset base) { fbb_.AddOffset(BatchMatMulLayer::VT_BASE, base); } void add_descriptor(flatbuffers::Offset descriptor) { fbb_.AddOffset(BatchMatMulLayer::VT_DESCRIPTOR, descriptor); } explicit BatchMatMulLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = flatbuffers::Offset(end); return o; } }; inline flatbuffers::Offset CreateBatchMatMulLayer( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset base = 0, flatbuffers::Offset descriptor = 0) { BatchMatMulLayerBuilder builder_(_fbb); builder_.add_descriptor(descriptor); 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; } const armnnSerializer::ReduceLayer *layer_as_ReduceLayer() const { return layer_type() == armnnSerializer::Layer_ReduceLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::CastLayer *layer_as_CastLayer() const { return layer_type() == armnnSerializer::Layer_CastLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::ShapeLayer *layer_as_ShapeLayer() const { return layer_type() == armnnSerializer::Layer_ShapeLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::UnidirectionalSequenceLstmLayer *layer_as_UnidirectionalSequenceLstmLayer() const { return layer_type() == armnnSerializer::Layer_UnidirectionalSequenceLstmLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::ChannelShuffleLayer *layer_as_ChannelShuffleLayer() const { return layer_type() == armnnSerializer::Layer_ChannelShuffleLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::Convolution3dLayer *layer_as_Convolution3dLayer() const { return layer_type() == armnnSerializer::Layer_Convolution3dLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::Pooling3dLayer *layer_as_Pooling3dLayer() const { return layer_type() == armnnSerializer::Layer_Pooling3dLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::GatherNdLayer *layer_as_GatherNdLayer() const { return layer_type() == armnnSerializer::Layer_GatherNdLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::BatchMatMulLayer *layer_as_BatchMatMulLayer() const { return layer_type() == armnnSerializer::Layer_BatchMatMulLayer ? static_cast(layer()) : nullptr; } const armnnSerializer::ElementwiseBinaryLayer *layer_as_ElementwiseBinaryLayer() const { return layer_type() == armnnSerializer::Layer_ElementwiseBinaryLayer ? static_cast(layer()) : nullptr; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_LAYER_TYPE, 1) && 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(); } template<> inline const armnnSerializer::ReduceLayer *AnyLayer::layer_as() const { return layer_as_ReduceLayer(); } template<> inline const armnnSerializer::CastLayer *AnyLayer::layer_as() const { return layer_as_CastLayer(); } template<> inline const armnnSerializer::ShapeLayer *AnyLayer::layer_as() const { return layer_as_ShapeLayer(); } template<> inline const armnnSerializer::UnidirectionalSequenceLstmLayer *AnyLayer::layer_as() const { return layer_as_UnidirectionalSequenceLstmLayer(); } template<> inline const armnnSerializer::ChannelShuffleLayer *AnyLayer::layer_as() const { return layer_as_ChannelShuffleLayer(); } template<> inline const armnnSerializer::Convolution3dLayer *AnyLayer::layer_as() const { return layer_as_Convolution3dLayer(); } template<> inline const armnnSerializer::Pooling3dLayer *AnyLayer::layer_as() const { return layer_as_Pooling3dLayer(); } template<> inline const armnnSerializer::GatherNdLayer *AnyLayer::layer_as() const { return layer_as_GatherNdLayer(); } template<> inline const armnnSerializer::BatchMatMulLayer *AnyLayer::layer_as() const { return layer_as_BatchMatMulLayer(); } template<> inline const armnnSerializer::ElementwiseBinaryLayer *AnyLayer::layer_as() const { return layer_as_ElementwiseBinaryLayer(); } 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(); } 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, VT_WEIGHTSLAYOUTSCHEME = 6, VT_CONSTANTTENSORSASINPUTS = 8 }; uint32_t bindingIdsScheme() const { return GetField(VT_BINDINGIDSSCHEME, 0); } uint32_t weightsLayoutScheme() const { return GetField(VT_WEIGHTSLAYOUTSCHEME, 0); } uint32_t constantTensorsAsInputs() const { return GetField(VT_CONSTANTTENSORSASINPUTS, 0); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_BINDINGIDSSCHEME, 4) && VerifyField(verifier, VT_WEIGHTSLAYOUTSCHEME, 4) && VerifyField(verifier, VT_CONSTANTTENSORSASINPUTS, 4) && 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); } void add_weightsLayoutScheme(uint32_t weightsLayoutScheme) { fbb_.AddElement(FeatureCompatibilityVersions::VT_WEIGHTSLAYOUTSCHEME, weightsLayoutScheme, 0); } void add_constantTensorsAsInputs(uint32_t constantTensorsAsInputs) { fbb_.AddElement(FeatureCompatibilityVersions::VT_CONSTANTTENSORSASINPUTS, constantTensorsAsInputs, 0); } explicit FeatureCompatibilityVersionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } 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, uint32_t weightsLayoutScheme = 0, uint32_t constantTensorsAsInputs = 0) { FeatureCompatibilityVersionsBuilder builder_(_fbb); builder_.add_constantTensorsAsInputs(constantTensorsAsInputs); builder_.add_weightsLayoutScheme(weightsLayoutScheme); 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(); } 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); } case Layer_ReduceLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_CastLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_ShapeLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_UnidirectionalSequenceLstmLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_ChannelShuffleLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_Convolution3dLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_Pooling3dLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_GatherNdLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_BatchMatMulLayer: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case Layer_ElementwiseBinaryLayer: { 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 SizePrefixedSerializedGraphBufferHasIdentifier(const void *buf) { return flatbuffers::BufferHasIdentifier( buf, SerializedGraphIdentifier(), true); } 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_