Simplified Measure class by making the double constructor non-explicit

Author: TimSchneider42

include/franky/motion/measure.hpp

@@ -8,24 +8,6 @@
 
 #include "franky/motion/condition.hpp"
 
-#define MEASURE_CMP_DECL(OP) \
-Condition operator OP(const Measure &m1, const Measure &m2); \
-inline Condition operator OP(const Measure &m1, double m2) { \
-  return m1 OP Measure(m2); \
-} \
-inline Condition operator OP(double m1, const Measure &m2) { \
-  return Measure(m1) OP m2; \
-}
-
-#define MEASURE_OP_DECL(OP) \
-Measure operator OP(const Measure &m1, const Measure &m2); \
-inline Measure operator OP(const Measure &m1, double m2){ \
-  return m1 OP Measure(m2); \
-} \
-inline Measure operator OP(double m1, const Measure &m2){ \
-  return Measure(m1) OP m2; \
-}
-
 namespace franky {
 
 class Measure {
@@ -34,7 +16,7 @@ class Measure {
  public:
   explicit Measure(MeasureFunc measure_func, std::string repr = "NULL");
 
-  explicit Measure(double constant);
+  Measure(double constant);
 
   inline double operator()(const franka::RobotState &robot_state, double rel_time, double abs_time) const {
     return measure_func_(robot_state, rel_time, abs_time);
@@ -59,26 +41,20 @@ class Measure {
   std::string repr_;
 };
 
-MEASURE_CMP_DECL(==)
-MEASURE_CMP_DECL(!=)
-MEASURE_CMP_DECL(<=)
-MEASURE_CMP_DECL(>=)
-MEASURE_CMP_DECL(<)
-MEASURE_CMP_DECL(>)
+Condition operator==(const Measure &m1, const Measure &m2);
+Condition operator!=(const Measure &m1, const Measure &m2);
+Condition operator<=(const Measure &m1, const Measure &m2);
+Condition operator>=(const Measure &m1, const Measure &m2);
+Condition operator<(const Measure &m1, const Measure &m2);
+Condition operator>(const Measure &m1, const Measure &m2);
 
-MEASURE_OP_DECL(+)
-MEASURE_OP_DECL(-)
-MEASURE_OP_DECL(*)
-MEASURE_OP_DECL(/)
+Measure operator+(const Measure &m1, const Measure &m2);
+Measure operator-(const Measure &m1, const Measure &m2);
+Measure operator*(const Measure &m1, const Measure &m2);
+Measure operator/(const Measure &m1, const Measure &m2);
 
 Measure operator-(const Measure &m);
 
 Measure measure_pow(const Measure &base, const Measure &exponent);
-inline Measure measure_pow(double base, const Measure &exponent) {
-  return measure_pow(Measure(base), exponent);
-}
-inline Measure measure_pow(const Measure &base, double exponent) {
-  return measure_pow(base, Measure(exponent));
-}
 
 }  // namespace franky

python/python.cpp

@@ -235,31 +235,34 @@ PYBIND11_MODULE(_franky, m) {
       .def_property_readonly_static("REL_TIME", [](py::object) { return Measure::RelTime(); })
       .def_property_readonly_static("ABS_TIME", [](py::object) { return Measure::AbsTime(); })
       .def("__eq__", py::overload_cast<const Measure &, const Measure &>(&operator==), py::is_operator())
-      .def("__eq__", py::overload_cast<const Measure &, double>(&operator==), py::is_operator())
+      .def("__eq__", [](const Measure &measure, double constant) { return measure == constant; }, py::is_operator())
       .def("__ne__", py::overload_cast<const Measure &, const Measure &>(&operator!=), py::is_operator())
-      .def("__ne__", py::overload_cast<const Measure &, double>(&operator!=), py::is_operator())
+      .def("__ne__", [](const Measure &measure, double constant) { return measure != constant; }, py::is_operator())
       .def("__gt__", py::overload_cast<const Measure &, const Measure &>(&operator>), py::is_operator())
-      .def("__gt__", py::overload_cast<const Measure &, double>(&operator>), py::is_operator())
+      .def("__gt__", [](const Measure &measure, double constant) { return measure > constant; }, py::is_operator())
       .def("__ge__", py::overload_cast<const Measure &, const Measure &>(&operator>=), py::is_operator())
-      .def("__ge__", py::overload_cast<const Measure &, double>(&operator>=), py::is_operator())
+      .def("__ge__", [](const Measure &measure, double constant) { return measure >= constant; }, py::is_operator())
       .def("__lt__", py::overload_cast<const Measure &, const Measure &>(&operator<), py::is_operator())
-      .def("__lt__", py::overload_cast<const Measure &, double>(&operator<), py::is_operator())
+      .def("__lt__", [](const Measure &measure, double constant) { return measure < constant; }, py::is_operator())
       .def("__le__", py::overload_cast<const Measure &, const Measure &>(&operator<=), py::is_operator())
-      .def("__le__", py::overload_cast<const Measure &, double>(&operator<=), py::is_operator())
+      .def("__le__", [](const Measure &measure, double constant) { return measure <= constant; }, py::is_operator())
+      .def("__neg__", py::overload_cast<const Measure &>(&operator-), py::is_operator())
       .def("__add__", py::overload_cast<const Measure &, const Measure &>(&operator+), py::is_operator())
-      .def("__add__", py::overload_cast<const Measure &, double>(&operator+), py::is_operator())
+      .def("__add__", [](const Measure &measure, double constant) { return measure + constant; }, py::is_operator())
       .def("__radd__", [](const Measure &measure, double constant) { return constant + measure; }, py::is_operator())
       .def("__sub__", py::overload_cast<const Measure &, const Measure &>(&operator-), py::is_operator())
-      .def("__sub__", py::overload_cast<const Measure &, double>(&operator-), py::is_operator())
+      .def("__sub__", [](const Measure &measure, double constant) { return constant - measure; }, py::is_operator())
       .def("__rsub__", [](const Measure &measure, double constant) { return constant - measure; }, py::is_operator())
       .def("__mul__", py::overload_cast<const Measure &, const Measure &>(&operator*), py::is_operator())
-      .def("__mul__", py::overload_cast<const Measure &, double>(&operator*), py::is_operator())
+      .def("__mul__", [](const Measure &measure, double constant) { return constant * measure; }, py::is_operator())
       .def("__rmul__", [](const Measure &measure, double constant) { return constant * measure; }, py::is_operator())
       .def("__div__", py::overload_cast<const Measure &, const Measure &>(&operator/), py::is_operator())
-      .def("__div__", py::overload_cast<const Measure &, double>(&operator/), py::is_operator())
+      .def("__div__", [](const Measure &measure, double constant) { return constant / measure; }, py::is_operator())
       .def("__rdiv__", [](const Measure &measure, double constant) { return constant / measure; }, py::is_operator())
       .def("__pow__", py::overload_cast<const Measure &, const Measure &>(&measure_pow), py::is_operator())
-      .def("__pow__", py::overload_cast<const Measure &, double>(&measure_pow), py::is_operator())
+      .def("__pow__",
+           [](const Measure &measure, double constant) { return measure_pow(measure, constant); },
+           py::is_operator())
       .def("__rpow__",
            [](const Measure &measure, double constant) { return measure_pow(constant, measure); },
            py::is_operator())