ParameterCollectionDescriptor.hpp

Go to the documentation of this file.

 
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA CORPORATION & AFFILIATES assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA CORPORATION & AFFILIATES. No third party distribution is allowed unless
// expressly authorized by NVIDIA. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA CORPORATION & AFFILIATES products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA CORPORATION & AFFILIATES.
//
// SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
//
// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
// property and proprietary rights in and to this material, related
// documentation and any modifications thereto. Any use, reproduction,
// disclosure or distribution of this material and related documentation
// without an express license agreement from NVIDIA CORPORATION or
// its affiliates is strictly prohibited.
//
 
#ifndef DW_FRAMEWORK_PARAMETERCOLLECTIONDESCRIPTOR_HPP_
#define DW_FRAMEWORK_PARAMETERCOLLECTIONDESCRIPTOR_HPP_
 
#include <dwcgf/parameter/ParameterDescriptor.hpp>
 
#include <dwshared/dwfoundation/dw/core/container/VectorFixed.hpp>
 
#include <modern-json/json.hpp>
 
#include <memory>
 
namespace dw
{
namespace framework
{
 
class ParameterDescriptor
{
public:
    ParameterDescriptor(
        dw::core::StringView const& name,
        dw::core::StringView const& typeName,
        const bool isIndex,
        size_t const arraySize) noexcept;
    virtual ~ParameterDescriptor() = default;
    ParameterDescriptor(ParameterDescriptor const&) = delete;
    ParameterDescriptor(ParameterDescriptor&&) = delete;
    ParameterDescriptor& operator=(ParameterDescriptor const&) & = delete;
    ParameterDescriptor& operator=(ParameterDescriptor&&) & = delete;
    dw::core::StringView const& getName() const noexcept;
    dw::core::StringView const& getTypeName() const noexcept;
    bool isIndex() const noexcept;
    size_t getArraySize() const noexcept;
    virtual void addDefault(nlohmann::ordered_json& object) const;
 
private:
    dw::core::StringView m_name;
    dw::core::StringView m_typeName;
    bool m_isIndex;
    size_t m_arraySize;
};
 
namespace detail
{
 
template <
    typename DefaultType,
    std::enable_if_t<
        !std::is_enum<DefaultType>::value>* = nullptr>
// coverity[autosar_cpp14_a2_10_5_violation] FP: nvbugs/3907242
nlohmann::json getDefaultValueForJson(DefaultType defaultValue)
{
    return nlohmann::json(defaultValue);
}
 
template <
    typename DefaultType,
    std::enable_if_t<
        std::is_enum<DefaultType>::value>* = nullptr>
// coverity[autosar_cpp14_a2_10_5_violation] FP: nvbugs/3907242
nlohmann::json getDefaultValueForJson(DefaultType defaultValue)
{
    StringView name{mapEnumValueToName<DefaultType>(defaultValue)};
    std::string nameStr{name.data(), name.size()};
    return nlohmann::json(nameStr);
}
 
template <
    typename DefaultType, size_t N,
    std::enable_if_t<
        std::is_enum<DefaultType>::value>* = nullptr>
// coverity[autosar_cpp14_a2_10_5_violation] FP: nvbugs/3907242
nlohmann::json getDefaultValueForJson(const std::array<DefaultType, N>& defaultValues)
{
    std::array<std::string, N> nameStrings{};
    // coverity[autosar_cpp14_a5_1_1_violation] RFD Accepted: TID-2056
    for (size_t i{0U}; i < N; ++i)
    {
        StringView name{mapEnumValueToName<DefaultType>(defaultValues[i])};
        std::string nameStr{name.data(), name.size()};
        nameStrings[i] = std::move(nameStr);
    }
    return nlohmann::json(nameStrings);
}
 
} // namespace detail
 
// static_assert needed covering all possible type accepted by nlohmann::json()
// beside enums and std::arrays of such types
template <typename DefaultType>
class ParameterDescriptorWithDefault : public ParameterDescriptor
{
    static_assert(std::is_trivially_copy_constructible<DefaultType>(), "DefaultType must be trivially copy constructible");
 
public:
    ParameterDescriptorWithDefault(
        dw::core::StringView name,
        dw::core::StringView typeName,
        bool isIndex,
        size_t arraySize,
        DefaultType defaultValue)
        : ParameterDescriptor(name, typeName, isIndex, arraySize)
        , m_defaultValue(defaultValue)
    {
    }
    ~ParameterDescriptorWithDefault() override = default;
    ParameterDescriptorWithDefault(ParameterDescriptorWithDefault const&) = delete;
    ParameterDescriptorWithDefault(ParameterDescriptorWithDefault&&) = delete;
    auto operator=(ParameterDescriptorWithDefault const&) -> ParameterDescriptorWithDefault& = delete;
    auto operator=(ParameterDescriptorWithDefault &&) -> ParameterDescriptorWithDefault& = delete;
    void addDefault(nlohmann::ordered_json& object) const override
    {
        const char* DEFAULT_KEY{"default"};
        object[DEFAULT_KEY] = detail::getDefaultValueForJson(m_defaultValue);
    }
 
private:
    DefaultType m_defaultValue;
};
 
class ParameterCollectionDescriptor
{
public:
    explicit ParameterCollectionDescriptor(size_t const capacity);
 
