Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r57988 - in trunk: boost/uuid libs libs/uuid libs/uuid/test status
From: atompkins_at_[hidden]
Date: 2009-11-27 23:16:46

Next message: dave_at_[hidden]: "[Boost-commit] svn:boost r57989 - in trunk: boost/iterator libs/iterator/test"
Previous message: ramey_at_[hidden]: "[Boost-commit] svn:boost r57987 - trunk/boost/serialization"

Author: atompkins
Date: 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
New Revision: 57988
URL: http://svn.boost.org/trac/boost/changeset/57988

Log:
Added uuid library
Added:
   trunk/boost/uuid/
   trunk/boost/uuid/seed_rng.hpp (contents, props changed)
   trunk/boost/uuid/sha1.hpp (contents, props changed)
   trunk/boost/uuid/uuid.hpp (contents, props changed)
   trunk/boost/uuid/uuid_generators.hpp (contents, props changed)
   trunk/boost/uuid/uuid_io.hpp (contents, props changed)
   trunk/boost/uuid/uuid_serialize.hpp (contents, props changed)
   trunk/libs/uuid/
   trunk/libs/uuid/index.html (contents, props changed)
   trunk/libs/uuid/test/
   trunk/libs/uuid/test/Jamfile.v2 (contents, props changed)
   trunk/libs/uuid/test/compile_uuid_generators_h.cpp (contents, props changed)
   trunk/libs/uuid/test/compile_uuid_h.cpp (contents, props changed)
   trunk/libs/uuid/test/compile_uuid_io_h.cpp (contents, props changed)
   trunk/libs/uuid/test/compile_uuid_serialize_h.cpp (contents, props changed)
   trunk/libs/uuid/test/test_generators.cpp (contents, props changed)
   trunk/libs/uuid/test/test_include1.cpp (contents, props changed)
   trunk/libs/uuid/test/test_include2.cpp (contents, props changed)
   trunk/libs/uuid/test/test_io.cpp (contents, props changed)
   trunk/libs/uuid/test/test_serialization.cpp (contents, props changed)
   trunk/libs/uuid/test/test_sha1.cpp (contents, props changed)
   trunk/libs/uuid/test/test_tagging.cpp (contents, props changed)
   trunk/libs/uuid/test/test_uuid.cpp (contents, props changed)
   trunk/libs/uuid/test/test_uuid_class.cpp (contents, props changed)
   trunk/libs/uuid/test/test_wserialization.cpp (contents, props changed)
   trunk/libs/uuid/uuid.html (contents, props changed)
Text files modified:
   trunk/libs/libraries.htm | 2 ++
   trunk/libs/maintainers.txt | 1 +
   trunk/status/Jamfile.v2 | 1 +
   3 files changed, 4 insertions(+), 0 deletions(-)

Added: trunk/boost/uuid/seed_rng.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/uuid/seed_rng.hpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,235 @@
+// Boost seed_rng.hpp header file ----------------------------------------------//
+
+// Copyright 2007 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)
+
+// Revision History
+// 09 Nov 2007 - Initial Revision
+// 25 Feb 2008 - moved to namespace boost::uuids::detail
+
+// seed_rng models a UniformRandomNumberGenerator (see Boost.Random).
+// Random number generators are hard to seed well. This is intended to provide
+// good seed values for random number generators.
+// It creates random numbers from a sha1 hash of data from a variary of sources,
+// all of which are standard function calls. It produces random numbers slowly.
+// Peter Dimov provided the details of sha1_random_digest_().
+// see http://archives.free.net.ph/message/20070507.175609.4c4f503a.en.html
+
+#ifndef BOOST_UUID_SEED_RNG_HPP
+#define BOOST_UUID_SEED_RNG_HPP
+
+#include <boost/config.hpp>
+#include <cstring>
+#include <limits>
+#include <memory.h>
+#include <ctime>
+#include <cstdlib>
+#include <boost/uuid/sha1.hpp>
+//#include <boost/nondet_random.hpp> //forward declare boost::random_device
+
+// can't use boost::generator_iterator since boost::random number seed(Iter&, Iter)
+// functions need a last iterator
+//#include <boost/generator_iterator.hpp>
+# include <boost/iterator/iterator_facade.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+ using ::memcpy;
+ using ::time_t;
+ using ::time;
+ using ::clock_t;
+ using ::clock;
+ using ::rand;
+ using ::FILE;
+ using ::fopen;
+ using ::fread;
+ using ::fclose;
+} //namespace std
+#endif
+
+// forward declare random number generators
+namespace boost {
+class random_device;
+} //namespace boost
+
+namespace boost {
+namespace uuids {
+namespace detail {
+
+// should this be part of Boost.Random?
+class seed_rng
+{
+public:
+ typedef unsigned int result_type;
+ BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
+ //BOOST_STATIC_CONSTANT(unsigned int, min_value = 0);
+ //BOOST_STATIC_CONSTANT(unsigned int, max_value = UINT_MAX);
+
+public:
+ seed_rng()
+ : rd_index_(5)
+ {}
+
+ result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const
+ {
+ return (std::numeric_limits<result_type>::min)();
+ }
+ result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const
+ {
+ return (std::numeric_limits<result_type>::max)();
+ }
+
+ result_type operator()()
+ {
+ if (rd_index_ >= 5) {
+ //get new digest
+ sha1_random_digest_();
+
+ rd_index_ = 0;
+ }
+
+ return rd_[rd_index_++];
+ }
+
+private:
+ static unsigned int * sha1_random_digest_state_()
+ {
+ static unsigned int state[ 5 ];
+ return state;
+ }
+
+ void sha1_random_digest_()
+ {
+ boost::uuids::detail::sha1 sha;
+
+ unsigned int * ps = sha1_random_digest_state_();
+
+ unsigned int state[ 5 ];
+ std::memcpy( state, ps, sizeof( state ) ); // harmless data race
+
+ sha.process_bytes( (unsigned char const*)state, sizeof( state ) );
+ sha.process_bytes( (unsigned char const*)&ps, sizeof( ps ) );
+
+ {
+ std::time_t tm = std::time( 0 );
+ sha.process_bytes( (unsigned char const*)&tm, sizeof( tm ) );
+ }
+
+ {
+ std::clock_t ck = std::clock();
+ sha.process_bytes( (unsigned char const*)&ck, sizeof( ck ) );
+ }
+
+ {
+ unsigned int rn[] = { std::rand(), std::rand(), std::rand() };
+ sha.process_bytes( (unsigned char const*)rn, sizeof( rn ) );
+ }
+
+ {
+ unsigned char buffer[ 20 ];
+
+ if( std::FILE * f = std::fopen( "/dev/urandom", "rb" ) )
+ {
+ std::fread( buffer, 1, 20, f );
+ std::fclose( f );
+ }
+
+ // using an uninitialized buffer[] if fopen fails
+ // intentional, we rely on its contents being random
+ sha.process_bytes( buffer, sizeof( buffer ) );
+ }
+
+ {
+ unsigned int * p = new unsigned int;
+
+ sha.process_bytes( (unsigned char const*)p, sizeof( *p ) );
+ sha.process_bytes( (unsigned char const*)&p, sizeof( p ) );
+
+ delete p;
+ }
+
+ sha.process_bytes( (unsigned char const*)rd_, sizeof( rd_ ) );
+
+ unsigned int digest[ 5 ];
+ sha.get_digest( digest );
+
+ for( int i = 0; i < 5; ++i )
+ {
+ // harmless data race
+ ps[ i ] ^= digest[ i ];
+ rd_[ i ] ^= digest[ i ];
+ }
+ }
+
+private:
+ unsigned int rd_[5];
+ int rd_index_;
+};
+
+// almost a copy of boost::generator_iterator
+// but default constructor sets m_g to NULL
+template <class Generator>
+class generator_iterator
+ : public iterator_facade<
+ generator_iterator<Generator>
+ , typename Generator::result_type
+ , single_pass_traversal_tag
+ , typename Generator::result_type const&
+ >
+{
+ typedef iterator_facade<
+ generator_iterator<Generator>
+ , typename Generator::result_type
+ , single_pass_traversal_tag
+ , typename Generator::result_type const&
+ > super_t;
+
+ public:
+ generator_iterator() : m_g(NULL) {}
+ generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
+
+ void increment()
+ {
+ m_value = (*m_g)();
+ }
+
+ const typename Generator::result_type&
+ dereference() const
+ {
+ return m_value;
+ }
+
+ bool equal(generator_iterator const& y) const
+ {
+ return this->m_g == y.m_g && this->m_value == y.m_value;
+ }
+
+ private:
+ Generator* m_g;
+ typename Generator::result_type m_value;
+};
+
+// seed() seeds a random number generator with good seed values
+
+template <typename UniformRandomNumberGenerator>
+inline void seed(UniformRandomNumberGenerator& rng)
+{
+ seed_rng seed_gen;
+ generator_iterator<seed_rng> begin(&seed_gen);
+ generator_iterator<seed_rng> end;
+ rng.seed(begin, end);
+}
+
+// random_device does not / can not be seeded
+template <>
+inline void seed<boost::random_device>(boost::random_device&) {}
+
+// random_device does not / can not be seeded
+template <>
+inline void seed<seed_rng>(seed_rng&) {}
+
+}}} //namespace boost::uuids::detail
+
+#endif

