simple_type_traits.h

Go to the documentation of this file.

#ifndef SIMPLE_TYPE_TRAITS_HPP
#define SIMPLE_TYPE_TRAITS_HPP
 
template <typename T>
struct is_pod
{
    static constexpr bool value = false;
};
 
// clang-format off
template <> struct is_pod<char>           { static constexpr bool value = true; };
template <> struct is_pod<unsigned char>  { static constexpr bool value = true; };
template <> struct is_pod<short>          { static constexpr bool value = true; };
template <> struct is_pod<unsigned short> { static constexpr bool value = true; };
template <> struct is_pod<int>            { static constexpr bool value = true; };
template <> struct is_pod<unsigned int>   { static constexpr bool value = true; };
template <> struct is_pod<long>           { static constexpr bool value = true; };
template <> struct is_pod<unsigned long>  { static constexpr bool value = true; };
template <> struct is_pod<float>          { static constexpr bool value = true; };
template <> struct is_pod<double>         { static constexpr bool value = true; };
// clang-format on
 
template <typename T>
inline constexpr bool is_pod_v = is_pod<T>::value;
 
template <typename T>
struct is_floating_point
{
    static constexpr bool value = false;
};
 
// clang-format off
template <> struct is_floating_point<float>  { static constexpr bool value = true; };
template <> struct is_floating_point<double> { static constexpr bool value = true; };
// clang-format on
 
template <typename T>
inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
 
template <typename A, typename B>
struct is_same
{
    static constexpr bool value = false;
};
 
template <typename T>
struct is_same<T, T>
{
    static constexpr bool value = true;
};
 
template <typename A, typename B>
inline constexpr bool is_same_v = is_same<A, B>::value;
 
template <typename T>
struct remove_reference
{
    using type = T;
};
 
template <typename T>
struct remove_reference<T &>
{
    using type = T;
};
 
template <typename T>
struct remove_reference<T &&>
{
    using type = T;
};
 
template <typename T>
using remove_reference_t = typename remove_reference<T>::type;
 
template <typename T>
struct remove_cv
{
    using type = T;
};
 
template <typename T>
struct remove_cv<const T>
{
    using type = T;
};
 
template <typename T>
struct remove_cv<volatile T>
{
    using type = T;
};
 
template <typename T>
struct remove_cv<const volatile T>
{
    using type = T;
};
 
template <typename T>
using remove_cv_t = typename remove_cv<T>::type;
 
template <typename T>
struct remove_cvref
{
    using type = remove_cv_t<remove_reference_t<T>>;
};
 
template <typename T>
using remove_cvref_t = typename remove_cvref<T>::type;
 
template <typename T>
[[nodiscard]] constexpr remove_reference_t<T> &&move(T &&t) noexcept
{
    return static_cast<remove_reference_t<T> &&>(t);
}
 
template <typename T>
constexpr T &&forward(remove_reference_t<T> &t) noexcept
{
    return static_cast<T &&>(t);
}
 
template <typename T>
constexpr T &&forward(remove_reference_t<T> &&t) noexcept
{
    return static_cast<T &&>(t);
}
 
template <typename Base, typename Derived>
struct is_base_of
{
#if defined(__has_builtin) && __has_builtin(__is_base_of)
    static constexpr bool value = __is_base_of(Base, Derived);
#elif defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)
    static constexpr bool value = __is_base_of(Base, Derived);
#else
    // Fallback implementation (not fully standards-compliant)
    static constexpr bool value = detail::is_base_of_impl<Base, Derived>::value;
#endif
};
 
template <typename Base, typename Derived>
inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
 
namespace detail
{
 
    template <typename Base, typename Derived>
    struct is_base_of_impl
    {
    private:
        static constexpr bool check(Base *) { return true; }
        static constexpr bool check(...) { return false; }
 
    public:
        static constexpr bool value = check(static_cast<Derived *>(nullptr));
    };
 
} // namespace detail
 
template <typename T>
struct is_trivially_destructible
{
    static constexpr bool value = __has_trivial_destructor(T);
};
 
template <typename T>
inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
 
template <typename T>
struct is_nothrow_move_constructible
{
    static constexpr bool value = __is_nothrow_constructible(T, T &&);
};
 
template <typename T>
inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<T>::value;
 
#if defined(__STDC_HOSTED__) && __STDC_HOSTED__ == 0
inline void *operator new(decltype(sizeof(0)), void *ptr) noexcept { return ptr; }
#else
#include <new>
#endif
 
#endif // SIMPLE_TYPE_TRAITS_HPP