named_operator.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_NAMED_OPERATOR_HPP_
#define GMP_META_NAMED_OPERATOR_HPP_
 
#include <concepts>
#include <functional>
#include <type_traits>
#include <tuple>
#include <utility>
 
#include <gmp/macro/macro.hpp>
 
namespace gmp {
 
namespace detail {
 
template<typename... Ts>
struct value_holder {
    std::tuple<Ts...> values;
 
    template<typename... Us>
        requires std::constructible_from<std::tuple<Ts...>, Us&&...>
    constexpr explicit value_holder(Us&&... us)
        : values(std::forward<Us>(us)...) {}
};
 
template<typename T>
using named_operator_lhs_storage_t = std::conditional_t<
    std::is_lvalue_reference_v<T>, T, std::remove_cvref_t<T>>;
 
template<typename Lhs, typename Func>
[[nodiscard]]
constexpr auto bind_named_operator(Lhs&& lhs, value_holder<Func> holder) {
    using lhs_storage_t = named_operator_lhs_storage_t<Lhs&&>;
 
    return value_holder<lhs_storage_t, Func>(
        std::forward<Lhs>(lhs),
        std::get<0>(std::move(holder.values))
    );
}
 
template<typename Lhs, typename Func, typename Rhs>
    requires std::invocable<Func&&, Lhs, Rhs&&>
constexpr decltype(auto) invoke_named_operator(value_holder<Lhs, Func>&& holder, Rhs&& rhs) {
    auto&& [lhs, func] = holder.values;
    return std::invoke(std::move(func), std::forward<Lhs>(lhs), std::forward<Rhs>(rhs));
}
 
#define GMP_DEFINE_NAMED_OPERATOR_PAIR(pair)                                       \
    template<typename Lhs, typename Func>                                           \
        requires std::movable<Func>                                                 \
    constexpr auto operator GMP_GET_TUPLE(0, pair) (Lhs&& lhs, ::gmp::detail::value_holder<Func> holder) { \
        return ::gmp::detail::bind_named_operator(std::forward<Lhs>(lhs), std::move(holder)); \
    }                                                                               \
                                                                                    \
    template<typename Lhs, typename Func, typename Rhs>                             \
        requires std::invocable<Func&&, Lhs, Rhs&&>                                 \
    constexpr decltype(auto) operator GMP_GET_TUPLE(1, pair) (                                         \
        ::gmp::detail::value_holder<Lhs, Func>&& holder, Rhs&& rhs) {               \
        return ::gmp::detail::invoke_named_operator(std::move(holder), std::forward<Rhs>(rhs)); \
    }
 
#define GMP_TO_PAIR(x) (x, x),
#define GMP_TO_PAIRS(...) GMP_REMOVE_TRAILING_COMMA(GMP_FOR_EACH(GMP_TO_PAIR, __VA_ARGS__))
 
#define GMP_GENERATE_NAMED_OPERATOR_PAIRS(...) \
    GMP_FOR_EACH(GMP_DEFINE_NAMED_OPERATOR_PAIR, __VA_ARGS__)
#define GMP_GENERATE_NAMED_OPERATOR_IDENTICAL_PAIRS(...) \
    _GMP_GENERATE_NAMED_OPERATOR_IDENTICAL_PAIRS_MSVC_COMPAT(GMP_TO_PAIRS(__VA_ARGS__))
#define _GMP_GENERATE_NAMED_OPERATOR_IDENTICAL_PAIRS_MSVC_COMPAT(...) \
    GMP_FOR_EACH(GMP_DEFINE_NAMED_OPERATOR_PAIR, __VA_ARGS__)
 
#ifndef GMP_DISABLE_DEFAULT_NAMED_OPERATORS
GMP_GENERATE_NAMED_OPERATOR_PAIRS((<, >))
GMP_GENERATE_NAMED_OPERATOR_IDENTICAL_PAIRS(+, ^, *, -, /, %, &, |)
#endif
 
#undef _GMP_GENERATE_NAMED_OPERATOR_IDENTICAL_PAIRS_MSVC_COMPAT
#undef GMP_GENERATE_NAMED_OPERATOR_IDENTICAL_PAIRS
#undef GMP_GENERATE_NAMED_OPERATOR_PAIRS
#undef GMP_TO_PAIRS
#undef GMP_TO_PAIR
#undef GMP_DEFINE_NAMED_OPERATOR_PAIR
 
} // namespace detail
 
template<typename Func>
[[nodiscard]]
constexpr auto make_named_operator(Func&& f) {
    using func_type = std::remove_cvref_t<Func>;
 
    return detail::value_holder<func_type>(std::forward<Func>(f));
}
 
} // namespace gmp
 
#endif // GMP_META_NAMED_OPERATOR_HPP_