Added: trunk/boost/uuid/sha1.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/uuid/sha1.hpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,208 @@
+// boost/uuid/sha1.hpp header file ----------------------------------------------//
+
+// Copyright 2007 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)
+
+// Revision History
+// 29 May 2007 - Initial Revision
+// 25 Feb 2008 - moved to namespace boost::uuids::detail
+
+// This is a byte oriented implementation
+// Note: this implementation does not handle message longer than
+// 2^32 bytes.
+
+#ifndef BOOST_UUID_SHA1_H
+#define BOOST_UUID_SHA1_H
+
+#include <boost/static_assert.hpp>
+#include <cstddef>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+ using ::size_t;
+} // namespace std
+#endif
+
+namespace boost {
+namespace uuids {
+namespace detail {
+
+BOOST_STATIC_ASSERT(sizeof(unsigned char)*8 == 8);
+BOOST_STATIC_ASSERT(sizeof(unsigned int)*8 == 32);
+
+inline unsigned int left_rotate(unsigned int x, std::size_t n)
+{
+ return (x<<n) ^ (x>> (32-n));
+}
+
+class sha1
+{
+public:
+ typedef unsigned int(&digest_type)[5];
+public:
+ sha1();
+
+ void reset();
+
+ void process_byte(unsigned char byte);
+ void process_block(void const* bytes_begin, void const* bytes_end);
+ void process_bytes(void const* buffer, std::size_t byte_count);
+
+ void get_digest(digest_type digest);
+
+private:
+ void process_block();
+
+private:
+ unsigned int h_[5];
+
+ unsigned char block_[64];
+
+ std::size_t block_byte_index_;
+ std::size_t byte_count_;
+};
+
+inline sha1::sha1()
+{
+ reset();
+}
+
+inline void sha1::reset()
+{
+ h_[0] = 0x67452301;
+ h_[1] = 0xEFCDAB89;
+ h_[2] = 0x98BADCFE;
+ h_[3] = 0x10325476;
+ h_[4] = 0xC3D2E1F0;
+
+ block_byte_index_ = 0;
+ byte_count_ = 0;
+}
+
+inline void sha1::process_byte(unsigned char byte)
+{
+ block_[block_byte_index_++] = byte;
+ ++byte_count_;
+ if (block_byte_index_ == 64) {
+ block_byte_index_ = 0;
+ process_block();
+ }
+}
+
+inline void sha1::process_block(void const* bytes_begin, void const* bytes_end)
+{
+ unsigned char const* begin = static_cast<unsigned char const*>(bytes_begin);
+ unsigned char const* end = static_cast<unsigned char const*>(bytes_end);
+ for(; begin != end; ++begin) {
+ process_byte(*begin);
+ }
+}
+
+inline void sha1::process_bytes(void const* buffer, std::size_t byte_count)
+{
+ unsigned char const* b = static_cast<unsigned char const*>(buffer);
+ process_block(b, b+byte_count);
+}
+
+inline void sha1::process_block()
+{
+ unsigned int w[80];
+ for (std::size_t i=0; i<16; ++i) {
+ w[i] = (block_[i*4 + 0] << 24);
+ w[i] |= (block_[i*4 + 1] << 16);
+ w[i] |= (block_[i*4 + 2] << 8);
+ w[i] |= (block_[i*4 + 3]);
+ }
+ for (std::size_t i=16; i<80; ++i) {
+ w[i] = left_rotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1);
+ }
+
+ unsigned int a = h_[0];
+ unsigned int b = h_[1];
+ unsigned int c = h_[2];
+ unsigned int d = h_[3];
+ unsigned int e = h_[4];
+
+ for (std::size_t i=0; i<80; ++i) {
+ unsigned int f;
+ unsigned int k;
+
+ if (i<20) {
+ f = (b & c) | (~b & d);
+ k = 0x5A827999;
+ } else if (i<40) {
+ f = b ^ c ^ d;
+ k = 0x6ED9EBA1;
+ } else if (i<60) {
+ f = (b & c) | (b & d) | (c & d);
+ k = 0x8F1BBCDC;
+ } else {
+ f = b ^ c ^ d;
+ k = 0xCA62C1D6;
+ }
+
+ unsigned temp = left_rotate(a, 5) + f + e + k + w[i];
+ e = d;
+ d = c;
+ c = left_rotate(b, 30);
+ b = a;
+ a = temp;
+ }
+
+ h_[0] += a;
+ h_[1] += b;
+ h_[2] += c;
+ h_[3] += d;
+ h_[4] += e;
+}
+
+inline void sha1::get_digest(digest_type digest)
+{
+ std::size_t bit_count = byte_count_*8;
+
+ // append the bit '1' to the message
+ process_byte(0x80);
+
+ // append k bits '0', where k is the minimum number >= 0
+ // such that the resulting message length is congruent to 56 (mod 64)
+ // check if there is enough space for padding and bit_count
+ if (block_byte_index_ > 56) {
+ // finish this block
+ while (block_byte_index_ != 0) {
+ process_byte(0);
+ }
+
+ // one more block
+ while (block_byte_index_ < 56) {
+ process_byte(0);
+ }
+ } else {
+ while (block_byte_index_ < 56) {
+ process_byte(0);
+ }
+ }
+
+ // append length of message (before pre-processing)
+ // as a 64-bit big-endian integer
+ process_byte(0);
+ process_byte(0);
+ process_byte(0);
+ process_byte(0);
+ process_byte( static_cast<unsigned char>((bit_count>>24) & 0xFF));
+ process_byte( static_cast<unsigned char>((bit_count>>16) & 0xFF));
+ process_byte( static_cast<unsigned char>((bit_count>>8 ) & 0xFF));
+ process_byte( static_cast<unsigned char>((bit_count) & 0xFF));
+
+ // get final digest
+ digest[0] = h_[0];
+ digest[1] = h_[1];
+ digest[2] = h_[2];
+ digest[3] = h_[3];
+ digest[4] = h_[4];
+}
+
+}}} // namespace boost::uuids::detail
+
+#endif

Added: trunk/boost/uuid/uuid.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/uuid/uuid.hpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,199 @@
+// Boost uuid.hpp header file ----------------------------------------------//
+
+// Copyright 2006 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)
+
+// Revision History
+// 06 Feb 2006 - Initial Revision
+// 09 Nov 2006 - fixed variant and version bits for v4 guids
+// 13 Nov 2006 - added serialization
+// 17 Nov 2006 - added name-based guid creation
+// 20 Nov 2006 - add fixes for gcc (from Tim Blechmann)
+// 07 Mar 2007 - converted to header only
+// 10 May 2007 - removed need for Boost.Thread
+// - added better seed - thanks Peter Dimov
+// - removed null()
+// - replaced byte_count() and output_bytes() with size() and begin() and end()
+// 11 May 2007 - fixed guid(ByteInputIterator first, ByteInputIterator last)
+// - optimized operator>>
+// 14 May 2007 - converted from guid to uuid
+// 29 May 2007 - uses new implementation of sha1
+// 01 Jun 2007 - removed using namespace directives
+// 09 Nov 2007 - moved implementation to uuid.ipp file
+// 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
+
+#ifndef BOOST_UUID_HPP
+#define BOOST_UUID_HPP
+
+#include <boost/config.hpp>
+#include <stddef.h>
+#include <boost/cstdint.hpp>
+#include <algorithm>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_pod.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+ using ::size_t
+ using ::ptrdiff_t
+} //namespace std
+#endif //BOOST_NO_STDC_NAMESPACE
+
+namespace boost {
+namespace uuids {
+
+struct uuid
+{
+public:
+ typedef uint8_t value_type;
+ typedef uint8_t& reference;
+ typedef uint8_t const& const_reference;
+ typedef uint8_t* iterator;
+ typedef uint8_t const* const_iterator;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+ enum { static_size = 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() */
+
+ size_type size() const { return static_size; } /* throw() */
+
+ bool is_nil() const /* throw() */
+ {
+ // could be more efficient by stopping at the firt
+ // non zero
+ return (std::count(begin(), end(), 0) == static_size);
+ }
+
+ 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 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;
+ } else if ( (octet7 & 0xC0) == 0x80 ) { // 0b10xxxxxx
+ return variant_rfc_4122;
+ } else if ( (octet7 & 0xE0) == 0xC0 ) { // 0b110xxxxx
+ return variant_microsoft;
+ } else {
+ //assert( (octet7 & 0xE0) == 0xE0 ) // 0b111xxxx
+ return variant_future;
+ }
+ }
+
+ 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 is stored in octet 9
+ // which is index 6, since indexes count backwards
+ unsigned char 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;
+ } else if ( (octet9 & 0xF0) == 0x40 ) {
+ return version_random_number_based;
+ } else if ( (octet9 & 0xF0) == 0x50 ) {
+ return version_name_based_sha1;
+ } else {
+ return version_unknown;
+ }
+ }
+
+ // note: linear complexity
+ void swap(uuid& rhs) /* throw() */
+ {
+ std::swap_ranges(begin(), end(), rhs.begin());
+ }
+
+public:
+ // or should it be array<uint8_t, 16>
+ uint8_t data[static_size];
+};
+
+inline bool operator==(uuid const& lhs, uuid const& rhs) /* throw() */
+{
+ return std::equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
+inline bool operator!=(uuid const& lhs, uuid const& rhs) /* throw() */
+{
+ 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() */
+{
+ return rhs < lhs;
+}
+inline bool operator<=(uuid const& lhs, uuid const& rhs) /* throw() */
+{
+ return !(rhs < lhs);
+}
+
+inline bool operator>=(uuid const& lhs, uuid const& rhs) /* throw() */
+{
+ return !(lhs < rhs);
+}
+
+inline void swap(uuid& lhs, uuid& rhs) /* throw() */
+{
+ lhs.swap(rhs);
+}
+
+// This is equivalent to boost::hash_range(u.begin(), u.end());
+inline std::size_t hash_value(uuid const& u) /* throw() */
+{
+ std::size_t seed = 0;
+ for(uuid::const_iterator i=u.begin(); i != u.end(); ++i)
+ {
+ seed ^= static_cast<std::size_t>(*i) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+ }
+
+ return seed;
+}
+
+}} //namespace boost::uuids
+
+// type traits specializations
+namespace boost {
+
+template <>
+struct is_pod<uuids::uuid> : mpl::true_
+{};
+
+} // namespace boost
+
+#endif // BOOST_UUID_HPP

