ParameterDescriptor.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_PARAMETERDESCRIPTOR_HPP_
#define DW_FRAMEWORK_PARAMETERDESCRIPTOR_HPP_
 
#include <dwcgf/enum/EnumDescriptor.hpp>
#include <dwcgf/parameter/ParameterProvider.hpp>
#include <dw/core/container/StringView.hpp>
#include <dw/core/language/Tuple.hpp>
 
namespace dw
{
namespace framework
{
 
// Indices within the tuple describing constructor arguments
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_CONSTRUCTOR_ARGUMENT_TYPE{0U};
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR{1U};
 
constexpr std::tuple<> describeConstructorArguments()
{
    return std::make_tuple();
}
 
template <
    typename Argument1T,
    typename Arg1>
// Overloaded functions are provided for ease of use
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a13_3_1_violation]
constexpr auto describeConstructorArguments(const Arg1&& arg1)
{
    return std::make_tuple(
        std::make_tuple(
            static_cast<Argument1T*>(nullptr),
            std::forward<const Arg1>(arg1)));
}
 
template <
    typename Argument1T, typename Argument2T,
    typename Arg1, typename Arg2>
// Overloaded functions are provided for ease of use
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a13_3_1_violation]
constexpr auto describeConstructorArguments(const Arg1&& arg1, const Arg2&& arg2)
{
    return std::make_tuple(
        std::make_tuple(
            static_cast<Argument1T*>(nullptr),
            std::forward<const Arg1>(arg1)),
        std::make_tuple(
            static_cast<Argument2T*>(nullptr),
            std::forward<const Arg2>(arg2)));
}
 
template <
    typename Argument1T, typename Argument2T, typename Argument3T,
    typename Arg1, typename Arg2, typename Arg3>
// Overloaded functions are provided for ease of use
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a13_3_1_violation]
constexpr auto describeConstructorArguments(const Arg1&& arg1, const Arg2&& arg2, const Arg3&& arg3)
{
    return std::make_tuple(
        std::make_tuple(
            static_cast<Argument1T*>(nullptr),
            std::forward<const Arg1>(arg1)),
        std::make_tuple(
            static_cast<Argument2T*>(nullptr),
            std::forward<const Arg2>(arg2)),
        std::make_tuple(
            static_cast<Argument3T*>(nullptr),
            std::forward<const Arg3>(arg3)));
}
 
template <
    typename Argument1T, typename Argument2T, typename Argument3T, typename Argument4T,
    typename Arg1, typename Arg2, typename Arg3, typename Arg4>
// Overloaded functions are provided for ease of use
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a13_3_1_violation]
constexpr auto describeConstructorArguments(const Arg1&& arg1, const Arg2&& arg2, const Arg3&& arg3, const Arg4&& arg4)
{
    return std::make_tuple(
        std::make_tuple(
            static_cast<Argument1T*>(nullptr),
            std::forward<const Arg1>(arg1)),
        std::make_tuple(
            static_cast<Argument2T*>(nullptr),
            std::forward<const Arg2>(arg2)),
        std::make_tuple(
            static_cast<Argument3T*>(nullptr),
            std::forward<const Arg3>(arg3)),
        std::make_tuple(
            static_cast<Argument4T*>(nullptr),
            std::forward<const Arg4>(arg4)));
}
 
template <
    typename Argument1T, typename Argument2T, typename Argument3T, typename Argument4T, typename Argument5T,
    typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
// Overloaded functions are provided for ease of use
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a13_3_1_violation]
constexpr auto describeConstructorArguments(const Arg1&& arg1, const Arg2&& arg2, const Arg3&& arg3, const Arg4&& arg4, const Arg5&& arg5)
{
    return std::make_tuple(
        std::make_tuple(
            static_cast<Argument1T*>(nullptr),
            std::forward<const Arg1>(arg1)),
        std::make_tuple(
            static_cast<Argument2T*>(nullptr),
            std::forward<const Arg2>(arg2)),
        std::make_tuple(
            static_cast<Argument3T*>(nullptr),
            std::forward<const Arg3>(arg3)),
        std::make_tuple(
            static_cast<Argument4T*>(nullptr),
            std::forward<const Arg4>(arg4)),
        std::make_tuple(
            static_cast<Argument5T*>(nullptr),
            std::forward<const Arg5>(arg5)));
}
 
