make_unsigned.hpp

Go to the documentation of this file.

// Copyright 2024, Toyota Motor Corporation
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
#ifndef INCLUDE_GUARD_ARENE_BASE_STDLIB_INCLUDE_STDLIB_DETAIL_MAKE_UNSIGNED_HPP_
#define INCLUDE_GUARD_ARENE_BASE_STDLIB_INCLUDE_STDLIB_DETAIL_MAKE_UNSIGNED_HPP_
 
// parasoft-begin-suppress CERT_CPP-DCL58-a-2 "Part of a standard library implementation"
// parasoft-begin-suppress AUTOSAR-A17_6_1-a-2 "Part of a standard library implementation"
 
// IWYU pragma: private, include <type_traits>
// IWYU pragma: friend "stdlib_detail/.*"
 
#include "arene/base/constraints.hpp"
#include "stdlib/include/stdlib_detail/add_const.hpp"
#include "stdlib/include/stdlib_detail/add_volatile.hpp"
#include "stdlib/include/stdlib_detail/conditional.hpp"
#include "stdlib/include/stdlib_detail/cstdint.hpp"
#include "stdlib/include/stdlib_detail/enable_if.hpp"
#include "stdlib/include/stdlib_detail/is_const.hpp"
#include "stdlib/include/stdlib_detail/is_enum.hpp"
#include "stdlib/include/stdlib_detail/is_integral.hpp"
#include "stdlib/include/stdlib_detail/is_same.hpp"
#include "stdlib/include/stdlib_detail/is_signed.hpp"
#include "stdlib/include/stdlib_detail/is_volatile.hpp"
#include "stdlib/include/stdlib_detail/remove_cv.hpp"
 