Added: trunk/boost/uuid/uuid_generators.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/uuid/uuid_generators.hpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,362 @@
+// Boost uuid_generators.hpp header file ----------------------------------------------//
+
+// Copyright 2006 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)
+
+// Revision History
+// 06 Feb 2006 - Initial Revision
+
+#ifndef BOOST_UUID_GENERATORS_HPP
+#define BOOST_UUID_GENERATORS_HPP
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/sha1.hpp>
+#include <boost/uuid/seed_rng.hpp>
+#include <algorithm>
+#include <string>
+#include <limits>
+#include <cstring>
+#include <cwchar>
+#include <boost/assert.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/random/uniform_int.hpp>
+#include <boost/random/variate_generator.hpp>
+#include <boost/random/mersenne_twister.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+ using ::strlen
+ using ::wcslen
+} //namespace std
+#endif //BOOST_NO_STDC_NAMESPACE
+
+namespace boost {
+namespace uuids {
+
+// generate a nil uuid
+struct nil_generator {
+ typedef uuid result_type;
+
+ uuid operator()() const {
+ // initialize to all zeros
+ uuid u = {0};
+ return u;
+ }
+};
+
+inline uuid nil_uuid() {
+ return nil_generator()();
+}
+
+// generate a uuid from a string
+// lexical_cast works fine using uuid_io.hpp
+// but this generator should accept more forms
+// and be more efficient
+// would like to accept the following forms:
+// 0123456789abcdef0123456789abcdef
+// 01234567-89ab-cdef-0123456789abcdef
+// {01234567-89ab-cdef-0123456789abcdef}
+// {0123456789abcdef0123456789abcdef}
+// others?
+struct string_generator {
+ typedef uuid result_type;
+
+ template <typename ch, typename char_traits, typename alloc>
+ uuid operator()(std::basic_string<ch, char_traits, alloc> const& s) const {
+ return operator()(s.begin(), s.end());
+ };
+
+ uuid operator()(char const*const s) const {
+ return operator()(s, s+std::strlen(s));
+ }
+
+ uuid operator()(wchar_t const*const s) const {
+ return operator()(s, s+std::wcslen(s));
+ }
+
+ template <typename CharIterator>
+ uuid operator()(CharIterator begin, CharIterator end) const
+ {
+ typedef std::iterator_traits<typename CharIterator>::value_type ch;
+
+ // check open brace
+ ch c = get_next_char(begin, end);
+ bool has_open_brace = is_open_brace(c);
+ ch open_brace_char = c;
+ if (has_open_brace) {
+ c = get_next_char(begin, end);
+ }
+
+ bool has_dashes = false;
+
+ uuid u;
+ int i=0;
+ for (uuid::iterator it_byte=u.begin(); it_byte!=u.end(); ++it_byte, ++i) {
+ if (it_byte != u.begin()) {
+ c = get_next_char(begin, end);
+ }
+
+ if (i == 4) {
+ has_dashes = is_dash(c);
+ if (has_dashes) {
+ c = get_next_char(begin, end);
+ }
+ }
+
+ if (has_dashes) {
+ if (i == 6 || i == 8 || i == 10) {
+ if (is_dash(c)) {
+ c = get_next_char(begin, end);
+ } else {
+ throw_invalid();
+ }
+ }
+ }
+
+ *it_byte = get_value(c);
+
+ c = get_next_char(begin, end);
+ *it_byte <<= 4;
+ *it_byte |= get_value(c);
+ }
+
+ // check close brace
+ if (has_open_brace) {
+ c = get_next_char(begin, end);
+ check_close_brace(c, open_brace_char);
+ }
+
+ return u;
+ }
+
+private:
+ template <typename CharIterator>
+ typename std::iterator_traits<CharIterator>::value_type
+ get_next_char(CharIterator& begin, CharIterator end) const {
+ if (begin == end) {
+ throw_invalid();
+ }
+ return *begin++;
+ }
+
+ unsigned char get_value(char c) const {
+ static char const digits[23] = "0123456789abcdefABCDEF";
+ static char const*const digits_end = digits+23;
+
+ unsigned char const values[23] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,10,11,12,13,14,15 };
+
+ char const* d = std::find(&digits[0], digits_end, c);
+ if (d == digits_end) {
+ return -1;
+ }
+
+ return values[std::distance(digits, d)];
+ }
+
+ unsigned char get_value(wchar_t c) const {
+ static wchar_t const digits[23] = L"0123456789abcdefABCDEF";
+ static wchar_t const*const digits_end = digits+23;
+
+ unsigned char const values[23] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,10,11,12,13,14,15 };
+
+ wchar_t const* d = std::find(digits, digits_end, c);
+ if (d == digits_end) {
+ return -1;
+ }
+
+ return values[std::distance(digits, d)];
+ }
+
+ bool is_dash(char c) const {
+ return c == '-';
+ }
+
+ bool is_dash(wchar_t c) const {
+ return c == L'-';
+ }
+
+ // return closing brace
+ bool is_open_brace(char c) const {
+ return (c == '{');
+ }
+
+ bool is_open_brace(wchar_t c) const {
+ return (c == L'{');
+ }
+
+ void check_close_brace(char c, char open_brace) const {
+ if (open_brace == '{' && c == '}') {
+ //great
+ } else {
+ throw_invalid();
+ }
+ }
+
+ void check_close_brace(wchar_t c, wchar_t open_brace) const {
+ if (open_brace == L'{' && c == L'}') {
+ // great
+ } else {
+ throw_invalid();
+ }
+ }
+
+ void throw_invalid() const {
+ throw std::runtime_error("invalid uuid string");
+ }
+};
+
+// 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) const {
+ return operator()(name, std::strlen(name));
+ }
+
+ uuid operator()(const wchar_t* name) const {
+ return operator()(name, std::wcslen(name)*sizeof(wchar_t));
+ }
+
+ template <typename ch, typename char_traits, typename alloc>
+ uuid operator()(std::basic_string<ch, char_traits, alloc> const& name) const {
+ return operator()(name.c_str(), name.length()*sizeof(ch));
+ }
+
+ uuid operator()(void const* buffer, std::size_t byte_count) const {
+ detail::sha1 sha;
+ sha.process_bytes(namespace_uuid.begin(), namespace_uuid.size());
+ sha.process_bytes(buffer, byte_count);
+ 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;
+};
+
+// generate a random-based uuid
+template <typename UniformRandomNumberGenerator>
+class basic_random_generator {
+private:
+ typedef uniform_int<unsigned long> distribution_type;
+ typedef variate_generator<typename UniformRandomNumberGenerator*, distribution_type> generator_type;
+
+ struct null_deleter
+ {
+ void operator()(void const *) const {}
+ };
+
+public:
+ typedef uuid result_type;
+
+ // default constructor creates the random number generator
+ basic_random_generator()
+ : pURNG(new UniformRandomNumberGenerator)
+ , generator
+ ( pURNG.get()
+ , distribution_type
+ ( (std::numeric_limits<unsigned long>::min)()
+ , (std::numeric_limits<unsigned long>::max)()
+ )
+ )
+ {
+ // seed the random number generator
+ detail::seed(*pURNG);
+ }
+
+ // keep a reference to a random number generator
+ // don't seed a given random number generator
+ explicit basic_random_generator(UniformRandomNumberGenerator& gen)
+ : pURNG(&gen, null_deleter())
+ , generator
+ ( pURNG.get()
+ , distribution_type
+ ( (std::numeric_limits<unsigned long>::min)()
+ , (std::numeric_limits<unsigned long>::max)()
+ )
+ )
+ {}
+
+ // keep a pointer to a random number generator
+ // don't seed a given random number generator
+ explicit basic_random_generator(UniformRandomNumberGenerator* pGen)
+ : pURNG(pGen, null_deleter())
+ , generator
+ ( pURNG.get()
+ , distribution_type
+ ( (std::numeric_limits<unsigned long>::min)()
+ , (std::numeric_limits<unsigned long>::max)()
+ )
+ )
+ {
+ BOOST_ASSERT(pURNG);
+ }
+
+ uuid operator()()
+ {
+ uuid u;
+
+ int i=0;
+ unsigned long random_value = generator();
+ for (uuid::iterator it=u.begin(); it!=u.end(); ++it, ++i) {
+ if (i==sizeof(unsigned long)) {
+ random_value = generator();
+ }
+
+ *it = ((random_value >> (i*8)) & 0xFF);
+ }
+
+ // set variant
+ // must be 0b10xxxxxx
+ *(u.begin()+8) &= 0xBF;
+ *(u.begin()+8) |= 0x80;
+
+ // set version
+ // must be 0b0100xxxx
+ *(u.begin()+6) &= 0x4F; //0b01001111
+ *(u.begin()+6) |= 0x40; //0b01000000
+
+ return u;
+ }
+
+private:
+ shared_ptr<UniformRandomNumberGenerator> pURNG;
+ generator_type generator;
+};
+
+typedef basic_random_generator<mt19937> random_generator;
+
+//TODO add native_generator
+
+}} //namespace boost::uuids
+
+#endif //BOOST_UUID_GENERATORS_HPP

Added: trunk/boost/uuid/uuid_io.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/uuid/uuid_io.hpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,109 @@
+// Boost uuid_io.hpp header file ----------------------------------------------//
+
+// Copyright 2009 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)
+
+// Revision History
+// 20 Mar 2009 - Initial Revision
+
+#ifndef BOOST_UUID_IO_HPP
+#define BOOST_UUID_IO_HPP
+
+#include <boost/uuid/uuid.hpp>
+#include <ios>
+#include <ostream>
+#include <istream>
+#include <boost/io/ios_state.hpp>
+#include <locale>
+#include <algorithm>
+
+namespace boost {
+namespace uuids {
+
+template <typename ch, typename char_traits>
+ std::basic_ostream<ch, char_traits>& operator<<(std::basic_ostream<ch, char_traits> &os, uuid const& u)
+{
+ io::ios_flags_saver flags_saver(os);
+ io::ios_width_saver width_saver(os);
+ io::basic_ios_fill_saver<ch, char_traits> fill_saver(os);
+
+ const typename std::basic_ostream<ch, char_traits>::sentry ok(os);
+ if (ok) {
+ os << std::hex;
+ os.fill(os.widen('0'));
+
+ std::size_t i=0;
+ for (uuid::const_iterator i_data = u.begin(); i_data!=u.end(); ++i_data, ++i) {
+ os.width(2);
+ os << static_cast<unsigned int>(*i_data);
+ if (i == 3 || i == 5 || i == 7 || i == 9) {
+ os << os.widen('-');
+ }
+ }
+ }
+ return os;
+}
+
+template <typename ch, typename char_traits>
+ std::basic_istream<ch, char_traits>& operator>>(std::basic_istream<ch, char_traits> &is, uuid &u)
+{
+ const typename std::basic_istream<ch, char_traits>::sentry ok(is);
+ if (ok) {
+ unsigned char data[16];
+
+ typedef std::ctype<ch> ctype_t;
+ ctype_t const& ctype = std::use_facet<ctype_t>(is.getloc());
+
+ ch xdigits[16];
+ {
+ char szdigits[17] = "0123456789ABCDEF";
+ ctype.widen(szdigits, szdigits+16, xdigits);
+ }
+ ch*const xdigits_end = xdigits+16;
+
+ ch c;
+ for (std::size_t i=0; i<u.size() && is; ++i) {
+ is >> c;
+ c = ctype.toupper(c);
+
+ ch* f = std::find(xdigits, xdigits_end, c);
+ if (f == xdigits_end) {
+ is.setstate(std::ios_base::failbit);
+ break;
+ }
+
+ unsigned char byte = static_cast<unsigned char>(std::distance(&xdigits[0], f));
+
+ is >> c;
+ c = ctype.toupper(c);
+ f = std::find(xdigits, xdigits_end, c);
+ if (f == xdigits_end) {
+ is.setstate(std::ios_base::failbit);
+ break;
+ }
+
+ byte <<= 4;
+ byte |= static_cast<unsigned char>(std::distance(&xdigits[0], f));
+
+ data[i] = byte;
+
+ if (is) {
+ if (i == 3 || i == 5 || i == 7 || i == 9) {
+ is >> c;
+ if (c != is.widen('-')) is.setstate(std::ios_base::failbit);
+ }
+ }
+ }
+
+ if (is) {
+ std::copy(data, data+16, u.begin());
+ }
+ }
+ return is;
+}
+
+}} //namespace boost::uuids
+
+#endif // BOOST_UUID_IO_HPP

Added: trunk/boost/uuid/uuid_serialize.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/uuid/uuid_serialize.hpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,20 @@
+// Boost uuid_serialize.hpp header file ----------------------------------------------//
+
+// Copyright 2007 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)
+
+// Revision History
+// 12 Nov 2007 - Initial Revision
+// 25 Feb 2008 - moved to namespace boost::uuids::detail
+
+#ifndef BOOST_UUID_SERIALIZE_HPP
+#define BOOST_UUID_SERIALIZE_HPP
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/serialization/level.hpp>
+
+BOOST_CLASS_IMPLEMENTATION(boost::uuids::uuid, boost::serialization::primitive_type)
+
+#endif // BOOST_UUID_SERIALIZE_HPP

Modified: trunk/libs/libraries.htm
==============================================================================
--- trunk/libs/libraries.htm (original)
+++ trunk/libs/libraries.htm 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -303,6 +303,7 @@
         function templates, plus <b>base-from-member idiom</b>, from Dave Abrahams and others.</li>
         <li>value_initialized - Wrapper for uniform-syntax value initialization,
         from Fernando Cacciola, based on the original idea of David Abrahams.</li>
+ <li>uuid - A universally unique identifier, from Andy Tompkins.</li>
     <li>variant - Safe, generic, stack-based discriminated union
     container, from Eric Friedman and Itay Maman.</li>
     <li>wave - Standards conformant
@@ -589,6 +590,7 @@
         Kalicinski and Sebastian Redl.
     <li>tuple - Ease definition of functions returning multiple values, and more,
     from Jaakko Järvi.</li>
+ <li>uuid - A universally unique identifier, from Andy Tompkins.</li>
     <li>variant - Safe, generic, stack-based
     discriminated union container, from Eric Friedman and Itay Maman.</li>
</ul>

Modified: trunk/libs/maintainers.txt
==============================================================================
--- trunk/libs/maintainers.txt (original)
+++ trunk/libs/maintainers.txt 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -89,6 +89,7 @@
utility
utility/enable_if Jaakko Jarvi <jarvi -at- cs.tamu.edu>, Jeremiah Willcock <jewillco -at- osl.iu.edu>
utility/swap Joseph Gauterin <joseph.gauterin -at- googlemail.com>
+uuid Andy Tompkins <atompkins -at- fastmail.fm>
variant Eric Friedman <ericbrandon -at- gmail.com>
wave Hartmut Kaiser <hartmut.kaiser -at- gmail.com>
xpressive Eric Niebler <eric -at- boostpro.com>

Added: trunk/libs/uuid/index.html
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/index.html 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,43 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<title>Boost Uuid Library</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<table border="1" bgcolor="#007F7F" cellpadding="2">
+ <tr>
+ <td bgcolor="#FFFFFF"><img src="../../boost.png" alt="boost.png (6897 bytes)" WIDTH="277" HEIGHT="86"></td>
+ <td>Home </td>
+ <td>Libraries </td>
+ <td>People </td>
+ <td>FAQ </td>
+ <td>More </td>
+ </tr>
+</table>
+
+<h1>Uuid library</h1>
+
+<p>The header uuid.hpp provides an implementation of Universally Unique Identifiers.
+</p>
+
+<p>This implementation is intended for general use.</p>
+
+<ul>
+ <li>Documentation (HTML).</li>
+ <li>Header uuid.hpp.</li>
+ <li>See the documentation for links to sample programs.</li>
+ <li>Submitted by Andy Tompkins</a>.</li>
+</ul>
+
+<p>Revised  May 14, 2007</p>
+
+<hr>
+<p>© Copyright Andy Tompkins, 2006</p>
+<p> Distributed under the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>