template <typename... Args>
constexpr auto describeConstructorArgument(const Args&&... args)
{
    return dw::core::make_tuple(
        std::forward<const Args>(args)...);
}
 
// Indices within the tuple describing parameters
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_TYPE_NAME{0U};
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_NAME{1U};
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_TYPE{2U};
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_SEMANTIC_TYPE{3U};
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_IS_INDEX{4U};
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_ARRAY_SIZE{5U};
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_MEMBER_PTRS{6U};
// coverity[autosar_cpp14_a0_1_1_violation]
// coverity[autosar_cpp14_m0_1_4_violation]
static constexpr size_t PARAMETER_DEFAULT_VALUE{7U};
 
} // namespace framework
} // namespace dw
 
// This is the only language feature able to avoid duplicating enumerators as strings
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_PARAMETER_TYPE_NAME_STRING_VIEW(TYPE_NAME_STR) TYPE_NAME_STR##_sv
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_PARAMETER(TYPE_NAME, args...) dw::framework::describeParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
 
namespace dw
{
namespace framework
{
 
template <typename T, typename S, typename... MemberPointers>
constexpr auto describeParameter(
    dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, const MemberPointers&&... memberPointers)
{
    return std::make_tuple(
        std::move(typeName),
        std::move(parameterName),
        static_cast<T*>(nullptr),
        static_cast<S*>(nullptr),
        false,
        static_cast<size_t>(0),
        std::move(
            std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)));
}
 
} // namespace framework
} // namespace dw
 
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_ABSTRACT_PARAMETER(TYPE_NAME, args...) dw::framework::describeAbstractParameter<TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_ABSTRACT_ARRAY_PARAMETER(TYPE_NAME, args...) dw::framework::describeAbstractArrayParameter<TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
 
namespace dw
{
namespace framework
{
 
template <typename T>
constexpr auto describeAbstractParameter(
    dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName)
{
    return std::make_tuple(
        std::move(typeName),
        std::move(parameterName),
        static_cast<T*>(nullptr),
        static_cast<T*>(nullptr),
        false,
        static_cast<size_t>(0));
}
 
template <typename T>
constexpr auto describeAbstractArrayParameter(
    dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, size_t arraySize)
{
    return std::make_tuple(
        std::move(typeName),
        std::move(parameterName),
        static_cast<T*>(nullptr),
        static_cast<T*>(nullptr),
        false,
        arraySize);
}
 
} // namespace framework
} // namespace dw
 
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_INDEX_PARAMETER(TYPE_NAME, args...) dw::framework::describeIndexParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_INDEX_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeIndexParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
 
namespace dw
{
namespace framework
{
 
template <typename T, typename S, typename... MemberPointers>
constexpr auto describeIndexParameter(
    dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, const MemberPointers&&... memberPointers)
{
    return std::make_tuple(
        std::move(typeName),
        std::move(parameterName),
        static_cast<T*>(nullptr),
        static_cast<S*>(nullptr),
        true,
        static_cast<size_t>(0),
        std::move(
            std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)));
}
 
} // namespace framework
} // namespace dw
 
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_ARRAY_PARAMETER(TYPE_NAME, args...) dw::framework::describeArrayParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_ARRAY_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeArrayParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
 
namespace dw
{
namespace framework
{
 
template <typename T, typename S, typename... MemberPointers>
constexpr auto describeArrayParameter(
    dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, size_t arraySize, const MemberPointers&&... memberPointers)
{
    return std::make_tuple(
        std::move(typeName),
        std::move(parameterName),
        static_cast<T*>(nullptr),
        static_cast<S*>(nullptr),
        false,
        arraySize,
        std::move(
            std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)));
}
 
} // namespace framework
} // namespace dw
 
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_UNNAMED_PARAMETER(TYPE_NAME, args...) dw::framework::describeUnnamedParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_UNNAMED_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeUnnamedParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
 
