HepMC3 event record library
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 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
22 PYBIND11_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>;
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>;
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 // WARNING: This usage of `abs` should only be done for existing STL overloads.
151 // Adding overloads directly in to the `std::` namespace is advised against:
152 // https://en.cppreference.com/w/cpp/language/extending_std
153 PYBIND11_UNARY_OPERATOR(abs, abs, std::abs(l))
154 PYBIND11_UNARY_OPERATOR(hash, hash, std::hash<L>()(l))
155 PYBIND11_UNARY_OPERATOR(invert, operator~, (~l))
156 PYBIND11_UNARY_OPERATOR(bool, operator!, !!l)
157 PYBIND11_UNARY_OPERATOR(int, int_, (int) l)
158 PYBIND11_UNARY_OPERATOR(float, float_, (double) l)
159 
160 #undef PYBIND11_BINARY_OPERATOR
161 #undef PYBIND11_INPLACE_OPERATOR
162 #undef PYBIND11_UNARY_OPERATOR
163 PYBIND11_NAMESPACE_END(detail)
164 
165 using detail::self;
166 // Add named operators so that they are accessible via `py::`.
167 using detail::hash;
168 
169 PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
170 
171 #if defined(_MSC_VER)
172 # pragma warning(pop)
173 #endif
Operator implementation generator.
Definition: attr.h:125
Type for an unused type slot.
Definition: operators.h:44
Annotation for operators.
Definition: attr.h:24
base template of operator implementations
Definition: operators.h:50
Definition: pytypes.h:1115
Feature< Feature_type > abs(const Feature< Feature_type > &input)
Obtain the absolute value of a Feature. This works as you&#39;d expect. If foo is a valid Feature...
Definition: Feature.h:316