Remove redundant "inline" on constexpr inline functions

joto · joto · commit 43a94eee8a25 · 2024-12-17T14:07:20.000+01:00
diff --git a/include/osmium/area/detail/vector.hpp b/include/osmium/area/detail/vector.hpp
@@ -73,37 +73,37 @@ namespace osmium {
             }; // struct vec
 
             // addition
-            constexpr inline vec operator+(const vec& lhs, const vec& rhs) noexcept {
+            constexpr vec operator+(const vec& lhs, const vec& rhs) noexcept {
                 return vec{lhs.x + rhs.x, lhs.y + rhs.y};
             }
 
             // subtraction
-            constexpr inline vec operator-(const vec& lhs, const vec& rhs) noexcept {
+            constexpr vec operator-(const vec& lhs, const vec& rhs) noexcept {
                 return vec{lhs.x - rhs.x, lhs.y - rhs.y};
             }
 
             // cross product
-            constexpr inline int64_t operator*(const vec& lhs, const vec& rhs) noexcept {
+            constexpr int64_t operator*(const vec& lhs, const vec& rhs) noexcept {
                 return lhs.x * rhs.y - lhs.y * rhs.x;
             }
 
             // scale vector
-            constexpr inline vec operator*(double s, const vec& v) noexcept {
+            constexpr vec operator*(double s, const vec& v) noexcept {
                 return vec{static_cast<int64_t>(s * static_cast<double>(v.x)), static_cast<int64_t>(s * static_cast<double>(v.y))};
             }
 
             // scale vector
-            constexpr inline vec operator*(const vec& v, double s) noexcept {
+            constexpr vec operator*(const vec& v, double s) noexcept {
                 return vec{static_cast<int64_t>(s * static_cast<double>(v.x)), static_cast<int64_t>(s * static_cast<double>(v.y))};
             }
 
             // equality
-            constexpr inline bool operator==(const vec& lhs, const vec& rhs) noexcept {
+            constexpr bool operator==(const vec& lhs, const vec& rhs) noexcept {
                 return lhs.x == rhs.x && lhs.y == rhs.y;
             }
 
             // inequality
-            constexpr inline bool operator!=(const vec& lhs, const vec& rhs) noexcept {
+            constexpr bool operator!=(const vec& lhs, const vec& rhs) noexcept {
                 return !(lhs == rhs);
             }
 
diff --git a/include/osmium/builder/attr.hpp b/include/osmium/builder/attr.hpp
@@ -381,7 +381,7 @@ namespace osmium {
             };
 
             template <typename TTagIterator>
-            inline constexpr detail::tags_from_iterator_pair<TTagIterator> _tags(TTagIterator first, TTagIterator last) {
+            constexpr detail::tags_from_iterator_pair<TTagIterator> _tags(TTagIterator first, TTagIterator last) {
                 return {first, last};
             }
 
@@ -409,7 +409,7 @@ namespace osmium {
             };
 
             template <typename TIdIterator>
-            inline constexpr detail::nodes_from_iterator_pair<TIdIterator> _nodes(TIdIterator first, TIdIterator last) {
+            constexpr detail::nodes_from_iterator_pair<TIdIterator> _nodes(TIdIterator first, TIdIterator last) {
                 return {first, last};
             }
 
@@ -449,7 +449,7 @@ namespace osmium {
             };
 
             template <typename TMemberIterator>
-            inline constexpr detail::members_from_iterator_pair<TMemberIterator> _members(TMemberIterator first, TMemberIterator last) {
+            constexpr detail::members_from_iterator_pair<TMemberIterator> _members(TMemberIterator first, TMemberIterator last) {
                 return {first, last};
             }
 
@@ -481,7 +481,7 @@ namespace osmium {
             };
 
             template <typename TCommentIterator>
-            inline constexpr detail::comments_from_iterator_pair<TCommentIterator> _comments(TCommentIterator first, TCommentIterator last) {
+            constexpr detail::comments_from_iterator_pair<TCommentIterator> _comments(TCommentIterator first, TCommentIterator last) {
                 return {first, last};
             }
 
@@ -501,7 +501,7 @@ namespace osmium {
 
 
             template <typename TIdIterator>
-            inline constexpr detail::outer_ring_from_iterator_pair<TIdIterator> _outer_ring(TIdIterator first, TIdIterator last) {
+            constexpr detail::outer_ring_from_iterator_pair<TIdIterator> _outer_ring(TIdIterator first, TIdIterator last) {
                 return {first, last};
             }
 
@@ -527,7 +527,7 @@ namespace osmium {
             }
 
             template <typename TIdIterator>
-            inline constexpr detail::inner_ring_from_iterator_pair<TIdIterator> _inner_ring(TIdIterator first, TIdIterator last) {
+            constexpr detail::inner_ring_from_iterator_pair<TIdIterator> _inner_ring(TIdIterator first, TIdIterator last) {
                 return {first, last};
             }
 
@@ -649,16 +649,16 @@ namespace osmium {
             // ==============================================================
 
             template <typename... TArgs>
-            inline constexpr const char* get_user(const attr::_user& user, const TArgs&... /*args*/) noexcept {
+            constexpr const char* get_user(const attr::_user& user, const TArgs&... /*args*/) noexcept {
                 return user.value;
             }
 
-            inline constexpr const char* get_user() noexcept {
+            constexpr const char* get_user() noexcept {
                 return "";
             }
 
             template <typename TFirst, typename... TRest>
-            inline constexpr typename std::enable_if<!std::is_same<attr::_user, TFirst>::value, const char*>::type
+            constexpr typename std::enable_if<!std::is_same<attr::_user, TFirst>::value, const char*>::type
             get_user(const TFirst& /*first*/, const TRest&... args) noexcept {
                 return get_user(args...);
             }
diff --git a/include/osmium/geom/mercator_projection.hpp b/include/osmium/geom/mercator_projection.hpp
@@ -49,7 +49,7 @@ namespace osmium {
             constexpr double earth_radius_for_epsg3857 = 6378137.0;
             constexpr double max_coordinate_epsg3857 = 20037508.34;
 
-            constexpr inline double lon_to_x(double lon) noexcept {
+            constexpr double lon_to_x(double lon) noexcept {
                 return earth_radius_for_epsg3857 * deg_to_rad(lon);
             }
 
@@ -96,7 +96,7 @@ namespace osmium {
             }
 #endif
 
-            constexpr inline double x_to_lon(double x) {
+            constexpr double x_to_lon(double x) {
                 return rad_to_deg(x) / earth_radius_for_epsg3857;
             }
 
diff --git a/include/osmium/geom/tile.hpp b/include/osmium/geom/tile.hpp
@@ -47,7 +47,7 @@ namespace osmium {
         namespace detail {
 
             template <typename T>
-            inline constexpr const T clamp(const T value, const T min, const T max) {
+            constexpr const T clamp(const T value, const T min, const T max) {
                 return value < min ? min : (max < value ? max : value);
             }
 
@@ -57,15 +57,15 @@ namespace osmium {
          * Returns the number of tiles (in each direction) for the given zoom
          * level.
          */
-        inline constexpr uint32_t num_tiles_in_zoom(uint32_t zoom) noexcept {
+        constexpr uint32_t num_tiles_in_zoom(uint32_t zoom) noexcept {
             return 1U << zoom;
         }
 
         /**
          * Returns the width or height of a tile in web mercator coordinates for
          * the given zoom level.
          */
-        inline constexpr double tile_extent_in_zoom(uint32_t zoom) noexcept {
+        constexpr double tile_extent_in_zoom(uint32_t zoom) noexcept {
             return detail::max_coordinate_epsg3857 * 2 / num_tiles_in_zoom(zoom);
         }
 
@@ -74,7 +74,7 @@ namespace osmium {
          * projection in the given zoom level. Tiles are numbered from left
          * to right.
          */
-        inline constexpr uint32_t mercx_to_tilex(uint32_t zoom, double x) noexcept {
+        constexpr uint32_t mercx_to_tilex(uint32_t zoom, double x) noexcept {
             return static_cast<uint32_t>(detail::clamp<int32_t>(
                 static_cast<int32_t>((x + detail::max_coordinate_epsg3857) / tile_extent_in_zoom(zoom)),
                 0, num_tiles_in_zoom(zoom) - 1));
@@ -85,7 +85,7 @@ namespace osmium {
          * projection in the given zoom level. Tiles are numbered from top
          * to bottom.
          */
-        inline constexpr uint32_t mercy_to_tiley(uint32_t zoom, double y) noexcept {
+        constexpr uint32_t mercy_to_tiley(uint32_t zoom, double y) noexcept {
             return static_cast<uint32_t>(detail::clamp<int32_t>(
                 static_cast<int32_t>((detail::max_coordinate_epsg3857 - y) / tile_extent_in_zoom(zoom)),
                 0, num_tiles_in_zoom(zoom) - 1));
diff --git a/include/osmium/geom/util.hpp b/include/osmium/geom/util.hpp
@@ -61,12 +61,12 @@ namespace osmium {
         constexpr double PI = 3.14159265358979323846;
 
         /// Convert angle from degrees to radians.
-        inline constexpr double deg_to_rad(double degree) noexcept {
+        constexpr double deg_to_rad(double degree) noexcept {
             return degree * (PI / 180.0);
         }
 
         /// Convert angle from radians to degrees.
-        inline constexpr double rad_to_deg(double radians) noexcept {
+        constexpr double rad_to_deg(double radians) noexcept {
             return radians * (180.0 / PI);
         }
 
diff --git a/include/osmium/index/index.hpp b/include/osmium/index/index.hpp
@@ -76,7 +76,7 @@ namespace osmium {
          * object, but it can be specialized.
          */
         template <typename T>
-        inline constexpr T empty_value() {
+        constexpr T empty_value() {
             return T{};
         }
 
@@ -86,7 +86,7 @@ namespace osmium {
          * the full range, so the max value is a good "empty" value.
          */
         template <>
-        inline constexpr size_t empty_value<size_t>() {
+        constexpr size_t empty_value<size_t>() {
             return std::numeric_limits<size_t>::max();
         }
 
diff --git a/include/osmium/io/detail/lz4.hpp b/include/osmium/io/detail/lz4.hpp
@@ -58,7 +58,7 @@ namespace osmium {
 
         namespace detail {
 
-            constexpr inline int lz4_default_compression_level() noexcept {
+            constexpr int lz4_default_compression_level() noexcept {
                 return 1; // LZ4_ACCELERATION_DEFAULT
             }
 
diff --git a/include/osmium/io/detail/zlib.hpp b/include/osmium/io/detail/zlib.hpp
@@ -55,7 +55,7 @@ namespace osmium {
 
         namespace detail {
 
-            constexpr inline int zlib_default_compression_level() noexcept {
+            constexpr int zlib_default_compression_level() noexcept {
                 return Z_DEFAULT_COMPRESSION;
             }
 
diff --git a/include/osmium/memory/item.hpp b/include/osmium/memory/item.hpp
@@ -61,7 +61,7 @@ namespace osmium {
             align_bytes = 8UL
         };
 
-        inline constexpr std::size_t padded_length(std::size_t length) noexcept {
+        constexpr std::size_t padded_length(std::size_t length) noexcept {
             return (length + align_bytes - 1) & ~(align_bytes - 1);
         }
 
diff --git a/include/osmium/memory/item_iterator.hpp b/include/osmium/memory/item_iterator.hpp
@@ -49,7 +49,7 @@ namespace osmium {
         namespace detail {
 
             template <typename T>
-            constexpr inline bool type_is_compatible(const osmium::item_type t) noexcept {
+            constexpr bool type_is_compatible(const osmium::item_type t) noexcept {
                 return T::is_compatible_to(t);
             }
 
diff --git a/include/osmium/osm/box.hpp b/include/osmium/osm/box.hpp
@@ -248,7 +248,7 @@ namespace osmium {
      * Boxes are equal if both locations are equal. Undefined boxes will
      * compare equal.
      */
-    inline constexpr bool operator==(const Box& lhs, const Box& rhs) noexcept {
+    constexpr bool operator==(const Box& lhs, const Box& rhs) noexcept {
         return lhs.bottom_left() == rhs.bottom_left() &&
                lhs.top_right() == rhs.top_right();
     }
diff --git a/include/osmium/osm/entity_bits.hpp b/include/osmium/osm/entity_bits.hpp
@@ -86,15 +86,15 @@ namespace osmium {
 
         }; // enum type
 
-        inline constexpr type operator|(const type lhs, const type rhs) noexcept {
+        constexpr type operator|(const type lhs, const type rhs) noexcept {
             return static_cast<type>(static_cast<unsigned char>(lhs) | static_cast<unsigned char>(rhs));
         }
 
-        inline constexpr type operator&(const type lhs, const type rhs) noexcept {
+        constexpr type operator&(const type lhs, const type rhs) noexcept {
             return static_cast<type>(static_cast<unsigned char>(lhs) & static_cast<unsigned char>(rhs));
         }
 
-        inline constexpr type operator~(const type value) noexcept {
+        constexpr type operator~(const type value) noexcept {
             return all & static_cast<type>(~static_cast<unsigned char>(value));
         }
 
diff --git a/include/osmium/osm/location.hpp b/include/osmium/osm/location.hpp
@@ -490,11 +490,11 @@ namespace osmium {
     /**
      * Locations are equal if both coordinates are equal.
      */
-    inline constexpr bool operator==(const Location& lhs, const Location& rhs) noexcept {
+    constexpr bool operator==(const Location& lhs, const Location& rhs) noexcept {
         return lhs.x() == rhs.x() && lhs.y() == rhs.y();
     }
 
-    inline constexpr bool operator!=(const Location& lhs, const Location& rhs) noexcept {
+    constexpr bool operator!=(const Location& lhs, const Location& rhs) noexcept {
         return !(lhs == rhs);
     }
 
@@ -503,19 +503,19 @@ namespace osmium {
      * the y coordinate. If either of the locations is
      * undefined the result is undefined.
      */
-    inline constexpr bool operator<(const Location& lhs, const Location& rhs) noexcept {
+    constexpr bool operator<(const Location& lhs, const Location& rhs) noexcept {
         return (lhs.x() == rhs.x() && lhs.y() < rhs.y()) || lhs.x() < rhs.x();
     }
 
-    inline constexpr bool operator>(const Location& lhs, const Location& rhs) noexcept {
+    constexpr bool operator>(const Location& lhs, const Location& rhs) noexcept {
         return rhs < lhs;
     }
 
-    inline constexpr bool operator<=(const Location& lhs, const Location& rhs) noexcept {
+    constexpr bool operator<=(const Location& lhs, const Location& rhs) noexcept {
         return !(rhs < lhs);
     }
 
-    inline constexpr bool operator>=(const Location& lhs, const Location& rhs) noexcept {
+    constexpr bool operator>=(const Location& lhs, const Location& rhs) noexcept {
         return !(lhs < rhs);
     }
 
diff --git a/include/osmium/osm/node_ref.hpp b/include/osmium/osm/node_ref.hpp
@@ -150,47 +150,47 @@ namespace osmium {
     /**
      * Compare two NodeRefs. They are equal if they reference the same Node ID.
      */
-    inline constexpr bool operator==(const NodeRef& lhs, const NodeRef& rhs) noexcept {
+    constexpr bool operator==(const NodeRef& lhs, const NodeRef& rhs) noexcept {
         return lhs.ref() == rhs.ref();
     }
 
     /**
      * Compare two NodeRefs. They are not equal if they reference different
      * Node IDs.
      */
-    inline constexpr bool operator!=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
+    constexpr bool operator!=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
         return !(lhs == rhs);
     }
 
     /**
      * Compare two NodeRefs. NodeRefs are ordered according to the Node ID
      * they reference.
      */
-    inline constexpr bool operator<(const NodeRef& lhs, const NodeRef& rhs) noexcept {
+    constexpr bool operator<(const NodeRef& lhs, const NodeRef& rhs) noexcept {
         return lhs.ref() < rhs.ref();
     }
 
     /**
      * Compare two NodeRefs. NodeRefs are ordered according to the Node ID
      * they reference.
      */
-    inline constexpr bool operator>(const NodeRef& lhs, const NodeRef& rhs) noexcept {
+    constexpr bool operator>(const NodeRef& lhs, const NodeRef& rhs) noexcept {
         return rhs < lhs;
     }
 
     /**
      * Compare two NodeRefs. NodeRefs are ordered according to the Node ID
      * they reference.
      */
-    inline constexpr bool operator<=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
+    constexpr bool operator<=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
         return !(rhs < lhs);
     }
 
     /**
      * Compare two NodeRefs. NodeRefs are ordered according to the Node ID
      * they reference.
      */
-    inline constexpr bool operator>=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
+    constexpr bool operator>=(const NodeRef& lhs, const NodeRef& rhs) noexcept {
         return !(lhs < rhs);
     }
 
diff --git a/include/osmium/osm/segment.hpp b/include/osmium/osm/segment.hpp
@@ -75,11 +75,11 @@ namespace osmium {
     }; // class Segment
 
     /// Segments are equal if both their locations are equal
-    inline constexpr bool operator==(const Segment& lhs, const Segment& rhs) noexcept {
+    constexpr bool operator==(const Segment& lhs, const Segment& rhs) noexcept {
         return lhs.first() == rhs.first() && lhs.second() == rhs.second();
     }
 
-    inline constexpr bool operator!=(const Segment& lhs, const Segment& rhs) noexcept {
+    constexpr bool operator!=(const Segment& lhs, const Segment& rhs) noexcept {
         return !(lhs == rhs);
     }
 
diff --git a/include/osmium/osm/timestamp.hpp b/include/osmium/osm/timestamp.hpp

Original file line number	Diff line number	Diff line change
`@@ -73,37 +73,37 @@ namespace osmium {`
`73`	`73`	`}; // struct vec`
`74`	`74`
`75`	`75`	`// addition`
`76`		`- constexpr inline vec operator+(const vec& lhs, const vec& rhs) noexcept {`
	`76`	`+ constexpr vec operator+(const vec& lhs, const vec& rhs) noexcept {`
`77`	`77`	`return vec{lhs.x + rhs.x, lhs.y + rhs.y};`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`// subtraction`
`81`		`- constexpr inline vec operator-(const vec& lhs, const vec& rhs) noexcept {`
	`81`	`+ constexpr vec operator-(const vec& lhs, const vec& rhs) noexcept {`
`82`	`82`	`return vec{lhs.x - rhs.x, lhs.y - rhs.y};`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`// cross product`
`86`		`- constexpr inline int64_t operator*(const vec& lhs, const vec& rhs) noexcept {`
	`86`	`+ constexpr int64_t operator*(const vec& lhs, const vec& rhs) noexcept {`
`87`	`87`	`return lhs.x * rhs.y - lhs.y * rhs.x;`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`// scale vector`
`91`		`- constexpr inline vec operator*(double s, const vec& v) noexcept {`
	`91`	`+ constexpr vec operator*(double s, const vec& v) noexcept {`
`92`	`92`	`return vec{static_cast<int64_t>(s * static_cast<double>(v.x)), static_cast<int64_t>(s * static_cast<double>(v.y))};`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`// scale vector`
`96`		`- constexpr inline vec operator*(const vec& v, double s) noexcept {`
	`96`	`+ constexpr vec operator*(const vec& v, double s) noexcept {`
`97`	`97`	`return vec{static_cast<int64_t>(s * static_cast<double>(v.x)), static_cast<int64_t>(s * static_cast<double>(v.y))};`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`// equality`
`101`		`- constexpr inline bool operator==(const vec& lhs, const vec& rhs) noexcept {`
	`101`	`+ constexpr bool operator==(const vec& lhs, const vec& rhs) noexcept {`
`102`	`102`	`return lhs.x == rhs.x && lhs.y == rhs.y;`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`// inequality`
`106`		`- constexpr inline bool operator!=(const vec& lhs, const vec& rhs) noexcept {`
	`106`	`+ constexpr bool operator!=(const vec& lhs, const vec& rhs) noexcept {`
`107`	`107`	`return !(lhs == rhs);`
`108`	`108`	`}`
`109`	`109`
Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,7 @@ namespace osmium {`
`381`	`381`	`};`
`382`	`382`
`383`	`383`	`template <typename TTagIterator>`
`384`		`- inline constexpr detail::tags_from_iterator_pair<TTagIterator> _tags(TTagIterator first, TTagIterator last) {`
	`384`	`+ constexpr detail::tags_from_iterator_pair<TTagIterator> _tags(TTagIterator first, TTagIterator last) {`
`385`	`385`	`return {first, last};`
`386`	`386`	`}`
`387`	`387`
`@@ -409,7 +409,7 @@ namespace osmium {`
`409`	`409`	`};`
`410`	`410`
`411`	`411`	`template <typename TIdIterator>`
`412`		`- inline constexpr detail::nodes_from_iterator_pair<TIdIterator> _nodes(TIdIterator first, TIdIterator last) {`
	`412`	`+ constexpr detail::nodes_from_iterator_pair<TIdIterator> _nodes(TIdIterator first, TIdIterator last) {`
`413`	`413`	`return {first, last};`
`414`	`414`	`}`
`415`	`415`
`@@ -449,7 +449,7 @@ namespace osmium {`
`449`	`449`	`};`
`450`	`450`
`451`	`451`	`template <typename TMemberIterator>`
`452`		`- inline constexpr detail::members_from_iterator_pair<TMemberIterator> _members(TMemberIterator first, TMemberIterator last) {`
	`452`	`+ constexpr detail::members_from_iterator_pair<TMemberIterator> _members(TMemberIterator first, TMemberIterator last) {`
`453`	`453`	`return {first, last};`
`454`	`454`	`}`
`455`	`455`
`@@ -481,7 +481,7 @@ namespace osmium {`
`481`	`481`	`};`
`482`	`482`
`483`	`483`	`template <typename TCommentIterator>`
`484`		`- inline constexpr detail::comments_from_iterator_pair<TCommentIterator> _comments(TCommentIterator first, TCommentIterator last) {`
	`484`	`+ constexpr detail::comments_from_iterator_pair<TCommentIterator> _comments(TCommentIterator first, TCommentIterator last) {`
`485`	`485`	`return {first, last};`
`486`	`486`	`}`
`487`	`487`
`@@ -501,7 +501,7 @@ namespace osmium {`
`501`	`501`
`502`	`502`
`503`	`503`	`template <typename TIdIterator>`
`504`		`- inline constexpr detail::outer_ring_from_iterator_pair<TIdIterator> _outer_ring(TIdIterator first, TIdIterator last) {`
	`504`	`+ constexpr detail::outer_ring_from_iterator_pair<TIdIterator> _outer_ring(TIdIterator first, TIdIterator last) {`
`505`	`505`	`return {first, last};`
`506`	`506`	`}`
`507`	`507`
`@@ -527,7 +527,7 @@ namespace osmium {`
`527`	`527`	`}`
`528`	`528`
`529`	`529`	`template <typename TIdIterator>`
`530`		`- inline constexpr detail::inner_ring_from_iterator_pair<TIdIterator> _inner_ring(TIdIterator first, TIdIterator last) {`
	`530`	`+ constexpr detail::inner_ring_from_iterator_pair<TIdIterator> _inner_ring(TIdIterator first, TIdIterator last) {`
`531`	`531`	`return {first, last};`
`532`	`532`	`}`
`533`	`533`
`@@ -649,16 +649,16 @@ namespace osmium {`
`649`	`649`	`// ==============================================================`
`650`	`650`
`651`	`651`	`template <typename... TArgs>`
`652`		`- inline constexpr const char* get_user(const attr::_user& user, const TArgs&... /args/) noexcept {`
	`652`	`+ constexpr const char* get_user(const attr::_user& user, const TArgs&... /args/) noexcept {`
`653`	`653`	`return user.value;`
`654`	`654`	`}`
`655`	`655`
`656`		`- inline constexpr const char* get_user() noexcept {`
	`656`	`+ constexpr const char* get_user() noexcept {`
`657`	`657`	`return "";`
`658`	`658`	`}`
`659`	`659`
`660`	`660`	`template <typename TFirst, typename... TRest>`
`661`		`- inline constexpr typename std::enable_if<!std::is_same<attr::_user, TFirst>::value, const char*>::type`
	`661`	`+ constexpr typename std::enable_if<!std::is_same<attr::_user, TFirst>::value, const char*>::type`
`662`	`662`	`get_user(const TFirst& /first/, const TRest&... args) noexcept {`
`663`	`663`	`return get_user(args...);`
`664`	`664`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ namespace osmium {`
`49`	`49`	`constexpr double earth_radius_for_epsg3857 = 6378137.0;`
`50`	`50`	`constexpr double max_coordinate_epsg3857 = 20037508.34;`
`51`	`51`
`52`		`- constexpr inline double lon_to_x(double lon) noexcept {`
	`52`	`+ constexpr double lon_to_x(double lon) noexcept {`
`53`	`53`	`return earth_radius_for_epsg3857 * deg_to_rad(lon);`
`54`	`54`	`}`
`55`	`55`
`@@ -96,7 +96,7 @@ namespace osmium {`
`96`	`96`	`}`
`97`	`97`	`#endif`
`98`	`98`
`99`		`- constexpr inline double x_to_lon(double x) {`
	`99`	`+ constexpr double x_to_lon(double x) {`
`100`	`100`	`return rad_to_deg(x) / earth_radius_for_epsg3857;`
`101`	`101`	`}`
`102`	`102`
Original file line number	Diff line number	Diff line change
`@@ -61,12 +61,12 @@ namespace osmium {`
`61`	`61`	`constexpr double PI = 3.14159265358979323846;`
`62`	`62`
`63`	`63`	`/// Convert angle from degrees to radians.`
`64`		`- inline constexpr double deg_to_rad(double degree) noexcept {`
	`64`	`+ constexpr double deg_to_rad(double degree) noexcept {`
`65`	`65`	`return degree * (PI / 180.0);`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`/// Convert angle from radians to degrees.`
`69`		`- inline constexpr double rad_to_deg(double radians) noexcept {`
	`69`	`+ constexpr double rad_to_deg(double radians) noexcept {`
`70`	`70`	`return radians * (180.0 / PI);`
`71`	`71`	`}`
`72`	`72`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ namespace osmium {`
`58`	`58`
`59`	`59`	`namespace detail {`
`60`	`60`
`61`		`- constexpr inline int lz4_default_compression_level() noexcept {`
	`61`	`+ constexpr int lz4_default_compression_level() noexcept {`
`62`	`62`	`return 1; // LZ4_ACCELERATION_DEFAULT`
`63`	`63`	`}`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ namespace osmium {`
`55`	`55`
`56`	`56`	`namespace detail {`
`57`	`57`
`58`		`- constexpr inline int zlib_default_compression_level() noexcept {`
	`58`	`+ constexpr int zlib_default_compression_level() noexcept {`
`59`	`59`	`return Z_DEFAULT_COMPRESSION;`
`60`	`60`	`}`
`61`	`61`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ namespace osmium {`
`61`	`61`	`align_bytes = 8UL`
`62`	`62`	`};`
`63`	`63`
`64`		`- inline constexpr std::size_t padded_length(std::size_t length) noexcept {`
	`64`	`+ constexpr std::size_t padded_length(std::size_t length) noexcept {`
`65`	`65`	`return (length + align_bytes - 1) & ~(align_bytes - 1);`
`66`	`66`	`}`
`67`	`67`