use nested namespace declarations

adapter.hpp

@@ -21,7 +21,7 @@
 #include <cstddef>
 #include <iterator>
 
-namespace util { namespace adapter {
+namespace util::adapter {
     namespace container {
         // reverse a container for range-based-for
         template <typename T>
@@ -144,6 +144,6 @@ namespace util { namespace adapter {
         //    size_t m_sequence;
         //};
     }
-} }
+}
 
 #endif

ascii.hpp

@@ -22,7 +22,7 @@
 #include <cstdint>
 #include <stdexcept>
 
-namespace util { namespace ascii {
+namespace util::ascii {
     ///////////////////////////////////////////////////////////////////////////
     constexpr inline
     bool
@@ -87,6 +87,6 @@ namespace util { namespace ascii {
             return false;
         }
     }
-} }
+}
 
 #endif

cmdopt.cpp

@@ -155,11 +155,11 @@ present::finish (void)
 
 
 //-----------------------------------------------------------------------------
-namespace util { namespace cmdopt { namespace option {
+namespace util::cmdopt::option {
     template class value<uint16_t>;
     template class value<uint32_t>;
     template class value<uint64_t>;
-} } }
+}
 
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -180,9 +180,9 @@ count<T>::execute (void)
 
 
 //-----------------------------------------------------------------------------
-namespace util { namespace cmdopt { namespace option {
+namespace util::cmdopt::option {
     template class count<unsigned>;
-} } }
+}
 
 
 ///////////////////////////////////////////////////////////////////////////////

cmdopt.hpp

@@ -25,7 +25,9 @@
 #include <tuple>
 #include <vector>
 
-namespace util { namespace cmdopt {
+
+///////////////////////////////////////////////////////////////////////////////
+namespace util::cmdopt {
     namespace option {
         class base {
         public:
@@ -199,7 +201,7 @@ namespace util { namespace cmdopt {
     private:
         const int m_index;
     };
-} }
+}
 
 #include "cmdopt.ipp"
 

cmdopt.ipp

@@ -25,7 +25,7 @@
 #include "./introspection.hpp"
 #include "./iterator.hpp"
 
-namespace util { namespace cmdopt {
+namespace util::cmdopt {
     ///////////////////////////////////////////////////////////////////////////
     template <typename T>
     option::value<T>::value (T &_data):
@@ -194,4 +194,4 @@ namespace util { namespace cmdopt {
         m_options.emplace_back (std::move (description), std::move (handler));
         return ref;
     }
-} }
+}

colour.cpp

@@ -330,7 +330,7 @@ util::hsv_to_rgb (colour3f hsv)
 /// Extract a colour object from a JSON node.
 #include "json/tree.hpp"
 
-namespace json { namespace tree {
+namespace json::tree {
     template <>
     util::colour4f
     io<util::colour4f>::deserialise (const node &root) {
@@ -341,7 +341,7 @@ namespace json { namespace tree {
             root[3].as<float> (),
         };
     }
-} }
+}
 
 
 ///////////////////////////////////////////////////////////////////////////////

coord/base.hpp

@@ -24,7 +24,7 @@
 #include <cstdlib>
 #include <type_traits>
 
-namespace util { namespace coord {
+namespace util::coord {
     /////////////////////////////////////////////////////////////////////////
     template <
         size_t S,
@@ -142,7 +142,7 @@ namespace util { namespace coord {
             return out;
         }
     };
-} }
+}
 
 
 #endif

coord/init.hpp

@@ -21,7 +21,7 @@
 
 #include <cstdlib>
 
-namespace util { namespace coord {
+namespace util::coord {
     template <size_t S, typename T, typename...>
     struct init;
 
@@ -71,6 +71,6 @@ namespace util { namespace coord {
             store<4,T,tags...> ({ v0, v1, v2, v3 })
         { ; }
     };
-} }
+}
 
 #endif

coord/names.hpp

@@ -17,7 +17,7 @@
 #ifndef __UTIL_COORD_NAMES_HPP
 #define __UTIL_COORD_NAMES_HPP
 
-namespace util { namespace coord {
+namespace util::coord {
     ///////////////////////////////////////////////////////////////////////
     // tags for accessor names
     //
@@ -37,6 +37,6 @@ namespace util { namespace coord {
     // quaternions
     struct wxyz { };
     struct abcd { };
-} }
+}
 
 #endif

coord/store.hpp

@@ -23,7 +23,8 @@
 
 #include <cstdlib>
 
-namespace util { namespace coord {
+
+namespace util::coord {
     ///////////////////////////////////////////////////////////////////////////
     // Coordinate storage class.
     //
@@ -179,6 +180,6 @@ namespace util { namespace coord {
             struct { T a,b,c,d; };
         };
     };
-} }
+}
 
 #endif

crypto/arc4.hpp

@@ -21,7 +21,7 @@
 #include <cstdint>
 #include <cstddef>
 
-namespace util { namespace crypto {
+namespace util::crypto {
     class ARC4 {
     public:
         ARC4 (const uint8_t *restrict key, size_t len);
@@ -35,6 +35,6 @@ namespace util { namespace crypto {
         size_t x, y;
         std::array<uint8_t,256> S;
     };
-} }
+}
 
 #endif

crypto/tea.hpp

@@ -21,7 +21,7 @@
 #include <cstdint>
 #include <cstddef>
 
-namespace util { namespace crypto {
+namespace util::crypto {
     // http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
     class TEA {
     public:
@@ -35,6 +35,6 @@ namespace util { namespace crypto {
     private:
         key_t m_key;
     };
-} }
+}
 
 #endif

crypto/xtea.hpp

@@ -21,7 +21,7 @@
 #include <cstdint>
 #include <cstddef>
 
-namespace util { namespace crypto {
+namespace util::crypto {
     // http://en.wikipedia.org/wiki/XTEA
     class XTEA {
     public:
@@ -35,6 +35,6 @@ namespace util { namespace crypto {
     private:
         key_t m_key;
     };
-} }
+}
 
 #endif

crypto/xxtea.hpp

@@ -21,7 +21,7 @@
 #include <cstdint>
 #include <cstddef>
 
-namespace util { namespace crypto {
+namespace util::crypto {
     // http://en.wikipedia.org/wiki/XXTEA
     // 'corrected' block TEA
     class XXTEA {
@@ -36,7 +36,7 @@ namespace util { namespace crypto {
     private:
         key_t m_key;
     };
-} }
+}
 
 #endif
 

debug.hpp

@@ -337,7 +337,7 @@ void disable_fpe (void);
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace debug {
+namespace util::debug {
     void init (void);
 
 
@@ -388,7 +388,7 @@ namespace util { namespace debug {
         (void)t;
         CHECK (is_valid (t));
     }
-} }
+}
 
 
 #include "./debug.ipp"

debug.ipp

@@ -25,7 +25,7 @@
 #include <limits>
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace debug { namespace detail {
+namespace util::debug::detail {
     void panic [[noreturn]] (const char *msg);
 
     template <typename ...Args, size_t N>
@@ -38,7 +38,7 @@ namespace util { namespace debug { namespace detail {
 
     void not_implemented [[noreturn]] (const char *msg);
     void unreachable [[noreturn]] (const char *msg);
-} } }
+}
 
 // not_implemented/unreachable/panic must be callable from constexpr contexts.
 // but they rely on functions that aren't constexpr to perform the controlled

format.cpp

@@ -19,7 +19,7 @@
 #include <utility>
 
 
-namespace util { namespace format { namespace detail {
+namespace util::format::detail {
     //-------------------------------------------------------------------------
     std::ostream&
     operator<< (std::ostream &os, specifier::repr r)
@@ -72,4 +72,4 @@ namespace util { namespace format { namespace detail {
             "length: "             << s.length              <<
         " }";
     }
-} } }
+}

format.hpp

@@ -20,7 +20,7 @@
 #include <stdexcept>
 #include <string>
 
-namespace util { namespace format {
+namespace util::format {
     //-------------------------------------------------------------------------
     // render a format string using the provided values.
     //
@@ -69,7 +69,7 @@ namespace util { namespace format {
             error ("missing argument for specifier")
         { ; }
     };
-} }
+}
 
 #include "format.ipp"
 

format.ipp

@@ -23,7 +23,7 @@
 #include <sstream>
 
 
-namespace util { namespace format { namespace detail {
+namespace util::format::detail {
     ///////////////////////////////////////////////////////////////////////////
     // GCC: workaround which allows a throw to appear in constexpr codepaths
     // that do not execute at compile time. See gcc#67371
@@ -933,11 +933,11 @@ namespace util { namespace format { namespace detail {
 
         return _render (os, first, last);
     }
-} } }
+}
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace format {
+namespace util::format {
     template <typename ...Args, size_t N>
     std::string
     render (const char (&fmt)[N], const Args& ...args)
@@ -946,4 +946,4 @@ namespace util { namespace format {
         detail::render (std::back_inserter (res), fmt, args...);
         return res;
     }
-} }
+}

geom/aabb.cpp

@@ -208,7 +208,7 @@ AABB<S,T>::operator== (const AABB<S,T> rhs) const
 
 
 //-----------------------------------------------------------------------------
-namespace util { namespace debug {
+namespace util::debug {
     template <size_t S, typename T>
     struct validator<AABB<S,T>> {
         static bool is_valid (const AABB<S,T> &b)
@@ -220,7 +220,7 @@ namespace util { namespace debug {
             return true;
         }
     };
-} }
+}
 
 
 //-----------------------------------------------------------------------------
@@ -234,8 +234,8 @@ util::geom::operator<< (std::ostream &os, util::geom::AABB<S,T> b)
 
 
 //-----------------------------------------------------------------------------
-#define INSTANTIATE_S_T(S,T)                    \
+#define INSTANTIATE_S_T(S,T)                             \
-namespace util { namespace geom { template struct AABB<S,T>; } }   \
+namespace util::geom { template struct AABB<S,T>; }      \
 template bool util::debug::is_valid (const AABB<S,T>&);  \
 template std::ostream& util::geom::operator<< (std::ostream&, AABB<S,T>);
 

geom/aabb.hpp

@@ -23,7 +23,7 @@
 
 #include <cstdint>
 
-namespace util { namespace geom {
+namespace util::geom {
     template <size_t S, typename T>
     struct AABB {
         AABB () = default;
@@ -64,7 +64,7 @@ namespace util { namespace geom {
     typedef AABB<3,float> AABB3f;
     typedef AABB<3,unsigned> AABB3u;
     typedef AABB<3,int> AABB3i;
-} }
+}
 
 #include "aabb.ipp"
 

geom/aabb.ipp

@@ -26,7 +26,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace geom {
+namespace util::geom {
     template <size_t S, typename T, typename G>
     struct sampler<S,T,AABB,G> {
         static point<S,T>
@@ -40,4 +40,4 @@ namespace util { namespace geom {
             return p * (b.p1 - b.p0) + b.p0.template as<util::vector> ();
         }
     };
-} }
+}

geom/cylinder.hpp

@@ -19,8 +19,8 @@
 
 #include "../point.hpp"
 
-namespace util { namespace geom {
+///////////////////////////////////////////////////////////////////////////////
-    ///////////////////////////////////////////////////////////////////////////
+namespace util::geom {
     template <size_t S, typename T>
     struct cylinder {
         util::point<S,T> p0, p1;
@@ -30,6 +30,6 @@ namespace util { namespace geom {
         bool includes (util::point<S,T>) const;
     };
 
-} }
+}
 
 #endif

geom/ellipse.hpp

@@ -22,14 +22,14 @@
 #include "../point.hpp"
 #include "../vector.hpp"
 
-namespace util { namespace geom {
+namespace util::geom {
     ///////////////////////////////////////////////////////////////////////////
     template <size_t S, typename T>
     struct ellipse {
         util::point<S,T> origin;
         util::vector<S,T> radius;
     };
-} }
+}
 
 #include "ellipse.ipp"
 

geom/ellipse.ipp

@@ -26,7 +26,7 @@
 #include <random>
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace geom {
+namespace util::geom {
     template <typename T, template <size_t,typename> class K, typename G>
     struct sampler<2,T,K,G>
     {
@@ -43,4 +43,4 @@ namespace util { namespace geom {
             } * rho * k.radius + k.origin.template as<util::vector> ();
         }
     };
-} }
+}

geom/fwd.hpp

@@ -19,7 +19,7 @@
 
 #include <cstdlib>
 
-namespace util { namespace geom {
+namespace util::geom {
     template <size_t S, typename T> struct ray;
     template <size_t S, typename T> struct plane;
     template <size_t S, typename T> struct AABB;
@@ -28,6 +28,6 @@ namespace util { namespace geom {
     template <size_t S, typename T> struct rect;
     template <size_t S, typename T> struct cylinder;
     template <size_t S, typename T> struct tri;
-} }
+}
 
 #endif

geom/iostream.hpp

@@ -21,7 +21,9 @@
 
 #include <ostream>
 
-namespace util { namespace geom {
+
+///////////////////////////////////////////////////////////////////////////////
+namespace util::geom {
     template <size_t S, typename T>
     std::ostream&
     operator<< (std::ostream&, AABB<S,T>);
@@ -33,6 +35,6 @@ namespace util { namespace geom {
     template <size_t S, typename T>
     std::ostream&
     operator<< (std::ostream&, sphere<S,T>);
-} }
+}
 
 #endif

geom/ops.hpp

@@ -20,7 +20,9 @@
 #include "aabb.hpp"
 #include "../point.hpp"
 
-namespace util { namespace geom {
+
+///////////////////////////////////////////////////////////////////////////////
+namespace util::geom {
     template <
         size_t S,
         typename T,
@@ -87,6 +89,6 @@ namespace util { namespace geom {
     >
     K<S,T>
     scale (K<S,T>, T);
-} }
+}
 
 #endif

geom/plane.hpp

@@ -20,7 +20,7 @@
 #include "../point.hpp"
 #include "../vector.hpp"
 
-namespace util { namespace geom {
+namespace util::geom {
     template <size_t S, typename T>
     struct plane {
         plane (util::point<S,T> p,
@@ -33,6 +33,6 @@ namespace util { namespace geom {
 
     typedef plane<2,float> plane2f;
     typedef plane<3,float> plane3f;
-} }
+}
 
 #endif

geom/ray.hpp

@@ -23,7 +23,9 @@
 #include "../vector.hpp"
 #include "../point.hpp"
 
-namespace util { namespace geom {
+
+///////////////////////////////////////////////////////////////////////////////
+namespace util::geom {
     template <size_t S, typename T>
     struct ray {
         ray (point<S,T> origin,
@@ -50,6 +52,6 @@ namespace util { namespace geom {
 
     typedef ray<2,float> ray2f;
     typedef ray<3,float> ray3f;
-} }
+}
 
 #endif

geom/sample.hpp

@@ -19,7 +19,9 @@
 
 #include "../point.hpp"
 
-namespace util { namespace geom {
+
+///////////////////////////////////////////////////////////////////////////////
+namespace util::geom {
     template <
         size_t S,
         typename T,
@@ -41,7 +43,7 @@ namespace util { namespace geom {
     {
         return sampler<S,T,K,G>::fn (k, g);
     }
-} }
+}
 
 #include "sample.ipp"
 

geom/sample.ipp

@@ -22,7 +22,7 @@
 
 #include "ops.hpp"
 
-namespace util { namespace geom {
+namespace util::geom {
     // use rejection sampling by default
     template <
         size_t S,
@@ -41,5 +41,5 @@ namespace util { namespace geom {
                 return p;
         }
     }
-} }
+}
 

geom/sphere.hpp

@@ -19,7 +19,9 @@
 
 #include "../point.hpp"
 
-namespace util { namespace geom {
+
+///////////////////////////////////////////////////////////////////////////////
+namespace util::geom {
     template <size_t S, typename T>
     struct sphere {
         point<S,T> centre;
@@ -28,6 +30,6 @@ namespace util { namespace geom {
 
     typedef sphere<2,float> sphere2f;
     typedef sphere<3,float> sphere3f;
-} }
+}
 
 #endif

hash.hpp

@@ -22,9 +22,9 @@
 #include <cstdint>
 #include <cstdlib>
 
-namespace util { namespace hash {
+namespace util::hash {
     uint32_t mix (uint32_t v) { return wang (v); }
     uint64_t mix (uint64_t v) { return wang (v); }
-} }
+}
 
 #endif

hash/adler.hpp

@@ -23,11 +23,11 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class adler32 : public fletcher<uint32_t> {
     public:
         adler32 ();
     };
-} }
+}
 
 #endif

hash/bsdsum.hpp

@@ -22,7 +22,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class bsdsum {
     public:
         using digest_t = uint16_t;
@@ -40,6 +40,6 @@ namespace util { namespace hash {
     private:
         digest_t m_accum;
     };
-} }
+}
 
 #endif

hash/crc.hpp

@@ -22,7 +22,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class crc32 {
     public:
         using digest_t = uint32_t;
@@ -36,7 +36,7 @@ namespace util { namespace hash {
 
         digest_t digest (void) const;
     };
+}
 
-} }
 #endif
 

hash/fasthash.hpp

@@ -21,12 +21,12 @@
 #include <cstdint>
 
 // Zilong Tan's FastHash, via George Marsaglia's "Xorshift RNGs"
-namespace util { namespace hash { namespace fasthash {
+namespace util::hash::fasthash {
     uint64_t mix (uint64_t);
 
     uint32_t hash32 (const void *restrict data, size_t len, uint32_t seed);
     uint64_t hash64 (const void *restrict data, size_t len, uint64_t seed);
-} } }
+}
 
 #endif
 

hash/fletcher.hpp

@@ -24,7 +24,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     template <typename DIGEST>
     class fletcher {
     public:
@@ -51,7 +51,7 @@ namespace util { namespace hash {
         const state_t m_initial;
         state_t m_state;
     };
-} }
+}
 
 
 #endif

hash/fnv1a.hpp

@@ -20,10 +20,10 @@
 #include <cstdint>
 #include <cstddef>
 
-namespace util { namespace hash {
+namespace util::hash {
     // Fast and general hashing using FNV-1a
     uint32_t fnv1a32 (const void *restrict, size_t);
     uint64_t fnv1a64 (const void *restrict, size_t);
-} }
+}
 
 #endif

hash/fwd.hpp

@@ -27,7 +27,7 @@
 
 
 // Forward declerations of class based hashes
-namespace util { namespace hash {
+namespace util::hash {
     template <class T> class HMAC;
 
     // checksums
@@ -49,6 +49,6 @@ namespace util { namespace hash {
     class RIPEMD;
     class SHA1;
     class SHA256;
-} }
+}
 
 #endif

hash/hmac.hpp

@@ -21,7 +21,7 @@
 #include <cstdint>
 #include <cstdlib>
 
-namespace util { namespace hash {
+namespace util::hash {
     template <class T>
     /// RFC 2104 key-hashing for message authentication
     class HMAC {
@@ -42,6 +42,6 @@ namespace util { namespace hash {
 
         T m_hash;
     };
-} }
+}
 
 #endif

hash/hotp.hpp

@@ -22,7 +22,7 @@
 
 #include <cstdint>
 
-namespace util { namespace hash {
+namespace util::hash {
     /// HMAC one-time password (RFC 4226)
     class HOTP {
     public:
@@ -38,6 +38,6 @@ namespace util { namespace hash {
         uint64_t m_counter;
         HMAC<SHA1> m_hash;
     };
-} }
+}
 
 #endif

hash/md2.hpp

@@ -22,7 +22,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class MD2 {
         public:
             typedef std::array<uint8_t,16> digest_t;
@@ -45,6 +45,6 @@ namespace util { namespace hash {
             uint8_t C[16];
             uint8_t X[48];
     };
-} }
+}
 
 #endif

hash/md4.hpp

@@ -22,7 +22,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class MD4 {
     public:
         typedef std::array<uint8_t,16> digest_t;
@@ -48,6 +48,6 @@ namespace util { namespace hash {
             uint8_t  Xb[64];
         };
     };
-} }
+}
 
 #endif

hash/md5.hpp

@@ -23,7 +23,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class MD5 {
     public:
         typedef std::array<uint8_t,16> digest_t;
@@ -51,6 +51,6 @@ namespace util { namespace hash {
             uint8_t  Xb[64];
         };
     };
-} }
+}
 
 #endif

hash/murmur/common.cpp

@@ -18,117 +18,124 @@
 
 #include "../../debug.hpp"
 
+
 ///////////////////////////////////////////////////////////////////////////////
-uint32_t
+namespace util::hash::murmur {
-util::hash::murmur::tail (const uint32_t *restrict data, size_t len)
+    template <>
-{
+    uint32_t
-    auto bytes = reinterpret_cast<const uint8_t*> (data);
+    tail<uint32_t> (const uint8_t *restrict bytes, size_t len)
-    uint32_t h = 0;
-
-    switch (len % sizeof (uint32_t)) {
-        case 3: h += bytes[2] << 16;
-        case 2: h += bytes[1] <<  8;
-        case 1: h += bytes[0];
-                break;
-
-        default:
-            unreachable ();
-    }
-
-    return h;
-}
-
-
-//-----------------------------------------------------------------------------
-uint64_t
-util::hash::murmur::tail (const uint64_t *restrict data, size_t len)
-{
-    auto bytes = reinterpret_cast<const uint8_t*> (data);
-    uint64_t h = 0;
-
-    switch (len % sizeof (uint64_t)) {
-        case 7: h += uint64_t(bytes[6]) << 48;
-        case 6: h += uint64_t(bytes[5]) << 40;
-        case 5: h += uint64_t(bytes[4]) << 32;
-        case 4: h += uint64_t(bytes[3]) << 24;
-        case 3: h += uint64_t(bytes[2]) << 16;
-        case 2: h += uint64_t(bytes[1]) <<  8;
-        case 1: h += uint64_t(bytes[0]);
-                break;
-
-        default:
-            unreachable ();
-    }
-
-    return h;
-}
-
-
-//-----------------------------------------------------------------------------
-std::array<uint32_t,4>
-util::hash::murmur::tail_array (const uint32_t *restrict data, size_t len)
-{
-    auto bytes = reinterpret_cast<const uint8_t*> (data);
-    std::array<uint32_t,4> result {0,0,0,0};
-
-    switch (len % 16) {
-        case 15: result[3] |= bytes[14] << 16;
-        case 14: result[3] |= bytes[13] <<  8;
-        case 13: result[3] |= bytes[12] <<  0;
-        case 12: result[2] |= bytes[11] << 24;
-        case 11: result[2] |= bytes[10] << 16;
-        case 10: result[2] |= bytes[ 9] <<  8;
-        case  9: result[2] |= bytes[ 8] <<  0;
-        case  8: result[1] |= bytes[ 7] << 24;
-        case  7: result[1] |= bytes[ 6] << 16;
-        case  6: result[1] |= bytes[ 5] <<  8;
-        case  5: result[1] |= bytes[ 4] <<  0;
-        case  4: result[0] |= bytes[ 3] << 24;
-        case  3: result[0] |= bytes[ 2] << 16;
-        case  2: result[0] |= bytes[ 1] <<  8;
-        case  1: result[0] |= bytes[ 0] <<  0;
-                 break;
-
-        default:
-            unreachable ();
-    }
-
-    return result;
-}
-
-
-//-----------------------------------------------------------------------------
-std::array<uint64_t,2>
-util::hash::murmur::tail_array (const uint64_t *restrict data, size_t len)
-{
-    auto bytes = reinterpret_cast<const uint8_t*> (data);
-    std::array<uint64_t,2> result {0, 0};
-
-    switch(len & 15)
     {
-        case 15: result[1] |= ((uint64_t)bytes[14]) << 48;
+        uint32_t h = 0;
-        case 14: result[1] |= ((uint64_t)bytes[13]) << 40;
-        case 13: result[1] |= ((uint64_t)bytes[12]) << 32;
-        case 12: result[1] |= ((uint64_t)bytes[11]) << 24;
-        case 11: result[1] |= ((uint64_t)bytes[10]) << 16;
-        case 10: result[1] |= ((uint64_t)bytes[ 9]) << 8;
-        case  9: result[1] |= ((uint64_t)bytes[ 8]) << 0;
 
-        case  8: result[0] |= ((uint64_t)bytes[ 7]) << 56;
+        switch (len % sizeof (uint32_t)) {
-        case  7: result[0] |= ((uint64_t)bytes[ 6]) << 48;
+            case 3: h += bytes[2] << 16;
-        case  6: result[0] |= ((uint64_t)bytes[ 5]) << 40;
+            case 2: h += bytes[1] <<  8;
-        case  5: result[0] |= ((uint64_t)bytes[ 4]) << 32;
+            case 1: h += bytes[0];
-        case  4: result[0] |= ((uint64_t)bytes[ 3]) << 24;
+                    break;
-        case  3: result[0] |= ((uint64_t)bytes[ 2]) << 16;
-        case  2: result[0] |= ((uint64_t)bytes[ 1]) << 8;
-        case  1: result[0] |= ((uint64_t)bytes[ 0]) << 0;
-                 break;
 
-        default:
+            default:
-            unreachable ();
+                unreachable ();
-    };
+        }
 
-    return result;
+        return h;
+    }
 }
 
 
+//-----------------------------------------------------------------------------
+namespace util::hash::murmur {
+    template <>
+    uint64_t
+    tail<uint64_t> (const uint8_t *restrict bytes, size_t len)
+    {
+        uint64_t h = 0;
+
+        switch (len % sizeof (uint64_t)) {
+            case 7: h += uint64_t(bytes[6]) << 48;
+            case 6: h += uint64_t(bytes[5]) << 40;
+            case 5: h += uint64_t(bytes[4]) << 32;
+            case 4: h += uint64_t(bytes[3]) << 24;
+            case 3: h += uint64_t(bytes[2]) << 16;
+            case 2: h += uint64_t(bytes[1]) <<  8;
+            case 1: h += uint64_t(bytes[0]);
+                    break;
+
+            default:
+                unreachable ();
+        }
+
+        return h;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+namespace util::hash::murmur {
+    template <>
+    std::array<uint32_t,4>
+    tail_array<uint32_t> (const uint8_t *restrict bytes, size_t len)
+    {
+        std::array<uint32_t,4> result {0,0,0,0};
+
+        switch (len % 16) {
+            case 15: result[3] |= bytes[14] << 16;
+            case 14: result[3] |= bytes[13] <<  8;
+            case 13: result[3] |= bytes[12] <<  0;
+            case 12: result[2] |= bytes[11] << 24;
+            case 11: result[2] |= bytes[10] << 16;
+            case 10: result[2] |= bytes[ 9] <<  8;
+            case  9: result[2] |= bytes[ 8] <<  0;
+            case  8: result[1] |= bytes[ 7] << 24;
+            case  7: result[1] |= bytes[ 6] << 16;
+            case  6: result[1] |= bytes[ 5] <<  8;
+            case  5: result[1] |= bytes[ 4] <<  0;
+            case  4: result[0] |= bytes[ 3] << 24;
+            case  3: result[0] |= bytes[ 2] << 16;
+            case  2: result[0] |= bytes[ 1] <<  8;
+            case  1: result[0] |= bytes[ 0] <<  0;
+                     break;
+
+            default:
+                unreachable ();
+        }
+
+        return result;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+namespace util::hash::murmur {
+    template <>
+    std::array<uint64_t,2>
+    tail_array<uint64_t> (const uint8_t *restrict bytes, size_t len)
+    {
+        std::array<uint64_t,2> result {0, 0};
+
+        switch(len & 15)
+        {
+            case 15: result[1] |= ((uint64_t)bytes[14]) << 48;
+            case 14: result[1] |= ((uint64_t)bytes[13]) << 40;
+            case 13: result[1] |= ((uint64_t)bytes[12]) << 32;
+            case 12: result[1] |= ((uint64_t)bytes[11]) << 24;
+            case 11: result[1] |= ((uint64_t)bytes[10]) << 16;
+            case 10: result[1] |= ((uint64_t)bytes[ 9]) << 8;
+            case  9: result[1] |= ((uint64_t)bytes[ 8]) << 0;
+
+            case  8: result[0] |= ((uint64_t)bytes[ 7]) << 56;
+            case  7: result[0] |= ((uint64_t)bytes[ 6]) << 48;
+            case  6: result[0] |= ((uint64_t)bytes[ 5]) << 40;
+            case  5: result[0] |= ((uint64_t)bytes[ 4]) << 32;
+            case  4: result[0] |= ((uint64_t)bytes[ 3]) << 24;
+            case  3: result[0] |= ((uint64_t)bytes[ 2]) << 16;
+            case  2: result[0] |= ((uint64_t)bytes[ 1]) << 8;
+            case  1: result[0] |= ((uint64_t)bytes[ 0]) << 0;
+                     break;
+
+            default:
+                unreachable ();
+        };
+
+        return result;
+    }
+}

hash/murmur/common.hpp

@@ -19,13 +19,12 @@
 #include <cstdint>
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash { namespace murmur {
+namespace util::hash::murmur {
-    uint32_t tail (const uint32_t *restrict data, size_t len);
+    template <typename T>
-    uint64_t tail (const uint64_t *restrict data, size_t len);
+    T
+    tail (const uint8_t *restrict data, size_t len);
 
-    std::array<uint32_t,4>
+    template <typename T>
-    tail_array (const uint32_t *restrict data, size_t len);
+    std::array<T,16/sizeof(T)>
-
+    tail_array (const uint8_t *restrict data, size_t len);
-    std::array<uint64_t,2>
+}
-    tail_array (const uint64_t *restrict data, size_t len);
-} } }

hash/murmur/murmur1.cpp

@@ -42,7 +42,7 @@ util::hash::murmur1::hash_32 (const void *restrict data,
     CHECK (data);
 
     static const uint32_t m = 0xc6a4a793;
-    uint32_t h = seed ^ (uint32_t (len) * m);
+    uint32_t h = seed ^ ((len & 0xffffffff) * m);
 
     // mix the body
     auto cursor = reinterpret_cast<const uint32_t*> (data);
@@ -52,7 +52,7 @@ util::hash::murmur1::hash_32 (const void *restrict data,
 
     // mix the tail
     if (len % sizeof (uint32_t))
-        h = mix (h, murmur::tail (cursor, len));
+        h = mix (h, murmur::tail<uint32_t> (reinterpret_cast<const uint8_t*> (cursor), len));
 
     // finalise
     h *= m; h ^= h >> 10;

hash/murmur/murmur1.hpp

@@ -21,9 +21,9 @@
 #include <cstddef>
 
 // Austin Appleby's MumurHash1
-namespace util { namespace hash { namespace murmur1 {
+namespace util::hash::murmur1 {
     uint32_t mix (uint32_t, uint32_t);
     uint32_t hash_32 (const void *restrict data, size_t len, uint32_t seed);
-} } }
+}
 
 #endif

hash/murmur/murmur2.cpp

@@ -31,7 +31,7 @@ util::hash::murmur2::hash_32 (const void *restrict key,
 
     // setup
     constexpr auto m = detail::constants<uint32_t>::m;
-    uint32_t h = seed ^ uint32_t (len);
+    uint32_t h = seed ^ (len & 0xffffffff);
 
     // body
     auto cursor = reinterpret_cast<const uint32_t*> (key);
@@ -41,7 +41,7 @@ util::hash::murmur2::hash_32 (const void *restrict key,
 
     // tail
     if (len % sizeof (uint32_t)) {
-        h ^= murmur::tail (cursor, len);
+        h ^= murmur::tail<uint32_t> (reinterpret_cast<const uint8_t*> (cursor), len);
         h *= m;
     }
 
@@ -74,7 +74,7 @@ util::hash::murmur2::hash_64 (const void *restrict key,
 
     // tail
     if (len % sizeof (uint64_t)) {
-        h ^= murmur::tail (cursor, len);
+        h ^= murmur::tail<uint64_t> (reinterpret_cast<const uint8_t*> (cursor), len);
         h *= m;
     }
 

hash/murmur/murmur2.hpp

@@ -23,13 +23,13 @@
 // Austin Appleby's MumurHash2, and MurmurHash64A. The exhaustive list of
 // variants is deliberately not provided. You can damn well align your data or
 // fix the algorithm.
-namespace util { namespace hash { namespace murmur2 {
+namespace util::hash::murmur2 {
     constexpr uint32_t mix (uint32_t, uint32_t);
     constexpr uint64_t mix (uint64_t, uint64_t);
 
     uint32_t hash_32 (const void *restrict data, size_t len, uint32_t seed);
     uint64_t hash_64 (const void *restrict data, size_t len, uint64_t seed);
-} } }
+}
 
 #include "./murmur2.ipp"
 

hash/murmur/murmur2.ipp

@@ -22,7 +22,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash { namespace murmur2 { namespace detail {
+namespace util::hash::murmur2::detail {
     template <typename T> struct constants;
 
     template <>
@@ -36,7 +36,7 @@ namespace util { namespace hash { namespace murmur2 { namespace detail {
         static const uint64_t m = 0xc6a4a7935bd1e995;
         static const  int64_t r = 47;
     };
-} } } }
+}
 
 
 /////////////////////////////////////////////////////////////////////

hash/murmur/murmur3.cpp

@@ -22,6 +22,18 @@
 #include <algorithm>
 
 
+///////////////////////////////////////////////////////////////////////////////
+static
+uint32_t
+read_u32 (const uint8_t *bytes)
+{
+    return bytes[0] <<  0 |
+           bytes[1] <<  8 |
+           bytes[2] << 16 |
+           bytes[3] << 24;
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // Finalization mix - force all bits of a hash block to avalanche
 uint32_t
@@ -67,10 +79,10 @@ util::hash::murmur3::hash_32(const void *restrict key,
 
     //----------
     // body
-    auto cursor = reinterpret_cast<const uint32_t *> (data);
+    auto cursor = data;
-    auto last   = cursor + nblocks;
+    auto last   = cursor + nblocks * sizeof (uint32_t);
-    for (; cursor < last; ++cursor) {
+    for (; cursor < last; cursor += sizeof (uint32_t)) {
-        uint32_t k1 = *cursor;
+        uint32_t k1 = read_u32 (cursor);
 
         k1 *= c1;
         k1 = util::rotatel (k1, 15);
@@ -85,7 +97,7 @@ util::hash::murmur3::hash_32(const void *restrict key,
     //----------
     // tail
     if (len % sizeof (uint32_t)) {
-        uint32_t k1 = 0 ^ murmur::tail (cursor, len);
+        uint32_t k1 = 0 ^ murmur::tail<uint32_t> (cursor, len);
 
         k1 *= c1;
         k1  = util::rotatel (k1, 15);
@@ -208,7 +220,7 @@ hash_128 (const void *restrict key,
 
     // process the tail
     if (len % 16) {
-        auto k = util::hash::murmur::tail_array (cursor, len);
+        auto k = util::hash::murmur::tail_array<T> (reinterpret_cast<const uint8_t*> (cursor), len);
 
         for (auto &v: k)
             v = 0 ^ v;

hash/murmur/murmur3.hpp

@@ -22,14 +22,14 @@
 #include <cstdint>
 
 // Austin Appleby's MurmurHash3
-namespace util { namespace hash { namespace murmur3 {
+namespace util::hash::murmur3 {
     uint32_t mix (uint32_t);
     uint64_t mix (uint64_t);
 
     uint32_t hash_32 (const void *restrict data, size_t len, uint32_t seed);
     std::array<uint32_t,4> hash_128_x86 (const void *restrict data, size_t len, uint32_t seed);
     std::array<uint64_t,2> hash_128_x64 (const void *restrict data, size_t len, uint32_t seed);
-} } }
+}
 
 #endif
 

hash/ripemd.hpp

@@ -22,7 +22,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class RIPEMD {
         public:
             typedef std::array<uint8_t,20> digest_t;
@@ -53,6 +53,6 @@ namespace util { namespace hash {
                 size_t size;
             } m_buffer;
     };
-} }
+}
 
 #endif

hash/sha1.hpp

@@ -24,7 +24,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class SHA1 {
     public:
         typedef std::array<uint8_t,20> digest_t;
@@ -59,6 +59,6 @@ namespace util { namespace hash {
             uint32_t W[16  +64  ];
         };
     };
-} }
+}
 
 #endif

hash/sha2.hpp

@@ -23,7 +23,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     class SHA256 {
     public:
         typedef std::array<uint8_t,32> digest_t;
@@ -50,6 +50,6 @@ namespace util { namespace hash {
             std::array<uint8_t,  64> C;
         };
     };
-} }
+}
 
 #endif

hash/simple.hpp

@@ -22,7 +22,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace hash {
+namespace util::hash {
     //template <class H, class InputT>
     template <class H, typename ...Args>
     typename H::digest_t
@@ -38,6 +38,6 @@ namespace util { namespace hash {
 
         return h.digest ();
     }
-} }
+}
 
 #endif

hash/wang.hpp

@@ -19,11 +19,11 @@
 
 #include <cstdint>
 
-namespace util { namespace hash {
+namespace util::hash {
     // Thomas Wang's integer mixing functions, ca 2007
     constexpr uint32_t wang (uint32_t);
     constexpr uint64_t wang (uint64_t);
-} }
+}
 
 #include "wang.ipp"
 

io_posix.hpp

@@ -28,7 +28,7 @@
 #include <fcntl.h>
 
 namespace util {
-    namespace detail { namespace posix {
+    namespace detail::posix {
         class mapped_file {
         public:
             mapped_file (const std::experimental::filesystem::path&, int fflags = O_RDONLY | O_BINARY, int mflags = PROT_READ);
@@ -73,7 +73,7 @@ namespace util {
             uint8_t *m_data;
             size_t   m_size;
         };
-    } }
+    }
 
     typedef detail::posix::mapped_file mapped_file;
 }

io_win32.hpp

@@ -51,7 +51,7 @@ enum : int {
 ///////////////////////////////////////////////////////////////////////////////
 // implementation definitions
 namespace util {
-    namespace detail { namespace win32 {
+    namespace detail::win32 {
         class mapped_file {
         public:
             mapped_file (::util::win32::handle &&,
@@ -97,7 +97,7 @@ namespace util {
             std::unique_ptr<uint8_t,BOOL(*)(LPCVOID)> m_data;
             uint64_t m_size;
         };
-    } }
+    }
 
     typedef detail::win32::mapped_file mapped_file;
 }

json/flat.hpp

@@ -22,7 +22,9 @@
 
 #include "../view.hpp"
 
-namespace json { namespace flat {
+
+///////////////////////////////////////////////////////////////////////////////
+namespace json::flat {
     enum class type {
         UNKNOWN,
 
@@ -53,6 +55,6 @@ namespace json { namespace flat {
     std::vector<item<T>> parse (util::view<T> data);
 
     std::ostream& operator<< (std::ostream&, type);
-} }
+}
 
 #endif

json/schema.hpp

@@ -21,7 +21,9 @@
 
 #include <experimental/filesystem>
 
-namespace json { namespace schema {
+
+///////////////////////////////////////////////////////////////////////////////
+namespace json::schema {
     // Validate the json tree using the provide schema object or path.
     //
     // Note that the data object being validated may be altered in the process
@@ -29,6 +31,6 @@ namespace json { namespace schema {
     // default, it will be realised in the data object.
     void validate (json::tree::node &data, const json::tree::object &schema);
     void validate (json::tree::node &data, const std::experimental::filesystem::path &schema);
-} }
+}
 
 #endif

json/tree.cpp

@@ -377,7 +377,7 @@ json::tree::node::as_chars (void) const&
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace json { namespace tree {
+namespace json::tree {
 #if defined(__clang__)
 #elif defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -445,7 +445,7 @@ namespace json { namespace tree {
 #elif defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-} }
+}
 
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1009,7 +1009,7 @@ json::tree::operator<< (std::ostream &os, const json::tree::node &n)
 //-----------------------------------------------------------------------------
 // to_json
 
-namespace json { namespace tree {
+namespace json::tree {
     template <>
     std::unique_ptr<node>
     io<bool>::serialise (const bool &b) {
@@ -1057,4 +1057,4 @@ namespace json { namespace tree {
     io<float>::serialise (const float &f) {
         return std::unique_ptr<node> (new number (f));
     }
-} }
+}

json/tree.hpp

@@ -32,7 +32,8 @@
 #include <experimental/filesystem>
 
 
-namespace json { namespace tree {
+///////////////////////////////////////////////////////////////////////////////
+namespace json::tree {
     enum type_t {
         OBJECT,
         ARRAY,
@@ -354,8 +355,10 @@ namespace json { namespace tree {
         static std::unique_ptr<json::tree::node> serialise (const T&);
         static T deserialise (const json::tree::node&);
     };
-} }
+}
 
+
+///////////////////////////////////////////////////////////////////////////////
 template <typename T, class ...Args>
 std::unique_ptr<json::tree::node>
 to_json (const T &t, Args&&... args)
@@ -365,6 +368,8 @@ to_json (const T &t, Args&&... args)
     );
 }
 
+
+///////////////////////////////////////////////////////////////////////////////
 template <typename T, class ...Args>
 T
 from_json (const json::tree::node &n, Args&&... args)
@@ -375,5 +380,3 @@ from_json (const json::tree::node &n, Args&&... args)
 }
 
 #endif
-
-

library_win32.hpp

@@ -22,7 +22,7 @@
 #include <experimental/filesystem>
 
 namespace util {
-    namespace detail { namespace win32 {
+    namespace detail::win32 {
         class library {
         public:
             library (const std::experimental::filesystem::path&);
@@ -33,7 +33,7 @@ namespace util {
         private:
             HMODULE m_handle;
         };
-    } }
+    }
 
     typedef detail::win32::library library;
 }

memory/buffer/circular.hpp

@@ -19,7 +19,7 @@
 
 #include <cstddef>
 
-namespace util { namespace memory { namespace buffer {
+namespace util::memory::buffer {
     // buffer size is advisory and will likely depend on page size. the user
     // must check the size after creation if this field is important for
     // their usage.
@@ -50,6 +50,6 @@ namespace util { namespace memory { namespace buffer {
         char *m_begin, *m_end;
 
     };
-} } }
+}
 
 #endif

memory/buffer/paged.hpp

@@ -19,7 +19,7 @@
 
 #include <cstddef>
 
-namespace util { namespace memory { namespace buffer {
+namespace util::memory::buffer {
     class paged {
     public:
         using value_type = char;
@@ -54,6 +54,6 @@ namespace util { namespace memory { namespace buffer {
         char *m_begin, *m_end, *m_cursor;
         size_t m_window;
     };
-} } }
+}
 
 #endif

memory/deleter.hpp

@@ -19,7 +19,7 @@
 
 #include <functional>
 
-namespace util { namespace memory {
+namespace util::memory {
     template <typename T>
     class func_deleter {
     public:
@@ -57,6 +57,6 @@ namespace util { namespace memory {
     private:
         U& m_owner;
     };
-} }
+}
 
 #endif

memory/system.hpp

@@ -19,8 +19,8 @@
 
 #include <cstddef>
 
-namespace util { namespace memory {
+namespace util::memory {
     size_t pagesize (void);
-} }
+}
 
 #endif

posix/dir.hpp

@@ -22,7 +22,7 @@
 #include <functional>
 #include <experimental/filesystem>
 
-namespace util { namespace posix {
+namespace util::posix {
     struct dir {
     public:
         explicit dir (const std::experimental::filesystem::path&);
@@ -46,7 +46,7 @@ namespace util { namespace posix {
     private:
         DIR *m_handle;
     };
-} }
+}
 
 #include "./dir.ipp"
 

rand/lcg.hpp

@@ -21,7 +21,7 @@
 #include <type_traits>
 
 
-namespace util { namespace rand {
+namespace util::rand {
     /// linear congruential generator
     ///
     /// T: output/state type
@@ -50,6 +50,6 @@ namespace util { namespace rand {
 
     // glibc: typedef lcg<uint32_t, pow2(31), 1103515245, 12345> lcg_t;
     using lcg_t = lcg<uint64_t,0u,6364136223846793005ul, 1ul>;
-} }
+}
 
 #endif

rand/mwc64x.hpp

@@ -19,7 +19,7 @@
 
 #include <cstdint>
 
-namespace util { namespace rand {
+namespace util::rand {
     // multiply-with-carry style generator suitable for rapid seeking and
     // GPU generation.
     //
@@ -37,7 +37,7 @@ namespace util { namespace rand {
     private:
         uint64_t m_state;
     };
-} }
+}
 
 
 #endif

rand/xorshift.hpp

@@ -17,7 +17,7 @@
 #ifndef __UTIL_RAND_XORSHIFT_HPP
 #define __UTIL_RAND_XORSHIFT_HPP
 
-namespace util { namespace rand {
+namespace util::rand {
     // implements a naive xorshift random generator.
     //
     // * does not comply with the c++11 rng class requirements
@@ -40,6 +40,6 @@ namespace util { namespace rand {
     private:
         T m_state;
     };
-} }
+}
 
 #endif

region.cpp

@@ -345,7 +345,7 @@ util::operator<< (std::ostream &os, const util::region<S,T> &rhs) {
 
 
 ///////////////////////////////////////////////////////////////////////////////
-namespace util { namespace debug {
+namespace util::debug {
     template <size_t S, typename T>
     struct validator<util::region<S,T>> {
         static bool is_valid (const util::region<S,T> &r)
@@ -353,7 +353,7 @@ namespace util { namespace debug {
             return util::debug::is_valid (r.p) && util::debug::is_valid (r.e);
         }
     };
-} }
+}
 
 
 ///////////////////////////////////////////////////////////////////////////////

roots/bisection.hpp

@@ -21,7 +21,7 @@
 
 #include <cmath>
 
-namespace util { namespace roots {
+namespace util::roots {
     /// find a root of a function using the bisection method
     ///
     /// the user is responsible for ensuring there is in fact a root. there
@@ -64,6 +64,6 @@ namespace util { namespace roots {
         // valid mathematically.
         return (a + b) / T{2};
     }
-} }
+}
 
 #endif

tap.hpp

@@ -19,7 +19,7 @@
 
 #include <functional>
 
-namespace util { namespace TAP {
+namespace util::TAP {
     /// A simple TAP (Test Anything Protocol) test case output
     class logger {
     public:
@@ -84,7 +84,7 @@ namespace util { namespace TAP {
         int m_status;
         size_t m_size;
     };
-} }
+}
 
 #include "tap.ipp"
 

term.hpp

@@ -19,7 +19,7 @@
 
 #include <ostream>
 
-namespace util { namespace term {
+namespace util::term {
     bool has_csi_support (void);
 
     namespace csi {
@@ -63,6 +63,6 @@ namespace util { namespace term {
         std::ostream& operator<< (std::ostream&, code);
         std::ostream& operator<< (std::ostream&, graphics);
     }
-} }
+}
 
 #endif

tuple.hpp

@@ -24,7 +24,7 @@
 #include <type_traits>
 
 
-namespace util { namespace tuple {
+namespace util::tuple {
     ///////////////////////////////////////////////////////////////////////////
     /// call a provided object with type_tag<T> for each type in a tuple
     template <
@@ -163,7 +163,7 @@ namespace util { namespace tuple {
             >::type...
         > type;
     };
-} }
+}
 
 
 #endif

win32/handle.hpp

@@ -16,7 +16,7 @@
 
 #include <windows.h>
 
-namespace util { namespace win32 {
+namespace util::win32 {
     struct handle {
         handle ();
         explicit handle (HANDLE&&);
@@ -36,4 +36,4 @@ namespace util { namespace win32 {
     private:
         HANDLE m_native;
     };
-} }
+}

win32/registry.hpp

@@ -22,7 +22,7 @@
 #include <set>
 #include <string>
 
-namespace util { namespace win32 {
+namespace util::win32 {
     class key {
     public:
         key (HKEY root, const char *child, REGSAM rights = KEY_READ);
@@ -37,6 +37,6 @@ namespace util { namespace win32 {
     private:
         HKEY m_handle;
     };
-} }
+}
 
 #endif