meta.hpp

Go to the documentation of this file.

//   ___ __  __ ___ 
//  / __|  \/  | _ \ GMP(Generative Metaprogramming)
// | (_ | |\/| |  _/ version 0.3.0
//  \___|_|  |_|_|   https://github.com/lkimuk/gmp
//
// SPDX-FileCopyrightText: 2026 Miles Li <https://www.cppmore.com/>
// SPDX-License-Identifier: MIT
//
// This file is part of the GMP (Generative Metaprogramming) library.
// Full project source: https://github.com/lkimuk/gmp
 
#ifndef GMP_META_HPP_
#define GMP_META_HPP_
 
#include <optional>
#include <source_location>
 
#include <gmp/meta/type_name.hpp>
#include <gmp/meta/detail/member_ref.hpp>
 
namespace gmp {
 
template<typename E>
struct enum_traits {
    static constexpr int min = -128;
    static constexpr int max = 127;
    // static constexpr bool is_flags = false;
    // static constexpr bool allow_alias = false;
};
 
#define GMP_ENUM_RANGE(Enum, Min, Max) \
    template<>                             \
    struct gmp::enum_traits<Enum> {             \
        static constexpr int min = Min;    \
        static constexpr int max = Max;    \
    }
 
#define GMP_ENUM_VALUES(Enum, ...) \
    template<>                             \
    struct gmp::enum_traits<Enum> {             \
        static constexpr auto values = std::to_array({__VA_ARGS__}); \
    }
 
template<typename E>
inline constexpr int enum_min_v = enum_traits<E>::min;
 
template<typename E>
inline constexpr int enum_max_v = enum_traits<E>::max;
 
namespace detail {
 
template<typename E>
concept has_enum_values =
    requires {
        enum_traits<E>::values;
        std::tuple_size<std::remove_cvref_t<decltype(enum_traits<E>::values)>>::value;
    } &&
    std::same_as<
        typename std::remove_cvref_t<decltype(enum_traits<E>::values)>::value_type,
        E
    >;
 
template<typename E, fixed_string P, auto V>
consteval bool is_valid_enum_value() {
    constexpr auto name = value_name_of<static_cast<E>(V)>();
    return name.find(P.data()) != std::string_view::npos;
}
 
template<typename E, fixed_string P, int Min, std::size_t... I>
consteval auto enum_values_scan(std::index_sequence<I...>) {
    constexpr std::size_t count = (std::size_t{0} + ... + (is_valid_enum_value<E, P, Min + static_cast<int>(I)>() ? 1u : 0u));
 
    std::array<E, count> result{};
    std::size_t index = 0;
 
    auto append = [&]<int V>() consteval {
        if constexpr (is_valid_enum_value<E, P, V>()) {
            result[index++] = static_cast<E>(V);
        }
    };
 
    (append.template operator()<Min + static_cast<int>(I)>(), ...);
    return result;
}
 
} // namespace detail
 
template<typename E, fixed_string P = type_name<E>() + fixed_string("::")>
consteval auto enum_values() {
    static_assert(std::is_enum_v<E>, "enum_values<E>() requires E to be an enum type");
 
    if constexpr (detail::has_enum_values<E>) {
        return enum_traits<E>::values;
    } else {
        constexpr int min = enum_min_v<E>;
        constexpr int max = enum_max_v<E>;
 
        static_assert(min <= max, "enum_traits<E>::min must be <= max");
 
        return detail::enum_values_scan<E, P, min>(
            std::make_index_sequence<static_cast<std::size_t>(max - min + 1)>{}
        );
    }
}
 
template<typename E, fixed_string P = type_name<E>() + fixed_string("::")>
consteval auto enum_count() {
    static_assert(std::is_enum_v<E>, "enum_count<E>() requires E to be an enum type");
 
    return enum_values<E, P>().size();
}
 
template<auto E, fixed_string P = fixed_string("::")>
consteval auto enum_name() {
    constexpr auto name = detail::value_name_of<E>();
    constexpr auto start = name.rfind(P.data());
    if constexpr (start != std::string_view::npos) {
#if GMP_COMPILER_CLANG || GMP_COMPILER_GCC
        constexpr auto end = name.find_last_of("]");
#else
        constexpr auto end = name.find_last_of(">");
#endif
        return name.substr(start + P.size(), end - start - P.size());
    } else {
        return "<unnamed>";
    }
}
 
template<typename E>
consteval auto enum_names() {
    constexpr auto values = enum_values<E>();
    constexpr std::size_t size = values.size();
 
    if constexpr (size == 0) {
        return std::array<std::string_view, 0>{};
    } else {
        return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
            return std::array<std::string_view, size>{
                enum_name<values[Is]>()...
            };
        }(std::make_index_sequence<size>{});
    }
}
 
template<typename E>
consteval auto enum_entries() {
    constexpr auto values = enum_values<E>();
    constexpr auto names  = enum_names<E>();
    constexpr std::size_t size = values.size();
 
    if constexpr (size == 0) {
        return std::array<std::pair<E, std::string_view>, 0>{};
    } else {
        return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
            return std::array<std::pair<E, std::string_view>, size>{
                std::pair<E, std::string_view>{ values[Is], names[Is] }...
            };
        }(std::make_index_sequence<size>{});
    }
}
 
template<typename E>
constexpr auto enum_index(E value) -> std::optional<std::size_t> {
    constexpr auto values = enum_values<E>();
    for (std::size_t i = 0; i < values.size(); ++i) {
        if (values[i] == value) {
            return i;
        }
    }
    return std::nullopt;
}
 
template<typename E>
constexpr auto enum_cast(std::string_view name) -> std::optional<E> {
    constexpr auto entries = enum_entries<E>();
    for (const auto& [value, n] : entries) {
        if (n == name) {
            return value;
        }
    }
    return std::nullopt;
}
 