Added: trunk/libs/uuid/test/Jamfile.v2
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/Jamfile.v2 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,63 @@
+# Copyright 2007 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)
+
+import testing ;
+
+project
+ : requirements
+ <include>../../..
+ ;
+
+test-suite "uuid"
+ : # make sure uuid.hpp is self-contained
+ [ compile compile_uuid_h.cpp ]
+
+ # make sure uuid_io.hpp is self-contained
+ [ compile compile_uuid_io_h.cpp ]
+
+ # make sure uuid_serialize.hpp is self-contained
+ [ compile compile_uuid_serialize_h.cpp ]
+
+ # make sure uuid_generators.hpp is self-contained
+ [ compile compile_uuid_generators_h.cpp ]
+
+ # I want to look for issues when multiple translation units include
+ # uuid header files. For example missing inline on non-template functions
+ #[ link test_uuid.cpp compile_uuid_h.cpp : : multiple_translation_units ]
+
+ # main test - added compile_uuid_header.cpp in lue of above test
+ [ unit-test test_uuid : test_uuid.cpp compile_uuid_h.cpp ]
+
+ # test inclucing all .hpp files in 2 translations units
+ # to make sure a inline state is not missing
+ [ unit-test test_inline : test_include1.cpp test_include2.cpp ]
+
+ # test uuid_io.hpp
+ [ unit-test test_io : test_io.cpp ]
+
+ # test uuid_generators.hpp
+ [ unit-test test_generators : test_generators.cpp ]
+
+ # test tagging an object
+ [ unit-test test_tagging : test_tagging.cpp ]
+
+ # test uuid class
+ [ unit-test test_uuid_class : test_uuid_class.cpp ]
+
+ # test serializing uuids
+ [ unit-test test_serialization
+ : test_serialization.cpp ../../serialization/build//boost_serialization
+ ]
+ # TODO - This test fails to like with boost_wserialization
+ #[ unit-test test_wserialization
+ # : test_wserialization.cpp
+ # ../../serialization/build//boost_serialization
+ # ../../serialization/build//boost_wserialization
+ # : <dependency>../../config/test/all//BOOST_NO_STD_WSTREAMBUF
+ #]
+
+ # test sha1 hash function
+ [ unit-test test_sha1 : test_sha1.cpp ]
+ ;

Added: trunk/libs/uuid/test/compile_uuid_generators_h.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/compile_uuid_generators_h.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,15 @@
+// (C) Copyright Andy Tompkins 2008. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/compile_uuid_generators_h.cpp -------------------------------//
+
+// Purpose to make sure that a translation unit consisting of just the contents
+// of the header file will compile successfully.
+
+#include <boost/uuid/uuid_generators.hpp>

Added: trunk/libs/uuid/test/compile_uuid_h.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/compile_uuid_h.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,15 @@
+// (C) Copyright Andy Tompkins 2008. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/compile_uuid_h.cpp -------------------------------//
+
+// Purpose to make sure that a translation unit consisting of just the contents
+// of the header file will compile successfully.
+
+#include <boost/uuid/uuid.hpp>

Added: trunk/libs/uuid/test/compile_uuid_io_h.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/compile_uuid_io_h.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,15 @@
+// (C) Copyright Andy Tompkins 2008. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/compile_uuid_io_h.cpp -------------------------------//
+
+// Purpose to make sure that a translation unit consisting of just the contents
+// of the header file will compile successfully.
+
+#include <boost/uuid/uuid_io.hpp>

Added: trunk/libs/uuid/test/compile_uuid_serialize_h.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/compile_uuid_serialize_h.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,15 @@
+// (C) Copyright Andy Tompkins 2008. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/compile_uuid_serialize_h.cpp -------------------------------//
+
+// Purpose to make sure that a translation unit consisting of just the contents
+// of the header file will compile successfully.
+
+#include <boost/uuid/uuid_serialize.hpp>

Added: trunk/libs/uuid/test/test_generators.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_generators.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,134 @@
+// (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/test_generators.cpp -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/test_tools.hpp>
+
+#include <boost/random.hpp>
+
+template <typename RandomUuidGenerator>
+void check_random_generator(RandomUuidGenerator& uuid_gen)
+{
+ boost::uuids::uuid u1 = uuid_gen();
+ boost::uuids::uuid u2 = uuid_gen();
+
+ BOOST_CHECK_NE(u1, u2);
+
+ // check variant
+ BOOST_CHECK_EQUAL(u1.variant(), boost::uuids::uuid::variant_rfc_4122);
+// BOOST_CHECK_EQUAL( *(u1.begin()+8) & 0xC0, 0x80);
+ // version
+ BOOST_CHECK_EQUAL( *(u1.begin()+6) & 0xF0, 0x40);
+}
+
+int test_main(int, char*[])
+{
+ using namespace boost::uuids;
+ using boost::test_tools::output_test_stream;
+
+ { // test nil generator
+ uuid u1 = nil_generator()();
+ uuid u2 = {0};
+ BOOST_CHECK_EQUAL(u1, u2);
+
+ uuid u3 = nil_uuid();
+ BOOST_CHECK_EQUAL(u3, u2);
+ }
+
+ { // test string_generator
+ string_generator gen;
+ uuid u = gen("00000000-0000-0000-0000-000000000000");
+ BOOST_CHECK_EQUAL(u, nil_uuid());
+ BOOST_CHECK_EQUAL(u.is_nil(), true);
+
+ const uuid u_increasing = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
+ const uuid u_decreasing = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
+
+ u = gen("0123456789abcdef0123456789ABCDEF");
+ BOOST_CHECK_EQUAL(u, u_increasing);
+
+ u = gen("{0123456789abcdef0123456789ABCDEF}");
+ BOOST_CHECK_EQUAL(u, u_increasing);
+
+ u = gen("{01234567-89AB-CDEF-0123-456789abcdef}");
+ BOOST_CHECK_EQUAL(u, u_increasing);
+
+ u = gen("01234567-89AB-CDEF-0123-456789abcdef");
+ BOOST_CHECK_EQUAL(u, u_increasing);
+
+ u = gen(std::string("fedcba98-7654-3210-fedc-ba9876543210"));
+ BOOST_CHECK_EQUAL(u, u_decreasing);
+
+#ifndef BOOST_NO_STD_WSTRING
+ u = gen(L"fedcba98-7654-3210-fedc-ba9876543210");
+ BOOST_CHECK_EQUAL(u, u_decreasing);
+
+ u = gen(std::wstring(L"01234567-89ab-cdef-0123-456789abcdef"));
+ BOOST_CHECK_EQUAL(u, u_increasing);
+#endif //BOOST_NO_STD_WSTRING
+ }
+
+ { // test name_generator
+ uuid dns_namespace_uuid = {0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8};
+ uuid correct = {0x21, 0xf7, 0xf8, 0xde, 0x80, 0x51, 0x5b, 0x89, 0x86, 0x80, 0x01, 0x95, 0xef, 0x79, 0x8b, 0x6a};
+ uuid wcorrect = {0x5b, 0xec, 0xf2, 0x07, 0x1c, 0xd2, 0x59, 0x66, 0x8b, 0x44, 0xf5, 0x7f, 0x23, 0x0a, 0x68, 0xb9};
+
+ name_generator gen(dns_namespace_uuid);
+
+ uuid u = gen("www.widgets.com");
+ BOOST_CHECK_EQUAL(u, correct);
+ BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+ u = gen(L"www.widgets.com");
+ BOOST_CHECK_EQUAL(u, wcorrect);
+ BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+ u = gen(std::string("www.widgets.com"));
+ BOOST_CHECK_EQUAL(u, correct);
+ BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+ u = gen(std::wstring(L"www.widgets.com"));
+ BOOST_CHECK_EQUAL(u, wcorrect);
+ BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+
+ char name[] = "www.widgets.com";
+ u = gen(name, 15);
+ BOOST_CHECK_EQUAL(u, correct);
+ BOOST_CHECK_EQUAL(u.variant(), boost::uuids::uuid::variant_rfc_4122);
+ }
+
+ { // test random_generator
+ random_generator uuid_gen1;
+ check_random_generator(uuid_gen1);
+
+ basic_random_generator<boost::rand48> uuid_gen2;
+ check_random_generator(uuid_gen2);
+
+ boost::rand48 rand48_gen;
+ basic_random_generator<boost::rand48> uuid_gen3(rand48_gen);
+ check_random_generator(uuid_gen3);
+
+ basic_random_generator<boost::rand48> uuid_gen4(&rand48_gen);
+ check_random_generator(uuid_gen4);
+
+ basic_random_generator<boost::lagged_fibonacci44497> uuid_gen5;
+ check_random_generator(uuid_gen5);
+
+ //basic_random_generator<boost::random_device> uuid_gen5;
+ //check_random_generator(uuid_gen5);
+ }
+
+ return 0;
+}

Added: trunk/libs/uuid/test/test_include1.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_include1.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,23 @@
+// (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/test_include1.cpp -------------------------------//
+
+#include <boost/test/included/test_exec_monitor.hpp>
+//#include <boost/test/test_tools.hpp>
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_serialize.hpp>
+
+int test_main(int, char*[])
+{
+ return 0;
+}

Added: trunk/libs/uuid/test/test_include2.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_include2.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,15 @@
+// (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/test_include2.cpp -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_serialize.hpp>

Added: trunk/libs/uuid/test/test_io.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_io.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,71 @@
+// (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/test_io.cpp -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/test_tools.hpp>
+#include <boost/test/output_test_stream.hpp>
+
+#include <boost/lexical_cast.hpp>
+#include <string>
+
+int test_main(int, char*[])
+{
+ using namespace boost::uuids;
+ using boost::test_tools::output_test_stream;
+
+ const uuid u1 = {0};
+ const uuid u2 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ const uuid u3 = {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef,0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};
+
+ { // test insert/extract operators
+ output_test_stream output;
+ output << u1;
+ BOOST_CHECK(!output.is_empty(false));
+ BOOST_CHECK(output.check_length(36, false));
+ BOOST_CHECK(output.is_equal("00000000-0000-0000-0000-000000000000"));
+
+ output << u2;
+ BOOST_CHECK(!output.is_empty(false));
+ BOOST_CHECK(output.check_length(36, false));
+ BOOST_CHECK(output.is_equal("00010203-0405-0607-0809-0a0b0c0d0e0f"));
+
+ output << u3;
+ BOOST_CHECK(!output.is_empty(false));
+ BOOST_CHECK(output.check_length(36, false));
+ BOOST_CHECK(output.is_equal("12345678-90ab-cdef-1234-567890abcdef"));
+ }
+
+ {
+ uuid u;
+
+ std::stringstream ss;
+ ss << "00000000-0000-0000-0000-000000000000";
+ ss >> u;
+ BOOST_CHECK_EQUAL(u, u1);
+
+ ss << "12345678-90ab-cdef-1234-567890abcdef";
+ ss >> u;
+ BOOST_CHECK_EQUAL(u, u3);
+ }
+
+ { // test with lexical_cast
+ BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(u1), std::string("00000000-0000-0000-0000-000000000000"));
+ BOOST_CHECK_EQUAL(boost::lexical_cast<uuid>("00000000-0000-0000-0000-000000000000"), u1);
+
+ BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(u3), std::string("12345678-90ab-cdef-1234-567890abcdef"));
+ BOOST_CHECK_EQUAL(boost::lexical_cast<uuid>("12345678-90ab-cdef-1234-567890abcdef"), u3);
+ }
+
+ return 0;
+}

Added: trunk/libs/uuid/test/test_serialization.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_serialization.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,72 @@
+// (C) Copyright Andy Tompkins 2007. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// Purpose to test serializing uuids with narrow archives
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/test_tools.hpp>
+#include <sstream>
+#include <iostream>
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_serialize.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+
+template <class OArchiveType, class IArchiveType, class OStringStreamType, class IStringStreamType>
+void test_archive()
+{
+ using namespace std;
+ using namespace boost::uuids;
+
+ OStringStreamType o_stream;
+
+ uuid u1 = {0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef};
+
+ uuid u2;
+
+ // save
+ {
+ OArchiveType oa(o_stream);
+
+ oa << BOOST_SERIALIZATION_NVP(u1);
+ }
+
+ //cout << "stream:" << o_stream.str() << "\n\n";
+
+ // load
+ {
+ IStringStreamType i_stream(o_stream.str());
+ IArchiveType ia(i_stream);
+
+ ia >> BOOST_SERIALIZATION_NVP(u2);
+ }
+
+ BOOST_CHECK_EQUAL(u1, u2);
+}
+
+int test_main( int /* argc */, char* /* argv */[] )
+{
+ using namespace std;
+ using namespace boost::archive;
+
+ test_archive<text_oarchive, text_iarchive, ostringstream, istringstream>();
+ test_archive<xml_oarchive, xml_iarchive, ostringstream, istringstream>();
+ test_archive<binary_oarchive, binary_iarchive, ostringstream, istringstream>();
+
+ return 0;
+}

