6 files changed, 270 insertions, 57 deletions
diff --git a/3rdParty/Boost/src/boost/uuid/detail/config.hpp b/3rdParty/Boost/src/boost/uuid/detail/config.hpp
new file mode 100644
index 0000000..997f882
--- /dev/null
+++ b/3rdParty/Boost/src/boost/uuid/detail/config.hpp
@@ -0,0 +1,62 @@
+/*
+ *            Copyright Andrey Semashev 2013.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   uuid/detail/config.hpp
+ *
+ * \brief  This header defines configuration macros for Boost.UUID.
+ */
+
+#ifndef BOOST_UUID_DETAIL_CONFIG_HPP_INCLUDED_
+#define BOOST_UUID_DETAIL_CONFIG_HPP_INCLUDED_
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if !defined(BOOST_UUID_NO_SIMD)
+
+#if defined(__GNUC__) && defined(__SSE2__)
+
+// GCC and its pretenders go here
+#ifndef BOOST_UUID_USE_SSE2
+#define BOOST_UUID_USE_SSE2
+#endif
+
+#if defined(__SSE3__) && !defined(BOOST_UUID_USE_SSE3)
+#define BOOST_UUID_USE_SSE3
+#endif
+
+#if defined(__SSE4_1__) && !defined(BOOST_UUID_USE_SSE41)
+#define BOOST_UUID_USE_SSE41
+#endif
+
+#elif defined(_MSC_VER) && (defined(_M_X64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2))
+
+#ifndef BOOST_UUID_USE_SSE2
+#define BOOST_UUID_USE_SSE2
+#endif
+
+#elif !defined(BOOST_UUID_USE_SSE41) && !defined(BOOST_UUID_USE_SSE3) && !defined(BOOST_UUID_USE_SSE2)
+
+#define BOOST_UUID_NO_SIMD
+
+#endif
+
+// More advanced ISA extensions imply less advanced are also available
+#if !defined(BOOST_UUID_USE_SSE3) && defined(BOOST_UUID_USE_SSE41)
+#define BOOST_UUID_USE_SSE3
+#endif
+
+#if !defined(BOOST_UUID_USE_SSE2) && defined(BOOST_UUID_USE_SSE3)
+#define BOOST_UUID_USE_SSE2
+#endif
+
+#endif // !defined(BOOST_UUID_NO_SIMD)
+
+#endif // BOOST_UUID_DETAIL_CONFIG_HPP_INCLUDED_
diff --git a/3rdParty/Boost/src/boost/uuid/detail/uuid_generic.hpp b/3rdParty/Boost/src/boost/uuid/detail/uuid_generic.hpp
new file mode 100644
index 0000000..1c4d775
--- /dev/null
+++ b/3rdParty/Boost/src/boost/uuid/detail/uuid_generic.hpp
@@ -0,0 +1,51 @@
+/*
+ *             Copyright Andy Tompkins 2006.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   uuid/detail/uuid_generic.hpp
+ *
+ * \brief  This header contains generic implementation of \c boost::uuid operations.
+ */
+
+#ifndef BOOST_UUID_DETAIL_UUID_GENERIC_HPP_INCLUDED_
+#define BOOST_UUID_DETAIL_UUID_GENERIC_HPP_INCLUDED_
+
+#include <string.h>
+
+namespace boost {
+namespace uuids {
+
+inline bool uuid::is_nil() const BOOST_NOEXCEPT
+{
+    for (std::size_t i = 0; i < sizeof(data); ++i)
+    {
+        if (data[i] != 0U)
+            return false;
+    }
+    return true;
+}
+
+inline void uuid::swap(uuid& rhs) BOOST_NOEXCEPT
+{
+    uuid tmp = *this;
+    *this = rhs;
+    rhs = tmp;
+}
+
+inline bool operator== (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT
+{
+    return memcmp(lhs.data, rhs.data, sizeof(lhs.data)) == 0;
+}
+
+inline bool operator< (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT
+{
+    return memcmp(lhs.data, rhs.data, sizeof(lhs.data)) < 0;
+}
+
+} // namespace uuids
+} // namespace boost
+
+#endif // BOOST_UUID_DETAIL_UUID_GENERIC_HPP_INCLUDED_
diff --git a/3rdParty/Boost/src/boost/uuid/detail/uuid_x86.hpp b/3rdParty/Boost/src/boost/uuid/detail/uuid_x86.hpp
new file mode 100644
index 0000000..1a329b0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/uuid/detail/uuid_x86.hpp
@@ -0,0 +1,109 @@
+/*
+ *            Copyright Andrey Semashev 2013.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   uuid/detail/uuid_x86.hpp
+ *
+ * \brief  This header contains optimized SSE implementation of \c boost::uuid operations.
+ */
+
+#ifndef BOOST_UUID_DETAIL_UUID_X86_HPP_INCLUDED_
+#define BOOST_UUID_DETAIL_UUID_X86_HPP_INCLUDED_
+
+// MSVC does not always have immintrin.h (at least, not up to MSVC 10), so include the appropriate header for each instruction set
+#if defined(BOOST_UUID_USE_SSE41)
+#include <smmintrin.h>
+#elif defined(BOOST_UUID_USE_SSE3)
+#include <pmmintrin.h>
+#else
+#include <emmintrin.h>
+#endif
+
+namespace boost {
+namespace uuids {
+namespace detail {
+
+BOOST_FORCEINLINE __m128i load_unaligned_si128(const uint8_t* p) BOOST_NOEXCEPT
+{
+#if defined(BOOST_UUID_USE_SSE3)
+    return _mm_lddqu_si128(reinterpret_cast< const __m128i* >(p));
+#else
+    return _mm_loadu_si128(reinterpret_cast< const __m128i* >(p));
+#endif
+}
+
+} // namespace detail
+
+inline bool uuid::is_nil() const BOOST_NOEXCEPT
+{
+    register __m128i mm = uuids::detail::load_unaligned_si128(data);
+#if defined(BOOST_UUID_USE_SSE41)
+    return _mm_test_all_zeros(mm, mm) != 0;
+#else
+    mm = _mm_cmpeq_epi8(mm, _mm_setzero_si128());
+    return _mm_movemask_epi8(mm) == 0xFFFF;
+#endif
+}
+
+inline void uuid::swap(uuid& rhs) BOOST_NOEXCEPT
+{
+    register __m128i mm_this = uuids::detail::load_unaligned_si128(data);
+    register __m128i mm_rhs = uuids::detail::load_unaligned_si128(rhs.data);
+    _mm_storeu_si128(reinterpret_cast< __m128i* >(rhs.data), mm_this);
+    _mm_storeu_si128(reinterpret_cast< __m128i* >(data), mm_rhs);
+}
+
+inline bool operator== (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT
+{
+    register __m128i mm_left = uuids::detail::load_unaligned_si128(lhs.data);
+    register __m128i mm_right = uuids::detail::load_unaligned_si128(rhs.data);
+
+    register __m128i mm_cmp = _mm_cmpeq_epi32(mm_left, mm_right);
+#if defined(BOOST_UUID_USE_SSE41)
+    return _mm_test_all_ones(mm_cmp);
+#else
+    return _mm_movemask_epi8(mm_cmp) == 0xFFFF;
+#endif
+}
+
+inline bool operator< (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT
+{
+    register __m128i mm_left = uuids::detail::load_unaligned_si128(lhs.data);
+    register __m128i mm_right = uuids::detail::load_unaligned_si128(rhs.data);
+
+    // To emulate lexicographical_compare behavior we have to perform two comparisons - the forward and reverse one.
+    // Then we know which bytes are equivalent and which ones are different, and for those different the comparison results
+    // will be opposite. Then we'll be able to find the first differing comparison result (for both forward and reverse ways),
+    // and depending on which way it is for, this will be the result of the operation. There are a few notes to consider:
+    //
+    // 1. Due to little endian byte order the first bytes go into the lower part of the xmm registers,
+    //    so the comparison results in the least significant bits will actually be the most signigicant for the final operation result.
+    //    This means we have to determine which of the comparison results have the least significant bit on, and this is achieved with
+    //    the "(x - 1) ^ x" trick.
+    // 2. Because there is only signed comparison in SSE/AVX, we have to invert byte comparison results whenever signs of the corresponding
+    //    bytes are different. I.e. in signed comparison it's -1 < 1, but in unsigned it is the opposite (255 > 1). To do that we XOR left and right,
+    //    making the most significant bit of each byte 1 if the signs are different, and later apply this mask with another XOR to the comparison results.
+    // 3. pcmpgtw compares for "greater" relation, so we swap the arguments to get what we need.
+
+    const __m128i mm_signs_mask = _mm_xor_si128(mm_left, mm_right);
+
+    __m128i mm_cmp = _mm_cmpgt_epi8(mm_right, mm_left), mm_rcmp = _mm_cmpgt_epi8(mm_left, mm_right);
+
+    mm_cmp = _mm_xor_si128(mm_signs_mask, mm_cmp);
+    mm_rcmp = _mm_xor_si128(mm_signs_mask, mm_rcmp);
+
+    uint32_t cmp = static_cast< uint32_t >(_mm_movemask_epi8(mm_cmp)), rcmp = static_cast< uint32_t >(_mm_movemask_epi8(mm_rcmp));
+
+    cmp = (cmp - 1u) ^ cmp;
+    rcmp = (rcmp - 1u) ^ rcmp;
+
+    return static_cast< uint16_t >(cmp) < static_cast< uint16_t >(rcmp);
+}
+
+} // namespace uuids
+} // namespace boost
+
+#endif // BOOST_UUID_DETAIL_UUID_X86_HPP_INCLUDED_
diff --git a/3rdParty/Boost/src/boost/uuid/name_generator.hpp b/3rdParty/Boost/src/boost/uuid/name_generator.hpp
index fe582b4..2e5d8c1 100644
--- a/3rdParty/Boost/src/boost/uuid/name_generator.hpp
+++ b/3rdParty/Boost/src/boost/uuid/name_generator.hpp
@@ -27,14 +27,14 @@ namespace uuids {
 // generate a name-based uuid
 // TODO: add in common namesspace uuids
 class name_generator {
 public:
     typedef uuid result_type;
 
-    explicit name_generator(uuid const& namespace_uuid)
-        : namespace_uuid(namespace_uuid)
+    explicit name_generator(uuid const& namespace_uuid_)
+        : namespace_uuid(namespace_uuid_)
     {}
 
     uuid operator()(const char* name) {
         reset();
         process_characters(name, std::strlen(name));
         return sha_to_uuid();
@@ -68,16 +68,16 @@ private:
     template <typename char_type>
     void process_characters(char_type const*const characters, size_t count) {
         BOOST_ASSERT(sizeof(uint32_t) >= sizeof(char_type));
 
         for (size_t i=0; i<count; i++) {
             uint32_t c = characters[i];
-            sha.process_byte( (c >>  0) & 0xFF );
-            sha.process_byte( (c >>  8) & 0xFF );
-            sha.process_byte( (c >> 16) & 0xFF );
-            sha.process_byte( (c >> 24) & 0xFF );
+            sha.process_byte(static_cast<unsigned char>((c >>  0) & 0xFF));
+            sha.process_byte(static_cast<unsigned char>((c >>  8) & 0xFF));
+            sha.process_byte(static_cast<unsigned char>((c >> 16) & 0xFF));
+            sha.process_byte(static_cast<unsigned char>((c >> 24) & 0xFF));
         }
     }
     
     void process_characters(char const*const characters, size_t count) {
         sha.process_bytes(characters, count);
     }
@@ -93,16 +93,16 @@ private:
         unsigned int digest[5];
 
         sha.get_digest(digest);
 
         uuid u;
         for (int i=0; i<4; ++i) {
-            *(u.begin() + i*4+0) = ((digest[i] >> 24) & 0xFF);
-            *(u.begin() + i*4+1) = ((digest[i] >> 16) & 0xFF);
-            *(u.begin() + i*4+2) = ((digest[i] >> 8) & 0xFF);
-            *(u.begin() + i*4+3) = ((digest[i] >> 0) & 0xFF);
+            *(u.begin() + i*4+0) = static_cast<uint8_t>((digest[i] >> 24) & 0xFF);
+            *(u.begin() + i*4+1) = static_cast<uint8_t>((digest[i] >> 16) & 0xFF);
+            *(u.begin() + i*4+2) = static_cast<uint8_t>((digest[i] >> 8) & 0xFF);
+            *(u.begin() + i*4+3) = static_cast<uint8_t>((digest[i] >> 0) & 0xFF);
         }
 
         // set variant
         // must be 0b10xxxxxx
         *(u.begin()+8) &= 0xBF;
         *(u.begin()+8) |= 0x80;
diff --git a/3rdParty/Boost/src/boost/uuid/uuid.hpp b/3rdParty/Boost/src/boost/uuid/uuid.hpp
index 2678d85..d8593c0 100644
--- a/3rdParty/Boost/src/boost/uuid/uuid.hpp
+++ b/3rdParty/Boost/src/boost/uuid/uuid.hpp
@@ -25,26 +25,29 @@
 //  12 Nov 2007 - moved serialize code to uuid_serialize.hpp file
 //  25 Feb 2008 - moved to namespace boost::uuids
 //  19 Mar 2009 - changed to a POD, reorganized files
 //  28 Nov 2009 - disabled deprecated warnings for MSVC
 //  30 Nov 2009 - used BOOST_STATIC_CONSTANT
 //  02 Dec 2009 - removed BOOST_STATIC_CONSTANT - not all compilers like it
+//  29 Apr 2013 - added support for noexcept and constexpr, added optimizations for SSE/AVX
 
 #ifndef BOOST_UUID_HPP
 #define BOOST_UUID_HPP
 
-#include <boost/config.hpp>
-#include <stddef.h>
+#include <cstddef>
 #include <boost/cstdint.hpp>
-#include <algorithm>
-#include <boost/config.hpp> // for static assert
+#include <boost/uuid/detail/config.hpp>
 #ifndef BOOST_UUID_NO_TYPE_TRAITS
 #include <boost/type_traits/is_pod.hpp>
 #include <boost/type_traits/integral_constant.hpp>
 #endif
 
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
 #if defined(_MSC_VER)
 #pragma warning(push) // Save warning settings.
 #pragma warning(disable : 4996) // Disable deprecated std::swap_ranges, std::equal
 #endif
 
 #ifdef BOOST_NO_STDC_NAMESPACE
@@ -66,43 +69,35 @@ public:
     typedef uint8_t* iterator;
     typedef uint8_t const* const_iterator;
     typedef std::size_t size_type;
     typedef std::ptrdiff_t difference_type;
 
     // This does not work on some compilers
-    // They seem to want the variable definec in 
+    // They seem to want the variable definec in
     // a cpp file
     //BOOST_STATIC_CONSTANT(size_type, static_size = 16);
-    static size_type static_size() { return 16; }
+    static BOOST_CONSTEXPR size_type static_size() BOOST_NOEXCEPT { return 16; }
 
 public:
-    iterator begin() { return data; } /* throw() */
-    const_iterator begin() const { return data; } /* throw() */
-    iterator end() { return data+size(); } /* throw() */
-    const_iterator end() const { return data+size(); } /* throw() */
+    iterator begin() BOOST_NOEXCEPT { return data; }
+    const_iterator begin() const BOOST_NOEXCEPT { return data; }
+    iterator end() BOOST_NOEXCEPT { return data+size(); }
+    const_iterator end() const BOOST_NOEXCEPT { return data+size(); }
 
-    size_type size() const { return static_size(); } /* throw() */
+    BOOST_CONSTEXPR size_type size() const BOOST_NOEXCEPT { return static_size(); }
 
-    bool is_nil() const /* throw() */
-    {
-        for(size_t i=0; i<static_size(); i++) {
-            if (data[i] != 0U) {
-                return false;
-            }
-        }
-        return true;
-    }
+    bool is_nil() const BOOST_NOEXCEPT;
 
     enum variant_type
     {
         variant_ncs, // NCS backward compatibility
         variant_rfc_4122, // defined in RFC 4122 document
         variant_microsoft, // Microsoft Corporation backward compatibility
         variant_future // future definition
     };
-    variant_type variant() const /* throw() */
+    variant_type variant() const BOOST_NOEXCEPT
     {
         // variant is stored in octet 7
         // which is index 8, since indexes count backwards
         unsigned char octet7 = data[8]; // octet 7 is array index 8
         if ( (octet7 & 0x80) == 0x00 ) { // 0b0xxxxxxx
             return variant_ncs;
@@ -112,27 +107,27 @@ public:
             return variant_microsoft;
         } else {
             //assert( (octet7 & 0xE0) == 0xE0 ) // 0b111xxxx
             return variant_future;
         }
     }
-    
-    enum version_type 
+
+    enum version_type
     {
         version_unknown = -1,
         version_time_based = 1,
         version_dce_security = 2,
         version_name_based_md5 = 3,
         version_random_number_based = 4,
         version_name_based_sha1 = 5
     };
-    version_type version() const /* throw() */
+    version_type version() const BOOST_NOEXCEPT
     {
-        //version is stored in octet 9
+        // version is stored in octet 9
         // which is index 6, since indexes count backwards
-        unsigned char octet9 = data[6];
+        uint8_t octet9 = data[6];
         if ( (octet9 & 0xF0) == 0x10 ) {
             return version_time_based;
         } else if ( (octet9 & 0xF0) == 0x20 ) {
             return version_dce_security;
         } else if ( (octet9 & 0xF0) == 0x30 ) {
             return version_name_based_md5;
@@ -143,61 +138,51 @@ public:
         } else {
             return version_unknown;
         }
     }
 
     // note: linear complexity
-    void swap(uuid& rhs) /* throw() */
-    {
-        std::swap_ranges(begin(), end(), rhs.begin());
-    }
+    void swap(uuid& rhs) BOOST_NOEXCEPT;
 
 public:
     // or should it be array<uint8_t, 16>
     uint8_t data[16];
 };
 
-inline bool operator==(uuid const& lhs, uuid const& rhs) /* throw() */
-{
-    return std::equal(lhs.begin(), lhs.end(), rhs.begin());
-}
+bool operator== (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT;
+bool operator< (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT;
 
-inline bool operator!=(uuid const& lhs, uuid const& rhs) /* throw() */
+inline bool operator!=(uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT
 {
     return !(lhs == rhs);
 }
 
-inline bool operator<(uuid const& lhs, uuid const& rhs) /* throw() */
-{
-    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
-}
-
-inline bool operator>(uuid const& lhs, uuid const& rhs) /* throw() */
+inline bool operator>(uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT
 {
     return rhs < lhs;
 }
-inline bool operator<=(uuid const& lhs, uuid const& rhs) /* throw() */
+inline bool operator<=(uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT
 {
     return !(rhs < lhs);
 }
 
-inline bool operator>=(uuid const& lhs, uuid const& rhs) /* throw() */
+inline bool operator>=(uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT
 {
     return !(lhs < rhs);
 }
 
-inline void swap(uuid& lhs, uuid& rhs) /* throw() */
+inline void swap(uuid& lhs, uuid& rhs) BOOST_NOEXCEPT
 {
     lhs.swap(rhs);
 }
 
 // This is equivalent to boost::hash_range(u.begin(), u.end());
-inline std::size_t hash_value(uuid const& u) /* throw() */
+inline std::size_t hash_value(uuid const& u) BOOST_NOEXCEPT
 {
     std::size_t seed = 0;
-    for(uuid::const_iterator i=u.begin(); i != u.end(); ++i)
+    for(uuid::const_iterator i=u.begin(), e=u.end(); i != e; ++i)
     {
         seed ^= static_cast<std::size_t>(*i) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
     }
 
     return seed;
 }
@@ -211,11 +196,17 @@ namespace boost {
 template <>
 struct is_pod<uuids::uuid> : true_type {};
 
 } // namespace boost
 #endif
 
+#if defined(BOOST_UUID_USE_SSE2)
+#include <boost/uuid/detail/uuid_x86.hpp>
+#else
+#include <boost/uuid/detail/uuid_generic.hpp>
+#endif
+
 #if defined(_MSC_VER)
 #pragma warning(pop) // Restore warnings to previous state.
 #endif
 
 #endif // BOOST_UUID_HPP
diff --git a/3rdParty/Boost/src/boost/uuid/uuid_io.hpp b/3rdParty/Boost/src/boost/uuid/uuid_io.hpp
index 592a509..1d30618 100644
--- a/3rdParty/Boost/src/boost/uuid/uuid_io.hpp
+++ b/3rdParty/Boost/src/boost/uuid/uuid_io.hpp
@@ -56,13 +56,13 @@ template <typename ch, typename char_traits>
             if (i == 3 || i == 5 || i == 7 || i == 9) {
                 os << os.widen('-');
             }
         }
         
         if (flags & std::ios_base::left) {
-            for (std::streamsize i=uuid_width; i<width; i++) {
+            for (std::streamsize s=uuid_width; s<width; s++) {
                 os << fill;
             }
         }
         
         os.width(0); //used the width so reset it
     }