template<typename T, typename... Args>
  requires std::is_aggregate_v<std::remove_cvref_t<T>>
consteval int member_count() {
    using value_type = std::remove_cvref_t<T>;
    if constexpr (requires { value_type{Args{}...}; }) {
        return member_count<value_type, Args..., gmp::any>();
    } else {
        return sizeof...(Args) - 1;
    }
}
 
template<std::size_t I, typename T>
    requires std::is_aggregate_v<T> &&
        (I < member_count<T>()) &&
        (member_count<T>() <= GMP_MAX_SUPPORTED_FIELDS)
consteval auto member_name() noexcept {
    constexpr auto name = detail::member_name_of<detail::field_getter<I, T>(constant_arg<member_count<T>()>)>();
    return name;
}
 
template<std::size_t I, typename T>
consteval auto member_name() noexcept {
    static_assert(std::is_aggregate_v<T>, "member_name() can only be used with aggregate types.");
    static_assert(I < member_count<T>(), "Index out of bounds in member_name().");
    static_assert(member_count<T>() <= GMP_MAX_SUPPORTED_FIELDS, "member_name() only supports up to " GMP_STRINGIFY(GMP_MAX_SUPPORTED_FIELDS) " fields.");
}
template<typename T>
consteval auto member_names() {
    using value_type = std::remove_cvref_t<T>;
    constexpr auto size = member_count<value_type>();
    if constexpr (size == 0) {
        return std::array<std::string_view, 0>{};
    } else {
        return []<std::size_t... Is>(std::index_sequence<Is...>) {
            return (std::array<std::string_view, size> {
                member_name<Is, value_type>()...
            });
        }(std::make_index_sequence<size>{});
    }
}
 
template<std::size_t I, typename T>
using member_type_t = std::remove_cvref_t<
    decltype(*detail::field_getter<I, T>(constant_arg<member_count<T>()>))>;
 
namespace detail {
 
template<typename T>
struct member_type_names_holder {
    static constexpr std::size_t N = member_count<T>();
 
    static constexpr auto fixed_names = []<std::size_t... Is>(std::index_sequence<Is...>) {
        return std::tuple{ pretty_type_name<member_type_t<Is, T>>()()... };
    }(std::make_index_sequence<N>{});
 
    static constexpr auto views = []<std::size_t... Is>(std::index_sequence<Is...>) {
        return std::array<std::string_view, N>{
            std::get<Is>(fixed_names).to_string_view()...
        };
    }(std::make_index_sequence<N>{});
};
 
} // namespace detail
 
template<typename T>
constexpr auto member_type_names() {
    return detail::member_type_names_holder<T>::views;
}
 
template<std::size_t I, typename T, typename UnqualifiedT = std::remove_cvref_t<T>>
    requires std::is_aggregate_v<UnqualifiedT>
        && (I < member_count<UnqualifiedT>())
        && (member_count<UnqualifiedT>() <= GMP_MAX_SUPPORTED_FIELDS)
decltype(auto) member_ref(T&& value) noexcept {
    return detail::member_ref<I, T>(value, constant_arg<member_count<UnqualifiedT>()>);
}
 
template<std::size_t I, typename T, typename UnqualifiedT = std::remove_cvref_t<T>>
decltype(auto) member_ref(T&&) noexcept {
    static_assert(std::is_aggregate_v<UnqualifiedT>, "member_ref() can only be used with aggregate types.");
    static_assert(I < member_count<UnqualifiedT>(), "Index out of bounds in member_ref().");
    static_assert(member_count<UnqualifiedT>() <= GMP_MAX_SUPPORTED_FIELDS, "member_ref() only supports up to " GMP_STRINGIFY(GMP_MAX_SUPPORTED_FIELDS) " fields.");
}
namespace detail {
 
#define GMP_FOR_EACH_MEMBER_DEFINE(N) \
  template<typename T, typename F> \
  void for_each_member_impl(T&& value, F&& f, constant_arg_t<N>) noexcept { \
    auto&& [GMP_GET_FIRST_N(N, GMP_IDENTIFIERS)] = value; \
    auto members = std::forward_as_tuple(GMP_GET_FIRST_N(N, GMP_IDENTIFIERS)); \
    constexpr auto mem_names = gmp::member_names<T>(); \
    std::size_t index = 0; \
    std::apply( \
      [&](auto&&... member) { (f(mem_names[index++], std::forward<decltype(member)>(member)), ...); }, members); \
  }
 
#if GMP_STANDARD_PREPROCESSOR
    // Standard preprocessor supports 256 arguments
    GMP_FOR_EACH(GMP_FOR_EACH_MEMBER_DEFINE, GMP_RANGE(1, 256))
#else
    // MSVC traditional preprocessor: MAX 199 due to nesting depth limit (fatal error C1009)
    GMP_FOR_EACH(GMP_FOR_EACH_MEMBER_DEFINE, GMP_RANGE(1, 119))
#endif
 
#undef GMP_FOR_EACH_MEMBER_DEFINE
 
} // namespace detail
 
template<typename T, typename F>
    requires std::is_aggregate_v<std::remove_cvref_t<T>>
void for_each_member(T&& value, F&& func) noexcept {
    detail::for_each_member_impl(
        std::forward<T>(value),
        std::forward<F>(func),
        constant_arg<member_count<T>()>
    );
}
 
template<typename T, typename F>
void for_each_member(T&& value, F&& func) noexcept {
    static_assert(std::is_aggregate_v<std::remove_cvref_t<T>>,
        "for_each_member() can only be used with aggregate types.");
}
} // namespace gmp
 
#endif // GMP_META_HPP_