Added: trunk/libs/uuid/test/test_sha1.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_sha1.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,239 @@
+// (C) Copyright Andy Tompkins 2007. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/test_sha1.cpp -------------------------------//
+
+#include <boost/uuid/sha1.hpp>
+#include <algorithm>
+#include <cstring>
+#include <cstddef>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/included/unit_test.hpp>
+
+#define BOOST_AUTO_TEST_MAIN
+#include <boost/test/auto_unit_test.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+ using ::strlen;
+ using ::size_t
+} //namespace std
+#endif
+
+void test_sha1(char const*const message, unsigned int length, const unsigned int (&correct_digest)[5])
+{
+ boost::uuids::detail::sha1 sha;
+ sha.process_bytes(message, length);
+
+ unsigned int digest[5];
+ sha.get_digest(digest);
+
+ BOOST_CHECK_EQUAL_COLLECTIONS(digest, digest+5, correct_digest, correct_digest+5);
+}
+
+BOOST_AUTO_TEST_CASE(test_quick)
+{
+ struct test_case
+ {
+ char const* message;
+ unsigned int digest[5];
+ };
+ test_case cases[] =
+ { { "",
+ { 0xda39a3ee, 0x5e6b4b0d, 0x3255bfef, 0x95601890, 0xafd80709 } }
+ , { "The quick brown fox jumps over the lazy dog",
+ { 0x2fd4e1c6, 0x7a2d28fc, 0xed849ee1, 0xbb76e739, 0x1b93eb12 } }
+ , { "The quick brown fox jumps over the lazy cog",
+ { 0xde9f2c7f, 0xd25e1b3a, 0xfad3e85a, 0x0bd17d9b, 0x100db4b3 } }
+ };
+
+ for (int i=0; i!=sizeof(cases)/sizeof(cases[0]); ++i) {
+ test_case const& tc = cases[i];
+ test_sha1(tc.message, std::strlen(tc.message), tc.digest);
+ }
+}
+
+//SHA Test Vector for Hashing Byte-Oriented Messages
+//http://csrc.nist.gov/cryptval/shs.htm
+//http://csrc.nist.gov/cryptval/shs/shabytetestvectors.zip
+//values from SHA1ShortMsg.txt
+BOOST_AUTO_TEST_CASE(test_short_messages)
+{
+ struct test_case
+ {
+ char const* message;
+ unsigned int digest[5];
+ };
+ test_case cases[] =
+ { { "",
+ { 0xda39a3ee, 0x5e6b4b0d, 0x3255bfef, 0x95601890, 0xafd80709 } }
+ , { "a8",
+ { 0x99f2aa95, 0xe36f95c2, 0xacb0eaf2, 0x3998f030, 0x638f3f15 } }
+ , { "3000",
+ { 0xf944dcd6, 0x35f9801f, 0x7ac90a40, 0x7fbc4799, 0x64dec024 } }
+ , { "42749e",
+ { 0xa444319e, 0x9b6cc1e8, 0x464c511e, 0xc0969c37, 0xd6bb2619 } }
+ , { "9fc3fe08",
+ { 0x16a0ff84, 0xfcc156fd, 0x5d3ca3a7, 0x44f20a23, 0x2d172253 } }
+ , { "b5c1c6f1af",
+ { 0xfec9deeb, 0xfcdedaf6, 0x6dda525e, 0x1be43597, 0xa73a1f93 } }
+ , { "e47571e5022e",
+ { 0x8ce05118, 0x1f0ed5e9, 0xd0c498f6, 0xbc4caf44, 0x8d20deb5 } }
+ , { "3e1b28839fb758",
+ { 0x67da5383, 0x7d89e03b, 0xf652ef09, 0xc369a341, 0x5937cfd3 } }
+ , { "a81350cbb224cb90",
+ { 0x305e4ff9, 0x888ad855, 0xa78573cd, 0xdf4c5640, 0xcce7e946 } }
+ , { "c243d167923dec3ce1",
+ { 0x5902b77b, 0x3265f023, 0xf9bbc396, 0xba1a93fa, 0x3509bde7 } }
+ , { "50ac18c59d6a37a29bf4",
+ { 0xfcade5f5, 0xd156bf6f, 0x9af97bdf, 0xa9c19bcc, 0xfb4ff6ab } }
+ , { "98e2b611ad3b1cccf634f6",
+ { 0x1d20fbe0, 0x0533c10e, 0x3cbd6b27, 0x088a5de0, 0xc632c4b5 } }
+ , { "73fe9afb68e1e8712e5d4eec",
+ { 0x7e1b7e0f, 0x7a8f3455, 0xa9c03e95, 0x80fd63ae, 0x205a2d93 } }
+ , { "9e701ed7d412a9226a2a130e66",
+ { 0x706f0677, 0x146307b2, 0x0bb0e8d6, 0x311e3299, 0x66884d13 } }
+ , { "6d3ee90413b0a7cbf69e5e6144ca",
+ { 0xa7241a70, 0x3aaf0d53, 0xfe142f86, 0xbf2e8492, 0x51fa8dff } }
+ , { "fae24d56514efcb530fd4802f5e71f",
+ { 0x400f5354, 0x6916d33a, 0xd01a5e6d, 0xf66822df, 0xbdc4e9e6 } }
+ , { "c5a22dd6eda3fe2bdc4ddb3ce6b35fd1",
+ { 0xfac8ab93, 0xc1ae6c16, 0xf0311872, 0xb984f729, 0xdc928ccd } }
+ , { "d98cded2adabf08fda356445c781802d95",
+ { 0xfba6d750, 0xc18da58f, 0x6e2aab10, 0x112b9a5e, 0xf3301b3b } }
+ , { "bcc6d7087a84f00103ccb32e5f5487a751a2",
+ { 0x29d27c2d, 0x44c205c8, 0x107f0351, 0xb05753ac, 0x708226b6 } }
+ , { "36ecacb1055434190dbbc556c48bafcb0feb0d",
+ { 0xb971bfc1, 0xebd6f359, 0xe8d74cb7, 0xecfe7f89, 0x8d0ba845 } }
+ , { "5ff9edb69e8f6bbd498eb4537580b7fba7ad31d0",
+ { 0x96d08c43, 0x0094b9fc, 0xc164ad2f, 0xb6f72d0a, 0x24268f68 } }
+ , { "c95b441d8270822a46a798fae5defcf7b26abace36",
+ { 0xa287ea75, 0x2a593d52, 0x09e28788, 0x1a09c49f, 0xa3f0beb1 } }
+ , { "83104c1d8a55b28f906f1b72cb53f68cbb097b44f860",
+ { 0xa06c7137, 0x79cbd885, 0x19ed4a58, 0x5ac0cb8a, 0x5e9d612b } }
+ , { "755175528d55c39c56493d697b790f099a5ce741f7754b",
+ { 0xbff7d52c, 0x13a36881, 0x32a1d407, 0xb1ab40f5, 0xb5ace298 } }
+ , { "088fc38128bbdb9fd7d65228b3184b3faac6c8715f07272f",
+ { 0xc7566b91, 0xd7b6f56b, 0xdfcaa978, 0x1a7b6841, 0xaacb17e9 } }
+ , { "a4a586eb9245a6c87e3adf1009ac8a49f46c07e14185016895",
+ { 0xffa30c0b, 0x5c550ea4, 0xb1e34f8a, 0x60ec9295, 0xa1e06ac1 } }
+ , { "8e7c555270c006092c2a3189e2a526b873e2e269f0fb28245256",
+ { 0x29e66ed2, 0x3e914351, 0xe872aa76, 0x1df6e4f1, 0xa07f4b81 } }
+ , { "a5f3bfa6bb0ba3b59f6b9cbdef8a558ec565e8aa3121f405e7f2f0",
+ { 0xb28cf5e5, 0xb806a014, 0x91d41f69, 0xbd924876, 0x5c5dc292 } }
+ , { "589054f0d2bd3c2c85b466bfd8ce18e6ec3e0b87d944cd093ba36469",
+ { 0x60224fb7, 0x2c460696, 0x52cd78bc, 0xd08029ef, 0x64da62f3 } }
+ , { "a0abb12083b5bbc78128601bf1cbdbc0fdf4b862b24d899953d8da0ff3",
+ { 0xb72c4a86, 0xf72608f2, 0x4c05f3b9, 0x088ef92f, 0xba431df7 } }
+ , { "82143f4cea6fadbf998e128a8811dc75301cf1db4f079501ea568da68eeb",
+ { 0x73779ad5, 0xd6b71b9b, 0x8328ef72, 0x20ff12eb, 0x167076ac } }
+ , { "9f1231dd6df1ff7bc0b0d4f989d048672683ce35d956d2f57913046267e6f3",
+ { 0xa09671d4, 0x452d7cf5, 0x0015c914, 0xa1e31973, 0xd20cc1a0 } }
+ , { "041c512b5eed791f80d3282f3a28df263bb1df95e1239a7650e5670fc2187919",
+ { 0xe88cdcd2, 0x33d99184, 0xa6fd260b, 0x8fca1b7f, 0x7687aee0 } }
+ , { "17e81f6ae8c2e5579d69dafa6e070e7111461552d314b691e7a3e7a4feb3fae418",
+ { 0x010def22, 0x850deb11, 0x68d525e8, 0xc84c2811, 0x6cb8a269 } }
+ , { "d15976b23a1d712ad28fad04d805f572026b54dd64961fda94d5355a0cc98620cf77",
+ { 0xaeaa40ba, 0x1717ed54, 0x39b1e6ea, 0x901b294b, 0xa500f9ad } }
+ , { "09fce4d434f6bd32a44e04b848ff50ec9f642a8a85b37a264dc73f130f22838443328f",
+ { 0xc6433791, 0x238795e3, 0x4f080a5f, 0x1f1723f0, 0x65463ca0 } }
+ , { "f17af27d776ec82a257d8d46d2b46b639462c56984cc1be9c1222eadb8b26594a25c709d",
+ { 0xe21e22b8, 0x9c1bb944, 0xa32932e6, 0xb2a2f20d, 0x491982c3 } }
+ , { "b13ce635d6f8758143ffb114f2f601cb20b6276951416a2f94fbf4ad081779d79f4f195b22",
+ { 0x575323a9, 0x661f5d28, 0x387964d2, 0xba6ab92c, 0x17d05a8a } }
+ , { "5498793f60916ff1c918dde572cdea76da8629ba4ead6d065de3dfb48de94d234cc1c5002910",
+ { 0xfeb44494, 0xaf72f245, 0xbfe68e86, 0xc4d7986d, 0x57c11db7 } }
+ , { "498a1e0b39fa49582ae688cd715c86fbaf8a81b8b11b4d1594c49c902d197c8ba8a621fd6e3be5",
+ { 0xcff2290b, 0x3648ba28, 0x31b98dde, 0x436a72f9, 0xebf51eee } }
+ , { "3a36ae71521f9af628b3e34dcb0d4513f84c78ee49f10416a98857150b8b15cb5c83afb4b570376e",
+ { 0x9b4efe9d, 0x27b96590, 0x5b0c3dab, 0x67b8d7c9, 0xebacd56c } }
+ , { "dcc76b40ae0ea3ba253e92ac50fcde791662c5b6c948538cffc2d95e9de99cac34dfca38910db2678f",
+ { 0xafedb0ff, 0x156205bc, 0xd831cbdb, 0xda43db8b, 0x0588c113 } }
+ , { "5b5ec6ec4fd3ad9c4906f65c747fd4233c11a1736b6b228b92e90cddabb0c7c2fcf9716d3fad261dff33",
+ { 0x8deb1e85, 0x8f88293a, 0x5e5e4d52, 0x1a34b2a4, 0xefa70fc4 } }
+ , { "df48a37b29b1d6de4e94717d60cdb4293fcf170bba388bddf7a9035a15d433f20fd697c3e4c8b8c5f590ab",
+ { 0x95cbdac0, 0xf74afa69, 0xcebd0e5c, 0x7defbc6f, 0xaf0cbeaf } }
+ , { "1f179b3b82250a65e1b0aee949e218e2f45c7a8dbfd6ba08de05c55acfc226b48c68d7f7057e5675cd96fcfc",
+ { 0xf0307bcb, 0x92842e5a, 0xe0cd4f4f, 0x14f3df7f, 0x877fbef2 } }
+ , { "ee3d72da3a44d971578972a8e6780ce64941267e0f7d0179b214fa97855e1790e888e09fbe3a70412176cb3b54",
+ { 0x7b13bb0d, 0xbf14964b, 0xd63b133a, 0xc85e2210, 0x0542ef55 } }
+ , { "d4d4c7843d312b30f610b3682254c8be96d5f6684503f8fbfbcd15774fc1b084d3741afb8d24aaa8ab9c104f7258",
+ { 0xc314d2b6, 0xcf439be6, 0x78d2a74e, 0x890d96cf, 0xac1c02ed } }
+ , { "32c094944f5936a190a0877fb9178a7bf60ceae36fd530671c5b38c5dbd5e6a6c0d615c2ac8ad04b213cc589541cf6",
+ { 0x4d0be361, 0xe410b47a, 0x9d67d8ce, 0x0bb6a8e0, 0x1c53c078 } }
+ , { "e5d3180c14bf27a5409fa12b104a8fd7e9639609bfde6ee82bbf9648be2546d29688a65e2e3f3da47a45ac14343c9c02",
+ { 0xe5353431, 0xffae097f, 0x675cbf49, 0x8869f6fb, 0xb6e1c9f2 } }
+ , { "e7b6e4b69f724327e41e1188a37f4fe38b1dba19cbf5a7311d6e32f1038e97ab506ee05aebebc1eed09fc0e357109818b9",
+ { 0xb8720a70, 0x68a085c0, 0x18ab1896, 0x1de2765a, 0xa6cd9ac4 } }
+ , { "bc880cb83b8ac68ef2fedc2da95e7677ce2aa18b0e2d8b322701f67af7d5e7a0d96e9e33326ccb7747cfff0852b961bfd475",
+ { 0xb0732181, 0x568543ba, 0x85f2b6da, 0x602b4b06, 0x5d9931aa } }
+ , { "235ea9c2ba7af25400f2e98a47a291b0bccdaad63faa2475721fda5510cc7dad814bce8dabb611790a6abe56030b798b75c944",
+ { 0x9c22674c, 0xf3222c3b, 0xa9216726, 0x94aafee4, 0xce67b96b } }
+ , { "07e3e29fed63104b8410f323b975fd9fba53f636af8c4e68a53fb202ca35dd9ee07cb169ec5186292e44c27e5696a967f5e67709",
+ { 0xd128335f, 0x4cecca90, 0x66cdae08, 0x958ce656, 0xff0b4cfc } }
+ , { "65d2a1dd60a517eb27bfbf530cf6a5458f9d5f4730058bd9814379547f34241822bf67e6335a6d8b5ed06abf8841884c636a25733f",
+ { 0x0b67c57a, 0xc578de88, 0xa2ae055c, 0xaeaec8bb, 0x9b0085a0 } }
+ , { "dcc86b3bd461615bab739d8daafac231c0f462e819ad29f9f14058f3ab5b75941d4241ea2f17ebb8a458831b37a9b16dead4a76a9b0e",
+ { 0xc766f912, 0xa89d4ccd, 0xa88e0cce, 0x6a713ef5, 0xf178b596 } }
+ , { "4627d54f0568dc126b62a8c35fb46a9ac5024400f2995e51635636e1afc4373dbb848eb32df23914230560b82477e9c3572647a7f2bb92",
+ { 0x9aa3925a, 0x9dcb177b, 0x15ccff9b, 0x78e70cf3, 0x44858779 } }
+ , { "ba531affd4381168ef24d8b275a84d9254c7f5cc55fded53aa8024b2c5c5c8aa7146fe1d1b83d62b70467e9a2e2cb67b3361830adbab28d7",
+ { 0x4811fa30, 0x042fc076, 0xacf37c8e, 0x2274d025, 0x307e5943 } }
+ , { "8764dcbcf89dcf4282eb644e3d568bdccb4b13508bfa7bfe0ffc05efd1390be22109969262992d377691eb4f77f3d59ea8466a74abf57b2ef4",
+ { 0x67430184, 0x50c97307, 0x61ee2b13, 0x0df9b91c, 0x1e118150 } }
+ , { "497d9df9ddb554f3d17870b1a31986c1be277bc44feff713544217a9f579623d18b5ffae306c25a45521d2759a72c0459b58957255ab592f3be4",
+ { 0x71ad4a19, 0xd37d92a5, 0xe6ef3694, 0xddbeb5aa, 0x61ada645 } }
+ , { "72c3c2e065aefa8d9f7a65229e818176eef05da83f835107ba90ec2e95472e73e538f783b416c04654ba8909f26a12db6e5c4e376b7615e4a25819",
+ { 0xa7d9dc68, 0xdacefb7d, 0x61161860, 0x48cb355c, 0xc548e11d } }
+ , { "7cc9894454d0055ab5069a33984e2f712bef7e3124960d33559f5f3b81906bb66fe64da13c153ca7f5cabc89667314c32c01036d12ecaf5f9a78de98",
+ { 0x142e429f, 0x0522ba5a, 0xbf5131fa, 0x81df82d3, 0x55b96909 } }
+ , { "74e8404d5a453c5f4d306f2cfa338ca65501c840ddab3fb82117933483afd6913c56aaf8a0a0a6b2a342fc3d9dc7599f4a850dfa15d06c61966d74ea59",
+ { 0xef72db70, 0xdcbcab99, 0x1e963797, 0x6c6faf00, 0xd22caae9 } }
+ , { "46fe5ed326c8fe376fcc92dc9e2714e2240d3253b105adfbb256ff7a19bc40975c604ad7c0071c4fd78a7cb64786e1bece548fa4833c04065fe593f6fb10",
+ { 0xf220a745, 0x7f4588d6, 0x39dc2140, 0x7c942e98, 0x43f8e26b } }
+ , { "836dfa2524d621cf07c3d2908835de859e549d35030433c796b81272fd8bc0348e8ddbc7705a5ad1fdf2155b6bc48884ac0cd376925f069a37849c089c8645",
+ { 0xddd2117b, 0x6e309c23, 0x3ede85f9, 0x62a0c2fc, 0x215e5c69 } }
+ , { "7e3a4c325cb9c52b88387f93d01ae86d42098f5efa7f9457388b5e74b6d28b2438d42d8b64703324d4aa25ab6aad153ae30cd2b2af4d5e5c00a8a2d0220c6116",
+ { 0xa3054427, 0xcdb13f16, 0x4a610b34, 0x8702724c, 0x808a0dcc } }
+ };
+
+ char const xdigits[17] = "0123456789abcdef";
+ char const*const xdigits_end = xdigits+16;
+
+ for (std::size_t i=0; i!=sizeof(cases)/sizeof(cases[0]); ++i) {
+ test_case const& tc = cases[i];
+
+ boost::uuids::detail::sha1 sha;
+ std::size_t message_length = std::strlen(tc.message);
+ BOOST_CHECK_EQUAL(message_length%2, 0u);
+
+ for (std::size_t b=0; b!=message_length; b+=2) {
+ char c = tc.message[b];
+ char const* f = std::find(xdigits, xdigits_end, c);
+ BOOST_CHECK(f != xdigits_end);
+
+ unsigned char byte = static_cast<unsigned char>(std::distance(&xdigits[0], f));
+
+ c = tc.message[b+1];
+ f = std::find(xdigits, xdigits_end, c);
+ BOOST_CHECK(f != xdigits_end);
+
+ byte <<= 4;
+ byte |= static_cast<unsigned char>(std::distance(&xdigits[0], f));
+
+ sha.process_byte(byte);
+ }
+
+ unsigned int digest[5];
+ sha.get_digest(digest);
+
+ BOOST_CHECK_EQUAL_COLLECTIONS(digest, digest+5, tc.digest, tc.digest+5);
+ }
+}

