test_operator_overloading.cpp 8.4 KB
Newer Older
Wenzel Jakob's avatar
Wenzel Jakob committed
1
/*
Dean Moldovan's avatar
Dean Moldovan committed
2
    tests/test_operator_overloading.cpp -- operator overloading
Wenzel Jakob's avatar
Wenzel Jakob committed
3

4
    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
Wenzel Jakob's avatar
Wenzel Jakob committed
5
6
7
8
9

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE file.
*/

Dean Moldovan's avatar
Dean Moldovan committed
10
11
#include "pybind11_tests.h"
#include "constructor_stats.h"
12
#include <pybind11/operators.h>
13
#include <functional>
Wenzel Jakob's avatar
Wenzel Jakob committed
14
15
16

class Vector2 {
public:
17
18
    Vector2(float x, float y) : x(x), y(y) { print_created(this, toString()); }
    Vector2(const Vector2 &v) : x(v.x), y(v.y) { print_copy_created(this); }
19
20
21
22
    Vector2(Vector2 &&v) noexcept : x(v.x), y(v.y) {
        print_move_created(this);
        v.x = v.y = 0;
    }
23
    Vector2 &operator=(const Vector2 &v) { x = v.x; y = v.y; print_copy_assigned(this); return *this; }
24
25
26
27
28
29
30
    Vector2 &operator=(Vector2 &&v) noexcept {
        x   = v.x;
        y   = v.y;
        v.x = v.y = 0;
        print_move_assigned(this);
        return *this;
    }
31
    ~Vector2() { print_destroyed(this); }
Wenzel Jakob's avatar
Wenzel Jakob committed
32

33
    std::string toString() const { return "[" + std::to_string(x) + ", " + std::to_string(y) + "]"; }
Wenzel Jakob's avatar
Wenzel Jakob committed
34

35
    Vector2 operator-() const { return Vector2(-x, -y); }
Wenzel Jakob's avatar
Wenzel Jakob committed
36
37
38
39
40
41
    Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); }
    Vector2 operator-(const Vector2 &v) const { return Vector2(x - v.x, y - v.y); }
    Vector2 operator-(float value) const { return Vector2(x - value, y - value); }
    Vector2 operator+(float value) const { return Vector2(x + value, y + value); }
    Vector2 operator*(float value) const { return Vector2(x * value, y * value); }
    Vector2 operator/(float value) const { return Vector2(x / value, y / value); }
42
43
    Vector2 operator*(const Vector2 &v) const { return Vector2(x * v.x, y * v.y); }
    Vector2 operator/(const Vector2 &v) const { return Vector2(x / v.x, y / v.y); }
Wenzel Jakob's avatar
Wenzel Jakob committed
44
45
46
47
    Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; }
    Vector2& operator-=(const Vector2 &v) { x -= v.x; y -= v.y; return *this; }
    Vector2& operator*=(float v) { x *= v; y *= v; return *this; }
    Vector2& operator/=(float v) { x /= v; y /= v; return *this; }
48
49
    Vector2& operator*=(const Vector2 &v) { x *= v.x; y *= v.y; return *this; }
    Vector2& operator/=(const Vector2 &v) { x /= v.x; y /= v.y; return *this; }
50
51
52
53
54

    friend Vector2 operator+(float f, const Vector2 &v) { return Vector2(f + v.x, f + v.y); }
    friend Vector2 operator-(float f, const Vector2 &v) { return Vector2(f - v.x, f - v.y); }
    friend Vector2 operator*(float f, const Vector2 &v) { return Vector2(f * v.x, f * v.y); }
    friend Vector2 operator/(float f, const Vector2 &v) { return Vector2(f / v.x, f / v.y); }
55
56
57
58
59
60
61

    bool operator==(const Vector2 &v) const {
        return x == v.x && y == v.y;
    }
    bool operator!=(const Vector2 &v) const {
        return x != v.x || y != v.y;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
62
63
64
65
private:
    float x, y;
};

66
67
68
69
70
71
72
73
class C1 { };
class C2 { };

int operator+(const C1 &, const C1 &) { return 11; }
int operator+(const C2 &, const C2 &) { return 22; }
int operator+(const C2 &, const C1 &) { return 21; }
int operator+(const C1 &, const C2 &) { return 12; }

74
75
76
77
78
// Note: Specializing explicit within `namespace std { ... }` is done due to a
// bug in GCC<7. If you are supporting compilers later than this, consider
// specializing `using template<> struct std::hash<...>` in the global
// namespace instead, per this recommendation:
// https://en.cppreference.com/w/cpp/language/extending_std#Adding_template_specializations
79
80
81
82
83
84
namespace std {
    template<>
    struct hash<Vector2> {
        // Not a good hash function, but easy to test
        size_t operator()(const Vector2 &) { return 4; }
    };
85
} // namespace std
86

87
88
89
90
91
// Not a good abs function, but easy to test.
std::string abs(const Vector2&) {
    return "abs(Vector2)";
}

92
93
// MSVC & Intel warns about unknown pragmas, and warnings are errors.
#if !defined(_MSC_VER) && !defined(__INTEL_COMPILER)
Henry Schreiner's avatar
Henry Schreiner committed
94
95
96
97
98
99
  #pragma GCC diagnostic push
  // clang 7.0.0 and Apple LLVM 10.0.1 introduce `-Wself-assign-overloaded` to
  // `-Wall`, which is used here for overloading (e.g. `py::self += py::self `).
  // Here, we suppress the warning using `#pragma diagnostic`.
  // Taken from: https://github.com/RobotLocomotion/drake/commit/aaf84b46
  // TODO(eric): This could be resolved using a function / functor (e.g. `py::self()`).
