EnumDescriptor.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_ENUMDESCRIPTOR_HPP_
#define DW_FRAMEWORK_ENUMDESCRIPTOR_HPP_
 
#include <dw/core/base/Status.h>
#include <dw/core/container/StringView.hpp>
 
#include <dwcgf/Exception.hpp>
 
#include <array>
#include <utility>
#include <type_traits>
 
#define DW_ENUMERATOR_NAME_STRING_VIEW(NAME_STR) NAME_STR##_sv
#define DW_DESCRIBE_ENUMERATOR(NAME) describeEnumerator(DW_ENUMERATOR_NAME_STRING_VIEW(#NAME), EnumT::NAME)
#define DW_DESCRIBE_C_ENUMERATOR(NAME) describeEnumerator(DW_ENUMERATOR_NAME_STRING_VIEW(#NAME), (NAME))
 
namespace dw
{
namespace framework
{
 
// API to declare the mapping of a concrete enum.
 
template <typename EnumT>
struct EnumDescription
{
    static_assert(std::is_enum<EnumT>::value, "EnumT must be an enumeration type");
 
    // coverity[autosar_cpp14_a2_10_5_violation]
    static constexpr auto get()
    {
        static_assert(sizeof(EnumT) == 0, "Needs specialization for specific enum type");
        constexpr const size_t numberOfEnumerators = 0;
        std::array<std::pair<dw::core::StringView, EnumT>, numberOfEnumerators> ret;
        return ret;
    }
};
 
// API needed to declare the enumerators of an enum.
 
template <typename EnumT, typename... Args>
constexpr auto describeEnumeratorCollection(Args const&&... args)
{
    return std::array<std::pair<dw::core::StringView, EnumT>, sizeof...(Args)>{std::forward<const Args>(args)...};
}
 
template <typename EnumT>
constexpr auto describeEnumerator(dw::core::StringView const&& name, EnumT value)
{
    return std::make_pair(std::move(name), value);
}
 
template <typename EnumT>
auto mapEnumNameToValue(dw::core::StringView const& name) -> EnumT
{
    const auto pairs = EnumDescription<EnumT>::get();
    for (const auto& pair : pairs)
    {
        if (pair.first == name)
        {
            return pair.second;
        }
    }
    FixedString<4096> validNames{};
    for (const auto& pair : pairs)
    {
        validNames << " " << pair.first;
    }
    throw ExceptionWithStatus(DW_INVALID_ARGUMENT, "Invalid enumerator name '", name, "' for enum type ", typeid(EnumT).name(), ", valid names:", validNames);
}
 
template <typename EnumT>
dw::core::StringView mapEnumValueToName(EnumT value)
{
    const auto pairs = EnumDescription<EnumT>::get();
    for (const auto& pair : pairs)
    {
        if (pair.second == value)
        {
            return pair.first;
        }
    }
    throw ExceptionWithStatus(DW_INVALID_ARGUMENT, "The enumerator value is invalid: ", typeid(EnumT).name(), " ", static_cast<std::underlying_type_t<EnumT>>(value));
}
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_ENUMDESCRIPTOR_HPP_