LayoutInspector.hpp

Go to the documentation of this file.

#pragma once
 
#include "Macros.hpp"
#include <iostream>
#include <cstddef>
#include <type_traits>
#include <tuple>
#include <typeinfo>
#include <cstdlib>
#include <cxxabi.h>
#include <utility>
#include <string>
 
template <typename T> 
std::string getObjectType(const T& obj) {
    try {
        const char* mangled = typeid(obj).name();
        int status;
        char* demangled = abi::__cxa_demangle(mangled, nullptr, nullptr, &status);
        std::string res = (status == 0 ? demangled : mangled);
        free(demangled);
        return res;
    } catch (const std::bad_typeid&) {
        return "Unknown";
    }
}
 
template <typename Tuple, typename F, std::size_t... Is>
void for_each_in_tuple(Tuple&& t, F&& f, std::index_sequence<Is...>) {
    (f(std::get<Is>(std::forward<Tuple>(t)), Is), ...);
}
 
template <typename Tuple, typename F>
void for_each_in_tuple(Tuple&& t, F&& f) {
    constexpr std::size_t size = std::tuple_size<std::decay_t<Tuple>>::value;
    for_each_in_tuple(std::forward<Tuple>(t), std::forward<F>(f), std::make_index_sequence<size>{});
}
 
namespace memviz {
            template <typename T>
            static void dumpLayout(const T& obj) {
                std::cout << "[Layout] Type: " << getObjectType(obj) << "\n";
                std::cout << "  Size: " << sizeof(T) << " bytes\n";
                std::cout << "  Alignment: " << alignof(T) << " bytes\n";
                std::cout << "  Location: " << static_cast<const void*>(&obj) << "\n";
 
                if constexpr (requires { MemberInfo<T>::get(); }) {
                    const auto members = MemberInfo<T>::get();
 
                    if constexpr (std::tuple_size<std::remove_cvref_t<decltype(members)>>::value == 0) {
                        std::cout << "\033[33m[NOTE]: use \"MEMVIZ_REGISTER(Type, ...)\" to reflect over members\033[0m\n";
                    } else {
                        std::cout << "  Members:\n";
                        std::apply([&](auto&&... pair) {
                            ((std::cout << "\t" << pair.first << ": offset = "
                                        << reinterpret_cast<const unsigned char*>(&(obj.*(pair.second)))
                                        - reinterpret_cast<const unsigned char*>(&obj) << '\n'), ...);
                        }, members);
                    }
                } else {
                    std::cout << "\033[33m[NOTE]: type not registered — layout fallback only.\033[0m\n";
                }
 
            }
 
 
} // namespace memviz