namespace dw
{
namespace framework
{
 
template <typename T, typename S, typename... MemberPointers>
constexpr auto describeUnnamedParameter(
    dw::core::StringView const&& typeName, const MemberPointers&&... memberPointers)
{
    return describeParameter<T, S>(
        std::move(typeName),
        ""_sv,
        std::forward<const MemberPointers>(memberPointers)...);
}
 
} // namespace framework
} // namespace dw
 
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_UNNAMED_ARRAY_PARAMETER(TYPE_NAME, args...) dw::framework::describeUnnamedArrayParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_UNNAMED_ARRAY_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeUnnamedArrayParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
 
namespace dw
{
namespace framework
{
 
template <typename T, typename S, typename... MemberPointers>
constexpr auto describeUnnamedArrayParameter(
    dw::core::StringView const&& typeName, size_t arraySize, const MemberPointers&&... memberPointers)
{
    return describeArrayParameter<T, S>(
        std::move(typeName),
        ""_sv,
        arraySize,
        std::forward<const MemberPointers>(memberPointers)...);
}
 
} // namespace framework
} // namespace dw
 
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_PARAMETER_WITH_DEFAULT(TYPE_NAME, args...) dw::framework::describeParameterWithDefault<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
 
namespace dw
{
namespace framework
{
 
template <typename T, typename S, typename... MemberPointers>
constexpr auto describeParameterWithDefault(
    dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, T defaultValue, const MemberPointers&&... memberPointers)
{
    return std::make_tuple(
        std::move(typeName),
        std::move(parameterName),
        static_cast<T*>(nullptr),
        static_cast<S*>(nullptr),
        false,
        static_cast<size_t>(0),
        std::move(
            std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)),
        std::move(defaultValue));
}
 
} // namespace framework
} // namespace dw
 
// This is the only language feature able to avoid duplicating enumerators as strings
// TODO(dwplc): FP -- Cannot enclose template type in parentheses
// the macro must perform stringification of the type as well as accept an arbitrary number of member pointers
// coverity[autosar_cpp14_a16_0_1_violation]
// coverity[autosar_cpp14_m16_0_6_violation]
// coverity[autosar_cpp14_m16_3_1_violation]
// coverity[autosar_cpp14_m16_3_2_violation]
#define DW_DESCRIBE_ARRAY_PARAMETER_WITH_DEFAULT(TYPE_NAME, args...) dw::framework::describeArrayParameterWithDefault<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
 
namespace dw
{
namespace framework
{
 
template <typename T, typename S, size_t ArraySize, typename... MemberPointers>
constexpr auto describeArrayParameterWithDefault(
    dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, std::array<T, ArraySize> defaultValue, const MemberPointers&&... memberPointers)
{
    return std::make_tuple(
        std::move(typeName),
        std::move(parameterName),
        static_cast<T*>(nullptr),
        static_cast<S*>(nullptr),
        false,
        ArraySize,
        std::move(
            std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)),
        std::move(defaultValue));
}
 
template <typename NodeT>
constexpr auto describeParameters()
{
    return NodeT::describeParameters();
}
 
namespace detail
{
 
template <
    typename Param, typename MemberPtr,
    typename std::enable_if_t<std::tuple_size<Param>() <= PARAMETER_DEFAULT_VALUE, void>* = nullptr>
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a8_4_8_violation]
void populateDefault(const Param& param, MemberPtr& memberPtr)
{
    static_cast<void>(param);
    static_cast<void>(memberPtr);
}
 
template <
    typename Param, typename MemberPtr,
    typename std::enable_if_t<PARAMETER_DEFAULT_VALUE<std::tuple_size<Param>(), void>* = nullptr>
    // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
    // Output parameter is needed to populate member of arbitrary struct
    // coverity[autosar_cpp14_a2_10_5_violation]
    // coverity[autosar_cpp14_a8_4_8_violation]
    void populateDefault(const Param& param, MemberPtr& memberPtr)
{
    auto defaultValue = std::get<PARAMETER_DEFAULT_VALUE>(param);
    memberPtr         = defaultValue;
}
 
template <
    typename Param, typename MemberPtr,
    typename std::enable_if_t<std::tuple_size<Param>() <= PARAMETER_DEFAULT_VALUE, void>* = nullptr>
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a8_4_8_violation]
void populateArrayDefault(const Param& param, MemberPtr& memberPtr, size_t index)
{
    static_cast<void>(param);
    static_cast<void>(memberPtr);
    static_cast<void>(index);
}
 
