Address PR comments

include/util/alias.hpp

@@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef ALIAS_HPP
+#ifndef OSRM_UTIL_ALIAS_HPP
-#define ALIAS_HPP
+#define OSRM_UTIL_ALIAS_HPP
 
 #include <functional>
 #include <iostream>
@@ -42,7 +42,7 @@ inline std::ostream &operator<<(std::ostream &stream, const Alias<From, Tag> &in
 template <typename From, typename Tag> struct Alias final
 {
     using value_type = From;
-    static_assert(std::is_arithmetic<From>(), "");
+    static_assert(std::is_arithmetic<From>::value, "Needs to be based on an arithmetic type");
 
     From __value;
     friend std::ostream &operator<<<From, Tag>(std::ostream &stream, const Alias &inst);
@@ -61,10 +61,12 @@ template <typename From, typename Tag> struct Alias final
     {
         return Alias{__value * static_cast<const From>(rhs_)};
     }
+    inline Alias operator*(const double rhs_) const { return Alias{__value * rhs_}; }
     inline Alias operator/(const Alias rhs_) const
     {
         return Alias{__value / static_cast<const From>(rhs_)};
     }
+    inline Alias operator/(const double rhs_) const { return Alias{__value / rhs_}; }
     inline Alias operator|(const Alias rhs_) const
     {
         return Alias{__value | static_cast<const From>(rhs_)};
@@ -80,15 +82,47 @@ template <typename From, typename Tag> struct Alias final
     inline bool operator==(const Alias z_) const { return __value == static_cast<const From>(z_); }
     inline bool operator!=(const Alias z_) const { return __value != static_cast<const From>(z_); }
 
-    inline Alias operator++() { __value++; return *this; }
+    inline Alias operator++()
-    inline Alias operator--() { __value--; return *this; }
+    {
+        __value++;
+        return *this;
+    }
+    inline Alias operator--()
+    {
+        __value--;
+        return *this;
+    }
 
-    inline Alias operator+=(const Alias z_) { __value += static_cast<const From>(z_); return *this; }
+    inline Alias operator+=(const Alias z_)
-    inline Alias operator-=(const Alias z_) { __value -= static_cast<const From>(z_); return *this; }
+    {
-    inline Alias operator/=(const Alias z_) { __value /= static_cast<const From>(z_); return *this; }
+        __value += static_cast<const From>(z_);
-    inline Alias operator*=(const Alias z_) { __value *= static_cast<const From>(z_); return *this; }
+        return *this;
-    inline Alias operator|=(const Alias z_) { __value |= static_cast<const From>(z_); return *this; }
+    }
-    inline Alias operator&=(const Alias z_) { __value &= static_cast<const From>(z_); return *this; }
+    inline Alias operator-=(const Alias z_)
+    {
+        __value -= static_cast<const From>(z_);
+        return *this;
+    }
+    inline Alias operator/=(const Alias z_)
+    {
+        __value /= static_cast<const From>(z_);
+        return *this;
+    }
+    inline Alias operator*=(const Alias z_)
+    {
+        __value *= static_cast<const From>(z_);
+        return *this;
+    }
+    inline Alias operator|=(const Alias z_)
+    {
+        __value |= static_cast<const From>(z_);
+        return *this;
+    }
+    inline Alias operator&=(const Alias z_)
+    {
+        __value &= static_cast<const From>(z_);
+        return *this;
+    }
 };
 
 template <typename From, typename Tag>
@@ -96,14 +130,6 @@ inline std::ostream &operator<<(std::ostream &stream, const Alias<From, Tag> &in
 {
     return stream << inst.__value;
 }
-
-template <typename T>
-struct is_valid_alias
-    : std::integral_constant<bool,
-                             std::is_trivial<T>::value && std::is_standard_layout<T>::value &&
-                                 std::is_pod<T>::value>
-{
-};
 }
 
 namespace std

include/util/coordinate.hpp

@@ -59,10 +59,10 @@ using FixedLatitude = Alias<std::int32_t, tag::latitude>;
 using FixedLongitude = Alias<std::int32_t, tag::longitude>;
 using FloatLatitude = Alias<double, tag::latitude>;
 using FloatLongitude = Alias<double, tag::longitude>;
-static_assert(osrm::is_valid_alias<FixedLatitude>(), "FixedLatitude is not a valid alias");
+static_assert(std::is_pod<FixedLatitude>(), "FixedLatitude is not a valid alias");
-static_assert(osrm::is_valid_alias<FixedLongitude>(), "FixedLongitude is not a valid alias");
+static_assert(std::is_pod<FixedLongitude>(), "FixedLongitude is not a valid alias");
-static_assert(osrm::is_valid_alias<FloatLatitude>(), "FloatLatitude is not a valid alias");
+static_assert(std::is_pod<FloatLatitude>(), "FloatLatitude is not a valid alias");
-static_assert(osrm::is_valid_alias<FloatLongitude>(), "FloatLongitude is not a valid alias");
+static_assert(std::is_pod<FloatLongitude>(), "FloatLongitude is not a valid alias");
 
 /**
  * Converts a typed latitude from floating to fixed representation.

include/util/typedefs.hpp

@@ -47,9 +47,9 @@ struct osm_way_id
 };
 }
 using OSMNodeID = osrm::Alias<std::uint64_t, tag::osm_node_id>;
-static_assert(osrm::is_valid_alias<OSMNodeID>(), "OSMNodeID is not a valid alias");
+static_assert(std::is_pod<OSMNodeID>(), "OSMNodeID is not a valid alias");
 using OSMWayID = osrm::Alias<std::uint64_t, tag::osm_way_id>;
-static_assert(osrm::is_valid_alias<OSMWayID>(), "OSMWayID is not a valid alias");
+static_assert(std::is_pod<OSMWayID>(), "OSMWayID is not a valid alias");
 
 static const OSMNodeID SPECIAL_OSM_NODEID = OSMNodeID{std::numeric_limits<std::uint64_t>::max()};
 static const OSMWayID SPECIAL_OSM_WAYID = OSMWayID{std::numeric_limits<std::uint32_t>::max()};

src/benchmarks/alias.cpp

@@ -4,11 +4,11 @@
 #include "util/timing_util.hpp"
 
 #include <algorithm>
+#include <iomanip>
 #include <numeric>
 #include <random>
 #include <string>
 #include <vector>
-#include <iomanip>
 
 using namespace osrm;