ParameterProvider.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_PARAMETERPROVIDER_HPP_
#define DW_FRAMEWORK_PARAMETERPROVIDER_HPP_

#include <dwcgf/enum/EnumDescriptor.hpp>

#include <dwcgf/Exception.hpp>

#include <dw/core/container/StringView.hpp>

#include <cstdint>
#include <string>
#include <typeinfo>
#include <vector>

namespace dw
{
namespace framework
{

class ParameterProvider
{
protected:
    ParameterProvider(ParameterProvider const&) = default;
    ParameterProvider(ParameterProvider&&) = default;
    ParameterProvider& operator=(ParameterProvider const&) = default;
    ParameterProvider& operator=(ParameterProvider&&) = default;

public:
    ParameterProvider() = default;
    virtual ~ParameterProvider() = default;

    template <typename T>
    void getRequired(dw::core::StringView const& key, T* out) const
    {
        if (!getOptional(key, out))
        {
            throw Exception(DW_NOT_AVAILABLE, "Required parameter not available: ", key);
        }
    }

    template <typename T>
    void getRequired(dw::core::StringView const& key, size_t const index, T* out) const
    {
        if (!getOptional(key, index, out))
        {
            throw Exception(DW_NOT_AVAILABLE, "Required parameter not available: ", key);
        }
    }

    template <typename T>
    bool getOptional(dw::core::StringView const& key, T* out) const
    {
        try
        {
            return get(key, out);
        }
        catch (Exception& e)
        {
            throw Exception(e.status(), "Failed to get parameter by name: ", key, " - ", e.messageStr());
        }
    }

    template <typename T>
    bool getOptional(dw::core::StringView const& key, size_t const index, T* out) const
    {
        try
        {
            return get(key, index, out);
        }
        catch (Exception& e)
        {
            throw Exception(e.status(), "Failed to get parameter by name and index: ", key, "[", index, "] - ", e.messageStr());
        }
    }

    template <
        typename T,
        typename std::enable_if_t<
            !std::is_array<T>::value &&
            !std::is_enum<T>::value>* = nullptr>
    bool get(dw::core::StringView const& key, T* out) const
    {
        return get(this, key, typeid(T), typeid(T), out);
    }

    template <
        typename T,
        typename std::enable_if_t<
            !std::is_array<T>::value &&
            !std::is_enum<T>::value>* = nullptr>
    bool get(dw::core::StringView const& key, size_t const index, T* out) const
    {
        return get(this, key, index, typeid(T), typeid(T), out);
    }

    template <
        typename T,
        typename std::enable_if_t<
            !std::is_array<T>::value &&
            !std::is_enum<T>::value>* = nullptr>
    bool get(dw::core::StringView const& key, std::vector<T>* out) const
    {
        return get(this, key, typeid(std::vector<T>), typeid(std::vector<T>), out);
    }

    template <
        typename T,
        typename std::enable_if_t<
            std::is_array<T>::value &&
            std::rank<T>::value == 1 &&
            !std::is_enum<std::remove_extent_t<T>>::value>* = nullptr>
    bool get(dw::core::StringView const& key, T* out) const
    {
        static_assert(std::extent<T>::value > 0, "Array must have size greater zero");
        using TElement = typename std::remove_extent_t<T>;
        std::vector<TElement> value;
        if (!get(key, &value))
        {
            return false;
        }

        constexpr size_t size = sizeof(T) / sizeof(TElement);
        if (value.size() != size)
        {
            throw Exception(DW_FAILURE, "Array sizes don't match");
        }

        TElement* element = &(*out[0]);
        for (size_t i = 0; i < size; ++i)
        {
            *(element + i) = value[i];
        }
        return true;
    }

    template <
        typename T,
        typename std::enable_if_t<
            std::is_array<T>::value &&
            std::rank<T>::value == 1 &&
            std::is_same<T, char8_t>::value>* = nullptr>
    bool get(dw::core::StringView const& key, T* out) const
    {
        static_assert(std::extent<T>::value > 0, "Array must have size greater zero");
        std::string value;
        if (!get(key, &value))
        {
            return false;
        }

        if (value.size() >= std::extent<T, 0>::value)
        {
            throw Exception(DW_FAILURE, "Array sizes don't match");
        }

        out[0] = '\n';
        strncat(out, value.c_str(), value.size());
        return true;
    }

