New class for return values of interface methods.

src/devices/RemoteControlBoard/RemoteControlBoard.cpp

@@ -1567,12 +1567,12 @@ bool RemoteControlBoard::getNumberOfMotors(int *num)
     return get1V1I(VOCAB_MOTORS_NUMBER, *num);
 }
 
-bool RemoteControlBoard::getTemperature      (int m, double* val)
+yarp::os::yarp_ret_value RemoteControlBoard::getTemperature      (int m, double* val)
 {
     return get1V1I1D(VOCAB_TEMPERATURE, m, val);
 }
 
-bool RemoteControlBoard::getTemperatures     (double *vals)
+yarp::os::yarp_ret_value RemoteControlBoard::getTemperatures     (double *vals)
 {
     return get1VDA(VOCAB_TEMPERATURES, vals);
 }

src/devices/RemoteControlBoard/RemoteControlBoard.h

@@ -329,8 +329,8 @@ class RemoteControlBoard :
 
     // IMotor
     bool getNumberOfMotors(int *num) override;
-    bool getTemperature(int m, double* val) override;
-    bool getTemperatures(double *vals) override;
+    yarp::os::yarp_ret_value getTemperature(int m, double* val) override;
+    yarp::os::yarp_ret_value getTemperatures(double *vals) override;
     bool getTemperatureLimit (int m, double* val) override;
     bool setTemperatureLimit (int m, const double val) override;
     bool getGearboxRatio(int m, double* val) override;

src/devices/controlBoardRemapper/ControlBoardRemapper.cpp

@@ -1986,7 +1986,7 @@ bool ControlBoardRemapper::getNumberOfMotors(int *num)
     return true;
 }
 
-bool ControlBoardRemapper::getTemperature(int m, double* val)
+yarp::os::yarp_ret_value ControlBoardRemapper::getTemperature(int m, double* val)
 {
     int off=(int)remappedControlBoards.lut[m].axisIndexInSubControlBoard;
     size_t subIndex=remappedControlBoards.lut[m].subControlBoardIndex;
@@ -2006,7 +2006,7 @@ bool ControlBoardRemapper::getTemperature(int m, double* val)
     return false;
 }
 
-bool ControlBoardRemapper::getTemperatures(double *vals)
+yarp::os::yarp_ret_value ControlBoardRemapper::getTemperatures(double *vals)
 {
     bool ret=true;
     for(int l=0;l<controlledJoints;l++)

src/devices/controlBoardRemapper/ControlBoardRemapper.h

@@ -451,9 +451,9 @@ class ControlBoardRemapper :
     /* IMotor */
     bool getNumberOfMotors(int *num) override;
 
-    bool getTemperature(int m, double *val) override;
+    yarp::os::yarp_ret_value getTemperature(int m, double *val) override;
 
-    bool getTemperatures(double *vals) override;
+    yarp::os::yarp_ret_value getTemperatures(double *vals) override;
 
     bool getTemperatureLimit(int m, double *val) override;
 

src/devices/fakeMotionControl/fakeMotionControl.cpp

@@ -3163,14 +3163,14 @@ bool FakeMotionControl::getNumberOfMotorsRaw(int* num)
     return true;
 }
 
-bool FakeMotionControl::getTemperatureRaw(int m, double* val)
+yarp::os::yarp_ret_value FakeMotionControl::getTemperatureRaw(int m, double* val)
 {
-    return NOT_YET_IMPLEMENTED("getTemperatureRaw");
+    return yarp::os::yarp_ret_value(true);
 }
 