namespace std {
 
// parasoft-begin-suppress AUTOSAR-A2_7_3-a "False positive: all declarations
// and typedefs *are* preceded by a comment with @brief"
 
namespace make_unsigned_detail {
/// @brief Internal class providing @c std::make_unsigned
/// @tparam Type The type to convert to an unsigned equivalent
// parasoft-begin-suppress AUTOSAR-A11_0_2 "False positive: Not used as a base class here"
template <typename Type, typename = arene::base::constraints<>>
struct make_unsigned {};
// parasoft-end-suppress AUTOSAR-A11_0_2
 
/// @brief Internal class providing @c std::make_unsigned for integral types that are already unsigned
/// @tparam Type The type to convert to an unsigned equivalent
template <typename Type>
struct make_unsigned<
    Type,
    arene::base::constraints<
        enable_if_t<is_integral_v<Type>>,
        enable_if_t<!is_signed_v<Type>>,
        enable_if_t<!is_same_v<Type, bool>>,
        enable_if_t<!is_const_v<Type>>,
        enable_if_t<!is_volatile_v<Type>>>> {
  /// @brief The resulting type
  using type = Type;
};
 
/// @brief Internal class providing @c std::make_unsigned for integral types or enumeration types that are @c const
/// qualified
/// @tparam Type The type to convert to an unsigned equivalent
template <typename Type>
struct make_unsigned<
    Type,
    arene::base::constraints<
        enable_if_t<is_integral_v<Type> || is_enum_v<Type>>,
        enable_if_t<is_const_v<Type>>,
        enable_if_t<!is_volatile_v<Type>>>> {
  /// @brief The resulting type
  using type = add_const_t<typename make_unsigned<remove_cv_t<Type>>::type>;
};
 
/// @brief Internal class providing @c std::make_unsigned for integral types or enumeration types that are @c volatile
/// qualified
/// @tparam Type The type to convert to an unsigned equivalent
template <typename Type>
struct make_unsigned<
    Type,
    arene::base::constraints<
        enable_if_t<is_integral_v<Type> || is_enum_v<Type>>,
        enable_if_t<is_volatile_v<Type>>,
        enable_if_t<!is_const_v<Type>>>> {
  /// @brief The resulting type
  using type = add_volatile_t<typename make_unsigned<remove_cv_t<Type>>::type>;
};
 
/// @brief Internal class providing @c std::make_unsigned for integral types or enumeration types that are @c const
/// and @c volatile qualified
/// @tparam Type The type to convert to an unsigned equivalent
template <typename Type>
struct make_unsigned<
    Type,
    arene::base::constraints<
        enable_if_t<is_integral_v<Type> || is_enum_v<Type>>,
        enable_if_t<is_const_v<Type>>,
        enable_if_t<is_volatile_v<Type>>>> {
  /// @brief The resulting type
  using type = add_const_t<add_volatile_t<typename make_unsigned<remove_cv_t<Type>>::type>>;
};
 
// parasoft-begin-suppress AUTOSAR-A3_9_1-b-2 "The built-in types must be handled explicitly here for correctness"
/// @brief Internal class providing @c std::make_unsigned for @c signed char
template <>
struct make_unsigned<signed char> {
  /// @brief The resulting type
  using type = unsigned char;
};
 
/// @brief Internal class providing @c std::make_unsigned for @c short
template <>
// NOLINTNEXTLINE(google-runtime-int)
struct make_unsigned<short> {
  /// @brief The resulting type
  // NOLINTNEXTLINE(google-runtime-int)
  using type = unsigned short;
};
 
/// @brief Internal class providing @c std::make_unsigned for @c int
template <>
struct make_unsigned<int> {
  /// @brief The resulting type
  using type = unsigned;
};
 
/// @brief Internal class providing @c std::make_unsigned for @c long
template <>
// NOLINTNEXTLINE(google-runtime-int)
struct make_unsigned<long> {
  /// @brief The resulting type
  // NOLINTNEXTLINE(google-runtime-int)
  using type = unsigned long;
};
 
/// @brief Internal class providing @c std::make_unsigned for @c long @c long
template <>
// NOLINTNEXTLINE(google-runtime-int)
struct make_unsigned<long long> {
  /// @brief The resulting type
  // NOLINTNEXTLINE(google-runtime-int)
  using type = unsigned long long;
};
 
/// @brief Internal class providing @c std::make_unsigned for @c char
template <>
struct make_unsigned<char> {
  /// @brief The resulting type
  // NOLINTNEXTLINE(google-runtime-int)
  using type = conditional_t<is_signed_v<char>, unsigned char, char>;
};
 
/// @brief Internal class providing an unsigned type with a specified size
/// @tparam Size the size to check
template <size_t Size, typename = arene::base::constraints<>>
struct sized_unsigned {};
 
/// @brief Internal class providing an unsigned type with the size of @c char
/// @tparam Size the size to check
template <size_t Size>
struct sized_unsigned<Size, arene::base::constraints<enable_if_t<Size == sizeof(char)>>> {
  /// @brief The resulting type
  using type = unsigned char;
};
 
/// @brief Internal class providing an unsigned type with the size of @c short
/// @tparam Size the size to check
template <size_t Size>
// NOLINTNEXTLINE(google-runtime-int)
struct sized_unsigned<Size, arene::base::constraints<enable_if_t<Size == sizeof(short)>>> {
  /// @brief The resulting type
  // NOLINTNEXTLINE(google-runtime-int)
  using type = unsigned short;
};
 
/// @brief Internal class providing an unsigned type with the size of @c int
/// @tparam Size the size to check
template <size_t Size>
struct sized_unsigned<
    Size,
    // NOLINTNEXTLINE(google-runtime-int)
    arene::base::constraints<enable_if_t<(Size > sizeof(short))>, enable_if_t<Size == sizeof(int)>>> {
  /// @brief The resulting type
  using type = unsigned;
};
 
/// @brief Internal class providing an unsigned type with the size of @c long
/// @tparam Size the size to check
template <size_t Size>
struct sized_unsigned<
    Size,
    // NOLINTNEXTLINE(google-runtime-int)
    arene::base::constraints<enable_if_t<(Size > sizeof(int))>, enable_if_t<Size == sizeof(long)>>> {
  /// @brief The resulting type
  // NOLINTNEXTLINE(google-runtime-int)
  using type = unsigned long;
};
 
/// @brief Internal class providing an unsigned type with the size of @c long long
/// @tparam Size the size to check
template <size_t Size>
struct sized_unsigned<
    Size,
    // NOLINTNEXTLINE(google-runtime-int)
    arene::base::constraints<enable_if_t<(Size > sizeof(long))>, enable_if_t<Size == sizeof(long long)>>> {
  /// @brief The resulting type
  // NOLINTNEXTLINE(google-runtime-int)
  using type = unsigned long long;
};
// parasoft-end-suppress AUTOSAR-A3_9_1-b-2
 
// parasoft-begin-suppress AUTOSAR-A2_13_3-a-2 "wchar_t must be used here to ensure correctness"
/// @brief Internal class providing an unsigned type for @c wchar_t
template <>
struct make_unsigned<wchar_t> {
  /// @brief The resulting type
  // NOLINTNEXTLINE(google-runtime-int)
  using type = typename sized_unsigned<sizeof(wchar_t)>::type;
};
// parasoft-end-suppress AUTOSAR-A2_13_3-a-2
 
/// @brief Internal class providing an unsigned type for @c char16_t
template <>
struct make_unsigned<char16_t> {
  /// @brief The resulting type
  using type = typename sized_unsigned<sizeof(char16_t)>::type;
};
 
/// @brief Internal class providing an unsigned type for @c char32_t
template <>
struct make_unsigned<char32_t> {
  /// @brief The resulting type
  using type = typename sized_unsigned<sizeof(char32_t)>::type;
};
 
/// @brief Internal class providing @c std::make_unsigned for integral types that are already unsigned
/// @tparam Type The type to convert to an unsigned equivalent
template <typename Type>
struct make_unsigned<
    Type,
    arene::base::
        constraints<enable_if_t<is_enum_v<Type>>, enable_if_t<!is_const_v<Type>>, enable_if_t<!is_volatile_v<Type>>>> {
  /// @brief The resulting type
  using type = typename sized_unsigned<sizeof(Type)>::type;
};
 
}  // namespace make_unsigned_detail
 
/// @brief A type trait to provide the equivalent unsigned type for integral and enumeration types other than @c bool
/// @tparam Type The type to get the equivalent of
template <typename Type>
using make_unsigned = make_unsigned_detail::make_unsigned<Type>;
 
/// @brief A type alias for the equivalent unsigned type for integral and enumeration types other than @c bool
/// @tparam Type The type to get the equivalent of
template <typename Type>
using make_unsigned_t = typename make_unsigned<Type>::type;
 
// parasoft-end-suppress AUTOSAR-A2_7_3-a
 
}  // namespace std
 
#endif  // INCLUDE_GUARD_ARENE_BASE_STDLIB_INCLUDE_STDLIB_DETAIL_MAKE_UNSIGNED_HPP_