LayersFwd.hpp File Reference

#include "InternalTypes.hpp"
#include "layers/ActivationLayer.hpp"
#include "layers/AdditionLayer.hpp"
#include "layers/ArgMinMaxLayer.hpp"
#include "layers/BatchNormalizationLayer.hpp"
#include "layers/BatchToSpaceNdLayer.hpp"
#include "layers/ComparisonLayer.hpp"
#include "layers/ConcatLayer.hpp"
#include "layers/ConstantLayer.hpp"
#include "layers/ConvertBf16ToFp32Layer.hpp"
#include "layers/ConvertFp16ToFp32Layer.hpp"
#include "layers/ConvertFp32ToBf16Layer.hpp"
#include "layers/ConvertFp32ToFp16Layer.hpp"
#include "layers/Convolution2dLayer.hpp"
#include "layers/DebugLayer.hpp"
#include "layers/DepthToSpaceLayer.hpp"
#include "layers/DepthwiseConvolution2dLayer.hpp"
#include "layers/DequantizeLayer.hpp"
#include "layers/DetectionPostProcessLayer.hpp"
#include "layers/DivisionLayer.hpp"
#include "layers/ElementwiseUnaryLayer.hpp"
#include "layers/FakeQuantizationLayer.hpp"
#include "layers/FloorLayer.hpp"
#include "layers/FullyConnectedLayer.hpp"
#include "layers/GatherLayer.hpp"
#include "layers/InputLayer.hpp"
#include "layers/InstanceNormalizationLayer.hpp"
#include "layers/L2NormalizationLayer.hpp"
#include "layers/LogSoftmaxLayer.hpp"
#include "layers/LstmLayer.hpp"
#include "layers/MaximumLayer.hpp"
#include "layers/MeanLayer.hpp"
#include "layers/MemCopyLayer.hpp"
#include "layers/MemImportLayer.hpp"
#include "layers/MergeLayer.hpp"
#include "layers/MinimumLayer.hpp"
#include "layers/MultiplicationLayer.hpp"
#include "layers/NormalizationLayer.hpp"
#include "layers/OutputLayer.hpp"
#include "layers/PadLayer.hpp"
#include "layers/PermuteLayer.hpp"
#include "layers/Pooling2dLayer.hpp"
#include "layers/PreCompiledLayer.hpp"
#include "layers/PreluLayer.hpp"
#include "layers/QuantizeLayer.hpp"
#include "layers/QLstmLayer.hpp"
#include "layers/QuantizedLstmLayer.hpp"
#include "layers/ReshapeLayer.hpp"
#include "layers/ResizeLayer.hpp"
#include "layers/SliceLayer.hpp"
#include "layers/SoftmaxLayer.hpp"
#include "layers/SpaceToBatchNdLayer.hpp"
#include "layers/SpaceToDepthLayer.hpp"
#include "layers/SplitterLayer.hpp"
#include "layers/StackLayer.hpp"
#include "layers/StandInLayer.hpp"
#include "layers/StridedSliceLayer.hpp"
#include "layers/SubtractionLayer.hpp"
#include "layers/SwitchLayer.hpp"
#include "layers/TransposeConvolution2dLayer.hpp"
#include "layers/TransposeLayer.hpp"

Go to the source code of this file.

Classes
struct	LayerTypeOfImpl< Type >
struct	LayerTypeOfImpl< LayerType::Activation >
struct	LayerTypeOfImpl< LayerType::Addition >
struct	LayerTypeOfImpl< LayerType::ArgMinMax >
struct	LayerTypeOfImpl< LayerType::BatchNormalization >
struct	LayerTypeOfImpl< LayerType::BatchToSpaceNd >
struct	LayerTypeOfImpl< LayerType::Comparison >
struct	LayerTypeOfImpl< LayerType::Concat >
struct	LayerTypeOfImpl< LayerType::Constant >
struct	LayerTypeOfImpl< LayerType::ConvertBf16ToFp32 >
struct	LayerTypeOfImpl< LayerType::ConvertFp16ToFp32 >
struct	LayerTypeOfImpl< LayerType::ConvertFp32ToBf16 >
struct	LayerTypeOfImpl< LayerType::ConvertFp32ToFp16 >
struct	LayerTypeOfImpl< LayerType::Convolution2d >
struct	LayerTypeOfImpl< LayerType::Debug >
struct	LayerTypeOfImpl< LayerType::DepthToSpace >
struct	LayerTypeOfImpl< LayerType::DepthwiseConvolution2d >
struct	LayerTypeOfImpl< LayerType::Dequantize >
struct	LayerTypeOfImpl< LayerType::DetectionPostProcess >
struct	LayerTypeOfImpl< LayerType::Division >
struct	LayerTypeOfImpl< LayerType::ElementwiseUnary >
struct	LayerTypeOfImpl< LayerType::FakeQuantization >
struct	LayerTypeOfImpl< LayerType::Floor >
struct	LayerTypeOfImpl< LayerType::FullyConnected >
struct	LayerTypeOfImpl< LayerType::Gather >
struct	LayerTypeOfImpl< LayerType::Input >
struct	LayerTypeOfImpl< LayerType::InstanceNormalization >
struct	LayerTypeOfImpl< LayerType::L2Normalization >
struct	LayerTypeOfImpl< LayerType::LogSoftmax >
struct	LayerTypeOfImpl< LayerType::Lstm >
struct	LayerTypeOfImpl< LayerType::Maximum >
struct	LayerTypeOfImpl< LayerType::Mean >
struct	LayerTypeOfImpl< LayerType::MemCopy >
struct	LayerTypeOfImpl< LayerType::MemImport >
struct	LayerTypeOfImpl< LayerType::Merge >
struct	LayerTypeOfImpl< LayerType::Minimum >
struct	LayerTypeOfImpl< LayerType::Multiplication >
struct	LayerTypeOfImpl< LayerType::Normalization >
struct	LayerTypeOfImpl< LayerType::Output >
struct	LayerTypeOfImpl< LayerType::Pad >
struct	LayerTypeOfImpl< LayerType::Permute >
struct	LayerTypeOfImpl< LayerType::Pooling2d >
struct	LayerTypeOfImpl< LayerType::PreCompiled >
struct	LayerTypeOfImpl< LayerType::Prelu >
struct	LayerTypeOfImpl< LayerType::Quantize >
struct	LayerTypeOfImpl< LayerType::QLstm >
struct	LayerTypeOfImpl< LayerType::QuantizedLstm >
struct	LayerTypeOfImpl< LayerType::Reshape >
struct	LayerTypeOfImpl< LayerType::Resize >
struct	LayerTypeOfImpl< LayerType::Slice >
struct	LayerTypeOfImpl< LayerType::Softmax >
struct	LayerTypeOfImpl< LayerType::SpaceToBatchNd >
struct	LayerTypeOfImpl< LayerType::SpaceToDepth >
struct	LayerTypeOfImpl< LayerType::Splitter >
struct	LayerTypeOfImpl< LayerType::Stack >
struct	LayerTypeOfImpl< LayerType::StandIn >
struct	LayerTypeOfImpl< LayerType::StridedSlice >
struct	LayerTypeOfImpl< LayerType::Subtraction >
struct	LayerTypeOfImpl< LayerType::Switch >
struct	LayerTypeOfImpl< LayerType::Transpose >
struct	LayerTypeOfImpl< LayerType::TransposeConvolution2d >

