sprinkle a number of noexcepts into the code

util/bearing.cpp

@@ -27,7 +27,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "bearing.hpp"
 
-std::string bearing::get(const double heading)
+std::string bearing::get(const double heading) noexcept
 {
     if (heading <= 22.5)
     {

util/bearing.hpp

@@ -32,7 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct bearing
 {
-    static std::string get(const double heading);
+    static std::string get(const double heading) noexcept;
 };
 
 #endif // BEARING_HPP

util/cast.hpp

@@ -109,7 +109,7 @@ struct cast
     }
 
     // source: http://tinodidriksen.com/2011/05/28/cpp-convert-string-to-double-speed/
-    static double string_to_double(const char *p)
+    static double string_to_double(const char *p) noexcept
     {
         double r = 0.0;
         bool neg = false;

util/compute_angle.cpp

@@ -36,7 +36,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 double ComputeAngle::OfThreeFixedPointCoordinates(const FixedPointCoordinate &first,
                                                   const FixedPointCoordinate &second,
-                                                  const FixedPointCoordinate &third)
+                                                  const FixedPointCoordinate &third) noexcept
 {
     const double v1x = (first.lon - second.lon) / COORDINATE_PRECISION;
     const double v1y = mercator::lat2y(first.lat / COORDINATE_PRECISION) -

util/compute_angle.hpp

@@ -36,7 +36,7 @@ struct ComputeAngle
     // atan2 magic, formerly cosine theorem
     static double OfThreeFixedPointCoordinates(const FixedPointCoordinate &first,
                                                const FixedPointCoordinate &second,
-                                               const FixedPointCoordinate &third);
+                                               const FixedPointCoordinate &third) noexcept;
 };
 
 #endif // COMPUTE_ANGLE_HPP

util/container.hpp

@@ -37,16 +37,17 @@ namespace osrm
 namespace detail
 {
 // Culled by SFINAE if reserve does not exist or is not accessible
-template <typename T> constexpr auto has_resize_method(T &t) -> decltype(t.resize(0), bool())
+template <typename T>
+constexpr auto has_resize_method(T &t) noexcept -> decltype(t.resize(0), bool())
 {
     return true;
 }
 
 // Used as fallback when SFINAE culls the template method
-constexpr bool has_resize_method(...) { return false; }
+constexpr bool has_resize_method(...) noexcept { return false; }
 }
 
-template <typename Container> void sort_unique_resize(Container &vector)
+template <typename Container> void sort_unique_resize(Container &vector) noexcept
 {
     std::sort(std::begin(vector), std::end(vector));
     const auto number_of_unique_elements =
@@ -72,7 +73,9 @@ template <typename Container> void sort_unique_resize(Container &vector)
 // }
 
 template <typename ForwardIterator, typename Function>
-Function for_each_pair(ForwardIterator begin, ForwardIterator end, Function function)
+Function for_each_pair(ForwardIterator begin,
+                       ForwardIterator end,
+                       Function function) noexcept(noexcept(function))
 {
     if (begin == end)
     {

util/integer_range.hpp

@@ -40,29 +40,30 @@ template <typename Integer> class range
     Integer iter;
 
   public:
-    range(Integer start, Integer end) : last(end), iter(start)
+    range(Integer start, Integer end) noexcept : last(end), iter(start)
     {
         static_assert(std::is_integral<Integer>::value, "range type must be integral");
     }
 
     // Iterable functions
-    const range &begin() const { return *this; }
+    const range &begin() const noexcept { return *this; }
-    const range &end() const { return *this; }
+    const range &end() const noexcept { return *this; }
-    Integer front() const { return iter; }
+    Integer front() const noexcept { return iter; }
-    Integer back() const { return last - 1; }
+    Integer back() const noexcept { return last - 1; }
-    Integer size() const { return last - iter; }
+    Integer size() const noexcept { return last - iter; }
 
     // Iterator functions
-    bool operator!=(const range &) const { return iter < last; }
+    bool operator!=(const range &) const noexcept { return iter < last; }
-    void operator++() { ++iter; }
+    void operator++() noexcept { ++iter; }
-    Integer operator*() const { return iter; }
+    Integer operator*() const noexcept { return iter; }
 };
 
 // convenience function to construct an integer range with type deduction
 template <typename Integer>
-range<Integer> irange(const Integer first,
+range<Integer>
-                      const Integer last,
+irange(const Integer first,
-                      typename std::enable_if<std::is_integral<Integer>::value>::type * = 0)
+       const Integer last,
+       typename std::enable_if<std::is_integral<Integer>::value>::type * = 0) noexcept
 {
     return range<Integer>(first, last);
 }

util/iterator_range.hpp

@@ -33,10 +33,10 @@ namespace osrm
 template <typename Iterator> class iter_range
 {
   public:
-    iter_range(Iterator begin, Iterator end) : begin_(begin), end_(end) {}
+    iter_range(Iterator begin, Iterator end) noexcept : begin_(begin), end_(end) {}
 
-    Iterator begin() const { return begin_; }
+    Iterator begin() const noexcept { return begin_; }
-    Iterator end() const { return end_; }
+    Iterator end() const noexcept { return end_; }
 
   private:
     Iterator begin_;
@@ -46,13 +46,14 @@ template <typename Iterator> class iter_range
 // Convenience functions for template parameter inference,
 // akin to std::make_pair.
 
-template <typename Iterator> iter_range<Iterator> integer_range(Iterator begin, Iterator end)
+template <typename Iterator>
+iter_range<Iterator> integer_range(Iterator begin, Iterator end) noexcept
 {
     return iter_range<Iterator>(begin, end);
 }
 
 template <typename Reversable>
-iter_range<typename Reversable::reverse_iterator> reverse(Reversable *reversable)
+iter_range<typename Reversable::reverse_iterator> reverse(Reversable *reversable) noexcept
 {
     return iter_range<typename Reversable::reverse_iterator>(reversable->rbegin(),
                                                              reversable->rend());
@@ -60,7 +61,7 @@ iter_range<typename Reversable::reverse_iterator> reverse(Reversable *reversable
 
 template <typename ConstReversable>
 iter_range<typename ConstReversable::const_reverse_iterator>
-const_reverse(const ConstReversable *const_reversable)
+const_reverse(const ConstReversable *const_reversable) noexcept
 {
     return iter_range<typename ConstReversable::const_reverse_iterator>(const_reversable->crbegin(),
                                                                         const_reversable->crend());

util/mercator.cpp

@@ -29,12 +29,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <cmath>
 
-double mercator::y2lat(const double value)
+double mercator::y2lat(const double value) noexcept
 {
     return 180. * M_1_PI * (2. * std::atan(std::exp(value * M_PI / 180.)) - M_PI_2);
 }
 
-double mercator::lat2y(const double latitude)
+double mercator::lat2y(const double latitude) noexcept
 {
     return 180. * M_1_PI * std::log(std::tan(M_PI_4 + latitude * (M_PI / 180.) / 2.));
 }

util/mercator.hpp

@@ -30,9 +30,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct mercator
 {
-    static double y2lat(const double value);
+    static double y2lat(const double value) noexcept;
 
-    static double lat2y(const double latitude);
+    static double lat2y(const double latitude) noexcept;
 };
 
 #endif // MERCATOR_HPP