    size_t getSize() const;
 
    const std::shared_ptr<const ParameterDescriptor>& getDescriptor(size_t const index) const;
 
    size_t getIndex(dw::core::StringView const& identifier) const;
 
    const std::shared_ptr<const ParameterDescriptor>& getDescriptor(dw::core::StringView const& identifier) const;
 
    bool isValid(size_t const index) const;
 
    bool isValid(dw::core::StringView const& identifier) const noexcept;
 
    void addDescriptor(const std::shared_ptr<const ParameterDescriptor>& descriptor);
 
    // coverity[autosar_cpp14_a2_10_5_violation] FP: nvbugs/3907242
    void addDescriptors(const std::tuple<>& t)
    {
        static_cast<void>(t);
    }
 
    template <typename THead>
    // coverity[autosar_cpp14_a2_10_5_violation] FP: nvbugs/3907242
    void addDescriptors(const std::tuple<THead>& t)
    {
        // coverity[autosar_cpp14_a8_5_2_violation] FP: nvbugs/3904083
        auto params = std::get<0>(t).parameterDescriptors;
        // all parameters of this constructor argument
        addDescriptors(params);
    }
 
    template <
        typename THead, typename... TTail,
        typename std::enable_if_t<sizeof...(TTail) != 0>* = nullptr>
    // coverity[autosar_cpp14_a2_10_5_violation] FP: nvbugs/3907242
    void addDescriptors(const std::tuple<THead, TTail...>& t)
    {
        // coverity[autosar_cpp14_a8_5_2_violation] FP: nvbugs/3904083
        auto params = std::get<0>(t).parameterDescriptors;
        // all parameters of the first constructor argument
        addDescriptors(params);
        // remaining constructor arguments
        addDescriptors(tail_impl(std::make_index_sequence<sizeof...(TTail)>(), t));
    }
 
private:
    template <size_t... Ns, typename... Ts>
    auto tail_impl(std::index_sequence<Ns...>, const std::tuple<Ts...>& t) -> decltype(std::make_tuple(std::get<Ns + 1U>(t)...))
    {
        return std::make_tuple(std::get<Ns + 1U>(t)...);
    }
 
    // LCOV_EXCL_START end of template recursion is never reached
    // coverity[autosar_cpp14_a0_1_3_violation]
    // coverity[autosar_cpp14_a2_10_5_violation]
    void addDescriptors(const dw::core::Tuple<>& t)
    {
        static_cast<void>(t);
    }
    // LCOV_EXCL_STOP
 
    template <typename THead>
    // coverity[autosar_cpp14_a2_10_5_violation]
    void addDescriptors(const dw::core::Tuple<THead>& t)
    {
        addDescriptor(t.m_head);
    }
 
    template <
        typename THead, typename... TTail,
        typename std::enable_if_t<sizeof...(TTail) != 0>* = nullptr>
    // coverity[autosar_cpp14_a2_10_5_violation]
    void addDescriptors(const dw::core::Tuple<THead, TTail...>& t)
    {
        addDescriptor(t.m_head);
        addDescriptors(t.m_tail);
    }
 
    template <
        typename ParamT,
        typename std::enable_if_t<!ParamT::HAS_DEFAULT, void>* = nullptr>
    void addDescriptor(const ParamT& param)
    {
        addDescriptor(std::make_shared<const ParameterDescriptor>(
            param.parameterName,
            param.typeName,
            ParamT::IS_INDEX,
            ParamT::ARRAY_SIZE));
    }
 
    template <
        typename ParamT,
        typename std::enable_if_t<ParamT::HAS_DEFAULT, void>* = nullptr>
    void addDescriptor(const ParamT& param)
    {
        addDescriptor(std::make_shared<const ParameterDescriptorWithDefault<decltype(ParamT::defaultValue)>>(
            param.parameterName,
            param.typeName,
            ParamT::IS_INDEX,
            ParamT::ARRAY_SIZE,
            param.defaultValue));
    }
 
    dw::core::VectorFixed<std::shared_ptr<const ParameterDescriptor>> m_descriptors;
};
 
template <typename NodeT>
// coverity[autosar_cpp14_a2_10_4_violation] FP: nvbugs/4040101
// coverity[autosar_cpp14_a2_10_5_violation] FP: nvbugs/3907242
static ParameterCollectionDescriptor createParameterCollectionDescriptor()
{
    ParameterCollectionDescriptor d{parameterSize<NodeT>()};
    d.addDescriptors(describeNodeParameters<NodeT>());
    return d;
}
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_PARAMETERCOLLECTIONDESCRIPTOR_HPP_