    template <
        typename T,
        typename std::enable_if_t<
            std::is_array<T>::value && std::rank<T>::value == 2 &&
            !std::is_enum<std::remove_all_extents_t<T>>::value>* = nullptr>
    bool get(dw::core::StringView const& key, T* out) const
    {
        static_assert(std::extent<T, 0>::value > 0, "Array must have 1st dimension size greater zero");
        static_assert(std::extent<T, 1>::value > 0, "Array must have 2nd dimension size greater zero");
        using TElement = typename std::remove_all_extents_t<T>;
        std::vector<TElement> value;
        if (!get(key, &value))
        {
            return false;
        }

        constexpr size_t size = sizeof(T) / sizeof(TElement);
        if (value.size() != size)
        {
            throw Exception(DW_FAILURE, "Array sizes don't match");
        }

        TElement* element = &(out[0][0]);
        for (size_t i = 0; i < size; ++i)
        {
            *(element + i) = value[i];
        }
        return true;
    }

    template <typename S, typename T>
    void getRequired(dw::core::StringView const& key, T* out) const
    {
        if (!getOptional<S, T>(key, out))
        {
            throw Exception(DW_NOT_AVAILABLE, "Required parameter not available: ", key);
        }
    }

    template <typename S, typename T>
    void getRequired(dw::core::StringView const& key, size_t const index, T* out) const
    {
        if (!getOptional<S, T>(key, index, out))
        {
            throw Exception(DW_NOT_AVAILABLE, "Required parameter not available: ", key);
        }
    }

    template <typename S, typename T>
    bool getOptional(dw::core::StringView const& key, T* out) const
    {
        try
        {
            return get<S, T>(key, out);
        }
        catch (Exception& e)
        {
            if (key.empty())
            {
                throw Exception(e.status(), "Failed to get unnamed parameter with mangled semantic type: ", typeid(S).name(), " - ", e.messageStr());
            }
            else
            {
                throw Exception(e.status(), "Failed to get parameter with semantic by name: ", key, " - ", e.messageStr());
            }
        }
    }

    template <typename S, typename T>
    bool getOptional(dw::core::StringView const& key, size_t const index, T* out) const
    {
        try
        {
            return get<S, T>(key, index, out);
        }
        catch (Exception& e)
        {
            if (key.empty())
            {
                throw Exception(e.status(), "Failed to get unnamed parameter with mangled semantic type and index: ", typeid(S).name(), " ", index, " - ", e.messageStr());
            }
            else
            {
                throw Exception(e.status(), "Failed to get parameter with semantic by name and index: ", key, " ", index, " - ", e.messageStr());
            }
        }
    }

    template <
        typename S, typename T,
        std::enable_if_t<!std::is_enum<T>::value>* = nullptr>
    bool get(dw::core::StringView const& key, T* out) const
    {
        static_assert(!std::is_same<T, dw::core::StringView>::value, "T shouldn't be a dw::core::StringView, use FixedString<N> instead");

        // TODO(dirkt) to be commented in once all usage has been removed
        // coverity[autosar_cpp14_a2_7_2_violation]
        // static_assert(!std::is_same<T, std::string>::value, "T shouldn't be a std::string, use FixedString<N> instead");

        // as long as the parameter provider makes sure that the const char* is valid throughout the life time of the parameter struct this is fine
        // atm this is only used by custom parameter providers which provides values from a static singleton
        // static_assert(!std::is_same<T, const char*>::value, "T shouldn't be a C-style string, use FixedString<N> instead");

        return get(this, key, typeid(S), typeid(T), out);
    }

