//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include <armnn/Types.hpp>
#include <armnn/utility/PolymorphicDowncast.hpp>
#include <armnn/Tensor.hpp>
#include <armnn/backends/ILayerSupport.hpp>
#include <armnn/utility/IgnoreUnused.hpp>

namespace armnn
{

ARMNN_NO_DEPRECATE_WARN_BEGIN
// IsLayerSupport() forwards to the deprecated virtual methods depending on input LayerType.
// Allows backends continue to behave as before maintaining backward compatibility.
bool ILayerSupport::IsLayerSupported(const LayerType& type,
                                     const std::vector<TensorInfo>& infos,
                                     const BaseDescriptor& descriptor,
                                     const Optional<LstmInputParamsInfo>& lstmParamsInfo,
                                     const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    switch (type)
    {
        case LayerType::Activation:
            return IsActivationSupported(infos[0],
                                         infos[1],
                                         *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
                                         reasonIfUnsupported);
        case LayerType::Addition:
            return IsAdditionSupported(infos[0],
                                       infos[1],
                                       infos[2],
                                       reasonIfUnsupported);
        case LayerType::ArgMinMax:
            return IsArgMinMaxSupported(infos[0],
                                        infos[1],
                                        *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        case LayerType::BatchNormalization:
            return IsBatchNormalizationSupported(infos[0],
                                                 infos[1],
                                                 infos[2],
                                                 infos[3],
                                                 infos[4],
                                                 infos[5],
                                                 *(PolymorphicDowncast<const BatchNormalizationDescriptor*>
                                                     (&descriptor)),
                                                 reasonIfUnsupported);
        case LayerType::BatchToSpaceNd:
            return IsBatchToSpaceNdSupported(infos[0],
                                             infos[1],
                                             *(PolymorphicDowncast<const BatchToSpaceNdDescriptor*>(&descriptor)),
                                             reasonIfUnsupported);
        case LayerType::Comparison:
        {
            return IsComparisonSupported(infos[0],
                                         infos[1],
                                         infos[2],
                                         *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
                                         reasonIfUnsupported);
        }
        case LayerType::Concat:
        {
            std::vector<const TensorInfo*> inputInfos;
            for (uint32_t i = 0; i < (infos.size() - 1); i++)
            {
                inputInfos.push_back(&infos[i]);
            }
            return IsConcatSupported(inputInfos,
                                     infos[infos.size() - 1],
                                     *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
                                     reasonIfUnsupported);
        }
        case LayerType::Constant:
            return IsConstantSupported(infos[0],
                                       reasonIfUnsupported);
        case LayerType::ConvertBf16ToFp32:
            return IsConvertBf16ToFp32Supported(infos[0],
                                                infos[1],
                                                reasonIfUnsupported);
        case LayerType::ConvertFp16ToFp32:
            return IsConvertFp16ToFp32Supported(infos[0],
                                                infos[1],
                                                reasonIfUnsupported);
        case LayerType::ConvertFp32ToBf16:
            return IsConvertFp32ToBf16Supported(infos[0],
                                                infos[1],
                                                reasonIfUnsupported);
        case LayerType::ConvertFp32ToFp16:
            return IsConvertFp32ToFp16Supported(infos[0],
                                                infos[1],
                                                reasonIfUnsupported);
        case LayerType::Convolution2d:
        {
            if (infos.size() != 4)
            {
                throw InvalidArgumentException("Invalid number of Convolution2d "
                                               "TensorInfos. TensorInfos should be of format: "
                                               "{input, output, weights, biases}.");
            }

            auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
            if (infos[3] == TensorInfo())
            {
                return IsConvolution2dSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                EmptyOptional(),
                                                reasonIfUnsupported);
            }
            else
            {
                return IsConvolution2dSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                infos[3],
                                                reasonIfUnsupported);
            }
        }
        case LayerType::Debug:
            return IsDebugSupported(infos[0],
                                    infos[1],
                                    reasonIfUnsupported);
        case LayerType::DepthToSpace:
            return IsDepthToSpaceSupported(infos[0],
                                           infos[1],
                                           *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
                                           reasonIfUnsupported);
        case LayerType::DepthwiseConvolution2d:
        {
            if (infos.size() != 4)
            {
                throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d "
                                               "TensorInfos. TensorInfos should be of format: "
                                               "{input, output, weights, biases}.");
            }

            auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
            if (infos[3] == TensorInfo())
            {
                return IsDepthwiseConvolutionSupported(infos[0],
                                                       infos[1],
                                                       desc,
                                                       infos[2],
                                                       EmptyOptional(),
                                                       reasonIfUnsupported);
            }
            else
            {
                return IsDepthwiseConvolutionSupported(infos[0],
                                                       infos[1],
                                                       desc,
                                                       infos[2],
                                                       infos[3],
                                                       reasonIfUnsupported);
            }
        }
        case LayerType::Dequantize:
            return IsDequantizeSupported(infos[0],
                                         infos[1],
                                         reasonIfUnsupported);
        case LayerType::DetectionPostProcess:
            return IsDetectionPostProcessSupported(infos[0],
                                                   infos[1],
                                                   infos[2],
                                                   infos[3],
                                                   infos[4],
                                                   infos[5],
                                                   infos[6],
                                                   *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>
                                                       (&descriptor)),
                                                   reasonIfUnsupported);
        case LayerType::Division:
            return IsDivisionSupported(infos[0],
                                       infos[1],
                                       infos[2],
                                       reasonIfUnsupported);
        case LayerType::ElementwiseUnary:
            return IsElementwiseUnarySupported(infos[0],
                                               infos[1],
                                               *(PolymorphicDowncast<const ElementwiseUnaryDescriptor*>
                                                   (&descriptor)),
                                               reasonIfUnsupported);
        case LayerType::FakeQuantization:
            return IsFakeQuantizationSupported(infos[0],
                                               *(PolymorphicDowncast<const FakeQuantizationDescriptor*>
                                                   (&descriptor)),
                                               reasonIfUnsupported);
        case LayerType::Fill:
            return IsFillSupported(infos[0],
                                   infos[1],
                                   *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
                                   reasonIfUnsupported);
        case LayerType::Floor:
            return IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::FullyConnected:
            return IsFullyConnectedSupported(infos[0],
                                             infos[1],
                                             infos[2],
                                             infos[3],
                                             *(PolymorphicDowncast<const FullyConnectedDescriptor*>(&descriptor)),
                                             reasonIfUnsupported);
        case LayerType::Gather:
            return IsGatherSupported(infos[0],
                                     infos[1],
                                     infos[2],
                                     *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
                                     reasonIfUnsupported);
        case LayerType::Input:
            return IsInputSupported(infos[0], reasonIfUnsupported);
        case LayerType::InstanceNormalization:
            return IsInstanceNormalizationSupported(infos[0],
                                                    infos[1],
                                                    *(PolymorphicDowncast<const InstanceNormalizationDescriptor*>
                                                        (&descriptor)),
                                                    reasonIfUnsupported);
        case LayerType::L2Normalization:
            return IsL2NormalizationSupported(infos[0],
                                              infos[1],
                                              *(PolymorphicDowncast<const L2NormalizationDescriptor*>
                                                  (&descriptor)),
                                              reasonIfUnsupported);
        case LayerType::LogicalBinary:
            return IsLogicalBinarySupported(infos[0],
                                            infos[1],
                                            infos[2],
                                            *(PolymorphicDowncast<const LogicalBinaryDescriptor*>(&descriptor)),
                                            reasonIfUnsupported);
        case LayerType::LogSoftmax:
            return IsLogSoftmaxSupported(infos[0],
                                         infos[1],
                                         *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
                                         reasonIfUnsupported);
        case LayerType::Lstm:
            return IsLstmSupported(infos[0],
                                   infos[1],
                                   infos[2],
                                   infos[3],
                                   infos[4],
                                   infos[5],
                                   infos[6],
                                   *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
                                   lstmParamsInfo.value(),
                                   reasonIfUnsupported);
        case LayerType::QLstm:
            return IsQLstmSupported(infos[0],
                                    infos[1],
                                    infos[2],
                                    infos[3],
                                    infos[4],
                                    infos[5],
                                    *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
                                    lstmParamsInfo.value(),
                                    reasonIfUnsupported);
        case LayerType::Map:
            return true;
        case LayerType::Maximum:
            return IsMaximumSupported(infos[0],
                                      infos[1],
                                      infos[2],
                                      reasonIfUnsupported);
        case LayerType::Mean:
            return IsMeanSupported(infos[0],
                                   infos[1],
                                   *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
                                   reasonIfUnsupported);
        case LayerType::MemCopy:
            return IsMemCopySupported(std::move(infos[0]),
                                      std::move(infos[1]),
                                      reasonIfUnsupported);
        case LayerType::MemImport:
            return IsMemImportSupported(infos[0],
                                        infos[1],
                                        reasonIfUnsupported);
        case LayerType::Merge:
            return IsMergeSupported(infos[0],
                                    infos[1],
                                    infos[2],
                                    reasonIfUnsupported);
        case LayerType::Minimum:
            return IsMinimumSupported(infos[0],
                                      infos[1],
                                      infos[2],
                                      reasonIfUnsupported);
        case LayerType::Multiplication:
            return IsMultiplicationSupported(infos[0],
                                             infos[1],
                                             infos[2],
                                             reasonIfUnsupported);
        case LayerType::Normalization:
            return IsNormalizationSupported(infos[0],
                                            infos[1],
                                            *(PolymorphicDowncast<const NormalizationDescriptor*>(&descriptor)),
                                            reasonIfUnsupported);
        case LayerType::Output:
            return IsOutputSupported(infos[0], reasonIfUnsupported);
        case LayerType::Pad:
            return IsPadSupported(infos[0],
                                  infos[1],
                                  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
                                  reasonIfUnsupported);
        case LayerType::Permute:
            return IsPermuteSupported(infos[0],
                                      infos[1],
                                      *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
                                      reasonIfUnsupported);
        case LayerType::Pooling2d:
            return IsPooling2dSupported(infos[0],
                                        infos[1],
                                        *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        case LayerType::PreCompiled:
            return IsPreCompiledSupported(infos[0],
                                          *(PolymorphicDowncast<const PreCompiledDescriptor*>(&descriptor)),
                                          reasonIfUnsupported);
        case LayerType::Prelu:
            return IsPreluSupported(infos[0],
                                    infos[1],
                                    infos[2],
                                    reasonIfUnsupported);
        case LayerType::Quantize:
            return IsQuantizeSupported(infos[0],
                                       infos[1],
                                       reasonIfUnsupported);
        case LayerType::QuantizedLstm:
            return IsQuantizedLstmSupported(infos[0],
                                            infos[1],
                                            infos[2],
                                            infos[3],
                                            infos[4],
                                            quantizedLstmParamsInfo.value(),
                                            reasonIfUnsupported);
        case LayerType::Reshape:
            return IsReshapeSupported(infos[0],
                                      infos[1],
                                      *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
                                      reasonIfUnsupported);
        case LayerType::Rank:
            return IsRankSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::Resize:
            return IsResizeSupported(infos[0],
                                     infos[1],
                                     *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
                                     reasonIfUnsupported);
        case LayerType::Reduce:
            return IsReduceSupported(infos[0],
                                     infos[1],
                                     *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
                                     reasonIfUnsupported);
        case LayerType::Slice:
            return IsSliceSupported(infos[0],
                                    infos[1],
                                    *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
                                    reasonIfUnsupported);
        case LayerType::Softmax:
            return IsSoftmaxSupported(infos[0],
                                      infos[1],
                                      *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
                                      reasonIfUnsupported);
        case LayerType::SpaceToBatchNd:
            return IsSpaceToBatchNdSupported(infos[0],
                                             infos[1],
                                             *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
                                             reasonIfUnsupported);
        case LayerType::SpaceToDepth:
            return IsSpaceToDepthSupported(infos[0],
                                           infos[1],
                                           *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
                                           reasonIfUnsupported);
        case LayerType::Splitter:
        {
            std::vector<TensorInfo> outputInfos;
            for (uint32_t i = 1; i < infos.size(); i++)
            {
                outputInfos.push_back(infos[i]);
            }
            return IsSplitterSupported(infos[0],
                                       {outputInfos.begin(), outputInfos.end()},
                                       *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
                                       reasonIfUnsupported);
        }
        case LayerType::Stack:
        {
            std::vector<const TensorInfo*> inputInfos;
            for (uint32_t i = 0; i < infos.size() - 1; i++)
            {
                inputInfos.push_back(&infos[i]);
            }
            return IsStackSupported(inputInfos,
                                    infos[infos.size() - 1],
                                    *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
                                    reasonIfUnsupported);
        }
        case LayerType::StandIn:
        {
            auto desc = *(PolymorphicDowncast<const StandInDescriptor*>(&descriptor));

            if (infos.size() != (desc.m_NumInputs + desc.m_NumOutputs))
            {
                throw InvalidArgumentException("Number of StandIn layer TensorInfos does not equal "
                                               "the combined number of input and output slots assigned "
                                               "to the StandIn descriptor");
            }

            std::vector<const TensorInfo*> inputInfos;
            for (uint32_t i = 0; i < desc.m_NumInputs; i++)
            {
                inputInfos.push_back(&infos[i]);
            }
            std::vector<const TensorInfo*> outputInfos;
            for (uint32_t i = desc.m_NumInputs; i < infos.size(); i++)
            {
                outputInfos.push_back(&infos[i]);
            }

            return IsStandInSupported(inputInfos,
                                      outputInfos,
                                      desc,
                                      reasonIfUnsupported);
        }
        case LayerType::StridedSlice:
            return IsStridedSliceSupported(infos[0],
                                           infos[1],
                                           *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
                                           reasonIfUnsupported);
        case LayerType::Subtraction:
            return IsSubtractionSupported(infos[0],
                                          infos[1],
                                          infos[2],
                                          reasonIfUnsupported);
        case LayerType::Switch:
            return IsSwitchSupported(infos[0],
                                     infos[1],
                                     infos[2],
                                     infos[3],
                                     reasonIfUnsupported);
        case LayerType::Transpose:
            return IsTransposeSupported(infos[0],
                                        infos[1],
                                        *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        case LayerType::TransposeConvolution2d:
        {
            if (infos.size() != 4)
            {
                throw InvalidArgumentException("Invalid number of TransposeConvolution2d "
                                               "TensorInfos. TensorInfos should be of format: "
                                               "{input, output, weights, biases}.");
            }

            auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
            if (infos[3] == TensorInfo())
            {
                return IsTransposeConvolution2dSupported(infos[0],
                                                         infos[1],
                                                         desc,
                                                         infos[2],
                                                         EmptyOptional(),
                                                         reasonIfUnsupported);
            }
            else
            {
                return IsTransposeConvolution2dSupported(infos[0],
                                                         infos[1],
                                                         desc,
                                                         infos[2],
                                                         infos[3],
                                                         reasonIfUnsupported);
            }
        }
        case LayerType::Unmap:
            return true;
        case LayerType::Cast:
            return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::Shape:
            return IsShapeSupported(infos[0], infos[1], reasonIfUnsupported);
        case LayerType::UnidirectionalSequenceLstm:
        {
            if (infos.size() != 6)
            {
                throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. TensorInfos "
                                               "should be of format: {input, outputStateIn, cellStateIn, "
                                               "hiddenStateOutputVal, cellStateOutputVal, output}");
            }
            auto desc = *(PolymorphicDowncast<const UnidirectionalSequenceLstmDescriptor*>(&descriptor));

            bool isHiddenStateOutputOptional = (infos[4] == TensorInfo());
            bool isCellStateOutput = (infos[5] == TensorInfo());
            if (isHiddenStateOutputOptional && isCellStateOutput)
            {
                return IsUnidirectionalSequenceLstmSupported(infos[0],
                                                             infos[1],
                                                             infos[2],
                                                             infos[3],
                                                             EmptyOptional(),
                                                             EmptyOptional(),
                                                             desc,
                                                             lstmParamsInfo.value(),
                                                             reasonIfUnsupported);
            }
            else if (isHiddenStateOutputOptional)
            {
                return IsUnidirectionalSequenceLstmSupported(infos[0],
                                                             infos[1],
                                                             infos[2],
                                                             infos[3],
                                                             EmptyOptional(),
                                                             infos[5],
                                                             desc,
                                                             lstmParamsInfo.value(),
                                                             reasonIfUnsupported);
            }
            else if (isCellStateOutput)
            {
                return IsUnidirectionalSequenceLstmSupported(infos[0],
                                                             infos[1],
                                                             infos[2],
                                                             infos[3],
                                                             infos[4],
                                                             EmptyOptional(),
                                                             desc,
                                                             lstmParamsInfo.value(),
                                                             reasonIfUnsupported);
            }
            else
            {
                return IsUnidirectionalSequenceLstmSupported(infos[0],
                                                             infos[1],
                                                             infos[2],
                                                             infos[3],
                                                             infos[4],
                                                             infos[5],
                                                             desc,
                                                             lstmParamsInfo.value(),
                                                             reasonIfUnsupported);
            }
        }
        case LayerType::ChannelShuffle:
            return IsChannelShuffleSupported(infos[0],
                                             infos[1],
                                             *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
                                             reasonIfUnsupported);
        case LayerType::Convolution3d:
        {
            if (infos.size() != 4)
            {
                throw InvalidArgumentException("Invalid number of Convolution3d "
                                               "TensorInfos. TensorInfos should be of format: "
                                               "{input, output, weights, biases}.");
            }

            auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
            if (infos[3] == TensorInfo())
            {
                return IsConvolution3dSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                EmptyOptional(),
                                                reasonIfUnsupported);
            }
            else
            {
                return IsConvolution3dSupported(infos[0],
                                                infos[1],
                                                desc,
                                                infos[2],
                                                infos[3],
                                                reasonIfUnsupported);
            }
        }
        case LayerType::Pooling3d:
            return IsPooling3dSupported(infos[0],
                                        infos[1],
                                        *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
                                        reasonIfUnsupported);
        default:
            return false;
    }
}

