array_interface.hpp

Go to the documentation of this file.

#pragma once
#include <array>
#include <cstddef>
#include <meta>
#include <string>
#include <type_traits>
#include <utility>

 
namespace welder::inline v0::rods::python {

consteval std::string ai_uint_string(std::size_t n) {
    if (n == 0)
        return "0";
    std::string s{};
    for (; n; n /= 10)
        s.insert(s.begin(), char('0' + n % 10));
    return s;
}

consteval bool ai_is_unsigned(std::meta::info t) {
    t = std::meta::dealias(t);
    for (std::meta::info u :
         {^^unsigned char, ^^unsigned short, ^^unsigned int, ^^unsigned long,
          ^^unsigned long long, ^^char8_t, ^^char16_t, ^^char32_t})
        if (t == u)
            return true;
    return false;
}

consteval std::string numpy_typestr(std::meta::info t) {
    t = std::meta::dealias(t);
    if (std::meta::is_enum_type(t))
        t = std::meta::dealias(std::meta::underlying_type(t));
    if (t == ^^bool)
        return "|b1";
    if (t == ^^float)
        return "<f4";
    if (t == ^^double)
        return "<f8";
    if (!std::meta::is_arithmetic_type(t) || t == ^^long double)
        return ""; // no portable NumPy scalar
    const std::size_t sz{std::meta::size_of(t)};
    const char code{ai_is_unsigned(t) ? 'u' : 'i'};
    const char prefix{sz == 1 ? '|' : '<'};
    return std::string{prefix} + code + ai_uint_string(sz);
}

template <class E>
consteval const char* ai_typestr() {
    return std::define_static_string("|V" + ai_uint_string(sizeof(E)));
}

consteval bool ai_all_fields_numpy(std::meta::info E) {
    const auto members{std::meta::nonstatic_data_members_of(
        E, std::meta::access_context::unchecked())};
    if (members.empty())
        return false;
    for (std::meta::info m : members)
        if (numpy_typestr(std::meta::type_of(m)).empty())
            return false;
    return true;
}

template <class E>
consteval bool pod_array_eligible() {
    return std::is_class_v<E> && std::is_trivially_copyable_v<E> &&
           std::is_standard_layout_v<E> && ai_all_fields_numpy(^^E);
}

consteval std::size_t ai_entry_count(std::meta::info E) {
    std::size_t n{0}, running{0};
    for (std::meta::info m : std::meta::nonstatic_data_members_of(
             E, std::meta::access_context::unchecked())) {
        // offset_of(m).bytes is std::ptrdiff_t (signed); a field offset is
        // non-negative, so cast to size_t (avoids -Werror=narrowing/sign-conversion).
        const std::size_t off{
            static_cast<std::size_t>(std::meta::offset_of(m).bytes)};
        if (off > running)
            ++n; // interior padding
        ++n;     // the field
        running = off + std::meta::size_of(std::meta::type_of(m));
    }
    if (running < std::meta::size_of(E))
        ++n; // trailing padding
    return n;
}

template <std::meta::info E>
consteval std::array<std::pair<const char*, const char*>, ai_entry_count(E)>
ai_descr() {
    std::array<std::pair<const char*, const char*>, ai_entry_count(E)> out{};
    std::size_t i{0}, running{0};
    for (std::meta::info m : std::meta::nonstatic_data_members_of(
             E, std::meta::access_context::unchecked())) {
        // offset_of(m).bytes is std::ptrdiff_t (signed); a field offset is
        // non-negative, so cast to size_t (avoids -Werror=narrowing/sign-conversion).
        const std::size_t off{
            static_cast<std::size_t>(std::meta::offset_of(m).bytes)};
        if (off > running)
            out[i++] = {"", std::define_static_string("|V" +
                                                      ai_uint_string(off - running))};
        out[i++] = {std::define_static_string(std::meta::identifier_of(m)),
                    std::define_static_string(numpy_typestr(std::meta::type_of(m)))};
        running = off + std::meta::size_of(std::meta::type_of(m));
    }
    if (running < std::meta::size_of(E))
        out[i++] = {"", std::define_static_string(
                            "|V" + ai_uint_string(std::meta::size_of(E) - running))};
    return out;
}
 
} // namespace welder::inline v0::rods::python