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 uuid_variant

Values:

enumerator ncs

enumerator rfc

enumerator microsoft

enumerator reserved

enum 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}}

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

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