bool ILayerSupport::IsActivationSupported(const TensorInfo& input,
                                          const TensorInfo& output,
                                          const ActivationDescriptor& descriptor,
                                          Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsAdditionSupported(const TensorInfo& input0,
                                        const TensorInfo& input1,
                                        const TensorInfo& output,
                                        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsArgMinMaxSupported(const TensorInfo& input,
                                         const TensorInfo& output,
                                         const ArgMinMaxDescriptor& descriptor,
                                         Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
                                                  const TensorInfo& output,
                                                  const TensorInfo& mean,
                                                  const TensorInfo& var,
                                                  const TensorInfo& beta,
                                                  const TensorInfo& gamma,
                                                  const BatchNormalizationDescriptor& descriptor,
                                                  Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, mean, var, beta, gamma, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
                                              const TensorInfo& output,
                                              const BatchToSpaceNdDescriptor& descriptor,
                                              Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsCastSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsChannelShuffleSupported(const TensorInfo& input,
                                              const TensorInfo& output,
                                              const ChannelShuffleDescriptor& descriptor,
                                              Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsComparisonSupported(const TensorInfo& input0,
                                          const TensorInfo& input1,
                                          const TensorInfo& output,
                                          const ComparisonDescriptor& descriptor,
                                          Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                                      const TensorInfo& output,
                                      const OriginsDescriptor& descriptor,
                                      Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(inputs, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsConstantSupported(const TensorInfo& output,
                                        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsConvertBf16ToFp32Supported(const TensorInfo& input,
                                                 const TensorInfo& output,
                                                 Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsConvertFp32ToBf16Supported(const TensorInfo& input,
                                                 const TensorInfo& output,
                                                 Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
                                                 const TensorInfo& output,
                                                 Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
                                                 const TensorInfo& output,
                                                 Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsConvolution2dSupported(const TensorInfo& input,
                                             const TensorInfo& output,
                                             const Convolution2dDescriptor& descriptor,
                                             const TensorInfo& weights,
                                             const Optional<TensorInfo>& biases,
                                             Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsConvolution3dSupported(const TensorInfo& input,
                                             const TensorInfo& output,
                                             const Convolution3dDescriptor& descriptor,
                                             const TensorInfo& weights,
                                             const Optional<TensorInfo>& biases,
                                             Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsDebugSupported(const TensorInfo& input,
                                     const TensorInfo& output,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
                                            const TensorInfo& output,
                                            const DepthToSpaceDescriptor& descriptor,
                                            Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsDepthwiseConvolutionSupported(
        const TensorInfo& input,
        const TensorInfo& output,
        const DepthwiseConvolution2dDescriptor& descriptor,
        const TensorInfo& weights,
        const Optional<TensorInfo>& biases,
        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input,
                 output,
                 descriptor,
                 weights,
                 biases,
                 reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsDequantizeSupported(const TensorInfo& input,
                                          const TensorInfo& output,
                                          Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
                                                    const TensorInfo& scores,
                                                    const TensorInfo& anchors,
                                                    const TensorInfo& detectionBoxes,
                                                    const TensorInfo& detectionClasses,
                                                    const TensorInfo& detectionScores,
                                                    const TensorInfo& numDetections,
                                                    const DetectionPostProcessDescriptor& descriptor,
                                                    Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(boxEncodings,
                 scores,
                 anchors,
                 detectionBoxes,
                 detectionClasses,
                 detectionScores,
                 numDetections,
                 descriptor,
                 reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsDilatedDepthwiseConvolutionSupported(
        const TensorInfo& input,
        const TensorInfo& output,
        const DepthwiseConvolution2dDescriptor& descriptor,
        const TensorInfo& weights,
        const Optional<TensorInfo>& biases,
        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsDivisionSupported(const TensorInfo& input0,
                                        const TensorInfo& input1,
                                        const TensorInfo& output,
                                        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
                                                const TensorInfo& output,
                                                const ElementwiseUnaryDescriptor& descriptor,
                                                Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
                                                const FakeQuantizationDescriptor& descriptor,
                                                Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsFillSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const FillDescriptor& descriptor,
                                    Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsFloorSupported(const TensorInfo& input,
                                     const TensorInfo& output,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
                                              const TensorInfo& output,
                                              const TensorInfo& weights,
                                              const TensorInfo& biases,
                                              const FullyConnectedDescriptor& descriptor,
                                              Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, weights, biases, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsGatherSupported(const TensorInfo& input0,
                                      const TensorInfo& input1,
                                      const TensorInfo& output,
                                      const GatherDescriptor& descriptor,
                                      Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsInputSupported(const TensorInfo& input,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsInstanceNormalizationSupported(
        const TensorInfo& input,
        const TensorInfo& output,
        const InstanceNormalizationDescriptor& descriptor,
        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
                                               const TensorInfo& output,
                                               const L2NormalizationDescriptor& descriptor,
                                               Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsLogicalBinarySupported(const TensorInfo& input0,
                                             const TensorInfo& input1,
                                             const TensorInfo& output,
                                             const LogicalBinaryDescriptor& descriptor,
                                             Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsLogicalUnarySupported(const TensorInfo& input,
                                            const TensorInfo& output,
                                            const ElementwiseUnaryDescriptor& descriptor,
                                            Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsLogSoftmaxSupported(const TensorInfo& input,
                                          const TensorInfo& output,
                                          const LogSoftmaxDescriptor& descriptor,
                                          Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsLstmSupported(const TensorInfo& input,
                                    const TensorInfo& outputStateIn,
                                    const TensorInfo& cellStateIn,
                                    const TensorInfo& scratchBuffer,
                                    const TensorInfo& outputStateOut,
                                    const TensorInfo& cellStateOut,
                                    const TensorInfo& output,
                                    const LstmDescriptor& descriptor,
                                    const LstmInputParamsInfo& paramsInfo,
                                    Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input,
                 outputStateIn,
                 cellStateIn,
                 scratchBuffer,
                 outputStateOut,
                 cellStateOut,
                 output,
                 descriptor,
                 paramsInfo,
                 reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsMaximumSupported(const TensorInfo& input0,
                                       const TensorInfo& input1,
                                       const TensorInfo& output,
                                       Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsMeanSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const MeanDescriptor& descriptor,
                                    Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsMemCopySupported(const TensorInfo& input,
                                       const TensorInfo& output,
                                       Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsMemImportSupported(const TensorInfo& input,
                                         const TensorInfo& output,
                                         Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsMergeSupported(const TensorInfo& input0,
                                     const TensorInfo& input1,
                                     const TensorInfo& output,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsMinimumSupported(const TensorInfo& input0,
                                       const TensorInfo& input1,
                                       const TensorInfo& output,
                                       Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
                                              const TensorInfo& input1,
                                              const TensorInfo& output,
                                              Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsNormalizationSupported(const TensorInfo& input,
                                             const TensorInfo& output,
                                             const NormalizationDescriptor& descriptor,
                                             Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsOutputSupported(const TensorInfo& output,
                                      Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsPadSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const PadDescriptor& descriptor,
                                   Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsPermuteSupported(const TensorInfo& input,
                                       const TensorInfo& output,
                                       const PermuteDescriptor& descriptor,
                                       Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsPooling2dSupported(const TensorInfo& input,
                                         const TensorInfo& output,
                                         const Pooling2dDescriptor& descriptor,
                                         Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsPooling3dSupported(const TensorInfo& input,
                                         const TensorInfo& output,
                                         const Pooling3dDescriptor& descriptor,
                                         Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsPreCompiledSupported(const TensorInfo& input,
                                           const PreCompiledDescriptor& descriptor,
                                           Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsPreluSupported(const TensorInfo& input,
                                     const TensorInfo& alpha,
                                     const TensorInfo& output,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, alpha, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsQuantizeSupported(const TensorInfo& input,
                                        const TensorInfo& output,
                                        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsQLstmSupported(const TensorInfo& input,
                                     const TensorInfo& previousOutputIn,
                                     const TensorInfo& previousCellStateIn,
                                     const TensorInfo& outputStateOut,
                                     const TensorInfo& cellStateOut,
                                     const TensorInfo& output,
                                     const QLstmDescriptor& descriptor,
                                     const LstmInputParamsInfo& paramsInfo,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input,
                 previousOutputIn,
                 previousCellStateIn,
                 outputStateOut,
                 cellStateOut,
                 output,
                 descriptor,
                 paramsInfo,
                 reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsQuantizedLstmSupported(const TensorInfo& input,
                                             const TensorInfo& previousCellStateIn,
                                             const TensorInfo& previousOutputIn,
                                             const TensorInfo& cellStateOut,
                                             const TensorInfo& output,
                                             const QuantizedLstmInputParamsInfo& paramsInfo,
                                             Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input,
                 previousCellStateIn,
                 previousOutputIn,
                 cellStateOut,
                 output,
                 paramsInfo,
                 reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsRankSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsReduceSupported(const TensorInfo& input,
                                      const TensorInfo& output,
                                      const ReduceDescriptor& descriptor,
                                      Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsReshapeSupported(const TensorInfo& input,
                                       const TensorInfo& output,
                                       const ReshapeDescriptor& descriptor,
                                       Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsResizeSupported(const TensorInfo& input,
                                      const TensorInfo& output,
                                      const ResizeDescriptor& descriptor,
                                      Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsShapeSupported(const TensorInfo& input,
                                     const TensorInfo& output,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsSliceSupported(const TensorInfo& input,
                                     const TensorInfo& output,
                                     const SliceDescriptor& descriptor,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsSoftmaxSupported(const TensorInfo& input,
                                       const TensorInfo& output,
                                       const SoftmaxDescriptor& descriptor,
                                       Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
                                              const TensorInfo& output,
                                              const SpaceToBatchNdDescriptor& descriptor,
                                              Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsSpaceToDepthSupported(const TensorInfo& input,
                                            const TensorInfo& output,
                                            const SpaceToDepthDescriptor& descriptor,
                                            Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsSplitterSupported(const TensorInfo& input,
                                        const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
                                        const ViewsDescriptor& descriptor,
                                        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, outputs, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
                                     const TensorInfo& output,
                                     const StackDescriptor& descriptor,
                                     Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(inputs, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsStandInSupported(const std::vector<const TensorInfo*>& inputs,
                                       const std::vector<const TensorInfo*>& outputs,
                                       const StandInDescriptor& descriptor,
                                       Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(inputs, outputs, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsStridedSliceSupported(const TensorInfo& input,
                                            const TensorInfo& output,
                                            const StridedSliceDescriptor& descriptor,
                                            Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsSubtractionSupported(const TensorInfo& input0,
                                           const TensorInfo& input1,
                                           const TensorInfo& output,
                                           Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsSwitchSupported(const TensorInfo& input0,
                                      const TensorInfo& input1,
                                      const TensorInfo& output0,
                                      const TensorInfo& output1,
                                      Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input0, input1, output0, output1, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsTransposeConvolution2dSupported(
        const TensorInfo& input,
        const TensorInfo& output,
        const TransposeConvolution2dDescriptor& descriptor,
        const TensorInfo& weights,
        const Optional<TensorInfo>& biases,
        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsTransposeSupported(const TensorInfo& input,
                                         const TensorInfo& output,
                                         const TransposeDescriptor& descriptor,
                                         Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
    return false;
}

bool ILayerSupport::IsUnidirectionalSequenceLstmSupported(
        const TensorInfo& input,
        const TensorInfo& outputStateIn,
        const TensorInfo& cellStateIn,
        const TensorInfo& output,
        const Optional<TensorInfo>& hiddenStateOutput,
        const Optional<TensorInfo>& cellStateOutput,
        const LstmDescriptor& descriptor,
        const LstmInputParamsInfo& paramsInfo,
        Optional<std::string&> reasonIfUnsupported) const
{
    IgnoreUnused(input,
                 outputStateIn,
                 cellStateIn,
                 output,
                 hiddenStateOutput,
                 cellStateOutput,
                 descriptor,
                 paramsInfo,
                 reasonIfUnsupported);
    return false;
}
ARMNN_NO_DEPRECATE_WARN_END
}