constexpr all operators

mapbox · Sep 28, 2016 · a1d32e3 · a1d32e3
1 parent 03778c6
commit a1d32e3
Show file tree

Hide file tree

Showing 4 changed files with 26 additions and 26 deletions.
diff --git a/include/mapbox/geometry/box.hpp b/include/mapbox/geometry/box.hpp
@@ -10,7 +10,7 @@ struct box
 {
  using point_type = point<T>;
 
- box(point_type const& min_, point_type const& max_)
+ constexpr box(point_type const& min_, point_type const& max_)
  : min(min_), max(max_)
  {}
 
@@ -19,13 +19,13 @@ struct box
 };
 
 template <typename T>
-bool operator==(box<T> const& lhs, box<T> const& rhs)
+constexpr bool operator==(box<T> const& lhs, box<T> const& rhs)
 {
  return lhs.min == rhs.min && lhs.max == rhs.max;
 }
 
 template <typename T>
-bool operator!=(box<T> const& lhs, box<T> const& rhs)
+constexpr bool operator!=(box<T> const& lhs, box<T> const& rhs)
 {
  return lhs.min != rhs.min || lhs.max != rhs.max;
 }

diff --git a/include/mapbox/geometry/feature.hpp b/include/mapbox/geometry/feature.hpp
@@ -21,8 +21,8 @@ struct null_value_t
  constexpr null_value_t(std::nullptr_t) {}
 };
 
-inline bool operator==(const null_value_t&, const null_value_t&) { return true; }
-inline bool operator!=(const null_value_t&, const null_value_t&) { return false; }
+constexpr bool operator==(const null_value_t&, const null_value_t&) { return true; }
+constexpr bool operator!=(const null_value_t&, const null_value_t&) { return false; }
 
 constexpr null_value_t null_value = null_value_t();
 
@@ -57,13 +57,13 @@ struct feature
 };
 
 template <class T>
-bool operator==(feature<T> const& lhs, feature<T> const& rhs)
+constexpr bool operator==(feature<T> const& lhs, feature<T> const& rhs)
 {
  return lhs.id == rhs.id && lhs.geometry == rhs.geometry && lhs.properties == rhs.properties;
 }
 
 template <class T>
-bool operator!=(feature<T> const& lhs, feature<T> const& rhs)
+constexpr bool operator!=(feature<T> const& lhs, feature<T> const& rhs)
 {
  return !(lhs == rhs);
 }

diff --git a/include/mapbox/geometry/point.hpp b/include/mapbox/geometry/point.hpp
@@ -20,15 +20,15 @@ struct point
 };
 
 template <typename T>
-bool operator==(point<T> const& lhs, point<T> const& rhs)
+constexpr bool operator==(point<T> const& lhs, point<T> const& rhs)
 {
  return lhs.x == rhs.x && lhs.y == rhs.y;
 }
 
 template <typename T>
-bool operator!=(point<T> const& lhs, point<T> const& rhs)
+constexpr bool operator!=(point<T> const& lhs, point<T> const& rhs)
 {
- return lhs.x != rhs.x || lhs.y != rhs.y;
+ return !(lhs == rhs);
 }
 
 } // namespace geometry

