operators.hpp

Go to the documentation of this file.

#pragma once
#include <meta>
 
#include <welder/bind_traits.hpp> // is_unary_operator

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

consteval const char* operator_dunder(std::meta::info f) {
    using std::meta::operators;
    const bool unary{::welder::detail::is_unary_operator(f)};
    switch (std::meta::operator_of(f)) {
        case operators::op_plus:    return unary ? "__pos__" : "__add__";
        case operators::op_minus:   return unary ? "__neg__" : "__sub__";
        case operators::op_star:    return unary ? nullptr : "__mul__"; // unary * = deref
        case operators::op_slash:   return "__truediv__";
        case operators::op_percent: return "__mod__";
        case operators::op_tilde:   return "__invert__";
        case operators::op_caret:   return "__xor__";
        case operators::op_ampersand: return unary ? nullptr : "__and__"; // unary & = address-of
        case operators::op_pipe:    return "__or__";
        case operators::op_less_less:       return "__lshift__";
        case operators::op_greater_greater: return "__rshift__";
        case operators::op_equals_equals:      return "__eq__";
        case operators::op_exclamation_equals: return "__ne__";
        case operators::op_less:           return "__lt__";
        case operators::op_greater:        return "__gt__";
        case operators::op_less_equals:    return "__le__";
        case operators::op_greater_equals: return "__ge__";
        case operators::op_parentheses:     return "__call__";
        case operators::op_square_brackets: return "__getitem__";
        default:                            return nullptr;
    }
}

consteval const char* reflected_dunder(std::meta::info f) {
    using std::meta::operators;
    if (::welder::detail::is_unary_operator(f))
        return nullptr; // a unary operator has no second operand to reflect
    switch (std::meta::operator_of(f)) {
        case operators::op_plus:    return "__radd__";
        case operators::op_minus:   return "__rsub__";
        case operators::op_star:    return "__rmul__";
        case operators::op_slash:   return "__rtruediv__";
        case operators::op_percent: return "__rmod__";
        case operators::op_caret:   return "__rxor__";
        case operators::op_ampersand: return "__rand__";
        case operators::op_pipe:    return "__ror__";
        case operators::op_less_less:       return "__rlshift__";
        case operators::op_greater_greater: return "__rrshift__";
        // Comparisons mirror rather than prefix with r.
        case operators::op_equals_equals:      return "__eq__";
        case operators::op_exclamation_equals: return "__ne__";
        case operators::op_less:           return "__gt__";
        case operators::op_greater:        return "__lt__";
        case operators::op_less_equals:    return "__ge__";
        case operators::op_greater_equals: return "__le__";
        default:                           return nullptr;
    }
}

consteval bool dunder_uses_not_implemented(std::meta::info f) {
    using std::meta::operators;
    if (::welder::detail::is_unary_operator(f))
        return false;
    switch (std::meta::operator_of(f)) {
        case operators::op_parentheses:
        case operators::op_square_brackets: return false;
        default: return operator_dunder(f) != nullptr;
    }
}

consteval const char* cmp_slot_dunder(::welder::detail::cmp_slot s) {
    switch (s) {
        case ::welder::detail::cmp_slot::lt: return "__lt__";
        case ::welder::detail::cmp_slot::le: return "__le__";
        case ::welder::detail::cmp_slot::gt: return "__gt__";
        case ::welder::detail::cmp_slot::ge: return "__ge__";
    }
    return nullptr;
}

template <class T, auto Fns, auto Covered, class Def>
void synthesize_comparisons(Def def) {
    using ::welder::detail::cmp_slot;
    using ::welder::detail::synthesized_comparison;
    template for (constexpr auto fn : std::define_static_array(Fns)) {
        using P = std::remove_cvref_t<
            typename [: ::welder::detail::comparison_operand(fn, ^^T) :]>;
        if constexpr (!Covered[0])
            def(cmp_slot_dunder(cmp_slot::lt),
                &synthesized_comparison<T, P, cmp_slot::lt>::call);
        if constexpr (!Covered[1])
            def(cmp_slot_dunder(cmp_slot::le),
                &synthesized_comparison<T, P, cmp_slot::le>::call);
        if constexpr (!Covered[2])
            def(cmp_slot_dunder(cmp_slot::gt),
                &synthesized_comparison<T, P, cmp_slot::gt>::call);
        if constexpr (!Covered[3])
            def(cmp_slot_dunder(cmp_slot::ge),
                &synthesized_comparison<T, P, cmp_slot::ge>::call);
    }
}
 
} // namespace welder::rods::python