RealParameterWrapper::setValue now respect limits attribute, corresponding unit tests.

Core/Tools/inc/AttLimits.h

@@ -29,38 +29,49 @@ class BA_CORE_API_ AttLimits
 {
  public:
     AttLimits() : m_has_lower_limit(false), m_has_upper_limit(false), m_is_fixed(false), m_lower_limit(0), m_upper_limit(0) {}
-    virtual ~AttLimits(){}
+    ~AttLimits(){}
 
     //! if has lower limit
-    virtual bool hasLowerLimit() const { return m_has_lower_limit; }
+    bool hasLowerLimit() const { return m_has_lower_limit; }
+
     //! Returns lower limit
-    virtual double getLowerLimit() const { return m_lower_limit; }
+    double getLowerLimit() const { return m_lower_limit; }
+
     //! Sets lower limit
-    virtual void setLowerLimit(double value) { m_lower_limit = value; m_has_lower_limit = true; }
+    void setLowerLimit(double value) { m_lower_limit = value; m_has_lower_limit = true; }
+
     //! remove lower limit
-    virtual void removeLowerLimit() { m_lower_limit = 0.0; m_has_lower_limit = false; }
+    void removeLowerLimit() { m_lower_limit = 0.0; m_has_lower_limit = false; }
 
     //! if has upper limit
-    virtual bool hasUpperLimit() const { return m_has_upper_limit; }
+    bool hasUpperLimit() const { return m_has_upper_limit; }
+
     //! Returns upper limit
-    virtual double getUpperLimit() const { return m_upper_limit; }
+    double getUpperLimit() const { return m_upper_limit; }
+
     //! Sets upper limit
-    virtual void setUpperLimit(double value) { m_upper_limit = value; m_has_upper_limit = true; }
+    void setUpperLimit(double value) { m_upper_limit = value; m_has_upper_limit = true; }
+
     //! remove upper limit
-    virtual void removeUpperLimit() { m_upper_limit = 0.0; m_has_upper_limit = false; }
+    void removeUpperLimit() { m_upper_limit = 0.0; m_has_upper_limit = false; }
 
     //! if has lower and upper limit
-    virtual bool hasLowerAndUpperLimits() const { return (m_has_lower_limit && m_has_upper_limit); }
+    bool hasLowerAndUpperLimits() const { return (m_has_lower_limit && m_has_upper_limit); }
 
     //! Sets object fixed
-    virtual void setFixed(bool is_fixed) { m_is_fixed = is_fixed; }
+    void setFixed(bool is_fixed) { m_is_fixed = is_fixed; }
+
     //! if object is fixed at some value
-    virtual bool isFixed() const { return m_is_fixed; }
+    bool isFixed() const { return m_is_fixed; }
 
     //! Sets lower and upper limits
-    virtual void setLimits(double xmin, double xmax) { setLowerLimit(xmin); setUpperLimit(xmax); }
+    void setLimits(double xmin, double xmax) { setLowerLimit(xmin); setUpperLimit(xmax); }
+
     //! remove limits
-    virtual void removeLimits() { removeLowerLimit(); removeUpperLimit(); }
+    void removeLimits() { removeLowerLimit(); removeUpperLimit(); }
+
+    //! returns true if proposed value is in limits range
+    bool isInRange(double value) const;
 
     // ---------
     // static creation methods
@@ -83,6 +94,9 @@ class BA_CORE_API_ AttLimits
     //! Prints class
     friend std::ostream& operator<<(std::ostream& ostr, const AttLimits& m) { m.print(ostr); return ostr; }
 
+    bool operator==(const AttLimits &other) const;
+    bool operator!=(const AttLimits &other) const;
+
  protected:
     AttLimits(bool has_lower_limit, bool has_upper_limit, bool is_fixed, double lower_limit, double upper_limit)
         : m_has_lower_limit(has_lower_limit)
@@ -115,6 +129,29 @@ class BA_CORE_API_ AttLimits
     }
 };
 
+
+inline bool AttLimits::isInRange(double value) const
+{
+    if(hasLowerLimit() && value < m_lower_limit) return false;
+    if(hasUpperLimit() && value >= m_upper_limit) return false;
+    return true;
+}
+
+inline bool AttLimits::operator==(const AttLimits &other) const
+{
+    return (m_has_lower_limit == other.m_has_lower_limit) &&
+            (m_has_upper_limit == other.m_has_upper_limit) &&
+            (m_lower_limit == other.m_lower_limit) &&
+            (m_upper_limit == other.m_upper_limit);
+
+}
+
+inline bool AttLimits::operator!=(const AttLimits &other) const
+{
+    return !(*this == other);
+}
+
+
 #endif // LIMITS_H
 
 

Core/Tools/inc/RealParameterWrapper.h

@@ -52,6 +52,11 @@ public:
         ostr << p.m_data; return ostr;
     }
 
+    AttLimits getAttLimits() const { return m_limits; }
+
+    bool operator==(const RealParameterWrapper &other) const;
+    bool operator!=(const RealParameterWrapper &other) const;
+
 private:
     //! swap function
     void swapContent(RealParameterWrapper& other);
@@ -75,7 +80,17 @@ inline void RealParameterWrapper::checkNull() const
 {
     if(isNull())
         throw NullPointerException(
-            "RealParameterWrapper::getValue() -> Attempt to access uninitialised pointer.");
+                "RealParameterWrapper::getValue() -> Attempt to access uninitialised pointer.");
+}
+
+inline bool RealParameterWrapper::operator==(const RealParameterWrapper &other) const
+{
+    return (m_limits == other.m_limits) && (m_data == other.m_data);
+}
+
+inline bool RealParameterWrapper::operator!=(const RealParameterWrapper &other) const
+{
+    return !(*this == other);
 }
 
 

Core/Tools/src/RealParameterWrapper.cpp

@@ -19,7 +19,11 @@ RealParameterWrapper::RealParameterWrapper(double *par, const AttLimits &limits)
     : m_data(par)
     , m_limits(limits)
 {
-
+    if(par && !m_limits.isInRange(getValue())) {
+        throw OutOfBoundsException(
+            "RealParameterWrapper::RealParameterWrapper() -> Error. Initial value is out of bounds"
+                    );
+    }
 }
 
 RealParameterWrapper::RealParameterWrapper(const RealParameterWrapper& other )
@@ -42,7 +46,11 @@ bool RealParameterWrapper::setValue(double value)
     bool success(true);
     checkNull();
     if(value != *m_data) {
-        *m_data = value;
+        if(m_limits.isInRange(value) && !m_limits.isFixed()) {
+            *m_data = value;
+        } else {
+            success = false;
+        }
     }
     return success;
 }

Tests/UnitTests/TestCore/AttLimitsTest.h

@@ -2,6 +2,7 @@
 #define ATTLIMITSTEST_H
 
 #include "AttLimits.h"
+#include <limits>
 
 #include "gtest/gtest.h"
 
@@ -30,38 +31,63 @@ TEST_F(AttLimitsTest, AttLimitsSetLimit)
 {
     AttLimits attLimits;
 
-    //set limit
+    //set limit [-1.0, 10.0[
     attLimits.setLimits(-1.0,10.0);
     EXPECT_TRUE(attLimits.hasLowerLimit());
     EXPECT_TRUE(attLimits.hasUpperLimit());
     EXPECT_TRUE(attLimits.hasLowerAndUpperLimits());
     EXPECT_FALSE(attLimits.isFixed());
 
-    //lower limit
     EXPECT_EQ(-1.0,attLimits.getLowerLimit());
+    EXPECT_EQ(10.0,attLimits.getUpperLimit());
+
+    EXPECT_FALSE(attLimits.isInRange(-2.0));
+    EXPECT_TRUE(attLimits.isInRange(-1.0));
+    EXPECT_TRUE(attLimits.isInRange(0.0));
+    EXPECT_TRUE(attLimits.isInRange(9.0));
+    EXPECT_FALSE(attLimits.isInRange(10.0));
+    EXPECT_FALSE(attLimits.isInRange(20.0));
 
+    // [inf, -10.0[
     attLimits.removeLowerLimit();
     EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
     EXPECT_FALSE(attLimits.hasLowerLimit());
     EXPECT_EQ(0.0,attLimits.getLowerLimit());
 
+    EXPECT_TRUE(attLimits.isInRange(-std::numeric_limits<double>::infinity()));
+    EXPECT_TRUE(attLimits.isInRange(-2.0));
+    EXPECT_TRUE(attLimits.isInRange(9.0));
+    EXPECT_FALSE(attLimits.isInRange(10.0));
+    EXPECT_FALSE(attLimits.isInRange(std::numeric_limits<double>::infinity()));
+
+    // [2.1, -10.0[
     attLimits.setLowerLimit(2.1);
     EXPECT_TRUE(attLimits.hasLowerLimit());
     EXPECT_EQ(2.1,attLimits.getLowerLimit());
 
-    //upper limit
-    EXPECT_EQ(10.0,attLimits.getUpperLimit());
+    EXPECT_FALSE(attLimits.isInRange(-std::numeric_limits<double>::infinity()));
+    EXPECT_FALSE(attLimits.isInRange(2.0));
+    EXPECT_TRUE(attLimits.isInRange(2.1));
 
+    //[2.1, inf]
     attLimits.removeUpperLimit();
     EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
     EXPECT_FALSE(attLimits.hasUpperLimit());
     EXPECT_EQ(0.0,attLimits.getUpperLimit());
 
+    EXPECT_FALSE(attLimits.isInRange(-std::numeric_limits<double>::infinity()));
+    EXPECT_FALSE(attLimits.isInRange(2.0));
+    EXPECT_TRUE(attLimits.isInRange(2.1));
+    EXPECT_TRUE(attLimits.isInRange(20.0));
+    EXPECT_TRUE(attLimits.isInRange(std::numeric_limits<double>::infinity()));
+
+    // [2.1, 2.2[
     attLimits.setUpperLimit(2.2);
     EXPECT_TRUE(attLimits.hasUpperLimit());
     EXPECT_EQ(2.2,attLimits.getUpperLimit());
-
     EXPECT_TRUE(attLimits.hasLowerAndUpperLimits());
+    EXPECT_TRUE(attLimits.isInRange(2.15));
+    EXPECT_FALSE(attLimits.isInRange(2.2));
 
     //remove limit
     attLimits.removeLimits();
@@ -70,6 +96,9 @@ TEST_F(AttLimitsTest, AttLimitsSetLimit)
     EXPECT_FALSE(attLimits.hasLowerAndUpperLimits());
     EXPECT_FALSE(attLimits.isFixed());
 
+    EXPECT_TRUE(attLimits.isInRange(-std::numeric_limits<double>::infinity()));
+    EXPECT_TRUE(attLimits.isInRange(std::numeric_limits<double>::infinity()));
+
 }
 
 TEST_F(AttLimitsTest, AttLimitsLowerLimited)
@@ -134,5 +163,39 @@ TEST_F(AttLimitsTest, AttLimitsFixed)
     EXPECT_FALSE(attLimits.isFixed());
 }
 
+TEST_F(AttLimitsTest, ComparisonOperators)
+{
+    AttLimits lim1 = AttLimits::limited(1.0, 2.0);
+    AttLimits lim2 = AttLimits::limited(1.0, 2.0);
+    EXPECT_TRUE(lim1 == lim2);
+    EXPECT_FALSE(lim1 != lim2);
+
+    AttLimits lim3 = AttLimits::limitless();
+    AttLimits lim4 = AttLimits::limitless();
+    EXPECT_TRUE(lim3 == lim4);
+    EXPECT_FALSE(lim3 != lim4);
+
+    AttLimits lim5 = AttLimits::lowerLimited(1.0);
+    AttLimits lim6 = AttLimits::lowerLimited(1.0);
+    EXPECT_TRUE(lim5 == lim6);
+    EXPECT_FALSE(lim5 != lim6);
+
+    AttLimits lim7 = AttLimits::upperLimited(1.0);
+    AttLimits lim8 = AttLimits::upperLimited(1.0);
+    EXPECT_TRUE(lim7 == lim8);
+    EXPECT_FALSE(lim7 != lim8);
+}
+
+TEST_F(AttLimitsTest, CopyConstructor)
+{
+    AttLimits lim1 = AttLimits::limited(1.0, 2.0);
+    AttLimits lim2 = lim1;
+    EXPECT_TRUE(lim1 == lim2);
+    EXPECT_FALSE(lim1 != lim2);
+
+    AttLimits lim3(lim1);
+    EXPECT_TRUE(lim1 == lim3);
+    EXPECT_FALSE(lim1 != lim3);
+}
 
 #endif // ATTLIMITSTEST_H

Tests/UnitTests/TestCore/RealParameterWrapperTest.h

@@ -44,6 +44,8 @@ TEST_F(RealParameterWrapperTest, InitialState)
     EXPECT_TRUE( par.isNull() );
     ASSERT_THROW( par.getValue(), NullPointerException );
     ASSERT_THROW( par.setValue(1.0), NullPointerException );
+
+    EXPECT_EQ(par.getAttLimits(), AttLimits::limitless());
 }
 
 TEST_F(RealParameterWrapperTest, ParameterAccess)
@@ -90,5 +92,31 @@ TEST_F(RealParameterWrapperTest, ParameterAccess)
 //    EXPECT_FALSE( obj2.m_status );
 //}
 
+TEST_F(RealParameterWrapperTest, LimitedParameter)
+{
+    m_real_parameter = 1.0;
+    EXPECT_THROW(RealParameterWrapper(&m_real_parameter, AttLimits::limited(10.0, 20.0)), OutOfBoundsException);
+    EXPECT_THROW(RealParameterWrapper(&m_real_parameter, AttLimits::lowerLimited(2.0)), OutOfBoundsException);
+    EXPECT_THROW(RealParameterWrapper(&m_real_parameter, AttLimits::upperLimited(0.0)), OutOfBoundsException);
+
+    m_real_parameter = 15.0;
+    AttLimits limits = AttLimits::limited(10, 20);
+    RealParameterWrapper par1(&m_real_parameter, limits);
+
+    EXPECT_TRUE(par1.setValue(16.0));
+    EXPECT_EQ(16.0, m_real_parameter);
+
+    EXPECT_FALSE(par1.setValue(21.0));
+    EXPECT_EQ(16.0, m_real_parameter);
+
+    RealParameterWrapper par2(par1);
+    EXPECT_TRUE(par1 == par2);
+
+    EXPECT_FALSE(par1.setValue(21.0));
+    EXPECT_EQ(16.0, m_real_parameter);
+
+    EXPECT_TRUE(par1.setValue(11.0));
+    EXPECT_EQ(11.0, m_real_parameter);
+}
 
 #endif // REALPARAMETERWRAPPERTEST_H