LayersFwd.hpp File Reference

#include "InternalTypes.hpp"
#include "layers/ActivationLayer.hpp"
#include "layers/AdditionLayer.hpp"
#include "layers/ArgMinMaxLayer.hpp"
#include "layers/BatchMatMulLayer.hpp"
#include "layers/BatchNormalizationLayer.hpp"
#include "layers/BatchToSpaceNdLayer.hpp"
#include "layers/BroadcastToLayer.hpp"
#include "layers/CastLayer.hpp"
#include "layers/ChannelShuffleLayer.hpp"
#include "layers/ComparisonLayer.hpp"
#include "layers/ConcatLayer.hpp"
#include "layers/ConstantLayer.hpp"
#include "layers/ConvertFp16ToFp32Layer.hpp"
#include "layers/ConvertFp32ToFp16Layer.hpp"
#include "layers/Convolution2dLayer.hpp"
#include "layers/Convolution3dLayer.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/ElementwiseBinaryLayer.hpp"
#include "layers/ElementwiseUnaryLayer.hpp"
#include "layers/FakeQuantizationLayer.hpp"
#include "layers/FillLayer.hpp"
#include "layers/FloorLayer.hpp"
#include "layers/FullyConnectedLayer.hpp"
#include "layers/FusedLayer.hpp"
#include "layers/GatherLayer.hpp"
#include "layers/GatherNdLayer.hpp"
#include "layers/InputLayer.hpp"
#include "layers/InstanceNormalizationLayer.hpp"
#include "layers/L2NormalizationLayer.hpp"
#include "layers/LogicalBinaryLayer.hpp"
#include "layers/LogSoftmaxLayer.hpp"
#include "layers/LstmLayer.hpp"
#include "layers/MapLayer.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/Pooling3dLayer.hpp"
#include "layers/PreCompiledLayer.hpp"
#include "layers/PreluLayer.hpp"
#include "layers/QuantizeLayer.hpp"
#include "layers/QLstmLayer.hpp"
#include "layers/QuantizedLstmLayer.hpp"
#include "layers/RankLayer.hpp"
#include "layers/ReduceLayer.hpp"
#include "layers/ReshapeLayer.hpp"
#include "layers/ResizeLayer.hpp"
#include "layers/ReverseV2Layer.hpp"
#include "layers/ShapeLayer.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/TileLayer.hpp"
#include "layers/TransposeConvolution2dLayer.hpp"
#include "layers/TransposeLayer.hpp"
#include "layers/UnidirectionalSequenceLstmLayer.hpp"
#include "layers/UnmapLayer.hpp"

Include dependency graph for LayersFwd.hpp:

This graph shows which files directly or indirectly include this file:

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::BatchMatMul >
struct	LayerTypeOfImpl< LayerType::BatchNormalization >
struct	LayerTypeOfImpl< LayerType::BatchToSpaceNd >
struct	LayerTypeOfImpl< LayerType::BroadcastTo >
struct	LayerTypeOfImpl< LayerType::Cast >
struct	LayerTypeOfImpl< LayerType::ChannelShuffle >
struct	LayerTypeOfImpl< LayerType::Comparison >
struct	LayerTypeOfImpl< LayerType::Concat >
struct	LayerTypeOfImpl< LayerType::Constant >
struct	LayerTypeOfImpl< LayerType::ConvertFp16ToFp32 >
struct	LayerTypeOfImpl< LayerType::ConvertFp32ToFp16 >
struct	LayerTypeOfImpl< LayerType::Convolution2d >
struct	LayerTypeOfImpl< LayerType::Convolution3d >
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::ElementwiseBinary >
struct	LayerTypeOfImpl< LayerType::ElementwiseUnary >
struct	LayerTypeOfImpl< LayerType::FakeQuantization >
struct	LayerTypeOfImpl< LayerType::Fill >
struct	LayerTypeOfImpl< LayerType::Floor >
struct	LayerTypeOfImpl< LayerType::FullyConnected >
struct	LayerTypeOfImpl< LayerType::Fused >
struct	LayerTypeOfImpl< LayerType::Gather >
struct	LayerTypeOfImpl< LayerType::GatherNd >
struct	LayerTypeOfImpl< LayerType::Input >
struct	LayerTypeOfImpl< LayerType::InstanceNormalization >
struct	LayerTypeOfImpl< LayerType::L2Normalization >
struct	LayerTypeOfImpl< LayerType::LogicalBinary >
struct	LayerTypeOfImpl< LayerType::LogSoftmax >
struct	LayerTypeOfImpl< LayerType::Lstm >
struct	LayerTypeOfImpl< LayerType::Map >
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::Pooling3d >
struct	LayerTypeOfImpl< LayerType::PreCompiled >
struct	LayerTypeOfImpl< LayerType::Prelu >
struct	LayerTypeOfImpl< LayerType::Quantize >
struct	LayerTypeOfImpl< LayerType::QLstm >
struct	LayerTypeOfImpl< LayerType::QuantizedLstm >
struct	LayerTypeOfImpl< LayerType::Rank >
struct	LayerTypeOfImpl< LayerType::Reduce >
struct	LayerTypeOfImpl< LayerType::Reshape >
struct	LayerTypeOfImpl< LayerType::Resize >
struct	LayerTypeOfImpl< LayerType::ReverseV2 >
struct	LayerTypeOfImpl< LayerType::Shape >
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::Tile >
struct	LayerTypeOfImpl< LayerType::Transpose >
struct	LayerTypeOfImpl< LayerType::TransposeConvolution2d >
struct	LayerTypeOfImpl< LayerType::UnidirectionalSequenceLstm >
struct	LayerTypeOfImpl< LayerType::Unmap >

Namespaces
	armnn
	Copyright (c) 2021 ARM Limited and Contributors.

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 BatchMatMulLayer *)
template<>
constexpr LayerType	LayerEnumOf (const BatchNormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const BatchToSpaceNdLayer *)
template<>
constexpr LayerType	LayerEnumOf (const BroadcastToLayer *)
template<>
constexpr LayerType	LayerEnumOf (const CastLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ChannelShuffleLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ComparisonLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConcatLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConstantLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertFp16ToFp32Layer *)
template<>
constexpr LayerType	LayerEnumOf (const ConvertFp32ToFp16Layer *)
template<>
constexpr LayerType	LayerEnumOf (const Convolution2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const Convolution3dLayer *)
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 ElementwiseBinaryLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ElementwiseUnaryLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FakeQuantizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FillLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FloorLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FullyConnectedLayer *)
template<>
constexpr LayerType	LayerEnumOf (const FusedLayer *)
template<>
constexpr LayerType	LayerEnumOf (const GatherLayer *)
template<>
constexpr LayerType	LayerEnumOf (const GatherNdLayer *)
template<>
constexpr LayerType	LayerEnumOf (const InputLayer *)
template<>
constexpr LayerType	LayerEnumOf (const InstanceNormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const L2NormalizationLayer *)
template<>
constexpr LayerType	LayerEnumOf (const LogicalBinaryLayer *)
template<>
constexpr LayerType	LayerEnumOf (const LogSoftmaxLayer *)
template<>
constexpr LayerType	LayerEnumOf (const LstmLayer *)
template<>
constexpr LayerType	LayerEnumOf (const MapLayer *)
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 Pooling3dLayer *)
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 RankLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ReduceLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ReshapeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ResizeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const ReverseV2Layer *)
template<>
constexpr LayerType	LayerEnumOf (const ShapeLayer *)
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 TileLayer *)
template<>
constexpr LayerType	LayerEnumOf (const TransposeLayer *)
template<>
constexpr LayerType	LayerEnumOf (const TransposeConvolution2dLayer *)
template<>
constexpr LayerType	LayerEnumOf (const UnidirectionalSequenceLstmLayer *)
template<>
constexpr LayerType	LayerEnumOf (const UnmapLayer *)

Macro Definition Documentation

DECLARE_LAYER

#define DECLARE_LAYER

(

LayerName

)

DECLARE_LAYER_IMPL(, LayerName)

Definition at line 112 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 99 of file LayersFwd.hpp.