diff --git a/DataStructures/HilbertValue.cpp b/DataStructures/HilbertValue.cpp
index 4f7d43c88..bc9f23113 100644
--- a/DataStructures/HilbertValue.cpp
+++ b/DataStructures/HilbertValue.cpp
@@ -27,12 +27,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "HilbertValue.h"
 
-uint64_t HilbertCode::operator() (
-    const FixedPointCoordinate & current_coordinate
-) const {
+#include <osrm/Coordinate.h>
+
+uint64_t HilbertCode::operator()(const FixedPointCoordinate &current_coordinate) const
+{
     unsigned location[2];
-    location[0] = current_coordinate.lat+( 90*COORDINATE_PRECISION);
-    location[1] = current_coordinate.lon+(180*COORDINATE_PRECISION);
+    location[0] = current_coordinate.lat + (90 * COORDINATE_PRECISION);
+    location[1] = current_coordinate.lon + (180 * COORDINATE_PRECISION);
 
     TransposeCoordinate(location);
     return BitInterleaving(location[0], location[1]);
@@ -41,48 +42,59 @@ uint64_t HilbertCode::operator() (
 uint64_t HilbertCode::BitInterleaving(const uint32_t latitude, const uint32_t longitude) const
 {
     uint64_t result = 0;
-    for(int8_t index = 31; index >= 0; --index){
+    for (int8_t index = 31; index >= 0; --index)
+    {
         result |= (latitude >> index) & 1;
         result <<= 1;
         result |= (longitude >> index) & 1;
-        if(0 != index){
+        if (0 != index)
+        {
             result <<= 1;
         }
     }
     return result;
 }
 
-void HilbertCode::TransposeCoordinate( uint32_t * X) const
+void HilbertCode::TransposeCoordinate(uint32_t *X) const
 {
-    uint32_t M = 1 << (32-1), P, Q, t;
+    uint32_t M = 1 << (32 - 1), P, Q, t;
     int i;
     // Inverse undo
-    for( Q = M; Q > 1; Q >>= 1 ) {
-        P=Q-1;
-        for( i = 0; i < 2; ++i ) {
+    for (Q = M; Q > 1; Q >>= 1)
+    {
+        P = Q - 1;
+        for (i = 0; i < 2; ++i)
+        {
 
             const bool condition = (X[i] & Q);
-            if( condition ) {
+            if (condition)
+            {
                 X[0] ^= P; // invert
-            } else {
-                t = (X[0]^X[i]) & P;
+            }
+            else
+            {
+                t = (X[0] ^ X[i]) & P;
                 X[0] ^= t;
                 X[i] ^= t;
             }
         } // exchange
     }
     // Gray encode
-    for( i = 1; i < 2; ++i ) {
-        X[i] ^= X[i-1];
+    for (i = 1; i < 2; ++i)
+    {
+        X[i] ^= X[i - 1];
     }
-    t=0;
-    for( Q = M; Q > 1; Q >>= 1 ) {
-        const bool condition = (X[2-1] & Q);
-        if( condition ) {
-            t ^= Q-1;
+    t = 0;
+    for (Q = M; Q > 1; Q >>= 1)
+    {
+        const bool condition = (X[2 - 1] & Q);
+        if (condition)
+        {
+            t ^= Q - 1;
         }
-    } //check if this for loop is wrong
-    for( i = 0; i < 2; ++i ) {
+    } // check if this for loop is wrong
+    for (i = 0; i < 2; ++i)
+    {
         X[i] ^= t;
     }
 }
diff --git a/DataStructures/HilbertValue.h b/DataStructures/HilbertValue.h
index b86c13180..9de23724f 100644
--- a/DataStructures/HilbertValue.h
+++ b/DataStructures/HilbertValue.h
@@ -28,23 +28,22 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef HILBERTVALUE_H_
 #define HILBERTVALUE_H_
 
-#include <osrm/Coordinate.h>
-
-#include <boost/integer.hpp>
-#include <boost/noncopyable.hpp>
+#include <cstdint>
 
 // computes a 64 bit value that corresponds to the hilbert space filling curve
 
-class HilbertCode : boost::noncopyable
+struct FixedPointCoordinate;
+
+class HilbertCode
 {
-public:
-	uint64_t operator()
-    (
-		const FixedPointCoordinate & current_coordinate
-	) const;
-private:
-	inline uint64_t BitInterleaving( const uint32_t a, const uint32_t b) const;
-	inline void TransposeCoordinate( uint32_t * X) const;
+  public:
+    uint64_t operator()(const FixedPointCoordinate &current_coordinate) const;
+    HilbertCode() {}
+    HilbertCode(const HilbertCode &) = delete;
+
+  private:
+    inline uint64_t BitInterleaving(const uint32_t a, const uint32_t b) const;
+    inline void TransposeCoordinate(uint32_t *X) const;
 };
 
 #endif /* HILBERTVALUE_H_ */