template <
    typename Param, typename MemberPtr,
    typename std::enable_if_t<PARAMETER_DEFAULT_VALUE<std::tuple_size<Param>(), void>* = nullptr>
    // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
    // Output parameter is needed to populate member of arbitrary struct
    // coverity[autosar_cpp14_a2_10_5_violation]
    // coverity[autosar_cpp14_a8_4_8_violation]
    void populateArrayDefault(const Param& param, MemberPtr& memberPtr, size_t index)
{
    auto defaultValue = std::get<PARAMETER_DEFAULT_VALUE>(param);
    memberPtr[index]  = defaultValue[index];
}
 
template <
    size_t MemberIndex, typename ArgType, typename MemberPtrs,
    typename std::enable_if_t<std::tuple_size<MemberPtrs>() == 0, void>* = nullptr>
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a8_4_8_violation]
auto& getMemberPtr(ArgType& arg, MemberPtrs memberPtrs)
{
    static_cast<void>(memberPtrs);
    return arg;
}
 
template <
    size_t MemberIndex, typename ArgType, typename MemberPtrs,
    typename std::enable_if_t<MemberIndex + 1 == std::tuple_size<MemberPtrs>(), void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
auto& getMemberPtr(ArgType& arg, MemberPtrs memberPtrs)
{
    auto member = std::get<MemberIndex>(memberPtrs);
    return arg.*member;
}
 
template <
    size_t MemberIndex, typename ArgType, typename MemberPtrs,
    typename std::enable_if_t<MemberIndex + 1 < std::tuple_size<MemberPtrs>(), void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
auto& getMemberPtr(ArgType& arg, MemberPtrs memberPtrs)
{
    auto& member = std::get<MemberIndex>(memberPtrs);
    auto& m      = arg.*member;
    return getMemberPtr<MemberIndex + 1>(m, memberPtrs);
}
 
template <typename NodeT, size_t ConstructorParameterIndex>
constexpr size_t constructorArgumentParameterSize()
{
    return dw::core::tuple_size<
        std::tuple_element_t<
            PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR,
            std::tuple_element_t<
                ConstructorParameterIndex,
                decltype(describeParameters<NodeT>())>>>();
}
 
template <
    typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
    typename std::enable_if_t<ParamIndex == constructorArgumentParameterSize<NodeT, ConstructorParameterIndex>(), void>* = nullptr>
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParametersRecursion(const ParameterProvider& provider, ArgType& arg)
{
    static_cast<void>(arg);
    static_cast<void>(provider);
}
 
