Add [[nodiscard]] to pure value-returning functions

Author: gistrec

include/geo/detail/math.hpp

@@ -25,66 +25,66 @@ inline constexpr double kEarthRadius = 6371009.0;
 // not portable to MSVC without _USE_MATH_DEFINES) or std::numbers::pi (C++20).
 inline constexpr double kPi = 3.14159265358979323846;
 
-inline double deg2rad(double degrees) noexcept {
+[[nodiscard]] inline double deg2rad(double degrees) noexcept {
     return degrees * kPi / 180.0;
 }
 
-inline double rad2deg(double angle) noexcept {
+[[nodiscard]] inline double rad2deg(double angle) noexcept {
     return angle * 180.0 / kPi;
 }
 
 // Returns the non-negative remainder of x / m.
-inline double mod(double x, double m) noexcept {
+[[nodiscard]] inline double mod(double x, double m) noexcept {
     return std::fmod(std::fmod(x, m) + m, m);
 }
 
 // Wraps the given value into the inclusive-exclusive interval [min, max).
-inline double wrap(double n, double min, double max) noexcept {
+[[nodiscard]] inline double wrap(double n, double min, double max) noexcept {
     return (n >= min && n < max) ? n : (mod(n - min, max - min) + min);
 }
 
 // Returns mercator Y corresponding to latitude.
-inline double mercator(double lat) noexcept {
+[[nodiscard]] inline double mercator(double lat) noexcept {
     return std::log(std::tan(lat * 0.5 + kPi / 4.0));
 }
 
 // Returns latitude from mercator Y.
-inline double inverse_mercator(double y) noexcept {
+[[nodiscard]] inline double inverse_mercator(double y) noexcept {
     return 2.0 * std::atan(std::exp(y)) - kPi / 2.0;
 }
 
 // Returns haversine(angle-in-radians).
 // hav(x) == (1 - cos(x)) / 2 == sin(x / 2)^2.
-inline double hav(double x) noexcept {
+[[nodiscard]] inline double hav(double x) noexcept {
     double sin_half = std::sin(x * 0.5);
     return sin_half * sin_half;
 }
 
 // Inverse haversine. arc_hav(x) == 2 * asin(sqrt(x)). Argument must be in [0, 1].
-inline double arc_hav(double x) noexcept {
+[[nodiscard]] inline double arc_hav(double x) noexcept {
     return 2.0 * std::asin(std::sqrt(std::clamp(x, 0.0, 1.0)));
 }
 
 // Given h == hav(x), returns sin(abs(x)).
-inline double sin_from_hav(double h) noexcept {
+[[nodiscard]] inline double sin_from_hav(double h) noexcept {
     return 2.0 * std::sqrt(h * (1.0 - h));
 }
 
 // Returns hav(asin(x)).
-inline double hav_from_sin(double x) noexcept {
+[[nodiscard]] inline double hav_from_sin(double x) noexcept {
     double x2 = x * x;
     return x2 / (1.0 + std::sqrt(1.0 - x2)) * 0.5;
 }
 
 // Returns sin(arc_hav(x) + arc_hav(y)).
-inline double sin_sum_from_hav(double x, double y) noexcept {
+[[nodiscard]] inline double sin_sum_from_hav(double x, double y) noexcept {
     double a = std::sqrt(x * (1.0 - x));
     double b = std::sqrt(y * (1.0 - y));
     return 2.0 * (a + b - 2.0 * (a * y + b * x));
 }
 
 // Returns hav() of distance from (lat1, lng1) to (lat2, lng2) on the unit sphere.
-inline double hav_distance(double lat1, double lat2, double d_lng) noexcept {
+[[nodiscard]] inline double hav_distance(double lat1, double lat2, double d_lng) noexcept {
     return hav(lat1 - lat2) + hav(d_lng) * std::cos(lat1) * std::cos(lat2);
 }
 

include/geo/latlng.hpp

@@ -38,18 +38,18 @@ struct LatLng {
      * latitude and longitude). Longitudes are compared modulo 360 so that 180°
      * and -180° are treated as equal (same meridian).
      */
-    bool approx_equal(const LatLng& other, double eps = kDefaultEpsilon) const noexcept {
+    [[nodiscard]] bool approx_equal(const LatLng& other, double eps = kDefaultEpsilon) const noexcept {
         if (std::fabs(lat - other.lat) >= eps) return false;
         double diff = std::fabs(std::fmod(lng - other.lng, 360.0));
         if (diff > 180.0) diff = 360.0 - diff;
         return diff < eps;
     }
 
-    bool operator==(const LatLng& other) const noexcept {
+    [[nodiscard]] bool operator==(const LatLng& other) const noexcept {
         return approx_equal(other);
     }
 
-    bool operator!=(const LatLng& other) const noexcept {
+    [[nodiscard]] bool operator!=(const LatLng& other) const noexcept {
         return !(*this == other);
     }
 

include/geo/poly.hpp

@@ -28,18 +28,18 @@ inline constexpr double kDefaultTolerance = 0.1;  // meters
 namespace detail {
 
 // Returns tan(latitude-at-lng3) on the great circle (lat1, 0) to (lat2, lng2).
-inline double tan_lat_gc(double lat1, double lat2, double lng2, double lng3) noexcept {
+[[nodiscard]] inline double tan_lat_gc(double lat1, double lat2, double lng2, double lng3) noexcept {
     return (std::tan(lat1) * std::sin(lng2 - lng3) + std::tan(lat2) * std::sin(lng3)) / std::sin(lng2);
 }
 
 // Returns mercator(latitude-at-lng3) on the Rhumb line (lat1, 0) to (lat2, lng2).
-inline double mercator_lat_rhumb(double lat1, double lat2, double lng2, double lng3) noexcept {
+[[nodiscard]] inline double mercator_lat_rhumb(double lat1, double lat2, double lng2, double lng3) noexcept {
     return (mercator(lat1) * (lng2 - lng3) + mercator(lat2) * lng3) / lng2;
 }
 
 // Computes whether the vertical segment (lat3, lng3) to South Pole intersects
 // the segment (lat1, 0) to (lat2, lng2). Longitudes are offset so lng1 == 0.
-inline bool intersects(double lat1, double lat2, double lng2, double lat3, double lng3, bool geodesic) noexcept {
+[[nodiscard]] inline bool intersects(double lat1, double lat2, double lng2, double lat3, double lng3, bool geodesic) noexcept {
     if ((lng3 >= 0 && lng3 >= lng2) || (lng3 < 0 && lng3 < lng2)) {
         return false;
     }
@@ -66,7 +66,7 @@ inline bool intersects(double lat1, double lat2, double lng2, double lat3, doubl
 
 // Returns sin(initial bearing from (lat1,lng1) to (lat3,lng3) minus initial
 // bearing from (lat1,lng1) to (lat2,lng2)).
-inline double sin_delta_bearing(double lat1, double lng1, double lat2, double lng2, double lat3, double lng3) noexcept {
+[[nodiscard]] inline double sin_delta_bearing(double lat1, double lng1, double lat2, double lng2, double lat3, double lng3) noexcept {
     double sin_lat1 = std::sin(lat1);
     double cos_lat2 = std::cos(lat2);
     double cos_lat3 = std::cos(lat3);
@@ -82,7 +82,7 @@ inline double sin_delta_bearing(double lat1, double lng1, double lat2, double ln
     return denom <= 0 ? 1 : (a * d - b * c) / std::sqrt(denom);
 }
 
-inline bool is_on_segment_gc(double lat1, double lng1, double lat2, double lng2, double lat3, double lng3, double hav_tolerance) noexcept {
+[[nodiscard]] inline bool is_on_segment_gc(double lat1, double lng1, double lat2, double lng2, double lat3, double lng3, double hav_tolerance) noexcept {
     double hav_dist13 = hav_distance(lat1, lat3, lng1 - lng3);
     if (hav_dist13 <= hav_tolerance) {
         return true;
@@ -114,7 +114,7 @@ inline bool is_on_segment_gc(double lat1, double lng1, double lat2, double lng2,
 
 // Computes whether a given point lies on or near a polyline within a tolerance.
 template <typename Path>
-bool on_edge_or_path(const LatLng& point, const Path& poly, bool closed, bool geodesic, double tolerance_earth) {
+[[nodiscard]] bool on_edge_or_path(const LatLng& point, const Path& poly, bool closed, bool geodesic, double tolerance_earth) {
     std::size_t size = poly.size();
     if (size == 0U) {
         return false;
@@ -187,7 +187,7 @@ bool on_edge_or_path(const LatLng& point, const Path& poly, bool closed, bool ge
  * the South Pole. Edges are great circle arcs if geodesic is true, rhumb lines otherwise.
  */
 template <typename Path>
-bool contains(const LatLng& point, const Path& polygon, bool geodesic = false) {
+[[nodiscard]] bool contains(const LatLng& point, const Path& polygon, bool geodesic = false) {
     std::size_t size = polygon.size();
     if (size == 0) {
         return false;
@@ -223,7 +223,7 @@ bool contains(const LatLng& point, const Path& polygon, bool geodesic = false) {
  * within a specified tolerance in meters. The polygon is implicitly closed.
  */
 template <typename Path>
-bool on_edge(const LatLng& point, const Path& polygon, bool geodesic = true, double tolerance = kDefaultTolerance) {
+[[nodiscard]] bool on_edge(const LatLng& point, const Path& polygon, bool geodesic = true, double tolerance = kDefaultTolerance) {
     return detail::on_edge_or_path(point, polygon, true, geodesic, tolerance);
 }
 
@@ -232,15 +232,15 @@ bool on_edge(const LatLng& point, const Path& polygon, bool geodesic = true, dou
  * specified tolerance in meters. The polyline is not closed.
  */
 template <typename Path>
-bool on_path(const LatLng& point, const Path& polyline, bool geodesic = true, double tolerance = kDefaultTolerance) {
+[[nodiscard]] bool on_path(const LatLng& point, const Path& polyline, bool geodesic = true, double tolerance = kDefaultTolerance) {
     return detail::on_edge_or_path(point, polyline, false, geodesic, tolerance);
 }
 
 /**
  * Computes the spherical distance between the point p and the line segment
  * (start, end), in meters.
  */
-inline double distance_to_segment(const LatLng& p, const LatLng& start, const LatLng& end) noexcept {
+[[nodiscard]] inline double distance_to_segment(const LatLng& p, const LatLng& start, const LatLng& end) noexcept {
     if (start == end) {
         return distance_between(end, p);
     }

include/geo/spherical.hpp

@@ -27,7 +27,7 @@ namespace geo {
  * Returns the heading from one LatLng to another LatLng. Headings are
  * expressed in degrees clockwise from North within the range [-180, 180).
  */
-inline double heading(const LatLng& from, const LatLng& to) noexcept {
+[[nodiscard]] inline double heading(const LatLng& from, const LatLng& to) noexcept {
     double from_lat = detail::deg2rad(from.lat);
     double from_lng = detail::deg2rad(from.lng);
     double to_lat = detail::deg2rad(to.lat);
@@ -44,7 +44,7 @@ inline double heading(const LatLng& from, const LatLng& to) noexcept {
  * Returns the LatLng resulting from moving a distance from an origin
  * in the specified heading (expressed in degrees clockwise from north).
  */
-inline LatLng offset(const LatLng& from, double distance, double heading_deg) noexcept {
+[[nodiscard]] inline LatLng offset(const LatLng& from, double distance, double heading_deg) noexcept {
     distance /= detail::kEarthRadius;
     double heading_rad = detail::deg2rad(heading_deg);
     double from_lat = detail::deg2rad(from.lat);
@@ -66,7 +66,7 @@ inline LatLng offset(const LatLng& from, double distance, double heading_deg) no
  * Returns the location of origin when provided with a destination,
  * meters travelled and original heading. Returns nullopt when no solution exists.
  */
-inline std::optional<LatLng> offset_origin(const LatLng& to, double distance, double heading_deg) noexcept {
+[[nodiscard]] inline std::optional<LatLng> offset_origin(const LatLng& to, double distance, double heading_deg) noexcept {
     double heading_rad = detail::deg2rad(heading_deg);
     distance /= detail::kEarthRadius;
     double n1 = std::cos(distance);
@@ -96,7 +96,7 @@ inline std::optional<LatLng> offset_origin(const LatLng& to, double distance, do
  * Returns the angle between two LatLngs, in radians. This is the same as the
  * distance on the unit sphere.
  */
-inline double angle_between(const LatLng& from, const LatLng& to) noexcept {
+[[nodiscard]] inline double angle_between(const LatLng& from, const LatLng& to) noexcept {
     double lat1 = detail::deg2rad(from.lat);
     double lng1 = detail::deg2rad(from.lng);
     double lat2 = detail::deg2rad(to.lat);
@@ -107,15 +107,15 @@ inline double angle_between(const LatLng& from, const LatLng& to) noexcept {
 /**
  * Returns the distance between two LatLngs, in meters.
  */
-inline double distance_between(const LatLng& from, const LatLng& to) noexcept {
+[[nodiscard]] inline double distance_between(const LatLng& from, const LatLng& to) noexcept {
     return angle_between(from, to) * detail::kEarthRadius;
 }
 
 /**
  * Returns the LatLng which lies the given fraction of the way between the
  * origin and the destination (spherical linear interpolation).
  */
-inline LatLng interpolate(const LatLng& from, const LatLng& to, double fraction) noexcept {
+[[nodiscard]] inline LatLng interpolate(const LatLng& from, const LatLng& to, double fraction) noexcept {
     double from_lat = detail::deg2rad(from.lat);
     double from_lng = detail::deg2rad(from.lng);
     double to_lat = detail::deg2rad(to.lat);
@@ -143,7 +143,7 @@ inline LatLng interpolate(const LatLng& from, const LatLng& to, double fraction)
  * Returns the length of the given path, in meters, on Earth.
  */
 template <typename Path>
-double path_length(const Path& path) {
+[[nodiscard]] double path_length(const Path& path) {
     const std::size_t size = path.size();
     if (size < 2U) {
         return 0.0;
@@ -169,7 +169,7 @@ double path_length(const Path& path) {
  * "Inside" is the surface that does not contain the South Pole.
  */
 template <typename Path>
-double signed_area(const Path& path) {
+[[nodiscard]] double signed_area(const Path& path) {
     std::size_t size = path.size();
     if (size < 3U) { return 0.0; }
     double total = 0.0;
@@ -196,7 +196,7 @@ double signed_area(const Path& path) {
  * Returns the area of a closed path on Earth.
  */
 template <typename Path>
-double area(const Path& path) {
+[[nodiscard]] double area(const Path& path) {
     return std::abs(signed_area(path));
 }