Add a new operator to access fuzzy value (#66)

* Add a new operator to access fuzzy value

Signed-off-by: jparisu <javierparis@eprosima.com>

* Add tests and docs

Signed-off-by: jparisu <javierparis@eprosima.com>

---------

Signed-off-by: jparisu <javierparis@eprosima.com>

Author: jparisu

cpp_utils/include/cpp_utils/types/Fuzzy.hpp

@@ -147,6 +147,12 @@ class Fuzzy
     bool operator !=(
             const T& other) const noexcept;
 
+    //! Operator to access the internal object
+    const T* operator ->() const noexcept;
+
+    //! Operator to access the internal object
+    T* operator ->() noexcept;
+
     /////////////////////////
     // GET METHODS
     /////////////////////////
@@ -194,15 +200,15 @@ class Fuzzy
      *
      * By default this value would be initialized with default constructor.
      */
-    T value = T();
+    T value_ = T();
 
     /**
      * @brief Fuzzy level of this object.
      *
      * This defines the certainty with which the internal \c value has been set.
      * By default is set to \c fuzzy_level_default if the internal value has not been set.
      */
-    FuzzyLevelType fuzzy_level = FuzzyLevelValues::fuzzy_level_default;
+    FuzzyLevelType fuzzy_level_ = FuzzyLevelValues::fuzzy_level_default;
 };
 
 

cpp_utils/include/cpp_utils/types/impl/Fuzzy.ipp

@@ -26,17 +26,17 @@ template <typename T>
 Fuzzy<T>::Fuzzy(
         const T& other,
         FuzzyLevelType level /* = FuzzyLevelValues::set */)
-    : value(other)
-    , fuzzy_level(level)
+    : value_(other)
+    , fuzzy_level_(level)
 {
 }
 
 template <typename T>
 Fuzzy<T>::Fuzzy(
         T&& other,
         FuzzyLevelType level /* = FuzzyLevelValues::set */)
-    : value(std::move(other))
-    , fuzzy_level(level)
+    : value_(std::move(other))
+    , fuzzy_level_(level)
 {
 }
 
@@ -47,13 +47,13 @@ Fuzzy<T>::Fuzzy(
 template <typename T>
 Fuzzy<T>::operator T&() noexcept
 {
-    return value;
+    return value_;
 }
 
 template <typename T>
 Fuzzy<T>::operator T() const noexcept
 {
-    return value;
+    return value_;
 }
 
 template <typename T>
@@ -67,7 +67,7 @@ bool Fuzzy<T>::operator ==(
     }
     else
     {
-        return this->fuzzy_level == other.fuzzy_level && this->value == other.get_reference();
+        return this->fuzzy_level_ == other.fuzzy_level_ && this->value_ == other.get_reference();
     }
 }
 
@@ -81,7 +81,7 @@ bool Fuzzy<T>::operator ==(
     }
     else
     {
-        return this->value == other;
+        return this->value_ == other;
     }
 }
 
@@ -99,44 +99,56 @@ bool Fuzzy<T>::operator !=(
     return !(this->operator ==(other));
 }
 
+template <typename T>
+const T* Fuzzy<T>::operator ->() const noexcept
+{
+    return &value_;
+}
+
+template <typename T>
+T* Fuzzy<T>::operator ->() noexcept
+{
+    return &value_;
+}
+
 /////////////////////////
 // GET METHODS
 /////////////////////////
 
 template <typename T>
 bool Fuzzy<T>::is_valid() const noexcept
 {
-    return fuzzy_level >= FuzzyLevelValues::fuzzy_level_default;
+    return fuzzy_level_ >= FuzzyLevelValues::fuzzy_level_default;
 }
 
 template <typename T>
 bool Fuzzy<T>::is_set() const noexcept
 {
-    return fuzzy_level >= FuzzyLevelValues::fuzzy_level_fuzzy;
+    return fuzzy_level_ >= FuzzyLevelValues::fuzzy_level_fuzzy;
 }
 
 template <typename T>
 T& Fuzzy<T>::get_reference() noexcept
 {
-    return value;
+    return value_;
 }
 
 template <typename T>
 const T& Fuzzy<T>::get_reference() const noexcept
 {
-    return value;
+    return value_;
 }
 
 template <typename T>
 T Fuzzy<T>::get_value() const noexcept
 {
-    return value;
+    return value_;
 }
 
 template <typename T>
 FuzzyLevelType Fuzzy<T>::get_level() const noexcept
 {
-    return fuzzy_level;
+    return fuzzy_level_;
 }
 
 /////////////////////////
@@ -146,24 +158,24 @@ FuzzyLevelType Fuzzy<T>::get_level() const noexcept
 template <typename T>
 void Fuzzy<T>::unset()
 {
-    // It is not needed to change value, as it would be used as it is not set
-    fuzzy_level = FuzzyLevelValues::fuzzy_level_unset;
+    // It is not needed to change value_, as it would be used as it is not set
+    fuzzy_level_ = FuzzyLevelValues::fuzzy_level_unset;
 }
 
 template <typename T>
 void Fuzzy<T>::set_value(
         const T& new_value,
         FuzzyLevelType level /* = FuzzyLevelValues::SET */)
 {
-    value = new_value;
-    fuzzy_level = level;
+    value_ = new_value;
+    fuzzy_level_ = level;
 }
 
 template <typename T>
 void Fuzzy<T>::set_level(
         FuzzyLevelType level /* = FuzzyLevelValues::fuzzy_level_set */)
 {
-    fuzzy_level = level;
+    fuzzy_level_ = level;
 }
 
 /////////////////////////
@@ -181,5 +193,3 @@ std::ostream& operator <<(
 
 } /* namespace utils */
 } /* namespace eprosima */
-
-

cpp_utils/test/unittest/types/CMakeLists.txt

@@ -28,6 +28,7 @@ set(TEST_LIST
         default_construct
         construct
         assign_operator
+        arrow_operator
     )
 
 set(TEST_EXTRA_LIBRARIES

cpp_utils/test/unittest/types/fuzzyTest.cpp

@@ -155,6 +155,29 @@ TEST(fuzzyTest, assign_operator)
     }
 }
 
+/**
+ * Test Fuzzy arrow operator
+ *
+ * CASES:
+ * - const
+ * - no const
+ */
+TEST(fuzzyTest, arrow_operator)
+{
+    // no const
+    {
+        Fuzzy<std::string> f;
+        f = std::string("hello");
+        ASSERT_EQ(f->size(), 5);
+    }
+
+    // const
+    {
+        const Fuzzy<std::string> f (std::string("hello"));
+        ASSERT_EQ(f->size(), 5);
+    }
+}
+
 int main(
         int argc,
         char** argv)