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-2022 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 <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 noexcept;
 
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>
auto getDefaultValueForJson(DefaultType defaultValue)
{
    return nlohmann::json(defaultValue);
}
 
template <
    typename DefaultType,
    std::enable_if_t<
        std::is_enum<DefaultType>::value>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// coverity[autosar_cpp14_a2_10_5_violation]
auto 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>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// coverity[autosar_cpp14_a2_10_5_violation]
auto getDefaultValueForJson(const std::array<DefaultType, N>& defaultValues)
{
    std::array<std::string, N> nameStrings;
    for (size_t i = 0; i < N; ++i)
    {
        StringView name = mapEnumValueToName<DefaultType>(defaultValues[i]);
        std::string nameStr{name.data(), name.size()};
        nameStrings[i] = 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
// coverity[autosar_cpp14_a14_1_1_violation]
template <typename DefaultType>
class ParameterDescriptorWithDefault : public ParameterDescriptor
{
 
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 noexcept override
    {
        object["default"] = 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);
 
    template <
        typename NodeT, size_t ConstructorArgumentIndex,
        typename std::enable_if_t<ConstructorArgumentIndex == std::tuple_size<decltype(describeParameters<NodeT>())>::value, void>* = nullptr>
    void addDescriptors()
    {
    }
 
    template <
        typename NodeT, size_t ConstructorArgumentIndex,
        typename std::enable_if_t<ConstructorArgumentIndex<std::tuple_size<decltype(describeParameters<NodeT>())>::value, void>* = nullptr> void addDescriptors()
    {
        auto t         = std::get<ConstructorArgumentIndex>(describeParameters<NodeT>());
        const auto& t2 = std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(t);
        // all parameters of this constructor argument
        addDescriptors<0>(t2);
        // next constructor argument
        addDescriptors<NodeT, ConstructorArgumentIndex + 1>();
    }
 
private:
    template <
        size_t ParameterIndex, typename ParamsT,
        typename std::enable_if_t<ParameterIndex == dw::core::tuple_size<ParamsT>::value, void>* = nullptr>
    void addDescriptors(const ParamsT& params)
    {
        static_cast<void>(params);
    }
 
    template <
        size_t ParameterIndex, typename ParamsT,
        typename std::enable_if_t<ParameterIndex<dw::core::tuple_size<ParamsT>::value, void>* = nullptr> void addDescriptors(const ParamsT& params)
    {
        const auto& p = dw::core::get<ParameterIndex>(params);
        addDescriptor(p);
        addDescriptors<ParameterIndex + 1>(params);
    }
 
    template <
        typename ParamT,
        typename std::enable_if_t<std::tuple_size<ParamT>::value <= PARAMETER_DEFAULT_VALUE, void>* = nullptr>
    void addDescriptor(const ParamT& param)
    {
        const auto d = std::make_shared<const ParameterDescriptor>(
            std::get<PARAMETER_NAME>(param),
            std::get<PARAMETER_TYPE_NAME>(param),
            std::get<PARAMETER_IS_INDEX>(param),
            std::get<PARAMETER_ARRAY_SIZE>(param));
        addDescriptor(d);
    }
 
    template <
        typename ParamT,
        typename std::enable_if_t<PARAMETER_DEFAULT_VALUE<std::tuple_size<ParamT>::value, void>* = nullptr> void addDescriptor(const ParamT& param)
    {
        using DefaultT = typename std::tuple_element_t<PARAMETER_DEFAULT_VALUE, ParamT>;
        const auto d   = std::make_shared<const ParameterDescriptorWithDefault<DefaultT>>(
            std::get<PARAMETER_NAME>(param),
            std::get<PARAMETER_TYPE_NAME>(param),
            std::get<PARAMETER_IS_INDEX>(param),
            std::get<PARAMETER_ARRAY_SIZE>(param),
            std::get<PARAMETER_DEFAULT_VALUE>(param));
        addDescriptor(d);
    }
 
    dw::core::VectorFixed<std::shared_ptr<const ParameterDescriptor>> m_descriptors;
};
 
template <typename NodeT>
static ParameterCollectionDescriptor createParameterCollectionDescriptor()
{
    ParameterCollectionDescriptor d(parameterSize<NodeT>());
    d.addDescriptors<NodeT, 0>();
    return d;
}
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_PARAMETERCOLLECTIONDESCRIPTOR_HPP_