    template <
        typename S, typename T, size_t N,
        std::enable_if_t<std::is_same<T, dw::core::FixedString<N>>::value>* = nullptr>
    bool get(dw::core::StringView const& key, dw::core::FixedString<N>* out) const
    {
        dw::core::StringView str;
        const auto& semanticTypeInfo = std::is_same<S, dw::core::FixedString<N>>::value ? typeid(dw::core::StringView) : typeid(S);
        bool success                 = get(this, key, semanticTypeInfo, typeid(dw::core::StringView), &str);
        if (success)
        {
            if (N <= str.size())
            {
                throw Exception(DW_BUFFER_FULL, "The FixedString parameter '", key, "' has a maximum capacity of N=", N, " but the value has a length of ", str.size() + 1, "(including trailing \\0)");
            }
            out->copyFrom(str.data(), str.size());
        }
        return success;
    }

    template <
        typename S, typename T,
        std::enable_if_t<std::is_enum<T>::value>* = nullptr>
    bool get(dw::core::StringView const& key, T* out) const
    {
        // get enum parameter from semantic parameter when key is empty
        if (key.empty())
        {
            return get(this, key, typeid(S), typeid(T), out);
        }

        dw::core::StringView str;
        if (!get(this, key, typeid(dw::core::StringView), typeid(dw::core::StringView), &str))
        {
            return false;
        }
        try
        {
            *out = mapEnumNameToValue<T>(str);
            return true;
        }
        catch (Exception& e)
        {
            throw Exception(e.status(), "Failed to map enum name '", str, "' for parameter '", key, "' to numeric value: ", e.messageStr());
        }
    }

    template <
        typename S, typename T,
        std::enable_if_t<!std::is_enum<T>::value>* = nullptr>
    bool get(dw::core::StringView const& key, size_t const index, T* out) const
    {
        return get(this, key, index, typeid(S), typeid(T), out);
    }

    template <
        typename S, typename T, size_t N,
        std::enable_if_t<std::is_same<T, dw::core::FixedString<N>>::value>* = nullptr>
    bool get(dw::core::StringView const& key, size_t const index, dw::core::FixedString<N>* out) const
    {
        dw::core::StringView str;
        const auto& semanticTypeInfo = std::is_same<S, dw::core::FixedString<N>>::value ? typeid(dw::core::StringView) : typeid(S);
        bool success                 = get(this, key, index, semanticTypeInfo, typeid(dw::core::StringView), &str);
        if (success)
        {
            if (N <= str.size())
            {
                throw Exception(DW_BUFFER_FULL, "The FixedString parameter '", key, "' and index ", index, " has a maximum capacity of N=", N, " but the value has a length of ", str.size() + 1, "(including trailing \\0)");
            }
            out->copyFrom(str.data(), str.size());
        }
        return success;
    }

    template <
        typename S, typename T,
        std::enable_if_t<std::is_enum<T>::value>* = nullptr>
    bool get(dw::core::StringView const& key, size_t const index, T* out) const
    {
        // get enum parameter from semantic parameter when key is empty
        if (key.empty())
        {
            return get(this, key, index, typeid(S), typeid(T), out);
        }

        dw::core::StringView str;
        if (!get(this, key, index, typeid(dw::core::StringView), typeid(dw::core::StringView), &str))
        {
            return false;
        }
        try
        {
            *out = mapEnumNameToValue<T>(str);
            return true;
        }
        catch (Exception& e)
        {
            throw Exception(e.status(), "Failed to map enum name '", str, "' for parameter '", key, "' and index ", index, " to numeric value: ", e.messageStr());
        }
    }

    virtual bool get(
        ParameterProvider const* const parentProvider,
        dw::core::StringView const& key,
        const std::type_info& semanticTypeInfo,
        const std::type_info& dataTypeInfo,
        void* out) const = 0;

    virtual bool get(
        ParameterProvider const* const parentProvider,
        dw::core::StringView const& key, size_t const index,
        const std::type_info& semanticTypeInfo,
        const std::type_info& dataTypeInfo,
        void* out) const = 0;
};

} // namespace framework
} // namespace dw

#endif // DW_FRAMEWORK_PARAMETERPROVIDER_HPP_