template <typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex>
constexpr bool isIndexParameter()
{
    constexpr auto param = dw::core::get<ParamIndex>(
        std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
            std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
    return std::get<PARAMETER_IS_INDEX>(param);
}
 
template <typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex>
constexpr bool isArrayParameter()
{
    constexpr auto param = dw::core::get<ParamIndex>(
        std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
            std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
    constexpr size_t arraySize = std::get<
        PARAMETER_ARRAY_SIZE>(param);
    return arraySize > 0;
}
 
template <typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex>
constexpr bool isAbstractParameter()
{
    constexpr auto param = dw::core::get<ParamIndex>(
        std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
            std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
    return std::tuple_size<decltype(param)>() <= PARAMETER_MEMBER_PTRS;
}
 
template <
    typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
    typename std::enable_if_t<isAbstractParameter<NodeT, ConstructorParameterIndex, ParamIndex>(), void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameter(const ParameterProvider& provider, ArgType& arg)
{
    static_cast<void>(arg);
    static_cast<void>(provider);
}
 
template <
    typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
    typename std::enable_if_t<!isAbstractParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && !isArrayParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && !isIndexParameter<NodeT, ConstructorParameterIndex, ParamIndex>(), void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameter(const ParameterProvider& provider, ArgType& arg)
{
    constexpr auto param = dw::core::get<ParamIndex>(
        std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
            std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
 
    using DataType = std::remove_pointer_t<
        std::tuple_element_t<
            PARAMETER_TYPE, decltype(param)>>;
    using SemanticDataType = std::remove_pointer_t<
        std::tuple_element_t<
            PARAMETER_SEMANTIC_TYPE, decltype(param)>>;
 
    DataType& memberPtr = getMemberPtr<0>(arg, std::get<PARAMETER_MEMBER_PTRS>(param));
    bool hadParameter   = provider.getOptional<SemanticDataType, DataType>(std::get<PARAMETER_NAME>(param), &memberPtr);
    if (!hadParameter)
    {
        populateDefault(param, memberPtr);
    }
}
 
template <
    typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
    typename std::enable_if_t<!isAbstractParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && !isArrayParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && isIndexParameter<NodeT, ConstructorParameterIndex, ParamIndex>(), void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameter(const ParameterProvider& provider, ArgType& arg)
{
    constexpr auto param = dw::core::get<ParamIndex>(
        std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
            std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
 
    using DataType = std::remove_pointer_t<
        std::tuple_element_t<
            PARAMETER_TYPE, decltype(param)>>;
    using SemanticDataType = std::remove_pointer_t<
        std::tuple_element_t<
            PARAMETER_SEMANTIC_TYPE, decltype(param)>>;
    DataType& memberPtr = getMemberPtr<0>(arg, std::get<PARAMETER_MEMBER_PTRS>(param));
 
    size_t index      = static_cast<size_t>(-1);
    bool hadParameter = provider.getOptional<size_t, size_t>(std::get<PARAMETER_NAME>(param), &index);
    if (hadParameter)
    {
        hadParameter = provider.getOptional<SemanticDataType, DataType>("", index, &memberPtr);
    }
    if (!hadParameter)
    {
        populateDefault(param, memberPtr);
    }
}
 
template <
    typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
    typename std::enable_if_t<!isAbstractParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && isArrayParameter<NodeT, ConstructorParameterIndex, ParamIndex>(), void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameter(const ParameterProvider& provider, ArgType& arg)
{
    constexpr auto param = dw::core::get<ParamIndex>(
        std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
            std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
 
    using DataType = std::remove_pointer_t<
        std::tuple_element_t<
            PARAMETER_TYPE, decltype(param)>>;
    using SemanticDataType = std::remove_pointer_t<
        std::tuple_element_t<
            PARAMETER_SEMANTIC_TYPE, decltype(param)>>;
 
    constexpr size_t arraySize = std::get<PARAMETER_ARRAY_SIZE>(
        param);
 
    DataType(&memberPtr)[arraySize] = getMemberPtr<0>(arg, std::get<PARAMETER_MEMBER_PTRS>(param));
    for (size_t i = 0; i < arraySize; ++i)
    {
        bool hadParameter = provider.getOptional<SemanticDataType, DataType>(std::get<PARAMETER_NAME>(param), i, &memberPtr[i]);
        if (!hadParameter)
        {
            populateArrayDefault(param, memberPtr, i);
        }
    }
}
 
template <
    typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
    typename std::enable_if_t<ParamIndex<constructorArgumentParameterSize<NodeT, ConstructorParameterIndex>(), void>* = nullptr>
    // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
    // Output parameter is needed to populate member of arbitrary struct
    // coverity[autosar_cpp14_a2_10_5_violation]
    // coverity[autosar_cpp14_a8_4_8_violation]
    void populateParametersRecursion(const ParameterProvider& provider, ArgType& arg)
{
    populateParameter<NodeT, ConstructorParameterIndex, ParamIndex>(provider, arg);
 
    populateParametersRecursion<NodeT, ConstructorParameterIndex, ParamIndex + 1>(provider, arg);
}
 
template <typename NodeT, size_t ConstructorParameterIndex, typename ArgType>
// TODO(dwplc): FP -- The other populateParameters() functions are defined in the parent namespace
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameters(const ParameterProvider& provider, ArgType& arg)
{
    try
    {
        populateParametersRecursion<NodeT, ConstructorParameterIndex, 0>(provider, arg);
    }
    catch (Exception& e)
    {
        throw Exception(e.status(), "Exception while populating parameters of mangled node type ", typeid(NodeT).name(), ": ", e.messageStr());
    }
}
 
} // namespace detail
 
template <
    typename NodeT,
    class ConstructorArguments,
    typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 1, void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
{
    auto& arg0 = std::get<0>(constructorArguments);
    detail::populateParameters<NodeT, 0>(arg0, provider);
}
 
template <
    typename NodeT,
    class ConstructorArguments,
    typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 2, void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
{
    auto& arg0 = std::get<0>(constructorArguments);
    detail::populateParameters<NodeT, 0>(provider, arg0);
    auto& arg1 = std::get<1>(constructorArguments);
    detail::populateParameters<NodeT, 1>(provider, arg1);
}
 
template <
    typename NodeT,
    class ConstructorArguments,
    typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 3, void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
{
    auto& arg0 = std::get<0>(constructorArguments);
    detail::populateParameters<NodeT, 0>(provider, arg0);
    auto& arg1 = std::get<1>(constructorArguments);
    detail::populateParameters<NodeT, 1>(provider, arg1);
    auto& arg2 = std::get<2>(constructorArguments);
    detail::populateParameters<NodeT, 2>(provider, arg2);
}
 
template <
    typename NodeT,
    class ConstructorArguments,
    typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 4, void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
{
    auto& arg0 = std::get<0>(constructorArguments);
    detail::populateParameters<NodeT, 0>(provider, arg0);
    auto& arg1 = std::get<1>(constructorArguments);
    detail::populateParameters<NodeT, 1>(provider, arg1);
    auto& arg2 = std::get<2>(constructorArguments);
    detail::populateParameters<NodeT, 2>(provider, arg2);
    auto& arg3 = std::get<3>(constructorArguments);
    detail::populateParameters<NodeT, 3>(provider, arg3);
}
 
template <
    typename NodeT,
    class ConstructorArguments,
    typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 5, void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// Output parameter is needed to populate member of arbitrary struct
// coverity[autosar_cpp14_a2_10_5_violation]
// coverity[autosar_cpp14_a8_4_8_violation]
void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
{
    auto& arg0 = std::get<0>(constructorArguments);
    detail::populateParameters<NodeT, 0>(provider, arg0);
    auto& arg1 = std::get<1>(constructorArguments);
    detail::populateParameters<NodeT, 1>(provider, arg1);
    auto& arg2 = std::get<2>(constructorArguments);
    detail::populateParameters<NodeT, 2>(provider, arg2);
    auto& arg3 = std::get<3>(constructorArguments);
    detail::populateParameters<NodeT, 3>(provider, arg3);
    auto& arg4 = std::get<4>(constructorArguments);
    detail::populateParameters<NodeT, 4>(provider, arg4);
}
 
namespace detail
{
 
// Get the Number of constructor arguments of the passed node.
template <typename NodeT>
constexpr std::size_t parameterConstructorArgumentSize()
{
    return std::tuple_size<decltype(describeParameters<NodeT>())>::value;
}
 
template <
    typename NodeT, size_t ConstructorArgumentIndex,
    typename std::enable_if_t<ConstructorArgumentIndex == parameterConstructorArgumentSize<NodeT>(), void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// coverity[autosar_cpp14_a2_10_5_violation]
auto createConstructorArguments()
{
    return std::make_tuple();
}
 
template <
    typename NodeT, size_t ConstructorArgumentIndex,
    typename std::enable_if_t<ConstructorArgumentIndex<parameterConstructorArgumentSize<NodeT>(), void>* = nullptr>
    // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
    // coverity[autosar_cpp14_a2_10_5_violation]
    auto createConstructorArguments()
{
    using NodeParams = decltype(describeParameters<NodeT>());
 
    using ConstructorParameter = std::tuple_element_t<ConstructorArgumentIndex, NodeParams>;
    using ArgType              = std::remove_pointer_t<
        typename std::tuple_element_t<PARAMETER_CONSTRUCTOR_ARGUMENT_TYPE, ConstructorParameter>>;
    ArgType arg{};
 
    return std::tuple_cat(std::make_tuple(arg), createConstructorArguments<NodeT, ConstructorArgumentIndex + 1>());
}
 
} // namespace detail
 
template <typename NodeT>
auto createConstructorArguments()
{
    return detail::createConstructorArguments<NodeT, 0>();
}
 
namespace detail
{
 
template <class T, class Tuple, size_t... Is>
// TODO(dwplc): FP -- The other parameterSize() functions are defined in a namespace
// coverity[autosar_cpp14_a2_10_5_violation]
auto makeUniqueFromTuple(const Tuple&& tuple, std::index_sequence<Is...>) -> std::unique_ptr<T>
{
    return std::unique_ptr<T>(new T{std::get<Is>(std::move(tuple))...});
}
}
 
template <typename NodeT, class ConstructorArguments>
auto makeUniqueFromTuple(const ConstructorArguments&& constructorArguments) -> std::unique_ptr<NodeT>
{
    return detail::makeUniqueFromTuple<NodeT>(
        std::move(constructorArguments),
        std::make_index_sequence<std::tuple_size<std::decay_t<ConstructorArguments>>::value>{});
}
 
template <typename NodeT>
auto create(const ParameterProvider& provider) -> std::unique_ptr<NodeT>
{
    auto constructorArguments = createConstructorArguments<NodeT>();
    populateParameters<NodeT>(constructorArguments, provider);
    return makeUniqueFromTuple<NodeT>(std::move(constructorArguments));
}
 
// Number of parameters (sum across all constructor arguments)
namespace detail
{
 
template <
    typename NodeT, size_t ConstructorArgumentIndex,
    typename std::enable_if_t<ConstructorArgumentIndex == parameterConstructorArgumentSize<NodeT>(), void>* = nullptr>
// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
// coverity[autosar_cpp14_a2_10_5_violation]
constexpr std::size_t parameterSize()
{
    return 0;
}
 
template <
    typename NodeT, size_t ConstructorArgumentIndex,
    typename std::enable_if_t<ConstructorArgumentIndex<parameterConstructorArgumentSize<NodeT>(), void>* = nullptr>
    // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
    // coverity[autosar_cpp14_a2_10_5_violation]
    constexpr std::size_t parameterSize()
{
    return constructorArgumentParameterSize<NodeT, ConstructorArgumentIndex>() + parameterSize<NodeT, ConstructorArgumentIndex + 1>();
}
 
} // namespace detail
 
// TODO(dwplc): FP -- The other parameterSize() functions are defined in a namespace
// coverity[autosar_cpp14_a2_10_5_violation]
template <typename NodeT>
constexpr std::size_t parameterSize()
{
    return detail::parameterSize<NodeT, 0>();
}
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_PARAMETERDESCRIPTOR_HPP_