111986Sandreas.sandberg@arm.com/* 211986Sandreas.sandberg@arm.com tests/test_operator_overloading.cpp -- operator overloading 311986Sandreas.sandberg@arm.com 411986Sandreas.sandberg@arm.com Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> 511986Sandreas.sandberg@arm.com 611986Sandreas.sandberg@arm.com All rights reserved. Use of this source code is governed by a 711986Sandreas.sandberg@arm.com BSD-style license that can be found in the LICENSE file. 811986Sandreas.sandberg@arm.com*/ 911986Sandreas.sandberg@arm.com 1011986Sandreas.sandberg@arm.com#include "pybind11_tests.h" 1111986Sandreas.sandberg@arm.com#include "constructor_stats.h" 1211986Sandreas.sandberg@arm.com#include <pybind11/operators.h> 1312391Sjason@lowepower.com#include <functional> 1411986Sandreas.sandberg@arm.com 1511986Sandreas.sandberg@arm.comclass Vector2 { 1611986Sandreas.sandberg@arm.compublic: 1711986Sandreas.sandberg@arm.com Vector2(float x, float y) : x(x), y(y) { print_created(this, toString()); } 1811986Sandreas.sandberg@arm.com Vector2(const Vector2 &v) : x(v.x), y(v.y) { print_copy_created(this); } 1911986Sandreas.sandberg@arm.com Vector2(Vector2 &&v) : x(v.x), y(v.y) { print_move_created(this); v.x = v.y = 0; } 2012391Sjason@lowepower.com Vector2 &operator=(const Vector2 &v) { x = v.x; y = v.y; print_copy_assigned(this); return *this; } 2112391Sjason@lowepower.com Vector2 &operator=(Vector2 &&v) { x = v.x; y = v.y; v.x = v.y = 0; print_move_assigned(this); return *this; } 2211986Sandreas.sandberg@arm.com ~Vector2() { print_destroyed(this); } 2311986Sandreas.sandberg@arm.com 2412391Sjason@lowepower.com std::string toString() const { return "[" + std::to_string(x) + ", " + std::to_string(y) + "]"; } 2511986Sandreas.sandberg@arm.com 2614299Sbbruce@ucdavis.edu Vector2 operator-() const { return Vector2(-x, -y); } 2711986Sandreas.sandberg@arm.com Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); } 2811986Sandreas.sandberg@arm.com Vector2 operator-(const Vector2 &v) const { return Vector2(x - v.x, y - v.y); } 2911986Sandreas.sandberg@arm.com Vector2 operator-(float value) const { return Vector2(x - value, y - value); } 3011986Sandreas.sandberg@arm.com Vector2 operator+(float value) const { return Vector2(x + value, y + value); } 3111986Sandreas.sandberg@arm.com Vector2 operator*(float value) const { return Vector2(x * value, y * value); } 3211986Sandreas.sandberg@arm.com Vector2 operator/(float value) const { return Vector2(x / value, y / value); } 3312391Sjason@lowepower.com Vector2 operator*(const Vector2 &v) const { return Vector2(x * v.x, y * v.y); } 3412391Sjason@lowepower.com Vector2 operator/(const Vector2 &v) const { return Vector2(x / v.x, y / v.y); } 3511986Sandreas.sandberg@arm.com Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; } 3611986Sandreas.sandberg@arm.com Vector2& operator-=(const Vector2 &v) { x -= v.x; y -= v.y; return *this; } 3711986Sandreas.sandberg@arm.com Vector2& operator*=(float v) { x *= v; y *= v; return *this; } 3811986Sandreas.sandberg@arm.com Vector2& operator/=(float v) { x /= v; y /= v; return *this; } 3912391Sjason@lowepower.com Vector2& operator*=(const Vector2 &v) { x *= v.x; y *= v.y; return *this; } 4012391Sjason@lowepower.com Vector2& operator/=(const Vector2 &v) { x /= v.x; y /= v.y; return *this; } 4111986Sandreas.sandberg@arm.com 4211986Sandreas.sandberg@arm.com friend Vector2 operator+(float f, const Vector2 &v) { return Vector2(f + v.x, f + v.y); } 4311986Sandreas.sandberg@arm.com friend Vector2 operator-(float f, const Vector2 &v) { return Vector2(f - v.x, f - v.y); } 4411986Sandreas.sandberg@arm.com friend Vector2 operator*(float f, const Vector2 &v) { return Vector2(f * v.x, f * v.y); } 4511986Sandreas.sandberg@arm.com friend Vector2 operator/(float f, const Vector2 &v) { return Vector2(f / v.x, f / v.y); } 4611986Sandreas.sandberg@arm.comprivate: 4711986Sandreas.sandberg@arm.com float x, y; 4811986Sandreas.sandberg@arm.com}; 4911986Sandreas.sandberg@arm.com 5012391Sjason@lowepower.comclass C1 { }; 5112391Sjason@lowepower.comclass C2 { }; 5212391Sjason@lowepower.com 5312391Sjason@lowepower.comint operator+(const C1 &, const C1 &) { return 11; } 5412391Sjason@lowepower.comint operator+(const C2 &, const C2 &) { return 22; } 5512391Sjason@lowepower.comint operator+(const C2 &, const C1 &) { return 21; } 5612391Sjason@lowepower.comint operator+(const C1 &, const C2 &) { return 12; } 5712391Sjason@lowepower.com 5812391Sjason@lowepower.comnamespace std { 5912391Sjason@lowepower.com template<> 6012391Sjason@lowepower.com struct hash<Vector2> { 6112391Sjason@lowepower.com // Not a good hash function, but easy to test 6212391Sjason@lowepower.com size_t operator()(const Vector2 &) { return 4; } 6312391Sjason@lowepower.com }; 6412391Sjason@lowepower.com} 6512391Sjason@lowepower.com 6614299Sbbruce@ucdavis.edu// MSVC warns about unknown pragmas, and warnings are errors. 6714299Sbbruce@ucdavis.edu#ifndef _MSC_VER 6814299Sbbruce@ucdavis.edu #pragma GCC diagnostic push 6914299Sbbruce@ucdavis.edu // clang 7.0.0 and Apple LLVM 10.0.1 introduce `-Wself-assign-overloaded` to 7014299Sbbruce@ucdavis.edu // `-Wall`, which is used here for overloading (e.g. `py::self += py::self `). 7114299Sbbruce@ucdavis.edu // Here, we suppress the warning using `#pragma diagnostic`. 7214299Sbbruce@ucdavis.edu // Taken from: https://github.com/RobotLocomotion/drake/commit/aaf84b46 7314299Sbbruce@ucdavis.edu // TODO(eric): This could be resolved using a function / functor (e.g. `py::self()`). 7414299Sbbruce@ucdavis.edu #if (__APPLE__) && (__clang__) 7514299Sbbruce@ucdavis.edu #if (__clang_major__ >= 10) && (__clang_minor__ >= 0) && (__clang_patchlevel__ >= 1) 7614299Sbbruce@ucdavis.edu #pragma GCC diagnostic ignored "-Wself-assign-overloaded" 7714299Sbbruce@ucdavis.edu #endif 7814299Sbbruce@ucdavis.edu #elif (__clang__) 7914299Sbbruce@ucdavis.edu #if (__clang_major__ >= 7) 8014299Sbbruce@ucdavis.edu #pragma GCC diagnostic ignored "-Wself-assign-overloaded" 8114299Sbbruce@ucdavis.edu #endif 8214299Sbbruce@ucdavis.edu #endif 8314299Sbbruce@ucdavis.edu#endif 8414299Sbbruce@ucdavis.edu 8512391Sjason@lowepower.comTEST_SUBMODULE(operators, m) { 8612391Sjason@lowepower.com 8712391Sjason@lowepower.com // test_operator_overloading 8811986Sandreas.sandberg@arm.com py::class_<Vector2>(m, "Vector2") 8911986Sandreas.sandberg@arm.com .def(py::init<float, float>()) 9011986Sandreas.sandberg@arm.com .def(py::self + py::self) 9111986Sandreas.sandberg@arm.com .def(py::self + float()) 9211986Sandreas.sandberg@arm.com .def(py::self - py::self) 9311986Sandreas.sandberg@arm.com .def(py::self - float()) 9411986Sandreas.sandberg@arm.com .def(py::self * float()) 9511986Sandreas.sandberg@arm.com .def(py::self / float()) 9612391Sjason@lowepower.com .def(py::self * py::self) 9712391Sjason@lowepower.com .def(py::self / py::self) 9811986Sandreas.sandberg@arm.com .def(py::self += py::self) 9911986Sandreas.sandberg@arm.com .def(py::self -= py::self) 10011986Sandreas.sandberg@arm.com .def(py::self *= float()) 10111986Sandreas.sandberg@arm.com .def(py::self /= float()) 10212391Sjason@lowepower.com .def(py::self *= py::self) 10312391Sjason@lowepower.com .def(py::self /= py::self) 10411986Sandreas.sandberg@arm.com .def(float() + py::self) 10511986Sandreas.sandberg@arm.com .def(float() - py::self) 10611986Sandreas.sandberg@arm.com .def(float() * py::self) 10711986Sandreas.sandberg@arm.com .def(float() / py::self) 10814299Sbbruce@ucdavis.edu .def(-py::self) 10911986Sandreas.sandberg@arm.com .def("__str__", &Vector2::toString) 11012391Sjason@lowepower.com .def(hash(py::self)) 11111986Sandreas.sandberg@arm.com ; 11211986Sandreas.sandberg@arm.com 11311986Sandreas.sandberg@arm.com m.attr("Vector") = m.attr("Vector2"); 11412391Sjason@lowepower.com 11512391Sjason@lowepower.com // test_operators_notimplemented 11612391Sjason@lowepower.com // #393: need to return NotSupported to ensure correct arithmetic operator behavior 11712391Sjason@lowepower.com py::class_<C1>(m, "C1") 11812391Sjason@lowepower.com .def(py::init<>()) 11912391Sjason@lowepower.com .def(py::self + py::self); 12012391Sjason@lowepower.com 12112391Sjason@lowepower.com py::class_<C2>(m, "C2") 12212391Sjason@lowepower.com .def(py::init<>()) 12312391Sjason@lowepower.com .def(py::self + py::self) 12412391Sjason@lowepower.com .def("__add__", [](const C2& c2, const C1& c1) { return c2 + c1; }) 12512391Sjason@lowepower.com .def("__radd__", [](const C2& c2, const C1& c1) { return c1 + c2; }); 12612391Sjason@lowepower.com 12712391Sjason@lowepower.com // test_nested 12812391Sjason@lowepower.com // #328: first member in a class can't be used in operators 12912391Sjason@lowepower.com struct NestABase { int value = -2; }; 13012391Sjason@lowepower.com py::class_<NestABase>(m, "NestABase") 13112391Sjason@lowepower.com .def(py::init<>()) 13212391Sjason@lowepower.com .def_readwrite("value", &NestABase::value); 13312391Sjason@lowepower.com 13412391Sjason@lowepower.com struct NestA : NestABase { 13512391Sjason@lowepower.com int value = 3; 13612391Sjason@lowepower.com NestA& operator+=(int i) { value += i; return *this; } 13712391Sjason@lowepower.com }; 13812391Sjason@lowepower.com py::class_<NestA>(m, "NestA") 13912391Sjason@lowepower.com .def(py::init<>()) 14012391Sjason@lowepower.com .def(py::self += int()) 14112391Sjason@lowepower.com .def("as_base", [](NestA &a) -> NestABase& { 14212391Sjason@lowepower.com return (NestABase&) a; 14312391Sjason@lowepower.com }, py::return_value_policy::reference_internal); 14412391Sjason@lowepower.com m.def("get_NestA", [](const NestA &a) { return a.value; }); 14512391Sjason@lowepower.com 14612391Sjason@lowepower.com struct NestB { 14712391Sjason@lowepower.com NestA a; 14812391Sjason@lowepower.com int value = 4; 14912391Sjason@lowepower.com NestB& operator-=(int i) { value -= i; return *this; } 15012391Sjason@lowepower.com }; 15112391Sjason@lowepower.com py::class_<NestB>(m, "NestB") 15212391Sjason@lowepower.com .def(py::init<>()) 15312391Sjason@lowepower.com .def(py::self -= int()) 15412391Sjason@lowepower.com .def_readwrite("a", &NestB::a); 15512391Sjason@lowepower.com m.def("get_NestB", [](const NestB &b) { return b.value; }); 15612391Sjason@lowepower.com 15712391Sjason@lowepower.com struct NestC { 15812391Sjason@lowepower.com NestB b; 15912391Sjason@lowepower.com int value = 5; 16012391Sjason@lowepower.com NestC& operator*=(int i) { value *= i; return *this; } 16112391Sjason@lowepower.com }; 16212391Sjason@lowepower.com py::class_<NestC>(m, "NestC") 16312391Sjason@lowepower.com .def(py::init<>()) 16412391Sjason@lowepower.com .def(py::self *= int()) 16512391Sjason@lowepower.com .def_readwrite("b", &NestC::b); 16612391Sjason@lowepower.com m.def("get_NestC", [](const NestC &c) { return c.value; }); 16712391Sjason@lowepower.com} 16814299Sbbruce@ucdavis.edu 16914299Sbbruce@ucdavis.edu#ifndef _MSC_VER 17014299Sbbruce@ucdavis.edu #pragma GCC diagnostic pop 17114299Sbbruce@ucdavis.edu#endif 172