| // 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 |
| // 28 Nov 2009 - disabled deprecated warnings for MSVC |
| // 30 Nov 2009 - used BOOST_STATIC_CONSTANT |
| // 02 Dec 2009 - removed BOOST_STATIC_CONSTANT - not all compilers like it |
| |
| #ifndef BOOST_UUID_HPP |
| #define BOOST_UUID_HPP |
| |
| #include <boost/config.hpp> |
| #include <stddef.h> |
| #include <boost/cstdint.hpp> |
| #include <algorithm> |
| #include <boost/config.hpp> // for static assert |
| #ifndef BOOST_UUID_NO_TYPE_TRAITS |
| #include <boost/type_traits/is_pod.hpp> |
| #include <boost/type_traits/integral_constant.hpp> |
| #endif |
| |
| #if defined(_MSC_VER) |
| #pragma warning(push) // Save warning settings. |
| #pragma warning(disable : 4996) // Disable deprecated std::swap_ranges, std::equal |
| #endif |
| |
| #ifdef BOOST_NO_STDC_NAMESPACE |
| 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; |
| |
| // This does not work on some compilers |
| // They seem to want the variable definec in |
| // a cpp file |
| //BOOST_STATIC_CONSTANT(size_type, static_size = 16); |
| static size_type static_size() { return 16; } |
| |
| 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() */ |
| { |
| for(size_t i=0; i<static_size(); i++) { |
| if (data[i] != 0U) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| 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[16]; |
| }; |
| |
| 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 |
| |
| #ifndef BOOST_UUID_NO_TYPE_TRAITS |
| // type traits specializations |
| namespace boost { |
| |
| template <> |
| struct is_pod<uuids::uuid> : true_type {}; |
| |
| } // namespace boost |
| #endif |
| |
| #if defined(_MSC_VER) |
| #pragma warning(pop) // Restore warnings to previous state. |
| #endif |
| |
| #endif // BOOST_UUID_HPP |