Added: trunk/libs/uuid/test/test_tagging.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_tagging.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,80 @@
+// (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/test_tagging.cpp -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/test_tools.hpp>
+
+class object
+{
+public:
+ object()
+ : tag(boost::uuids::random_generator()())
+ , state(0)
+ {}
+
+ explicit object(int state)
+ : tag(boost::uuids::random_generator()())
+ , state(state)
+ {}
+
+ object(object const& rhs)
+ : tag(rhs.tag)
+ , state(rhs.state)
+ {}
+
+ bool operator==(object const& rhs) const {
+ return tag == rhs.tag;
+ }
+
+ object& operator=(object const& rhs) {
+ tag = rhs.tag;
+ state = rhs.state;
+ }
+
+ int get_state() const { return state; }
+ void set_state(int new_state) { state = new_state; }
+
+private:
+ boost::uuids::uuid tag;
+
+ int state;
+};
+
+template <typename elem, typename traits>
+std::basic_ostream<elem, traits>& operator<<(std::basic_ostream<elem, traits>& os, object const& o)
+{
+ os << o.get_state();
+ return os;
+}
+
+int test_main(int, char*[])
+{
+ //using boost::test_tools::output_test_stream;
+
+ object o1(1);
+
+ object o2 = o1;
+ BOOST_CHECK_EQUAL(o1, o2);
+
+ o2.set_state(2);
+ BOOST_CHECK_EQUAL(o1, o2);
+
+ object o3;
+ o3.set_state(3);
+
+ BOOST_CHECK_NE(o1, o3);
+ BOOST_CHECK_NE(o2, o3);
+
+ return 0;
+}

