python_packaging/src/external/pybind/include/pybind11/operators.h

   1 /*
   2     pybind11/operator.h: Metatemplates for operator overloading
   3
   4     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
   5
   6     All rights reserved. Use of this source code is governed by a
   7     BSD-style license that can be found in the LICENSE file.
   8 */
   9
  10 #pragma once
  11
  12 #include "pybind11.h"
  13
  14 #if defined(__clang__) && !defined(__INTEL_COMPILER)
  15 #  pragma clang diagnostic ignored "-Wunsequenced" // multiple unsequenced modifications to 'self' (when using def(py::self OP Type()))
  16 #elif defined(_MSC_VER)
  17 #  pragma warning(push)
  18 #  pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
  19 #endif
  20
  21 NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  22 NAMESPACE_BEGIN(detail)
  23
  24 /// Enumeration with all supported operator types
  25 enum op_id : int {
  26     op_add, op_sub, op_mul, op_div, op_mod, op_divmod, op_pow, op_lshift,
  27     op_rshift, op_and, op_xor, op_or, op_neg, op_pos, op_abs, op_invert,
  28     op_int, op_long, op_float, op_str, op_cmp, op_gt, op_ge, op_lt, op_le,
  29     op_eq, op_ne, op_iadd, op_isub, op_imul, op_idiv, op_imod, op_ilshift,
  30     op_irshift, op_iand, op_ixor, op_ior, op_complex, op_bool, op_nonzero,
  31     op_repr, op_truediv, op_itruediv, op_hash
  32 };
  33
  34 enum op_type : int {
  35     op_l, /* base type on left */
  36     op_r, /* base type on right */
  37     op_u  /* unary operator */
  38 };
  39
  40 struct self_t { };
  41 static const self_t self = self_t();
  42
  43 /// Type for an unused type slot
  44 struct undefined_t { };
  45
  46 /// Don't warn about an unused variable
  47 inline self_t __self() { return self; }
  48
  49 /// base template of operator implementations
  50 template <op_id, op_type, typename B, typename L, typename R> struct op_impl { };
  51
  52 /// Operator implementation generator
  53 template <op_id id, op_type ot, typename L, typename R> struct op_ {
  54     template <typename Class, typename... Extra> void execute(Class &cl, const Extra&... extra) const {
  55         using Base = typename Class::type;
  56         using L_type = conditional_t<std::is_same<L, self_t>::value, Base, L>;
  57         using R_type = conditional_t<std::is_same<R, self_t>::value, Base, R>;
  58         using op = op_impl<id, ot, Base, L_type, R_type>;
  59         cl.def(op::name(), &op::execute, is_operator(), extra...);
  60         #if PY_MAJOR_VERSION < 3
  61         if (id == op_truediv || id == op_itruediv)
  62             cl.def(id == op_itruediv ? "__idiv__" : ot == op_l ? "__div__" : "__rdiv__",
  63                     &op::execute, is_operator(), extra...);
  64         #endif
  65     }
  66     template <typename Class, typename... Extra> void execute_cast(Class &cl, const Extra&... extra) const {
  67         using Base = typename Class::type;
  68         using L_type = conditional_t<std::is_same<L, self_t>::value, Base, L>;
  69         using R_type = conditional_t<std::is_same<R, self_t>::value, Base, R>;
  70         using op = op_impl<id, ot, Base, L_type, R_type>;
  71         cl.def(op::name(), &op::execute_cast, is_operator(), extra...);
  72         #if PY_MAJOR_VERSION < 3
  73         if (id == op_truediv || id == op_itruediv)
  74             cl.def(id == op_itruediv ? "__idiv__" : ot == op_l ? "__div__" : "__rdiv__",
  75                     &op::execute, is_operator(), extra...);
  76         #endif
  77     }
  78 };
  79
  80 #define PYBIND11_BINARY_OPERATOR(id, rid, op, expr)                                    \
  81 template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
  82     static char const* name() { return "__" #id "__"; }                                \
  83     static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); }   \
  84     static B execute_cast(const L &l, const R &r) { return B(expr); }                  \
  85 };                                                                                     \
  86 template <typename B, typename L, typename R> struct op_impl<op_##id, op_r, B, L, R> { \
  87     static char const* name() { return "__" #rid "__"; }                               \
  88     static auto execute(const R &r, const L &l) -> decltype(expr) { return (expr); }   \
  89     static B execute_cast(const R &r, const L &l) { return B(expr); }                  \
  90 };                                                                                     \
  91 inline op_<op_##id, op_l, self_t, self_t> op(const self_t &, const self_t &) {         \
  92     return op_<op_##id, op_l, self_t, self_t>();                                       \
  93 }                                                                                      \
  94 template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) {    \
  95     return op_<op_##id, op_l, self_t, T>();                                            \
  96 }                                                                                      \
  97 template <typename T> op_<op_##id, op_r, T, self_t> op(const T &, const self_t &) {    \
  98     return op_<op_##id, op_r, T, self_t>();                                            \
  99 }
 100
 101 #define PYBIND11_INPLACE_OPERATOR(id, op, expr)                                        \
 102 template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
 103     static char const* name() { return "__" #id "__"; }                                \
 104     static auto execute(L &l, const R &r) -> decltype(expr) { return expr; }           \
 105     static B execute_cast(L &l, const R &r) { return B(expr); }                        \
 106 };                                                                                     \
 107 template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) {    \
 108     return op_<op_##id, op_l, self_t, T>();                                            \
 109 }
 110
 111 #define PYBIND11_UNARY_OPERATOR(id, op, expr)                                          \
 112 template <typename B, typename L> struct op_impl<op_##id, op_u, B, L, undefined_t> {   \
 113     static char const* name() { return "__" #id "__"; }                                \
 114     static auto execute(const L &l) -> decltype(expr) { return expr; }                 \
 115     static B execute_cast(const L &l) { return B(expr); }                              \
 116 };                                                                                     \
 117 inline op_<op_##id, op_u, self_t, undefined_t> op(const self_t &) {                    \
 118     return op_<op_##id, op_u, self_t, undefined_t>();                                  \
 119 }
 120
 121 PYBIND11_BINARY_OPERATOR(sub,       rsub,         operator-,    l - r)
 122 PYBIND11_BINARY_OPERATOR(add,       radd,         operator+,    l + r)
 123 PYBIND11_BINARY_OPERATOR(mul,       rmul,         operator*,    l * r)
 124 PYBIND11_BINARY_OPERATOR(truediv,   rtruediv,     operator/,    l / r)
 125 PYBIND11_BINARY_OPERATOR(mod,       rmod,         operator%,    l % r)
 126 PYBIND11_BINARY_OPERATOR(lshift,    rlshift,      operator<<,   l << r)
 127 PYBIND11_BINARY_OPERATOR(rshift,    rrshift,      operator>>,   l >> r)
 128 PYBIND11_BINARY_OPERATOR(and,       rand,         operator&,    l & r)
 129 PYBIND11_BINARY_OPERATOR(xor,       rxor,         operator^,    l ^ r)
 130 PYBIND11_BINARY_OPERATOR(eq,        eq,           operator==,   l == r)
 131 PYBIND11_BINARY_OPERATOR(ne,        ne,           operator!=,   l != r)
 132 PYBIND11_BINARY_OPERATOR(or,        ror,          operator|,    l | r)
 133 PYBIND11_BINARY_OPERATOR(gt,        lt,           operator>,    l > r)
 134 PYBIND11_BINARY_OPERATOR(ge,        le,           operator>=,   l >= r)
 135 PYBIND11_BINARY_OPERATOR(lt,        gt,           operator<,    l < r)
 136 PYBIND11_BINARY_OPERATOR(le,        ge,           operator<=,   l <= r)
 137 //PYBIND11_BINARY_OPERATOR(pow,       rpow,         pow,          std::pow(l,  r))
 138 PYBIND11_INPLACE_OPERATOR(iadd,     operator+=,   l += r)
 139 PYBIND11_INPLACE_OPERATOR(isub,     operator-=,   l -= r)
 140 PYBIND11_INPLACE_OPERATOR(imul,     operator*=,   l *= r)
 141 PYBIND11_INPLACE_OPERATOR(itruediv, operator/=,   l /= r)
 142 PYBIND11_INPLACE_OPERATOR(imod,     operator%=,   l %= r)
 143 PYBIND11_INPLACE_OPERATOR(ilshift,  operator<<=,  l <<= r)
 144 PYBIND11_INPLACE_OPERATOR(irshift,  operator>>=,  l >>= r)
 145 PYBIND11_INPLACE_OPERATOR(iand,     operator&=,   l &= r)
 146 PYBIND11_INPLACE_OPERATOR(ixor,     operator^=,   l ^= r)
 147 PYBIND11_INPLACE_OPERATOR(ior,      operator|=,   l |= r)
 148 PYBIND11_UNARY_OPERATOR(neg,        operator-,    -l)
 149 PYBIND11_UNARY_OPERATOR(pos,        operator+,    +l)
 150 PYBIND11_UNARY_OPERATOR(abs,        abs,          std::abs(l))
 151 PYBIND11_UNARY_OPERATOR(hash,       hash,         std::hash<L>()(l))
 152 PYBIND11_UNARY_OPERATOR(invert,     operator~,    (~l))
 153 PYBIND11_UNARY_OPERATOR(bool,       operator!,    !!l)
 154 PYBIND11_UNARY_OPERATOR(int,        int_,         (int) l)
 155 PYBIND11_UNARY_OPERATOR(float,      float_,       (double) l)
 156
 157 #undef PYBIND11_BINARY_OPERATOR
 158 #undef PYBIND11_INPLACE_OPERATOR
 159 #undef PYBIND11_UNARY_OPERATOR
 160 NAMESPACE_END(detail)
 161
 162 using detail::self;
 163
 164 NAMESPACE_END(PYBIND11_NAMESPACE)
 165
 166 #if defined(_MSC_VER)
 167 #  pragma warning(pop)
 168 #endif