TypeTraits.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2019 - 2023.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SIMPLE_UTILITY_TYPE_TRAITS_HPP
#define SIMPLE_UTILITY_TYPE_TRAITS_HPP
 
#include <type_traits>
 
#include "Simple-Utility/concepts/stl_extensions.hpp"
 
namespace sl
{
    template <class T>
    struct cv_qualified_type
    {
        using type = T;
    };
 
    template <class T>
    using cv_qualified_type_t = typename cv_qualified_type<T>::type;
 
    template <concepts::reference T>
    struct cv_qualified_type<T>
    {
        using type = cv_qualified_type_t<std::remove_reference_t<T>>;
    };
 
    template <concepts::pointer T>
    struct cv_qualified_type<T>
    {
        using type = cv_qualified_type_t<std::remove_pointer_t<T>>;
    };
 
    template <class T>
    struct add_type_const
    {
        using type = const T;
    };
 
    template <class T>
    using add_type_const_t = typename add_type_const<T>::type;
 
    template <class T>
    struct add_type_const<T&>
    {
        using type = add_type_const_t<T>&;
    };
 
    template <class T>
    struct add_type_const<T&&>
    {
        using type = add_type_const_t<T>&&;
    };
 
    template <class T>
    struct add_type_const<T*>
    {
        using type = add_type_const_t<T>*;
    };
 
    template <class T>
    struct add_type_const<T* volatile>
    {
        using type = add_type_const_t<T>* volatile;
    };
 
    template <class T>
    struct add_type_const<T* const>
    {
        using type = add_type_const_t<T>* const;
    };
 
    template <class T>
    struct add_type_const<T* const volatile>
    {
        using type = add_type_const_t<T>* const volatile;
    };
 
    template <class T>
    struct remove_type_const
    {
        using type = std::remove_const_t<T>;
    };
 
    template <class T>
    using remove_type_const_t = typename remove_type_const<T>::type;
 
    template <class T>
    struct remove_type_const<T&>
    {
        using type = remove_type_const_t<T>&;
    };
 
    template <class T>
    struct remove_type_const<T&&>
    {
        using type = remove_type_const_t<T>&&;
    };
 
    template <class T>
    struct remove_type_const<T*>
    {
        using type = remove_type_const_t<T>*;
    };
 
    template <class T>
    struct remove_type_const<T* volatile>
    {
        using type = remove_type_const_t<T>* volatile;
    };
 
    template <class T>
    struct remove_type_const<T* const>
    {
        using type = remove_type_const_t<T>* const;
    };
 
    template <class T>
    struct remove_type_const<T* const volatile>
    {
        using type = remove_type_const_t<T>* const volatile;
    };
 
    template <class T>
    struct add_type_volatile
    {
        using type = volatile T;
    };
 
    template <class T>
    using add_type_volatile_t = typename add_type_volatile<T>::type;
 
    template <class T>
    struct add_type_volatile<T&>
    {
        using type = add_type_volatile_t<T>&;
    };
 
    template <class T>
    struct add_type_volatile<T&&>
    {
        using type = add_type_volatile_t<T>&&;
    };
 
    template <class T>
    struct add_type_volatile<T*>
    {
        using type = add_type_volatile_t<T>*;
    };
 
    template <class T>
    struct add_type_volatile<T* volatile>
    {
        using type = add_type_volatile_t<T>* volatile;
    };
 
    template <class T>
    struct add_type_volatile<T* const>
    {
        using type = add_type_volatile_t<T>* const;
    };
 
    template <class T>
    struct add_type_volatile<T* const volatile>
    {
        using type = add_type_volatile_t<T>* const volatile;
    };
 
    template <class T>
    struct remove_type_volatile
    {
        using type = std::remove_volatile_t<T>;
    };
 
    template <class T>
    using remove_type_volatile_t = typename remove_type_volatile<T>::type;
 
    template <class T>
    struct remove_type_volatile<T&>
    {
        using type = remove_type_volatile_t<T>&;
    };
 
    template <class T>
    struct remove_type_volatile<T&&>
    {
        using type = remove_type_volatile_t<T>&&;
    };
 
    template <class T>
    struct remove_type_volatile<T*>
    {
        using type = remove_type_volatile_t<T>*;
    };
 
    template <class T>
    struct remove_type_volatile<T* volatile>
    {
        using type = remove_type_volatile_t<T>* volatile;
    };
 
    template <class T>
    struct remove_type_volatile<T* const>
    {
        using type = remove_type_volatile_t<T>* const;
    };
 
    template <class T>
    struct remove_type_volatile<T* const volatile>
    {
        using type = remove_type_volatile_t<T>* const volatile;
    };
 
    template <class T>
    struct add_type_cv
    {
        using type = add_type_const_t<add_type_volatile_t<T>>;
    };
 
    template <class T>
    using add_type_cv_t = typename add_type_cv<T>::type;
 
    template <class T>
    struct remove_type_cv
    {
        using type = remove_type_const_t<remove_type_volatile_t<T>>;
    };
 
    template <class T>
    using remove_type_cv_t = typename remove_type_cv<T>::type;
 
    template <class To, class From>
    struct value_category_as
    {
        using type = std::remove_reference_t<To>;
    };
 
    template <class To, class From>
    struct value_category_as<To, From&>
    {
        using type = std::add_lvalue_reference_t<To>;
    };
 
    template <class To, class From>
    struct value_category_as<To, From&&>
    {
        using type = std::add_rvalue_reference_t<std::remove_reference_t<To>>;
    };
 
    template <class To, class From>
    using value_category_as_t = typename value_category_as<To, From>::type;
 
    template <class To, class From>
    struct type_constness_as
    {
        using type = std::conditional_t<
            std::is_const_v<cv_qualified_type_t<From>>,
            add_type_const_t<To>,
            remove_type_const_t<To>>;
    };
 
    template <class To, class From>
    using type_constness_as_t = typename type_constness_as<To, From>::type;
 
    template <class To, class From>
    struct type_volatileness_as
    {
        using type = std::conditional_t<
            std::is_volatile_v<cv_qualified_type_t<From>>,
            add_type_volatile_t<To>,
            remove_type_volatile_t<To>>;
    };
 
    template <class To, class From>
    using type_volatileness_as_t = typename type_volatileness_as<To, From>::type;
 
    template <class To, class From>
    struct type_qualification_as
    {
        using type = type_constness_as_t<
            type_volatileness_as_t<To, From>,
            From>;
    };
 
    template <class To, class From>
    using type_qualification_as_t = typename type_qualification_as<To, From>::type;
 
    template <class To, class From>
    struct qualified_category_as
    {
        using type = value_category_as_t<
            type_qualification_as_t<To, From>,
            From>;
    };
 
    template <class To, class From>
    using qualified_category_as_t = typename qualified_category_as<To, From>::type;
 
}
 
#endif