100
  #if defined(__APPLE__) && defined(__clang__)
101
    #if (__clang_major__ >= 10)
Henry Schreiner's avatar
Henry Schreiner committed
102
103
      #pragma GCC diagnostic ignored "-Wself-assign-overloaded"
    #endif
104
  #elif defined(__clang__)
Henry Schreiner's avatar
Henry Schreiner committed
105
106
107
108
109
110
    #if (__clang_major__ >= 7)
      #pragma GCC diagnostic ignored "-Wself-assign-overloaded"
    #endif
  #endif
#endif

111
TEST_SUBMODULE(operators, m) {
112

113
    // test_operator_overloading
Wenzel Jakob's avatar
Wenzel Jakob committed
114
115
116
117
118
119
120
121
    py::class_<Vector2>(m, "Vector2")
        .def(py::init<float, float>())
        .def(py::self + py::self)
        .def(py::self + float())
        .def(py::self - py::self)
        .def(py::self - float())
        .def(py::self * float())
        .def(py::self / float())
122
123
        .def(py::self * py::self)
        .def(py::self / py::self)
Wenzel Jakob's avatar
Wenzel Jakob committed
124
125
126
127
        .def(py::self += py::self)
        .def(py::self -= py::self)
        .def(py::self *= float())
        .def(py::self /= float())
128
129
        .def(py::self *= py::self)
        .def(py::self /= py::self)
130
131
132
133
        .def(float() + py::self)
        .def(float() - py::self)
        .def(float() * py::self)
        .def(float() / py::self)
134
        .def(-py::self)
135
        .def("__str__", &Vector2::toString)
136
137
138
139
140
141
142
        .def("__repr__", &Vector2::toString)
        .def(py::self == py::self)
        .def(py::self != py::self)
        .def(py::hash(py::self))
        // N.B. See warning about usage of `py::detail::abs(py::self)` in
        // `operators.h`.
        .def("__abs__", [](const Vector2& v) { return abs(v); })
143
        ;
Wenzel Jakob's avatar
Wenzel Jakob committed
144
145

    m.attr("Vector") = m.attr("Vector2");
146

147
    // test_operators_notimplemented
148
149
150
151
152
153
154
155
156
157
158
    // #393: need to return NotSupported to ensure correct arithmetic operator behavior
    py::class_<C1>(m, "C1")
        .def(py::init<>())
        .def(py::self + py::self);

    py::class_<C2>(m, "C2")
        .def(py::init<>())
        .def(py::self + py::self)
        .def("__add__", [](const C2& c2, const C1& c1) { return c2 + c1; })
        .def("__radd__", [](const C2& c2, const C1& c1) { return c1 + c2; });

159
    // test_nested
160
    // #328: first member in a class can't be used in operators
161
    struct NestABase { int value = -2; };
162
163
164
165
    py::class_<NestABase>(m, "NestABase")
        .def(py::init<>())
        .def_readwrite("value", &NestABase::value);

166
167
168
169
    struct NestA : NestABase {
        int value = 3;
        NestA& operator+=(int i) { value += i; return *this; }
    };
170
171
172
173
174
175
    py::class_<NestA>(m, "NestA")
        .def(py::init<>())
        .def(py::self += int())
        .def("as_base", [](NestA &a) -> NestABase& {
            return (NestABase&) a;
        }, py::return_value_policy::reference_internal);
176
    m.def("get_NestA", [](const NestA &a) { return a.value; });
177

178
179
180
181
182
    struct NestB {
        NestA a;
        int value = 4;
        NestB& operator-=(int i) { value -= i; return *this; }
    };
183
184
185
186
    py::class_<NestB>(m, "NestB")
        .def(py::init<>())
        .def(py::self -= int())
        .def_readwrite("a", &NestB::a);
187
    m.def("get_NestB", [](const NestB &b) { return b.value; });
188

189
190
191
192
193
    struct NestC {
        NestB b;
        int value = 5;
        NestC& operator*=(int i) { value *= i; return *this; }
    };
194
195
196
197
198
    py::class_<NestC>(m, "NestC")
        .def(py::init<>())
        .def(py::self *= int())
        .def_readwrite("b", &NestC::b);
    m.def("get_NestC", [](const NestC &c) { return c.value; });
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230


    // test_overriding_eq_reset_hash
    // #2191 Overriding __eq__ should set __hash__ to None
    struct Comparable {
        int value;
        bool operator==(const Comparable& rhs) const {return value == rhs.value;}
    };

    struct Hashable : Comparable {
        explicit Hashable(int value): Comparable{value}{};
        size_t hash() const { return static_cast<size_t>(value); }
    };

    struct Hashable2 : Hashable {
        using Hashable::Hashable;
    };

    py::class_<Comparable>(m, "Comparable")
        .def(py::init<int>())
        .def(py::self == py::self);

    py::class_<Hashable>(m, "Hashable")
        .def(py::init<int>())
        .def(py::self == py::self)
        .def("__hash__", &Hashable::hash);

    // define __hash__ before __eq__
    py::class_<Hashable2>(m, "Hashable2")
        .def("__hash__", &Hashable::hash)
        .def(py::init<int>())
        .def(py::self == py::self);
231
}
Henry Schreiner's avatar
Henry Schreiner committed
232

233
#if !defined(_MSC_VER) && !defined(__INTEL_COMPILER)
Henry Schreiner's avatar
Henry Schreiner committed
234
235
  #pragma GCC diagnostic pop
#endif