c++20/exercise-2-4.hpp

Go to the documentation of this file.

// ===-- chapter-2/c++20/exercise-2-4.hpp ----------------- -*- C++ -*- --=== //
#ifndef EXERCISE_2_4
#define EXERCISE_2_4
 
#include <iostream>
#include <string>
 
 
namespace exercise_2_4 {
 
inline namespace cpp20 {
 
template <typename T> struct type_descriptor { };
 
template <typename T> consteval T *error_unhandled_type() { return nullptr; }
 
template <typename T>
std::ostream& operator<<(std::ostream& os, type_descriptor<T> const&)
{
    // Non-leaf data-types:
 
    if constexpr (std::is_const<T>::value) {
        return os << type_descriptor<typename std::remove_const<T>::type>()
                  << " const";
    } else if constexpr (std::is_lvalue_reference<T>::value) {
        return os << type_descriptor<typename std::remove_reference<T>::type>()
                  << '&';
    } else if constexpr (std::is_pointer<T>::value) {
        using PointedT = typename std::remove_pointer<T>::type;
        if constexpr (std::is_function<PointedT>::value) {
            return os << type_descriptor<
                             typename std::invoke_result<PointedT>::type>()
                      << "(*)()";
        } else {
            return os << type_descriptor<PointedT>() << '*';
        }
    } else if constexpr (std::is_array<T>::value) {
        if constexpr (std::is_bounded_array<T>::value) {
            return os << type_descriptor<typename std::remove_extent<T>::type>()
                      << '[' << std::extent<T>::value << ']';
        } else {
            return os << type_descriptor<
                typename std::remove_extent<T>::type>() << "[]";
        }
    } else if constexpr (std::is_function<T>::value) {
        return os << type_descriptor<typename std::invoke_result<T>::type>()
                  << "()";
    } else if constexpr (std::is_fundamental<T>::value) {
        // Leaf data-types:
 
        if constexpr (std::is_integral<T>::value) {
            // NOTE: This "unsigned" is a three line change with if-constexpr,
            // but with template specialization, it requires doubling the count
            // of integral type specializations!
            if constexpr (std::is_unsigned<T>::value) {
                os << "unsigned ";
            }
 
            if constexpr (sizeof(T) == 1) { return os << "char"; }
            else if constexpr (sizeof(T) == 2) { return os << "short int"; }
            else if constexpr (sizeof(T) == 4) { return os << "int"; }
            else if constexpr (sizeof(T) == 8) { return os << "long int"; }
            else return error_unhandled_type<T>();
        } else {
            return error_unhandled_type<T>();
        }
    } else {
        return error_unhandled_type<T>();
    }
}
 
} // inline namespace cpp20
} // namespace exercise_2_4
 
#endif // EXERCISE_2_4