File uuid.h#

Defines

BOUT_UUID_H#
template<>
struct hash<uuids::uuid>#

Public Types

using argument_type = uuids::uuid#
using result_type = std::size_t#

Public Functions

inline result_type operator()(argument_type const &uuid) const#
namespace uuids#

Typedefs

using uuid_random_generator = basic_uuid_random_generator<std::mt19937>#

Enums

enum class uuid_variant#

Values:

enumerator ncs#
enumerator rfc#
enumerator microsoft#
enumerator reserved#
enum class uuid_version#

Values:

enumerator none#
enumerator time_based#
enumerator dce_security#
enumerator name_based_md5#
enumerator random_number_based#
enumerator name_based_sha1#

Functions

inline bool operator==(uuid const &lhs, uuid const &rhs) noexcept#
inline bool operator!=(uuid const &lhs, uuid const &rhs) noexcept#
inline bool operator<(uuid const &lhs, uuid const &rhs) noexcept#
template<class Elem, class Traits>
std::basic_ostream<Elem, Traits> &operator<<(std::basic_ostream<Elem, Traits> &s, uuid const &id)#
template<class CharT = char, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
inline std::basic_string<CharT, Traits, Allocator> to_string(uuid const &id)#
inline void swap(uuids::uuid &lhs, uuids::uuid &rhs) noexcept#

Variables

static uuid uuid_namespace_dns{{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}}#
static uuid uuid_namespace_url{{0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}}#
static uuid uuid_namespace_oid{{0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}}#
static uuid uuid_namespace_x500{{0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}}#
class uuid#

Public Types

using value_type = uint8_t#

Public Functions

inline constexpr uuid() noexcept#
inline uuid(value_type (&arr)[16]) noexcept#
inline uuid(std::array<value_type, 16> const &arr) noexcept#
template<typename ForwardIterator>
inline explicit uuid(ForwardIterator first, ForwardIterator last)#
inline constexpr uuid_variant variant() const noexcept#
inline constexpr uuid_version version() const noexcept#
inline constexpr bool is_nil() const noexcept#
inline void swap(uuid &other) noexcept#
inline char const *as_bytes() const#

Public Static Functions

template<class CharT = char>
static inline bool is_valid_uuid(CharT const *str) noexcept#
template<class CharT = char, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
static inline bool is_valid_uuid(std::basic_string<CharT, Traits, Allocator> const &str) noexcept#
template<class CharT = char>
static inline uuid from_string(CharT const *str) noexcept#
template<class CharT = char, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
static inline uuid from_string(std::basic_string<CharT, Traits, Allocator> const &str) noexcept#

Private Members

std::array<value_type, 16> data = {{0}}#

Friends

friend bool operator==(uuid const &lhs, uuid const &rhs) noexcept#
friend bool operator<(uuid const &lhs, uuid const &rhs) noexcept#
template<class Elem, class Traits>
friend std::basic_ostream<Elem, Traits> &operator<<(std::basic_ostream<Elem, Traits> &s, uuid const &id)#
class uuid_system_generator#

Public Types

using result_type = uuid#

Public Functions

inline uuid operator()()#
template<typename UniformRandomNumberGenerator>
class basic_uuid_random_generator#

Public Types

using engine_type = UniformRandomNumberGenerator#

Public Functions

inline explicit basic_uuid_random_generator(engine_type &gen)#
inline explicit basic_uuid_random_generator(engine_type *gen)#
inline uuid operator()()#

Private Members

std::uniform_int_distribution<uint32_t> distribution#
std::shared_ptr<UniformRandomNumberGenerator> generator#
class uuid_name_generator#

Public Functions

inline explicit uuid_name_generator(uuid const &namespace_uuid) noexcept#
template<class CharT = char>
inline uuid operator()(CharT const *name)#
template<class CharT = char, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
inline uuid operator()(std::basic_string<CharT, Traits, Allocator> const &name)#

Private Functions

inline void reset()#
template<typename char_type, typename = std::enable_if_t<std::is_integral<char_type>::value>>
inline void process_characters(char_type const *const characters, size_t const count)#
inline void process_characters(const char *const characters, size_t const count)#
inline uuid make_uuid()#

Private Members

uuid nsuuid#
detail::sha1 hasher#
class uuid_time_generator#

Public Functions

inline uuid_time_generator()#
inline uuid operator()()#

Private Types

using mac_address = std::array<unsigned char, 6>#

Private Functions

inline bool get_mac_address()#
inline long long get_time_intervals()#

Private Members

mac_address device_address#
bool has_mac_address = false#
namespace detail#

Functions

template<typename TChar>
inline constexpr unsigned char hex2char(TChar const ch)#
template<typename TChar>
inline constexpr bool is_hex(TChar const ch)#
template<typename TChar>
inline constexpr unsigned char hexpair2char(TChar const a, TChar const b)#
static std::mt19937 clock_gen (std::random_device{}())

Variables

static std::uniform_int_distribution<short> clock_dis = {-32768, 32767}#
static std::atomic_short clock_sequence = {clock_dis(clock_gen)}#
class sha1#

Public Types

using digest32_t = uint32_t[5]#
using digest8_t = uint8_t[20]#

Public Functions

inline sha1()#
inline void reset()#
inline void process_byte(uint8_t octet)#
inline void process_block(void const *const start, void const *const end)#
inline void process_bytes(void const *const data, size_t const len)#
inline uint32_t const *get_digest(digest32_t digest)#
inline uint8_t const *get_digest_bytes(digest8_t digest)#

Public Static Functions

static inline uint32_t left_rotate(uint32_t value, size_t const count)#

Public Static Attributes

static constexpr unsigned int block_bytes = 64#

Private Functions

inline void process_block()#

Private Members

digest32_t m_digest#
uint8_t m_block[64]#
size_t m_blockByteIndex#
size_t m_byteCount#
namespace std#

STL namespace.

template<> uuid >

Public Types

using argument_type = uuids::uuid#
using result_type = std::size_t#

Public Functions

inline result_type operator()(argument_type const &uuid) const#