diff DEPENDENCIES/generic/include/boost/uuid/name_generator.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/uuid/name_generator.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,125 @@
+// Boost name_generator.hpp header file  ----------------------------------------------//
+
+// Copyright 2010 Andy Tompkins.
+// 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)
+
+#ifndef BOOST_UUID_NAME_GENERATOR_HPP
+#define BOOST_UUID_NAME_GENERATOR_HPP
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/sha1.hpp>
+#include <boost/assert.hpp>
+#include <string>
+#include <cstring> // for strlen, wcslen
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+    using ::strlen;
+    using ::wcslen;
+} //namespace std
+#endif //BOOST_NO_STDC_NAMESPACE
+
+namespace boost {
+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)
+    {}
+
+    uuid operator()(const char* name) {
+        reset();
+        process_characters(name, std::strlen(name));
+        return sha_to_uuid();
+    }
+
+    uuid operator()(const wchar_t* name) {
+        reset();
+        process_characters(name, std::wcslen(name));
+        return sha_to_uuid();
+    }
+
+    template <typename ch, typename char_traits, typename alloc>
+    uuid operator()(std::basic_string<ch, char_traits, alloc> const& name) {
+        reset();
+        process_characters(name.c_str(), name.length());
+        return sha_to_uuid();
+    }
+    
+    uuid operator()(void const* buffer, std::size_t byte_count) {
+        reset();
+        sha.process_bytes(buffer, byte_count);
+        return sha_to_uuid();
+    };
+
+private:
+    // we convert all characters to uint32_t so that each
+    // character is 4 bytes reguardless of sizeof(char) or
+    // sizeof(wchar_t).  We want the name string on any
+    // platform / compiler to generate the same uuid
+    // except for char
+    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 );
+        }
+    }
+    
+    void process_characters(char const*const characters, size_t count) {
+        sha.process_bytes(characters, count);
+    }
+
+    void reset()
+    {
+        sha.reset();
+        sha.process_bytes(namespace_uuid.begin(), namespace_uuid.size());
+    }
+    
+    uuid sha_to_uuid()
+    {
+        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);
+        }
+
+        // set variant
+        // must be 0b10xxxxxx
+        *(u.begin()+8) &= 0xBF;
+        *(u.begin()+8) |= 0x80;
+
+        // set version
+        // must be 0b0101xxxx
+        *(u.begin()+6) &= 0x5F; //0b01011111
+        *(u.begin()+6) |= 0x50; //0b01010000
+
+        return u;
+    }
+
+private:
+    uuid namespace_uuid;
+    detail::sha1 sha;
+};
+
+}} // namespace boost::uuids
+
+#endif // BOOST_UUID_NAME_GENERATOR_HPP