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

Go to the documentation of this file.

// ===-- chapter-2/c++20/exercise-2-5.hpp ----------------- -*- C++ -*- --=== //
#ifndef EXERCISE_2_5
#define EXERCISE_2_5
 
#include <iostream>
 
 
#ifndef EXERCISE_2_4
namespace exercise_2_4 {
template <typename T> consteval T *error_unhandled_type() { return nullptr; }
} // namespace exercise_2_4
#endif
 
namespace exercise_2_5 {
 
inline namespace cpp20 {
 
template <typename T> struct type_descriptor_eng { };
 
template <typename T>
std::ostream& operator<<(std::ostream& os, type_descriptor_eng<T> const&)
{
    // Non-leaf data-types:
 
    if constexpr (std::is_const<T>::value) {
        return os << "const "
                  << type_descriptor_eng<typename std::remove_const<T>::type>();
    } else if constexpr (std::is_lvalue_reference<T>::value) {
        return os << "reference to "
                  << type_descriptor_eng<
                         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 << "pointer to function returning "
                      << type_descriptor_eng<
                             typename std::invoke_result<PointedT>::type>();
        } else {
            return os << "pointer to " << type_descriptor_eng<PointedT>();
        }
    } else if constexpr (std::is_array<T>::value) {
        if constexpr (std::is_bounded_array<T>::value) {
            os << std::extent<T>::value << " element ";
        }
 
        return os << "array of "
                  << type_descriptor_eng<
                         typename std::remove_extent<T>::type>();
    } else if constexpr (std::is_function<T>::value) {
        return os << "function returning "
                  << type_descriptor_eng<
                         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 exercise_2_4::error_unhandled_type<T>();
        } else {
            return exercise_2_4::error_unhandled_type<T>();
        }
    } else {
        return exercise_2_4::error_unhandled_type<T>();
    }
}
 
} // inline namespace cpp20
} // namespace exercise_2_4
 
#endif // EXERCISE_2_5