diff --git a/include/mapbox/geometry/point_arithmetic.hpp b/include/mapbox/geometry/point_arithmetic.hpp
@@ -4,111 +4,111 @@ namespace mapbox {
 namespace geometry {
 
 template <typename T>
-point<T> operator+(point<T> const& lhs, point<T> const& rhs)
+constexpr point<T> operator+(point<T> const& lhs, point<T> const& rhs)
 {
  return point<T>(lhs.x + rhs.x, lhs.y + rhs.y);
 }
 
 template <typename T>
-point<T> operator+(point<T> const& lhs, T const& rhs)
+constexpr point<T> operator+(point<T> const& lhs, T const& rhs)
 {
  return point<T>(lhs.x + rhs, lhs.y + rhs);
 }
 
 template <typename T>
-point<T> operator-(point<T> const& lhs, point<T> const& rhs)
+constexpr point<T> operator-(point<T> const& lhs, point<T> const& rhs)
 {
  return point<T>(lhs.x - rhs.x, lhs.y - rhs.y);
 }
 
 template <typename T>
-point<T> operator-(point<T> const& lhs, T const& rhs)
+constexpr point<T> operator-(point<T> const& lhs, T const& rhs)
 {
  return point<T>(lhs.x - rhs, lhs.y - rhs);
 }
 
 template <typename T>
-point<T> operator*(point<T> const& lhs, point<T> const& rhs)
+constexpr point<T> operator*(point<T> const& lhs, point<T> const& rhs)
 {
  return point<T>(lhs.x * rhs.x, lhs.y * rhs.y);
 }
 
 template <typename T>
-point<T> operator*(point<T> const& lhs, T const& rhs)
+constexpr point<T> operator*(point<T> const& lhs, T const& rhs)
 {
  return point<T>(lhs.x * rhs, lhs.y * rhs);
 }
 
 template <typename T>
-point<T> operator/(point<T> const& lhs, point<T> const& rhs)
+constexpr point<T> operator/(point<T> const& lhs, point<T> const& rhs)
 {
  return point<T>(lhs.x / rhs.x, lhs.y / rhs.y);
 }
 
 template <typename T>
-point<T> operator/(point<T> const& lhs, T const& rhs)
+constexpr point<T> operator/(point<T> const& lhs, T const& rhs)
 {
  return point<T>(lhs.x / rhs, lhs.y / rhs);
 }
 
 template <typename T>
-point<T>& operator+=(point<T>& lhs, point<T> const& rhs)
+constexpr point<T>& operator+=(point<T>& lhs, point<T> const& rhs)
 {
  lhs.x += rhs.x;
  lhs.y += rhs.y;
  return lhs;
 }
 
 template <typename T>
-point<T>& operator+=(point<T>& lhs, T const& rhs)
+constexpr point<T>& operator+=(point<T>& lhs, T const& rhs)
 {
  lhs.x += rhs;
  lhs.y += rhs;
  return lhs;
 }
 
 template <typename T>
-point<T>& operator-=(point<T>& lhs, point<T> const& rhs)
+constexpr point<T>& operator-=(point<T>& lhs, point<T> const& rhs)
 {
  lhs.x -= rhs.x;
  lhs.y -= rhs.y;
  return lhs;
 }
 
 template <typename T>
-point<T>& operator-=(point<T>& lhs, T const& rhs)
+constexpr point<T>& operator-=(point<T>& lhs, T const& rhs)
 {
  lhs.x -= rhs;
  lhs.y -= rhs;
  return lhs;
 }
 
 template <typename T>
-point<T>& operator*=(point<T>& lhs, point<T> const& rhs)
+constexpr point<T>& operator*=(point<T>& lhs, point<T> const& rhs)
 {
  lhs.x *= rhs.x;
  lhs.y *= rhs.y;
  return lhs;
 }
 
 template <typename T>
-point<T>& operator*=(point<T>& lhs, T const& rhs)
+constexpr point<T>& operator*=(point<T>& lhs, T const& rhs)
 {
  lhs.x *= rhs;
  lhs.y *= rhs;
  return lhs;
 }
 
 template <typename T>
-point<T>& operator/=(point<T>& lhs, point<T> const& rhs)
+constexpr point<T>& operator/=(point<T>& lhs, point<T> const& rhs)
 {
  lhs.x /= rhs.x;
  lhs.y /= rhs.y;
  return lhs;
 }
 
 template <typename T>
-point<T>& operator/=(point<T>& lhs, T const& rhs)
+constexpr point<T>& operator/=(point<T>& lhs, T const& rhs)
 {
  lhs.x /= rhs;
  lhs.y /= rhs;