// 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 |