Added: trunk/libs/uuid/test/test_uuid.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_uuid.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,178 @@
+// (C) Copyright Andy Tompkins 2007. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/test_uuid.cpp -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/test_tools.hpp>
+
+#include <boost/functional/hash.hpp>
+
+#include <boost/uuid/uuid_io.hpp>
+
+int test_main(int, char*[])
+{
+ using namespace boost::uuids;
+ using boost::test_tools::output_test_stream;
+
+ // uuid::static_size
+ BOOST_CHECK_EQUAL(uuid::static_size, 16U);
+
+ { // uuid::operator=()
+ uuid u1 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ uuid u2 = u1;
+ BOOST_CHECK_EQUAL(u2, u1);
+ }
+
+ { // uuid::begin(), end()
+ uuid u = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ unsigned char values[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ BOOST_CHECK_EQUAL_COLLECTIONS(u.begin(), u.end(), values, values+16);
+ }
+
+ { // uuid::begin() const, end() const
+ const uuid u = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ unsigned char values[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ BOOST_CHECK_EQUAL_COLLECTIONS(u.begin(), u.end(), values, values+16);
+ }
+
+ { // uuid::size()
+ uuid u; // uninitialized
+ BOOST_CHECK_EQUAL(u.size(), 16U);
+ }
+
+ { // uuid::is_nil()
+ uuid u1 = {0};
+ BOOST_CHECK_EQUAL(u1.is_nil(), true);
+
+ uuid u2 = {1,0};
+ BOOST_CHECK_EQUAL(u2.is_nil(), false);
+ }
+
+ { // uuid::variant()
+ struct Test {
+ unsigned char octet7;
+ boost::uuids::uuid::variant_type variant;
+ };
+ const Test tests[] =
+ { { 0x00, boost::uuids::uuid::variant_ncs }
+ , { 0x10, boost::uuids::uuid::variant_ncs }
+ , { 0x20, boost::uuids::uuid::variant_ncs }
+ , { 0x30, boost::uuids::uuid::variant_ncs }
+ , { 0x40, boost::uuids::uuid::variant_ncs }
+ , { 0x50, boost::uuids::uuid::variant_ncs }
+ , { 0x60, boost::uuids::uuid::variant_ncs }
+ , { 0x70, boost::uuids::uuid::variant_ncs }
+ , { 0x80, boost::uuids::uuid::variant_rfc_4122 }
+ , { 0x90, boost::uuids::uuid::variant_rfc_4122 }
+ , { 0xa0, boost::uuids::uuid::variant_rfc_4122 }
+ , { 0xb0, boost::uuids::uuid::variant_rfc_4122 }
+ , { 0xc0, boost::uuids::uuid::variant_microsoft }
+ , { 0xd0, boost::uuids::uuid::variant_microsoft }
+ , { 0xe0, boost::uuids::uuid::variant_future }
+ , { 0xf0, boost::uuids::uuid::variant_future }
+ };
+ for (int i=0; i<sizeof(tests)/sizeof(Test); i++) {
+ uuid u = {};
+ u.data[8] = tests[i].octet7; // note that octet7 is array index 8
+
+ BOOST_CHECK_EQUAL(u.variant(), tests[i].variant);
+ }
+ }
+
+ { // uuid::version()
+ struct Test {
+ unsigned char octet9;
+ boost::uuids::uuid::version_type version;
+ };
+ const Test tests[] =
+ { { 0x00, boost::uuids::uuid::version_unknown }
+ , { 0x10, boost::uuids::uuid::version_time_based }
+ , { 0x20, boost::uuids::uuid::version_dce_security }
+ , { 0x30, boost::uuids::uuid::version_name_based_md5 }
+ , { 0x40, boost::uuids::uuid::version_random_number_based }
+ , { 0x50, boost::uuids::uuid::version_name_based_sha1 }
+ , { 0x60, boost::uuids::uuid::version_unknown }
+ , { 0x70, boost::uuids::uuid::version_unknown }
+ , { 0x80, boost::uuids::uuid::version_unknown }
+ , { 0x90, boost::uuids::uuid::version_unknown }
+ , { 0xa0, boost::uuids::uuid::version_unknown }
+ , { 0xb0, boost::uuids::uuid::version_unknown }
+ , { 0xc0, boost::uuids::uuid::version_unknown }
+ , { 0xd0, boost::uuids::uuid::version_unknown }
+ , { 0xe0, boost::uuids::uuid::version_unknown }
+ , { 0xf0, boost::uuids::uuid::version_unknown }
+ };
+ for (int i=0; i<sizeof(tests)/sizeof(Test); i++) {
+ uuid u = {};
+ u.data[6] = tests[i].octet9; // note that octet9 is array index 8
+
+ BOOST_CHECK_EQUAL(u.version(), tests[i].version);
+ }
+ }
+
+ { // uuid::swap(), swap()
+ uuid u1 = {0};
+ uuid u2 = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ u1.swap(u2);
+
+ unsigned char values1[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+ unsigned char values2[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ BOOST_CHECK_EQUAL_COLLECTIONS(u1.begin(), u1.end(), values2, values2+16);
+ BOOST_CHECK_EQUAL_COLLECTIONS(u2.begin(), u2.end(), values1, values1+16);
+
+ swap(u1, u2);
+ BOOST_CHECK_EQUAL_COLLECTIONS(u1.begin(), u1.end(), values1, values1+16);
+ BOOST_CHECK_EQUAL_COLLECTIONS(u2.begin(), u2.end(), values2, values2+16);
+ }
+
+ { // test comparsion
+ uuid u1 = {0};
+ uuid u2 = {1,0};
+ uuid u3 = {255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255};
+
+ BOOST_CHECK_EQUAL(u1, u1);
+
+ BOOST_CHECK_NE(u1, u2);
+
+ BOOST_CHECK_LT(u1, u2);
+ BOOST_CHECK_LT(u2, u3);
+
+ BOOST_CHECK_LE(u1, u1);
+ BOOST_CHECK_LE(u1, u2);
+ BOOST_CHECK_LE(u2, u3);
+
+ BOOST_CHECK_GT(u2, u1);
+ BOOST_CHECK_GT(u3, u1);
+
+ BOOST_CHECK_GE(u3, u3);
+ BOOST_CHECK_GE(u2, u1);
+ BOOST_CHECK_GE(u3, u1);
+ }
+
+ { // test hash
+ uuid u1 = {0};
+ uuid u2 = {1,0};
+ uuid u3 = {255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255};
+
+ boost::hash<uuid> uuid_hasher;
+
+ BOOST_CHECK_EQUAL(uuid_hasher(u1), 3565488559U);
+ BOOST_CHECK_EQUAL(uuid_hasher(u2), 1668670635U);
+ BOOST_CHECK_EQUAL(uuid_hasher(u3), 223353791U);
+ }
+
+ { // test is_pod
+ BOOST_CHECK_EQUAL(boost::is_pod<uuid>::value, true);
+ }
+
+ return 0;
+}

Added: trunk/libs/uuid/test/test_uuid_class.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_uuid_class.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,51 @@
+// (C) Copyright Andy Tompkins 2009. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// libs/uuid/test/test_uuid_class.cpp -------------------------------//
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/test_tools.hpp>
+
+class uuid_class : public boost::uuids::uuid
+{
+public:
+ uuid_class()
+ : boost::uuids::uuid(boost::uuids::random_generator()())
+ {}
+
+ explicit uuid_class(boost::uuids::uuid const& u)
+ : boost::uuids::uuid(u)
+ {}
+
+ operator boost::uuids::uuid() {
+ return static_cast<boost::uuids::uuid&>(*this);
+ }
+
+ operator boost::uuids::uuid() const {
+ return static_cast<boost::uuids::uuid const&>(*this);
+ }
+};
+
+int test_main(int, char*[])
+{
+ uuid_class u1;
+ uuid_class u2;
+ BOOST_CHECK_NE(u1, u2);
+ BOOST_CHECK_EQUAL(u1.is_nil(), false);
+ BOOST_CHECK_EQUAL(u2.is_nil(), false);
+
+ u2 = u1;
+ BOOST_CHECK_EQUAL(u1, u2);
+
+ return 0;
+}

Added: trunk/libs/uuid/test/test_wserialization.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/test/test_wserialization.cpp 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,72 @@
+// (C) Copyright Andy Tompkins 2008. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+// 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)
+
+// Purpose to test serializing uuids with wide stream archives
+
+#include <boost/test/included/test_exec_monitor.hpp>
+#include <boost/test/test_tools.hpp>
+#include <sstream>
+#include <iostream>
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_serialize.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <boost/archive/text_woarchive.hpp>
+#include <boost/archive/text_wiarchive.hpp>
+
+#include <boost/archive/xml_woarchive.hpp>
+#include <boost/archive/xml_wiarchive.hpp>
+
+#include <boost/archive/binary_woarchive.hpp>
+#include <boost/archive/binary_wiarchive.hpp>
+
+template <class OArchiveType, class IArchiveType, class OStringStreamType, class IStringStreamType>
+void test_archive()
+{
+ using namespace std;
+ using namespace boost::uuids;
+
+ OStringStreamType o_stream;
+
+ uuid u1 = {0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef};
+
+ uuid u2;
+
+ // save
+ {
+ OArchiveType oa(o_stream);
+
+ oa << BOOST_SERIALIZATION_NVP(u1);
+ }
+
+ //wcout << "stream:" << o_stream.str() << "\n\n";
+
+ // load
+ {
+ IStringStreamType i_stream(o_stream.str());
+ IArchiveType ia(i_stream);
+
+ ia >> BOOST_SERIALIZATION_NVP(u2);
+ }
+
+ BOOST_CHECK_EQUAL(u1, u2);
+}
+
+int test_main( int /* argc */, char* /* argv */[] )
+{
+ using namespace std;
+ using namespace boost::archive;
+
+ test_archive<text_woarchive, text_wiarchive, wostringstream, wistringstream>();
+ test_archive<xml_woarchive, xml_wiarchive, wostringstream, wistringstream>();
+ test_archive<binary_woarchive, binary_wiarchive, wostringstream, wistringstream>();
+
+ return 0;
+}

Added: trunk/libs/uuid/uuid.html
==============================================================================
--- (empty file)
+++ trunk/libs/uuid/uuid.html 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -0,0 +1,470 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<title>Uuid Library</title>
+</head>
+<body>
+<h1><img src="../../boost.png" alt="boost.png (6897 bytes)"
+ align="center" WIDTH="277" HEIGHT="86">
+Uuid</h1>
+
+<h2><a name="Contents">Contents</h2>
+
+<ol>
+ <li>Introduction</li>
+ <li>Class uuid synopsis</li>
+ <li>Rationale</li>
+ <li>Interface</li>
+ <ul>
+ <li>Operators</li>
+ <li>Input and Output</li>
+ <li>Nil uuid</li>
+ <li>Byte Extraction</li>
+ <li>Hash Function</li>
+ <li>Generation</li>
+ </ul>
+ <li>Serialization</li>
+ <li>Design notes</li>
+ <li>References</li>
+ <li>History and Acknowledgements</li>
+</ol>
+
+<h2><a name="Introduction">Introduction</h2>
+UUIDs are a 128 bit or 16 byte value. They are often
+used to tag objects. If a UUID is generated by one of the defined
+mechanisms, it is either guaranteed to be unique, different from all other
+generated UUIDs (that is, it has never been generated before and it will
+never be generated again), or it is extremely likely to be unique (depending
+on the mechanism).
+<pre>
+// example of tagging an object with a uuid
+// see boost/libs/uuid/test/test_tagging.cpp
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+
+class object
+{
+public:
+ object()
+ : tag(boost::uuids::random_generator()())
+ , state(0)
+ {}
+
+ explicit object(int state)
+ : tag(boost::uuids::random_generator()())
+ , state(state)
+ {}
+
+ object(object const& rhs)
+ : tag(rhs.tag)
+ , state(rhs.state)
+ {}
+
+ bool operator==(object const& rhs) const {
+ return tag == rhs.tag;
+ }
+
+ object& operator=(object const& rhs) {
+ tag = rhs.tag;
+ state = rhs.state;
+ }
+
+ int get_state() const { return state; }
+ void set_state(int new_state) { state = new_state; }
+
+private:
+ boost::uuids::uuid tag;
+
+ int state;
+};
+
+object o1(1);
+object o2 = o1;
+o2.set_state(2);
+assert(o1 == o2);
+
+object o3(3);
+assert(o1 != o3);
+assert(o2 != o3);
+</pre>
+<p>
+This library implements a UUID as a POD allowing a UUID
+to be used in the most efficient ways, including using memcpy,
+and aggregate initializers. A drawback is that a POD can
+not have any constructors, and thus declaring a UUID will not
+initialize it to a value generated by one of the defined
+mechanisms. But a class based on a UUID can be defined
+that does initialize itself to a value generated by one of
+the defined mechanisms.
+<pre>
+// example using memcpy and aggregate initializers
+// example of a class uuid see boost/libs/uuid/test/test_uuid_class.cpp
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+
+{ // example using memcpy
+ unsigned char uuid_data[16];
+ // fill uuid_data
+
+ boost::uuids::uuid u;
+
+ memcpy(&u, uuid_data, 16);
+}
+
+{ // example using aggregate initializers
+ boost::uuids::uuid u =
+ { 0x12 ,0x34, 0x56, 0x78
+ , 0x90, 0xab
+ , 0xcd, 0xef
+ , 0x12, 0x34
+ , 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef
+ };
+}
+
+// example of creating a uuid class that
+// initializes the uuid in the constructor
+// using a defined mechanism
+
+class uuid_class : public boost::uuids::uuid
+{
+public:
+ uuid_class()
+ : boost::uuids::uuid(boost::uuids::random_generator()())
+ {}
+
+ explicit uuid_class(boost::uuids::uuid const& u)
+ : boost::uuids::uuid(u)
+ {}
+
+ operator boost::uuids::uuid() {
+ return static_cast<boost::uuids::uuid&>(*this);
+ }
+
+ operator boost::uuids::uuid() const {
+ return static_cast<boost::uuids::uuid const&>(*this);
+ }
+};
+
+uuid_class u1;
+uuid_class u2;
+
+assert(u1 != u2);
+</pre>
+
+<h2><a name="Class uuid synopsis">Class uuid synopsis</h2>
+<pre>
+#include <boost/uuid/uuid.hpp>
+
+namespace boost {
+namespace uuids {
+
+class uuid {
+public:
+ typedef uint8_t value_type;
+ typedef uint8_t& reference;
+ typedef uint8_t const& const_reference;
+ typedef uint8_t* iterator;
+ typedef uint8_t const* const_iterator;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+ enum { static_size = 16 };
+
+ // iteration
+ iterator begin();
+ iterator end();
+ const_iterator begin() const;
+ const_iterator end() const;
+
+ size_type size() const;
+
+ bool is_nil() const;
+
+ 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;
+
+ 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;
+
+ // Swap function
+ void swap(uuid& rhs);
+
+ uint8_t data[static_size];
+};
+
+// standard operators
+bool operator==(uuid const& lhs, uuid const& rhs);
+bool operator!=(uuid const& lhs, uuid const& rhs);
+bool operator<(uuid const& lhs, uuid const& rhs);
+bool operator>(uuid const& lhs, uuid const& rhs);
+bool operator<=(uuid const& lhs, uuid const& rhs);
+bool operator>=(uuid const& lhs, uuid const& rhs);
+
+void swap(uuid& lhs, uuid& rhs);
+
+std::size_t hash_value(uuid const& u);
+
+}} // namespace boost::uuids
+</pre>
+<pre>
+#include <boost/uuid/uuid_io.hpp>
+
+namespace boost {
+namespace uuids {
+
+template <typename ch, typename char_traits>
+ std::basic_ostream<ch, char_traits>& operator<<(std::basic_ostream<ch, char_traits> &os, uuid const& u);
+
+template <typename ch, typename char_traits>
+ std::basic_istream<ch, char_traits>& operator>>(std::basic_istream<ch, char_traits> &is, uuid &u);
+
+}} // namespace boost::uuids
+</pre>
+<pre>
+#include <boost/uuid/uuid_serialize.hpp>
+
+namespace boost {
+namespace uuids {
+
+BOOST_CLASS_IMPLEMENTATION(boost::uuids::uuid, boost::serialization::primitive_type)
+
+}} // namespace boost::uuids
+</pre>
+<pre>
+#include <boost/uuid/uuid_generators.hpp>
+
+namespace boost {
+namespace uuids {
+
+struct nil_generator {
+ typedef uuid result_type;
+
+ uuid operator()() const;
+};
+uuid nil_uuid();
+
+struct string_generator {
+ typedef uuid result_type;
+
+ template <typename ch, typename char_traits, typename alloc>
+ uuid operator()(std::basic_string<ch, char_traits, alloc> const& s) const;
+};
+
+class name_generator {
+public:
+ typedef uuid result_type;
+
+ explicit name_generator(uuid const& namespace_uuid);
+
+ uuid operator()(const char* name) const;
+ uuid operator()(const wchar_t* name) const;
+ tempate <typename ch, typename char_traits, typename alloc>
+ uuid operator()(std::basic_string<ch, char_traits, alloc> const& name) const;
+ uuid operator()(void const* buffer, std::size_t byte_count) const;
+};
+
+template <typename UniformRandomNumberGenerator>
+class basic_random_generator {
+public:
+ typedef uuid result_type;
+
+ basic_random_generator();
+ explicit basic_random_generator(UniformRandomNumberGenerator& gen);
+ explicit basic_random_generator(UniformRandomNumberGenerator* pGen);
+
+ uuid operator()();
+};
+typedef basic_random_generator<mt19937> random_generator;
+
+}} // namespace boost::uuids
+</pre>
+<h2><a name="Rationale">Rationale</h2>
+
+A UUID, or Universally unique identifier, is indended to uniquely identify
+information in a distributed environment without significant central
+coordination. It can be used to tag objects with very short lifetimes, or
+to reliably identify very persistent objects across a network.
+<p>
+UUIDs have many applications. Some examples follow: Databases may use UUIDs
+to identify rows or records in order to ensure that they are unique across
+different databases, or for publication/subscription services. Network messages
+may be identified with a UUID to ensure that different parts of a message are put
+back together again. Distributed computing may use UUIDs to identify a remote
+procedure call. Transactions and classes involved in serialization may be
+identified by UUIDs. Microsoft's component object model (COM) uses UUIDs to
+distinguish different software component interfaces. UUIDs are inserted into
+documents from Microsoft Office programs. UUIDs identify audio or
+video streams in the Advanced Systems Format (ASF). UUIDs are also a basis
+for OIDs (object identifiers), and URNs (uniform resource name).
+
+<p>
+An attractive feature of UUIDs when compared to alternatives is their relative
+small size, of 128-bits, or 16-bytes. Another is that the creation of UUIDs
+does not require a centralized authority.
+
+<h2><a name="Interface">Interface</h2>
+
+<h3><a name="Operators">Operators</h3>
+All of the standard numeric operators are defined for the <b>uuid</b>
+class. These include:
+<br>
+
+<pre>
+ operator==
+ operator!=
+ operator<
+ operator>
+ operator<=
+ operator>=
+</pre>
+
+<h3><a name="Input and Output">Input and Output</h3>
+Input and output stream operators <tt><<</tt> and <tt>>></tt>
+are provided by including boost/uuid/uuid_io.hpp.
+The external representation of a <b>uuid</b> is a string of
+hexidecimal digits of the following form:
+<br>
+hhhhhhhh-hhhh-hhhh-hhhh-hhhhhhhhhhhh
+
+<h3><a name="NilUuid">Nil uuid</h3>
+The function, <tt>boost::uuids::uuid::is_null()</tt> returns true if and
+only if the <b>uuid</b> is equal to {00000000-0000-0000-0000-000000000000}
+and returns false otherwise.
+Note that <tt>boost::uuids::uuid().is_null() == true</tt>.
+
+<h3><a name="ByteExtraction">Byte Extraction</h3>
+These functions are useful to get at the 16 bytes of a <b>uuid</b>. Typical use is as follows:
+
+<pre>
+boost::uuids::uuid u;
+std::vector<char> v(u.size());
+std::copy(u.begin(), u.end(), v.begin());
+</pre>
+
+<p>Note: <tt>boost::uuids::uuid::size()</tt> always returnes 16.
+
+<h3><a name="Hash">Hash Function</h3>
+This function allows <b>uuid</b>s to be used with
+boost::hash
+
+<pre>
+boost::hash<boost::uuids::uuid> uuid_hasher;
+std::size_t uuid_hash_value = uuid_hasher(boost::uuids::uuid());
+</pre>
+
+<h3><a name="Generation">Generation</h3>
+There are a number of classes provided that generate <b>uuid</b>s.
+<p>
+Include boost/uuid/uuid_generators.hpp.
+
+<p>
+The <tt>boost::uuids::nil_generator</tt> class always generates a nil <b>uuid</b>.
+<pre>
+boost::uuids::nil_generator gen;
+boost::uuids::uuid u = gen();
+assert(u.is_nil() == true);
+
+// or for convenience
+boost::uuids::uuid u = boost::uuids::nil_uuid();
+assert(u.is_nil() == true);
+</pre>
+
+The <tt>boost::uuids::string_generator</tt> class generates a uuid from a string.
+<pre>
+boost::uuids::string_generator gen;
+boost::uuids::uuid u1 = gen("{01234567-89ab-cdef-0123456789abcdef}");
+boost::uuids::uuid u2 = gen(L"01234567-89ab-cdef-0123456789abcdef");
+boost::uuids::uuid u3 = gen(std::string("0123456789abcdef0123456789abcdef"));
+boost::uuids::uuid u4 = gen(std::wstring(L"01234567-89ab-cdef-0123456789abcdef"));
+</pre>
+
+The <tt>boost::uuids::name_generator</tt> class generates a name based uuid from a
+namespace uuid and a name.
+<pre>
+boost::uuids::uuid dns_namespace_uuid; // initialize to {6ba7b810-9dad-11d1-80b4-00c04fd430c8}
+
+boost::uuids::name_generator gen(dns_namespace_uuid);
+boost::uuids::uuid u = gen("boost.org");
+</pre>
+
+The <tt>boost::uuids::basic_random_generator</tt> class generates a random number
+based uuid from a random number generator (one that conforms to the
+UniformRandomNumberGenerator
+concept).
+<pre>
+//default construct the random number generator and seed it
+boost::uuids::basic_random_generator<boost::mt19937> gen;
+boost::uuids::uuid u = gen();
+
+//for convenience boost::uuids::random_generator
+//is equivalent to boost::uuids::basic_random_generator<boost::mt19937>
+boost::uuids::random_generator gen;
+boost::uuids::uuid u = gen();
+
+//use an existing random number generator
+//pass either a reference or a pointer to the random number generator
+boost::mt19937 ran;
+boost::uuids::basic_random_generator<boost::mt19937> gen(&ran);
+boost::uuids::uuid u = gen();
+</pre>
+
+<h2><a name="Serialization">Serialization</h2>
+Serialization is accomplished with the <a href="http://www.boost.org/libs/serialization/doc/index.html">
+Boost Serialization</a> library. A <b>uuid</b> is serialized as a
+<a href="http://www.boost.org/libs/serialization/doc/serialization.html#primitiveoperators">
+primitive type</a>, thus only the <b>uuid</b> value will be saved to/loaded from an archive.
+<p>
+Include boost/uuid/uuid_serialize.hpp to enable serialization for <b>uuid</b>s.
+
+<h2><a name="Design notes">Design notes</h2>
+The document,<a href=http://www.itu.int/ITU-T/studygroups/com17/oid/X.667-E.pdf>
+http://www.itu.int/ITU-T/studygroups/com17/oid/X.667-E.pdf>, was used to design
+and implement the <b>boost::uuids::uuid</b> struct.
+
+<p>The <tt>boost::uuids::basic_random_generator</tt> class' default constructor
+seeds the random number generator with a SHA-1 hash of a number of different
+values including <tt>std::time(0)</tt>, <tt>std::clock()</tt>, uninitialized
+data, value return from <tt>new unsigned int</tt>, etc..
+
+<p>The <tt>boost::uuids::name_generator</tt> class uses the SHA-1 hash function to
+compute the <b>uuid</b>.
+
+<p>All functions are re-entrant. Classes are as thread-safe as an int. That is an
+instance can not be shared between threads without proper synchronization.
+
+<h2><a name="References">References</h2>
+<ul>
+<li>The uuid header: uuid.hpp
+<li>The test code: test_uuid.cpp,
+test_serialization.cpp,
+test_sha1.cpp
+</ul>
+
+<h2><a name="History and Acknowledgements">History and Acknowledgements</h2>
+
+A number of people on the boost.org
+mailing list provided useful comments and greatly helped to shape the library.
+
+<p>Revised  November 25, 2009</p>
+
+<hr>
+<p>© Copyright Andy Tompkins, 2006</p>
+<p> Distributed under the Boost Software
+License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>

Modified: trunk/status/Jamfile.v2
==============================================================================
--- trunk/status/Jamfile.v2 (original)
+++ trunk/status/Jamfile.v2 2009-11-27 23:16:43 EST (Fri, 27 Nov 2009)
@@ -135,6 +135,7 @@
     utility/enable_if/test # test-suite utility/enable_if
     utility/swap/test # test-suite utility/swap
     utility/test # test-suite utility
+ uuid/test # test-suite uuid
     variant/test # test-suite variant
     wave/test/build # test-suite wave
     xpressive/test # test-suite xpressive

Next message: dave_at_[hidden]: "[Boost-commit] svn:boost r57989 - in trunk: boost/iterator libs/iterator/test"
Previous message: ramey_at_[hidden]: "[Boost-commit] svn:boost r57987 - trunk/boost/serialization"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk