Move overflow protected add helpers to math.

diff --git a/simgear/canvas/layout/BoxLayout.cxx b/simgear/canvas/layout/BoxLayout.cxx
index ec2aee530b558f7024dd5669f833f928b13dc4cf..3da5d98e29242627c32c2f40efb2880e1ebd3127 100644 (file)
--- a/simgear/canvas/layout/BoxLayout.cxx
+++ b/simgear/canvas/layout/BoxLayout.cxx
@@ -305,9 +305,9 @@ namespace canvas
       }
 
       // Add sizes of all children in layout direction
-      safeAdd(min_size.x(),  item_data.min_size);
-      safeAdd(max_size.x(),  item_data.max_size);
-      safeAdd(size_hint.x(), item_data.size_hint);
+      SGMisc<int>::addClipOverflowInplace(min_size.x(),  item_data.min_size);
+      SGMisc<int>::addClipOverflowInplace(max_size.x(),  item_data.max_size);
+      SGMisc<int>::addClipOverflowInplace(size_hint.x(), item_data.size_hint);
 
       // Take maximum in fixed (non-layouted) direction
       min_size.y()  = std::max( min_size.y(),
@@ -320,9 +320,9 @@ namespace canvas
       _layout_data.has_hfw = _layout_data.has_hfw || item.hasHeightForWidth();
     }
 
-    safeAdd(min_size.x(),  _layout_data.padding);
-    safeAdd(max_size.x(),  _layout_data.padding);
-    safeAdd(size_hint.x(), _layout_data.padding);
+    SGMisc<int>::addClipOverflowInplace(min_size.x(),  _layout_data.padding);
+    SGMisc<int>::addClipOverflowInplace(max_size.x(),  _layout_data.padding);
+    SGMisc<int>::addClipOverflowInplace(size_hint.x(), _layout_data.padding);
 
     _layout_data.min_size = min_size.x();
     _layout_data.max_size = max_size.x();

diff --git a/simgear/canvas/layout/Layout.cxx b/simgear/canvas/layout/Layout.cxx
index 8ae4e6e88b76987436a73d2e62bf55547f50cba7..d3ae38867007e97fb9dd23673b78eeaef1afb3a5 100644 (file)
--- a/simgear/canvas/layout/Layout.cxx
+++ b/simgear/canvas/layout/Layout.cxx
@@ -108,15 +108,6 @@ namespace canvas
       return layout_item->minimumSize().y();
   }
 
-  //----------------------------------------------------------------------------
-  void Layout::safeAdd(int& a, int b)
-  {
-    if( SGLimits<int>::max() - b < a )
-      a = SGLimits<int>::max();
-    else
-      a += b;
-  }
-
   //----------------------------------------------------------------------------
   void Layout::distribute(std::vector<ItemData>& items, const ItemData& space)
   {

diff --git a/simgear/canvas/layout/Layout.hxx b/simgear/canvas/layout/Layout.hxx
index b91767f46d5a2b156a50209079dd55566d42e25b..f28763cbde4836d825c3cb83c76c90fc5a9c5a9b 100644 (file)
--- a/simgear/canvas/layout/Layout.hxx
+++ b/simgear/canvas/layout/Layout.hxx
@@ -104,11 +104,6 @@ namespace canvas
        */
       virtual void doLayout(const SGRecti& geom) = 0;
 
-      /**
-       * Add two integers taking care of overflow (limit to INT_MAX)
-       */
-      static void safeAdd(int& a, int b);
-
       /**
        * Distribute the available @a space to all @a items
        */

diff --git a/simgear/math/SGMisc.hxx b/simgear/math/SGMisc.hxx
index 0f57edf17713d8cef1a9fb9c181acb5591366b48..abf162d819e5ab285c397a2d8330077ec4097802 100644 (file)
--- a/simgear/math/SGMisc.hxx
+++ b/simgear/math/SGMisc.hxx
@@ -41,6 +41,30 @@ public:
   static T clip(const T& a, const T& _min, const T& _max)
   { return max(_min, min(_max, a)); }
 
+
+  /// Add two (integer) values taking care of overflows.
+  static T addClipOverflow(T a, T b)
+  {
+    if( b > 0 )
+    {
+      if( SGLimits<T>::max() - b < a )
+        return SGLimits<T>::max();
+    }
+    else
+    {
+      if( SGLimits<T>::min() - b > a )
+        return SGLimits<T>::min();
+    }
+
+    return a + b;
+  }
+
+  /// Add two (integer) values in place, taking care of overflows.
+  static T& addClipOverflowInplace(T& a, T b)
+  {
+    return a = addClipOverflow(a, b);
+  }
+
   /**
    * Seek a variable towards a target value with given rate and timestep
    *

diff --git a/simgear/math/SGVec2.hxx b/simgear/math/SGVec2.hxx
index 0695cded19f232e7cc14b698e2f1c6892be2e0fe..1ed150d82f4428f194359b61f8e6135cc093f414 100644 (file)
--- a/simgear/math/SGVec2.hxx
+++ b/simgear/math/SGVec2.hxx
@@ -196,6 +196,17 @@ SGVec2<T>
 max(S s, const SGVec2<T>& v)
 { return SGVec2<T>(SGMisc<T>::max(s, v(0)), SGMisc<T>::max(s, v(1))); }
 
+/// Add two vectors taking care of (integer) overflows. The values are limited
+/// to the respective minimum and maximum values.
+template<class T>
+SGVec2<T> addClipOverflow(SGVec2<T> const& lhs, SGVec2<T> const& rhs)
+{
+  return SGVec2<T>(
+    SGMisc<T>::addClipOverflow(lhs.x(), rhs.x()),
+    SGMisc<T>::addClipOverflow(lhs.y(), rhs.y())
+  );
+}
+
 /// Scalar dot product
 template<typename T>
 inline

diff --git a/simgear/math/SGVec3.hxx b/simgear/math/SGVec3.hxx
index dbc8af543bf9a5d39a933be30d55e32b9dfc9c43..b0f6b20625c54b1bb9bce07cb8750ada27657022 100644 (file)
--- a/simgear/math/SGVec3.hxx
+++ b/simgear/math/SGVec3.hxx
@@ -288,6 +288,18 @@ max(S s, const SGVec3<T>& v)
                    SGMisc<T>::max(s, v(2)));
 }
 
+/// Add two vectors taking care of (integer) overflows. The values are limited
+/// to the respective minimum and maximum values.
+template<class T>
+SGVec3<T> addClipOverflow(SGVec3<T> const& lhs, SGVec3<T> const& rhs)
+{
+  return SGVec3<T>(
+    SGMisc<T>::addClipOverflow(lhs.x(), rhs.x()),
+    SGMisc<T>::addClipOverflow(lhs.y(), rhs.y()),
+    SGMisc<T>::addClipOverflow(lhs.z(), rhs.z())
+  );
+}
+
 /// Scalar dot product
 template<typename T>
 inline

diff --git a/simgear/math/SGVec4.hxx b/simgear/math/SGVec4.hxx
index 301aaca3ccb4ff8df41259100a409d2b50858838..4339dfd9b79879a3fab0da2b59a5cca747cc5578 100644 (file)
--- a/simgear/math/SGVec4.hxx
+++ b/simgear/math/SGVec4.hxx
@@ -244,6 +244,19 @@ max(S s, const SGVec4<T>& v)
                    SGMisc<T>::max(s, v(3)));
 }
 
+/// Add two vectors taking care of (integer) overflows. The values are limited
+/// to the respective minimum and maximum values.
+template<class T>
+SGVec4<T> addClipOverflow(SGVec4<T> const& lhs, SGVec4<T> const& rhs)
+{
+  return SGVec4<T>(
+    SGMisc<T>::addClipOverflow(lhs.x(), rhs.x()),
+    SGMisc<T>::addClipOverflow(lhs.y(), rhs.y()),
+    SGMisc<T>::addClipOverflow(lhs.z(), rhs.z()),
+    SGMisc<T>::addClipOverflow(lhs.w(), rhs.w())
+  );
+}
+
 /// Scalar dot product
 template<typename T>
 inline