-bool FakeMotionControl::getTemperaturesRaw(double *vals)
+yarp::os::yarp_ret_value FakeMotionControl::getTemperaturesRaw(double *vals)
 {
-    bool ret = true;
+    yarp::os::yarp_ret_value ret = true;
     for(int j=0; j< _njoints; j++)
     {
         ret &= getTemperatureRaw(j, &vals[j]);

src/devices/fakeMotionControl/fakeMotionControl.h

@@ -475,8 +475,8 @@ class FakeMotionControl :
 
     // IMotor interface
     bool getNumberOfMotorsRaw(int * num) override;
-    bool getTemperatureRaw(int m, double* val) override;
-    bool getTemperaturesRaw(double *vals) override;
+    yarp::os::yarp_ret_value getTemperatureRaw(int m, double* val) override;
+    yarp::os::yarp_ret_value getTemperaturesRaw(double *vals) override;
     bool getTemperatureLimitRaw(int m, double *temp) override;
     bool setTemperatureLimitRaw(int m, const double temp) override;
     bool getGearboxRatioRaw(int m, double* gearbox) override;

src/libYARP_dev/src/yarp/dev/IMotor.h

@@ -9,6 +9,7 @@
 #include <yarp/os/Vocab.h>
 #include <yarp/os/Log.h>
 #include <yarp/dev/api.h>
+#include <yarp/os/ReturnValue.h>
 
 namespace yarp::dev {
 class IMotorRaw;
@@ -41,14 +42,14 @@ class YARP_dev_API yarp::dev::IMotorRaw
      * @param val retrieved motor temperature
      * @return true/false
      */
-    virtual bool getTemperatureRaw(int m, double* val)=0;
+    virtual yarp::os::yarp_ret_value getTemperatureRaw(int m, double* val)=0;
 
     /**
      * Get temperature of all the motors.
      * @param vals pointer to an array containing all motor temperatures
      * @return true/false
      */
-    virtual bool getTemperaturesRaw(double *vals)=0;
+    virtual yarp::os::yarp_ret_value getTemperaturesRaw(double *vals)=0;
 
     /**
      * Retreives the current temperature limit for a specific motor.
@@ -111,14 +112,14 @@ class YARP_dev_API yarp::dev::IMotor
      * @param val retrieved motor temperature
      * @return true/false
      */
-    virtual bool getTemperature(int m, double *val)=0;
+    virtual yarp::os::yarp_ret_value getTemperature(int m, double *val)=0;
 
     /**
      * Get temperature of all the motors.
      * @param vals pointer to an array containing all motor temperatures
      * @return true/false
      */
-    virtual bool getTemperatures(double *vals)=0;
+    virtual yarp::os::yarp_ret_value getTemperatures(double *vals)=0;
 
     /**
      * Retreives the current temperature limit for a specific motor.

src/libYARP_dev/src/yarp/dev/ImplementMotor.cpp

@@ -67,10 +67,10 @@ bool ImplementMotor::getNumberOfMotors(int *num)
     return true;
 }
 
-bool ImplementMotor::getTemperature(int m, double* value)
+yarp::os::yarp_ret_value ImplementMotor::getTemperature(int m, double* value)
 {
     JOINTIDCHECK
-    bool ret;
+    yarp::os::yarp_ret_value ret;
     int k=castToMapper(helper)->toHw(m);
 
     ret=imotor->getTemperatureRaw(k, value);
@@ -122,11 +122,11 @@ bool ImplementMotor::setGearboxRatio(int m, const double value)
     return ret;
 }
 
-bool ImplementMotor::getTemperatures(double *v)
+yarp::os::yarp_ret_value ImplementMotor::getTemperatures(double *v)
 {
     yarp::dev::impl::Buffer<double> buffValues = doubleBuffManager->getBuffer();
 
-    bool ret = imotor->getTemperaturesRaw(buffValues.getData());
+    yarp::os::yarp_ret_value ret = imotor->getTemperaturesRaw(buffValues.getData());
     for (size_t i=0; i< buffValues.getSize(); i++)
     {
         int k = castToMapper(helper)->toHw(i);

src/libYARP_dev/src/yarp/dev/ImplementMotor.h

@@ -54,8 +54,8 @@ class YARP_dev_API yarp::dev::ImplementMotor: public IMotor
 
     bool getNumberOfMotors(int *num) override;
 
-    bool getTemperature      (int m, double* val) override;
-    bool getTemperatures     (double *vals) override;
+    yarp::os::yarp_ret_value getTemperature      (int m, double* val) override;
+    yarp::os::yarp_ret_value getTemperatures     (double *vals) override;
     bool getTemperatureLimit (int m, double* val) override;
     bool setTemperatureLimit (int m, const double val) override;
     bool getGearboxRatio     (int m, double* val) override;

src/libYARP_os/src/CMakeLists.txt

@@ -96,6 +96,7 @@ set(YARP_os_HDRS
   yarp/os/Random.h
   yarp/os/ResourceFinder.h
   yarp/os/ResourceFinderOptions.h
+  yarp/os/ReturnValue.h
   yarp/os/RFModule.h
   yarp/os/RFPlugin.h
   yarp/os/RosNameSpace.h
@@ -210,6 +211,7 @@ set(YARP_os_SRCS
   yarp/os/Random.cpp
   yarp/os/ResourceFinder.cpp
   yarp/os/ResourceFinderOptions.cpp
+  yarp/os/ReturnValue.cpp
   yarp/os/RFModule.cpp
   yarp/os/RFPlugin.cpp
   yarp/os/RosNameSpace.cpp

src/libYARP_os/tests/CMakeLists.txt

@@ -28,6 +28,7 @@ target_sources(harness_os PRIVATE
   PropertyTest.cpp
   PublisherTest.cpp
   ResourceFinderTest.cpp
+  ReturnValueTest.cpp
   RFModuleTest.cpp
   RouteTest.cpp
   SemaphoreTest.cpp

src/libYARP_os/tests/ReturnValueTest.cpp

@@ -0,0 +1,101 @@
+/*
+ * SPDX-FileCopyrightText: 2023-2023 Istituto Italiano di Tecnologia (IIT)
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+
+#include <yarp/os/ReturnValue.h>
+
+#include <catch2/catch_amalgamated.hpp>
+#include <harness.h>
+
+using namespace yarp::os;
+
+TEST_CASE("os::ReturnValue", "[yarp::os]")
+{
+    SECTION("test block 1")
+    {
+        yarp_ret_value val_f1(false);
+        yarp_ret_value val_f2(false);
+
+        yarp_ret_value val_t1(true);
+        yarp_ret_value val_t2(true);
+
+        CHECK(val_f1 == val_f2);
+        CHECK(val_t1 == val_t2);
+        CHECK(val_f1 != val_t1);
+        CHECK(val_t1);
+        CHECK(!val_f1);
+
+        std::string sf = val_f1.toString();
+        std::string st = val_t1.toString();
+    }
+
+    SECTION("test block 2")
+    {
+        yarp_ret_value val1;
+        CHECK(val1 == yarp_ret_value::return_code::return_value_unitialized);
+
+        std::string s;
+        val1 = yarp_ret_value::return_code::return_value_ok;
+        s = val1.toString();
+        CHECK(val1);
+        CHECK(s!="unknown");
+
+        val1 = yarp_ret_value::return_code::return_value_error_generic;
+        s = val1.toString(); 
+        CHECK(!val1);
+        CHECK(s != "unknown");
+
+        val1 = yarp_ret_value::return_code::return_value_error_method_failed;
+        s = val1.toString(); 
+        CHECK(!val1);
+        CHECK(s != "unknown");
+
+        val1 = yarp_ret_value::return_code::return_value_error_not_implemented_by_device;
+        s = val1.toString(); 
+        CHECK(!val1);
+        CHECK(s != "unknown");
+
+        val1 = yarp_ret_value::return_code::return_value_error_nws_nwc_communication_error;
+        s = val1.toString(); 
+        CHECK(!val1);
+        CHECK(s != "unknown");
+
+        val1 = yarp_ret_value::return_code::return_value_unitialized;
+        s = val1.toString(); 
+        CHECK(!val1);
+        CHECK(s != "unknown");
+    }
+
+    SECTION("test block 3")
+    {
+        yarp_ret_value val1;
+        val1 = yarp_ret_value::return_code::return_value_ok;
+        yarp_ret_value val2(val1);
+        CHECK(val2);
+        CHECK(val2 == yarp_ret_value::return_code::return_value_ok);
+
+        val1 = yarp_ret_value::return_code::return_value_error_method_failed;
+        yarp_ret_value val3 = val1;
+        CHECK(!val3);
+        CHECK(val3 == yarp_ret_value::return_code::return_value_error_method_failed);
+    }
+
+    SECTION("test block 4")
+    {
+        yarp_ret_value val_f1(false);
+        yarp_ret_value val_t1(true);
+        bool bool_f1 = val_f1;
+        bool bool_t1 = val_t1;
+        CHECK (bool_f1 == false);
+        CHECK (bool_t1 == true);
+
+        yarp_ret_value val_f2(yarp_ret_value::return_code::return_value_error_method_failed);
+        yarp_ret_value val_t2(yarp_ret_value::return_code::return_value_ok);
+        bool bool_f2 = val_f2;
+        bool bool_t2 = val_t2;
+        CHECK(bool_f2 == false);
+        CHECK(bool_t2 == true);
+    }
+}