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 <array>
#include <functional>
#include <optional>
#include <source_location>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <gmp/meta/config.hpp>
#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)>();
    if (name.find(P.data()) != std::string_view::npos) {
        return true;
    }
 
#if GMP_COMPILER_GCC
    // GCC spells types declared in an anonymous namespace differently in
    // `source_location::function_name()`: `type_name<E>()` contains
    // `{anonymous}`, while the enumerator signature uses `<unnamed>`.
    // Normalize only the default prefix; an explicitly supplied prefix must
    // retain its documented filtering semantics.
    constexpr auto default_prefix = type_name<E>() + fixed_string("::");
    constexpr auto type = type_name_of<E>();
    constexpr std::string_view anonymous_prefix = "{anonymous}::";
    constexpr std::string_view gcc_anonymous_prefix = "<unnamed>::";
    if constexpr (P.to_string_view() == default_prefix.to_string_view() &&
                  type.starts_with(anonymous_prefix)) {
        constexpr auto visible_type = type.substr(anonymous_prefix.size());
        constexpr auto type_pos = name.find(visible_type);
        if constexpr (type_pos >= gcc_anonymous_prefix.size() &&
                      type_pos + visible_type.size() + 1 < name.size()) {
            constexpr auto namespace_pos = type_pos - gcc_anonymous_prefix.size();
            if (name.substr(namespace_pos, gcc_anonymous_prefix.size()) ==
                    gcc_anonymous_prefix &&
                name[type_pos + visible_type.size()] == ':' &&
                name[type_pos + visible_type.size() + 1] == ':') {
                return true;
            }
        }
    }
#endif
 
    return false;
}
 
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 E>
    requires std::is_enum_v<E>
constexpr auto enum_underlying(E value) noexcept -> std::underlying_type_t<E> {
    return static_cast<std::underlying_type_t<E>>(value);
}
 
template<typename E>
    requires std::is_enum_v<E>
constexpr bool enum_contains(E value) {
    return enum_index(value).has_value();
}
 
template<typename E, typename U>
    requires std::is_enum_v<E> && std::is_integral_v<U>
constexpr bool enum_contains(U value) {
    constexpr auto values = enum_values<E>();
    for (const auto enumerator : values) {
        if (std::cmp_equal(+enum_underlying(enumerator), +value)) {
            return true;
        }
    }
    return false;
}
 
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 static_cast<int>(sizeof...(Args)) - 1;
    }
}
 
template<typename T>
inline constexpr auto member_count_v = member_count<T>();
 
template<typename T>
concept reflectable =
    std::is_class_v<std::remove_cvref_t<T>> &&
    std::is_aggregate_v<std::remove_cvref_t<T>> &&
    (member_count<std::remove_cvref_t<T>>() >= 0) &&
    (member_count<std::remove_cvref_t<T>>() <= GMP_MAX_SUPPORTED_FIELDS);
 
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<
        T,
        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<typename T>
    requires reflectable<T>
constexpr auto member_index(std::string_view name) -> std::optional<std::size_t> {
    constexpr auto names = member_names<std::remove_cvref_t<T>>();
    for (std::size_t i = 0; i < names.size(); ++i) {
        if (names[i] == name) {
            return i;
        }
    }
    return std::nullopt;
}
 
template<typename T>
    requires reflectable<T>
constexpr bool has_member(std::string_view name) {
    return member_index<T>(name).has_value();
}
 
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>(
        std::forward<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.");
}
template<typename T>
    requires reflectable<T>
constexpr auto tie_members(T& value) noexcept {
    constexpr auto size = member_count_v<T>;
    return [&]<std::size_t... Is>(std::index_sequence<Is...>) noexcept {
        return std::forward_as_tuple(
            member_ref<Is>(value)...
        );
    }(std::make_index_sequence<size>{});
}
 
template<typename T, typename F>
    requires reflectable<T>
constexpr decltype(auto) apply_members(T& value, F&& func)
    noexcept(noexcept(std::apply(
        std::forward<F>(func),
        tie_members(value)
    ))) {
    return std::apply(
        std::forward<F>(func),
        tie_members(value)
    );
}
 
namespace detail {
 
template<typename T, typename F, std::size_t... Is>
constexpr void for_each_member_impl(T&& value, F&& func, std::index_sequence<Is...>)
    noexcept((std::is_nothrow_invocable_v<
        F&,
        std::string_view,
        decltype(gmp::member_ref<Is>(std::forward<T>(value)))
    > && ...)) {
    constexpr auto names = member_names<std::remove_cvref_t<T>>();
    (std::invoke(
        func,
        names[Is],
        gmp::member_ref<Is>(std::forward<T>(value))
    ), ...);
}
 
} // namespace detail
 
template<typename T, typename F>
    requires reflectable<T>
constexpr void for_each_member(T&& value, F&& func)
    noexcept(noexcept(detail::for_each_member_impl(
        std::forward<T>(value),
        std::forward<F>(func),
        std::make_index_sequence<member_count_v<std::remove_cvref_t<T>>>{}
    ))) {
    detail::for_each_member_impl(
        std::forward<T>(value),
        std::forward<F>(func),
        std::make_index_sequence<member_count_v<std::remove_cvref_t<T>>>{}
    );
}
 
template<typename T, typename F>
void for_each_member(T&&, F&&) noexcept {
    using value_type = std::remove_cvref_t<T>;
    static_assert(std::is_aggregate_v<value_type>,
        "for_each_member() can only be used with aggregate types.");
    if constexpr (std::is_aggregate_v<value_type>) {
        static_assert(std::is_class_v<value_type>,
            "for_each_member() does not support arrays or unions.");
        static_assert(reflectable<value_type>,
            "for_each_member() does not support this aggregate type.");
    }
}
template<typename T, typename F>
    requires reflectable<T>
constexpr bool visit_member(T&& value, std::string_view name, F&& func) {
    bool visited = false;
    for_each_member(
        std::forward<T>(value),
        [&](std::string_view current_name, auto&& member) {
            if (!visited && current_name == name) {
                std::invoke(
                    func,
                    std::forward<decltype(member)>(member)
                );
                visited = true;
            }
        }
    );
    return visited;
}
 
} // namespace gmp
 
#endif // GMP_META_HPP_