Namespaces
	armnn
	Copyright (c) 2020 ARM Limited.

Macros
#define	DECLARE_LAYER_IMPL(_, LayerName)
#define	DECLARE_LAYER(LayerName)   DECLARE_LAYER_IMPL(, LayerName)

Typedefs
template<LayerType Type>
using	LayerTypeOf = typename LayerTypeOfImpl< Type >::Type

Functions
template<typename T >
constexpr LayerType	LayerEnumOf (const T *=nullptr)
template<>
constexpr LayerType	LayerEnumOf (const ActivationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const AdditionLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ArgMinMaxLayer *)
template<>
constexpr LayerType	LayerEnumOf (const BatchNormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const BatchToSpaceNdLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ComparisonLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConcatLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConstantLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertBf16ToFp32Layer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertFp16ToFp32Layer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertFp32ToBf16Layer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertFp32ToFp16Layer *)
template<>
constexpr LayerType	LayerEnumOf (const Convolution2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DebugLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DepthToSpaceLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DepthwiseConvolution2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DequantizeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DetectionPostProcessLayer *)
template<>
constexpr LayerType	LayerEnumOf (const DivisionLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ElementwiseUnaryLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FakeQuantizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FloorLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FullyConnectedLayer *)
template<>
constexpr LayerType	LayerEnumOf (const GatherLayer *)
template<>
constexpr LayerType	LayerEnumOf (const InputLayer *)
template<>
constexpr LayerType	LayerEnumOf (const InstanceNormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const L2NormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const LogSoftmaxLayer *)
template<>
constexpr LayerType	LayerEnumOf (const LstmLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MaximumLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MeanLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MemCopyLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MemImportLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MergeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MinimumLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MultiplicationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const NormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const OutputLayer *)
template<>
constexpr LayerType	LayerEnumOf (const PadLayer *)
template<>
constexpr LayerType	LayerEnumOf (const PermuteLayer *)
template<>
constexpr LayerType	LayerEnumOf (const Pooling2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const PreCompiledLayer *)
template<>
constexpr LayerType	LayerEnumOf (const PreluLayer *)
template<>
constexpr LayerType	LayerEnumOf (const QuantizeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const QLstmLayer *)
template<>
constexpr LayerType	LayerEnumOf (const QuantizedLstmLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ReshapeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ResizeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SliceLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SoftmaxLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SpaceToBatchNdLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SpaceToDepthLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SplitterLayer *)
template<>
constexpr LayerType	LayerEnumOf (const StackLayer *)
template<>
constexpr LayerType	LayerEnumOf (const StandInLayer *)
template<>
constexpr LayerType	LayerEnumOf (const StridedSliceLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SubtractionLayer *)
template<>
constexpr LayerType	LayerEnumOf (const SwitchLayer *)
template<>
constexpr LayerType	LayerEnumOf (const TransposeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const TransposeConvolution2dLayer *)

Macro Definition Documentation

DECLARE_LAYER

#define DECLARE_LAYER

(

LayerName

)

DECLARE_LAYER_IMPL(, LayerName)

Definition at line 95 of file LayersFwd.hpp.

DECLARE_LAYER_IMPL

#define DECLARE_LAYER_IMPL	(		_,
			LayerName
	)

Value:

class LayerName##Layer;                                  \
    template <>                                              \
    struct LayerTypeOfImpl<LayerType::_##LayerName>          \
    {                                                        \
        using Type = LayerName##Layer;                       \
    };                                                       \
    template <>                                              \
    constexpr LayerType LayerEnumOf(const LayerName##Layer*) \
    {                                                        \
        return LayerType::_##LayerName;                      \
    }

Definition at line 82 of file LayersFwd.hpp.