877 lines
28 KiB
C++
877 lines
28 KiB
C++
#ifndef STDUUID_H
|
|
#define STDUUID_H
|
|
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
#include <array>
|
|
#include <string_view>
|
|
#include <iterator>
|
|
#include <random>
|
|
#include <memory>
|
|
#include <functional>
|
|
#include <type_traits>
|
|
#include <optional>
|
|
#include <chrono>
|
|
#include <numeric>
|
|
#include <atomic>
|
|
|
|
#ifdef __cplusplus
|
|
|
|
#if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
|
|
#define LIBUUID_CPP20_OR_GREATER
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#ifdef LIBUUID_CPP20_OR_GREATER
|
|
#include <span>
|
|
#else
|
|
#include <gsl/span>
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
|
|
#ifdef UUID_SYSTEM_GENERATOR
|
|
#include <objbase.h>
|
|
#endif
|
|
|
|
#ifdef UUID_TIME_GENERATOR
|
|
#include <iphlpapi.h>
|
|
#pragma comment(lib, "IPHLPAPI.lib")
|
|
#endif
|
|
|
|
#elif defined(__linux__) || defined(__unix__)
|
|
|
|
#ifdef UUID_SYSTEM_GENERATOR
|
|
#include <uuid/uuid.h>
|
|
#endif
|
|
|
|
#elif defined(__APPLE__)
|
|
|
|
#ifdef UUID_SYSTEM_GENERATOR
|
|
#include <CoreFoundation/CFUUID.h>
|
|
#endif
|
|
|
|
#endif
|
|
|
|
namespace uuids {
|
|
#ifdef __cpp_lib_span
|
|
template <class ElementType, std::size_t Extent>
|
|
using span = std::span<ElementType, Extent>;
|
|
#else
|
|
template <class ElementType, std::ptrdiff_t Extent>
|
|
using span = gsl::span<ElementType, Extent>;
|
|
#endif
|
|
|
|
namespace detail {
|
|
template <typename TChar>
|
|
[[nodiscard]] constexpr inline unsigned char hex2char(TChar const ch) noexcept {
|
|
if (ch >= static_cast<TChar>('0') && ch <= static_cast<TChar>('9'))
|
|
return static_cast<unsigned char>(ch - static_cast<TChar>('0'));
|
|
if (ch >= static_cast<TChar>('a') && ch <= static_cast<TChar>('f'))
|
|
return static_cast<unsigned char>(10 + ch - static_cast<TChar>('a'));
|
|
if (ch >= static_cast<TChar>('A') && ch <= static_cast<TChar>('F'))
|
|
return static_cast<unsigned char>(10 + ch - static_cast<TChar>('A'));
|
|
return 0;
|
|
}
|
|
|
|
template <typename TChar>
|
|
[[nodiscard]] constexpr inline bool is_hex(TChar const ch) noexcept {
|
|
return (ch >= static_cast<TChar>('0') && ch <= static_cast<TChar>('9')) ||
|
|
(ch >= static_cast<TChar>('a') && ch <= static_cast<TChar>('f')) ||
|
|
(ch >= static_cast<TChar>('A') && ch <= static_cast<TChar>('F'));
|
|
}
|
|
|
|
template <typename TChar>
|
|
[[nodiscard]] constexpr std::basic_string_view<TChar>
|
|
to_string_view(TChar const *str) noexcept {
|
|
if (str)
|
|
return str;
|
|
return {};
|
|
}
|
|
|
|
template <typename StringType>
|
|
[[nodiscard]] constexpr std::basic_string_view<typename StringType::value_type,
|
|
typename StringType::traits_type>
|
|
to_string_view(StringType const &str) noexcept {
|
|
return str;
|
|
}
|
|
|
|
class sha1 {
|
|
public:
|
|
using digest32_t = uint32_t[5];
|
|
using digest8_t = uint8_t[20];
|
|
|
|
static constexpr unsigned int block_bytes = 64;
|
|
|
|
[[nodiscard]] inline static uint32_t
|
|
left_rotate(uint32_t value, size_t const count) noexcept {
|
|
return (value << count) ^ (value >> (32 - count));
|
|
}
|
|
|
|
sha1() { reset(); }
|
|
|
|
void reset() noexcept {
|
|
m_digest[0] = 0x67452301;
|
|
m_digest[1] = 0xEFCDAB89;
|
|
m_digest[2] = 0x98BADCFE;
|
|
m_digest[3] = 0x10325476;
|
|
m_digest[4] = 0xC3D2E1F0;
|
|
m_blockByteIndex = 0;
|
|
m_byteCount = 0;
|
|
}
|
|
|
|
void process_byte(uint8_t octet) {
|
|
this->m_block[this->m_blockByteIndex++] = octet;
|
|
++this->m_byteCount;
|
|
if (m_blockByteIndex == block_bytes) {
|
|
this->m_blockByteIndex = 0;
|
|
process_block();
|
|
}
|
|
}
|
|
|
|
void process_block(void const *const start, void const *const end) {
|
|
const uint8_t *begin = static_cast<const uint8_t *>(start);
|
|
const uint8_t *finish = static_cast<const uint8_t *>(end);
|
|
while (begin != finish) {
|
|
process_byte(*begin);
|
|
begin++;
|
|
}
|
|
}
|
|
|
|
void process_bytes(void const *const data, size_t const len) {
|
|
const uint8_t *block = static_cast<const uint8_t *>(data);
|
|
process_block(block, block + len);
|
|
}
|
|
|
|
uint32_t const *get_digest(digest32_t digest) {
|
|
size_t const bitCount = this->m_byteCount * 8;
|
|
process_byte(0x80);
|
|
if (this->m_blockByteIndex > 56) {
|
|
while (m_blockByteIndex != 0) {
|
|
process_byte(0);
|
|
}
|
|
while (m_blockByteIndex < 56) {
|
|
process_byte(0);
|
|
}
|
|
} else {
|
|
while (m_blockByteIndex < 56) {
|
|
process_byte(0);
|
|
}
|
|
}
|
|
process_byte(0);
|
|
process_byte(0);
|
|
process_byte(0);
|
|
process_byte(0);
|
|
process_byte(static_cast<unsigned char>((bitCount >> 24) & 0xFF));
|
|
process_byte(static_cast<unsigned char>((bitCount >> 16) & 0xFF));
|
|
process_byte(static_cast<unsigned char>((bitCount >> 8) & 0xFF));
|
|
process_byte(static_cast<unsigned char>((bitCount)&0xFF));
|
|
|
|
memcpy(digest, m_digest, 5 * sizeof(uint32_t));
|
|
return digest;
|
|
}
|
|
|
|
uint8_t const *get_digest_bytes(digest8_t digest) {
|
|
digest32_t d32;
|
|
get_digest(d32);
|
|
size_t di = 0;
|
|
digest[di++] = static_cast<uint8_t>(d32[0] >> 24);
|
|
digest[di++] = static_cast<uint8_t>(d32[0] >> 16);
|
|
digest[di++] = static_cast<uint8_t>(d32[0] >> 8);
|
|
digest[di++] = static_cast<uint8_t>(d32[0] >> 0);
|
|
|
|
digest[di++] = static_cast<uint8_t>(d32[1] >> 24);
|
|
digest[di++] = static_cast<uint8_t>(d32[1] >> 16);
|
|
digest[di++] = static_cast<uint8_t>(d32[1] >> 8);
|
|
digest[di++] = static_cast<uint8_t>(d32[1] >> 0);
|
|
|
|
digest[di++] = static_cast<uint8_t>(d32[2] >> 24);
|
|
digest[di++] = static_cast<uint8_t>(d32[2] >> 16);
|
|
digest[di++] = static_cast<uint8_t>(d32[2] >> 8);
|
|
digest[di++] = static_cast<uint8_t>(d32[2] >> 0);
|
|
|
|
digest[di++] = static_cast<uint8_t>(d32[3] >> 24);
|
|
digest[di++] = static_cast<uint8_t>(d32[3] >> 16);
|
|
digest[di++] = static_cast<uint8_t>(d32[3] >> 8);
|
|
digest[di++] = static_cast<uint8_t>(d32[3] >> 0);
|
|
|
|
digest[di++] = static_cast<uint8_t>(d32[4] >> 24);
|
|
digest[di++] = static_cast<uint8_t>(d32[4] >> 16);
|
|
digest[di++] = static_cast<uint8_t>(d32[4] >> 8);
|
|
digest[di++] = static_cast<uint8_t>(d32[4] >> 0);
|
|
|
|
return digest;
|
|
}
|
|
|
|
private:
|
|
void process_block() {
|
|
uint32_t w[80];
|
|
for (size_t i = 0; i < 16; i++) {
|
|
w[i] = static_cast<uint32_t>(m_block[i * 4 + 0] << 24);
|
|
w[i] |= static_cast<uint32_t>(m_block[i * 4 + 1] << 16);
|
|
w[i] |= static_cast<uint32_t>(m_block[i * 4 + 2] << 8);
|
|
w[i] |= static_cast<uint32_t>(m_block[i * 4 + 3]);
|
|
}
|
|
for (size_t i = 16; i < 80; i++) {
|
|
w[i] = left_rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1);
|
|
}
|
|
|
|
uint32_t a = m_digest[0];
|
|
uint32_t b = m_digest[1];
|
|
uint32_t c = m_digest[2];
|
|
uint32_t d = m_digest[3];
|
|
uint32_t e = m_digest[4];
|
|
|
|
for (std::size_t i = 0; i < 80; ++i) {
|
|
uint32_t f = 0;
|
|
uint32_t k = 0;
|
|
|
|
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;
|
|
}
|
|
uint32_t temp = left_rotate(a, 5) + f + e + k + w[i];
|
|
e = d;
|
|
d = c;
|
|
c = left_rotate(b, 30);
|
|
b = a;
|
|
a = temp;
|
|
}
|
|
|
|
m_digest[0] += a;
|
|
m_digest[1] += b;
|
|
m_digest[2] += c;
|
|
m_digest[3] += d;
|
|
m_digest[4] += e;
|
|
}
|
|
|
|
private:
|
|
digest32_t m_digest;
|
|
uint8_t m_block[64];
|
|
size_t m_blockByteIndex;
|
|
size_t m_byteCount;
|
|
};
|
|
|
|
template <typename CharT>
|
|
inline constexpr CharT empty_guid[37] = "00000000-0000-0000-0000-000000000000";
|
|
|
|
template <>
|
|
inline constexpr wchar_t empty_guid<wchar_t>[37] =
|
|
L"00000000-0000-0000-0000-000000000000";
|
|
|
|
template <typename CharT>
|
|
inline constexpr CharT guid_encoder[17] = "0123456789abcdef";
|
|
|
|
template <>
|
|
inline constexpr wchar_t guid_encoder<wchar_t>[17] = L"0123456789abcdef";
|
|
} // namespace detail
|
|
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// UUID format https://tools.ietf.org/html/rfc4122
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// Field NDR Data Type Octet # Note
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// time_low unsigned long 0 - 3 The low field
|
|
// of the timestamp. time_mid unsigned short 4 - 5
|
|
// The middle field of the timestamp.
|
|
// time_hi_and_version unsigned short 6 - 7 The high
|
|
// field of the timestamp multiplexed with the version number.
|
|
// clock_seq_hi_and_reserved unsigned small 8 The high field of
|
|
// the clock sequence multiplexed with the variant. clock_seq_low
|
|
// unsigned small 9 The low field of the clock sequence. node
|
|
// character 10 - 15 The spatially unique node identifier.
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// 0 1 2 3
|
|
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
|
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
// | time_low |
|
|
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
// | time_mid | time_hi_and_version |
|
|
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
// |clk_seq_hi_res | clk_seq_low | node (0-1) |
|
|
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
// | node (2-5) |
|
|
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// enumerations
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// indicated by a bit pattern in octet 8, marked with N in
|
|
// xxxxxxxx-xxxx-xxxx-Nxxx-xxxxxxxxxxxx
|
|
enum class uuid_variant {
|
|
// NCS backward compatibility (with the obsolete Apollo Network Computing
|
|
// System 1.5 UUID format) N bit pattern: 0xxx > the first 6 octets of the
|
|
// UUID are a 48-bit timestamp (the number of 4 microsecond units of time
|
|
// since 1 Jan 1980 UTC); > the next 2 octets are reserved; > the next octet
|
|
// is the "address family"; > the final 7 octets are a 56-bit host ID in the
|
|
// form specified by the address family
|
|
ncs,
|
|
|
|
// RFC 4122/DCE 1.1
|
|
// N bit pattern: 10xx
|
|
// > big-endian byte order
|
|
rfc,
|
|
|
|
// Microsoft Corporation backward compatibility
|
|
// N bit pattern: 110x
|
|
// > little endian byte order
|
|
// > formely used in the Component Object Model (COM) library
|
|
microsoft,
|
|
|
|
// reserved for possible future definition
|
|
// N bit pattern: 111x
|
|
reserved
|
|
};
|
|
|
|
// indicated by a bit pattern in octet 6, marked with M in
|
|
// xxxxxxxx-xxxx-Mxxx-xxxx-xxxxxxxxxxxx
|
|
enum class uuid_version {
|
|
none = 0, // only possible for nil or invalid uuids
|
|
time_based = 1, // The time-based version specified in RFC 4122
|
|
dce_security = 2, // DCE Security version, with embedded POSIX UIDs.
|
|
name_based_md5 =
|
|
3, // The name-based version specified in RFS 4122 with MD5 hashing
|
|
random_number_based = 4, // The randomly or pseudo-randomly generated version
|
|
// specified in RFS 4122
|
|
name_based_sha1 =
|
|
5 // The name-based version specified in RFS 4122 with SHA1 hashing
|
|
};
|
|
|
|
// Forward declare uuid & to_string so that we can declare to_string as a friend
|
|
// later.
|
|
class uuid;
|
|
template <class CharT = char, class Traits = std::char_traits<CharT>,
|
|
class Allocator = std::allocator<CharT>>
|
|
std::basic_string<CharT, Traits, Allocator> to_string(uuid const &id);
|
|
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// uuid class
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
class uuid {
|
|
public:
|
|
using value_type = uint8_t;
|
|
|
|
constexpr uuid() noexcept = default;
|
|
|
|
uuid(value_type (&arr)[16]) noexcept {
|
|
std::copy(std::cbegin(arr), std::cend(arr), std::begin(data));
|
|
}
|
|
|
|
constexpr uuid(std::array<value_type, 16> const &arr) noexcept : data{arr} {}
|
|
|
|
explicit uuid(span<value_type, 16> bytes) {
|
|
std::copy(std::cbegin(bytes), std::cend(bytes), std::begin(data));
|
|
}
|
|
|
|
template <typename ForwardIterator>
|
|
explicit uuid(ForwardIterator first, ForwardIterator last) {
|
|
if (std::distance(first, last) == 16)
|
|
std::copy(first, last, std::begin(data));
|
|
}
|
|
|
|
[[nodiscard]] constexpr uuid_variant variant() const noexcept {
|
|
if ((data[8] & 0x80) == 0x00)
|
|
return uuid_variant::ncs;
|
|
else if ((data[8] & 0xC0) == 0x80)
|
|
return uuid_variant::rfc;
|
|
else if ((data[8] & 0xE0) == 0xC0)
|
|
return uuid_variant::microsoft;
|
|
else
|
|
return uuid_variant::reserved;
|
|
}
|
|
|
|
[[nodiscard]] constexpr uuid_version version() const noexcept {
|
|
if ((data[6] & 0xF0) == 0x10)
|
|
return uuid_version::time_based;
|
|
else if ((data[6] & 0xF0) == 0x20)
|
|
return uuid_version::dce_security;
|
|
else if ((data[6] & 0xF0) == 0x30)
|
|
return uuid_version::name_based_md5;
|
|
else if ((data[6] & 0xF0) == 0x40)
|
|
return uuid_version::random_number_based;
|
|
else if ((data[6] & 0xF0) == 0x50)
|
|
return uuid_version::name_based_sha1;
|
|
else
|
|
return uuid_version::none;
|
|
}
|
|
|
|
[[nodiscard]] constexpr bool is_nil() const noexcept {
|
|
for (size_t i = 0; i < data.size(); ++i)
|
|
if (data[i] != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void swap(uuid &other) noexcept { data.swap(other.data); }
|
|
|
|
[[nodiscard]] inline span<std::byte const, 16> as_bytes() const {
|
|
return span<std::byte const, 16>(
|
|
reinterpret_cast<std::byte const *>(data.data()), 16);
|
|
}
|
|
|
|
template <typename StringType>
|
|
[[nodiscard]] constexpr static bool
|
|
is_valid_uuid(StringType const &in_str) noexcept {
|
|
auto str = detail::to_string_view(in_str);
|
|
bool firstDigit = true;
|
|
size_t hasBraces = 0;
|
|
size_t index = 0;
|
|
|
|
if (str.empty())
|
|
return false;
|
|
|
|
if (str.front() == '{')
|
|
hasBraces = 1;
|
|
if (hasBraces && str.back() != '}')
|
|
return false;
|
|
|
|
for (size_t i = hasBraces; i < str.size() - hasBraces; ++i) {
|
|
if (str[i] == '-')
|
|
continue;
|
|
|
|
if (index >= 16 || !detail::is_hex(str[i])) {
|
|
return false;
|
|
}
|
|
|
|
if (firstDigit) {
|
|
firstDigit = false;
|
|
} else {
|
|
index++;
|
|
firstDigit = true;
|
|
}
|
|
}
|
|
|
|
if (index < 16) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename StringType>
|
|
[[nodiscard]] constexpr static std::optional<uuid>
|
|
from_string(StringType const &in_str) noexcept {
|
|
auto str = detail::to_string_view(in_str);
|
|
bool firstDigit = true;
|
|
size_t hasBraces = 0;
|
|
size_t index = 0;
|
|
|
|
std::array<uint8_t, 16> data{{0}};
|
|
|
|
if (str.empty())
|
|
return {};
|
|
|
|
if (str.front() == '{')
|
|
hasBraces = 1;
|
|
if (hasBraces && str.back() != '}')
|
|
return {};
|
|
|
|
for (size_t i = hasBraces; i < str.size() - hasBraces; ++i) {
|
|
if (str[i] == '-')
|
|
continue;
|
|
|
|
if (index >= 16 || !detail::is_hex(str[i])) {
|
|
return {};
|
|
}
|
|
|
|
if (firstDigit) {
|
|
data[index] = static_cast<uint8_t>(detail::hex2char(str[i]) << 4);
|
|
firstDigit = false;
|
|
} else {
|
|
data[index] =
|
|
static_cast<uint8_t>(data[index] | detail::hex2char(str[i]));
|
|
index++;
|
|
firstDigit = true;
|
|
}
|
|
}
|
|
|
|
if (index < 16) {
|
|
return {};
|
|
}
|
|
|
|
return uuid{data};
|
|
}
|
|
|
|
private:
|
|
std::array<value_type, 16> data{{0}};
|
|
|
|
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);
|
|
|
|
template <class CharT, class Traits, class Allocator>
|
|
friend std::basic_string<CharT, Traits, Allocator> to_string(uuid const &id);
|
|
|
|
friend std::hash<uuid>;
|
|
};
|
|
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// operators and non-member functions
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
|
|
[[nodiscard]] inline bool operator==(uuid const &lhs,
|
|
uuid const &rhs) noexcept {
|
|
return lhs.data == rhs.data;
|
|
}
|
|
|
|
[[nodiscard]] inline bool operator!=(uuid const &lhs,
|
|
uuid const &rhs) noexcept {
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
[[nodiscard]] inline bool operator<(uuid const &lhs, uuid const &rhs) noexcept {
|
|
return lhs.data < rhs.data;
|
|
}
|
|
|
|
template <class CharT, class Traits, class Allocator>
|
|
[[nodiscard]] inline std::basic_string<CharT, Traits, Allocator>
|
|
to_string(uuid const &id) {
|
|
std::basic_string<CharT, Traits, Allocator> uustr{detail::empty_guid<CharT>};
|
|
|
|
for (size_t i = 0, index = 0; i < 36; ++i) {
|
|
if (i == 8 || i == 13 || i == 18 || i == 23) {
|
|
continue;
|
|
}
|
|
uustr[i] = detail::guid_encoder<CharT>[id.data[index] >> 4 & 0x0f];
|
|
uustr[++i] = detail::guid_encoder<CharT>[id.data[index] & 0x0f];
|
|
index++;
|
|
}
|
|
|
|
return uustr;
|
|
}
|
|
|
|
template <class Elem, class Traits>
|
|
std::basic_ostream<Elem, Traits> &
|
|
operator<<(std::basic_ostream<Elem, Traits> &s, uuid const &id) {
|
|
s << to_string(id);
|
|
return s;
|
|
}
|
|
|
|
inline void swap(uuids::uuid &lhs, uuids::uuid &rhs) noexcept { lhs.swap(rhs); }
|
|
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// namespace IDs that could be used for generating name-based uuids
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
|
|
// Name string is a fully-qualified domain name
|
|
static uuid uuid_namespace_dns{{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1,
|
|
0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30,
|
|
0xc8}};
|
|
|
|
// Name string is a URL
|
|
static uuid uuid_namespace_url{{0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1,
|
|
0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30,
|
|
0xc8}};
|
|
|
|
// Name string is an ISO OID (See https://oidref.com/,
|
|
// https://en.wikipedia.org/wiki/Object_identifier)
|
|
static uuid uuid_namespace_oid{{0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1,
|
|
0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30,
|
|
0xc8}};
|
|
|
|
// Name string is an X.500 DN, in DER or a text output format (See
|
|
// https://en.wikipedia.org/wiki/X.500,
|
|
// https://en.wikipedia.org/wiki/Abstract_Syntax_Notation_One)
|
|
static uuid uuid_namespace_x500{{0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1,
|
|
0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30,
|
|
0xc8}};
|
|
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
// uuid generators
|
|
// --------------------------------------------------------------------------------------------------------------------------
|
|
|
|
#ifdef UUID_SYSTEM_GENERATOR
|
|
class uuid_system_generator {
|
|
public:
|
|
using result_type = uuid;
|
|
|
|
uuid operator()() {
|
|
#ifdef _WIN32
|
|
|
|
GUID newId;
|
|
HRESULT hr = ::CoCreateGuid(&newId);
|
|
|
|
if (FAILED(hr)) {
|
|
throw std::system_error(hr, std::system_category(),
|
|
"CoCreateGuid failed");
|
|
}
|
|
|
|
std::array<uint8_t, 16> bytes = {
|
|
{static_cast<unsigned char>((newId.Data1 >> 24) & 0xFF),
|
|
static_cast<unsigned char>((newId.Data1 >> 16) & 0xFF),
|
|
static_cast<unsigned char>((newId.Data1 >> 8) & 0xFF),
|
|
static_cast<unsigned char>((newId.Data1) & 0xFF),
|
|
|
|
(unsigned char)((newId.Data2 >> 8) & 0xFF),
|
|
(unsigned char)((newId.Data2) & 0xFF),
|
|
|
|
(unsigned char)((newId.Data3 >> 8) & 0xFF),
|
|
(unsigned char)((newId.Data3) & 0xFF),
|
|
|
|
newId.Data4[0], newId.Data4[1], newId.Data4[2], newId.Data4[3],
|
|
newId.Data4[4], newId.Data4[5], newId.Data4[6], newId.Data4[7]}};
|
|
|
|
return uuid{std::begin(bytes), std::end(bytes)};
|
|
|
|
#elif defined(__linux__) || defined(__unix__)
|
|
|
|
uuid_t id;
|
|
uuid_generate(id);
|
|
|
|
std::array<uint8_t, 16> bytes = {{id[0], id[1], id[2], id[3], id[4], id[5],
|
|
id[6], id[7], id[8], id[9], id[10],
|
|
id[11], id[12], id[13], id[14], id[15]}};
|
|
|
|
return uuid{std::begin(bytes), std::end(bytes)};
|
|
|
|
#elif defined(__APPLE__)
|
|
auto newId = CFUUIDCreate(NULL);
|
|
auto bytes = CFUUIDGetUUIDBytes(newId);
|
|
CFRelease(newId);
|
|
|
|
std::array<uint8_t, 16> arrbytes = {
|
|
{bytes.byte0, bytes.byte1, bytes.byte2, bytes.byte3, bytes.byte4,
|
|
bytes.byte5, bytes.byte6, bytes.byte7, bytes.byte8, bytes.byte9,
|
|
bytes.byte10, bytes.byte11, bytes.byte12, bytes.byte13, bytes.byte14,
|
|
bytes.byte15}};
|
|
return uuid{std::begin(arrbytes), std::end(arrbytes)};
|
|
#else
|
|
return uuid{};
|
|
#endif
|
|
}
|
|
};
|
|
#endif
|
|
|
|
template <typename UniformRandomNumberGenerator>
|
|
class basic_uuid_random_generator {
|
|
public:
|
|
using engine_type = UniformRandomNumberGenerator;
|
|
|
|
explicit basic_uuid_random_generator(engine_type &gen)
|
|
: generator(&gen, [](auto) {}) {}
|
|
explicit basic_uuid_random_generator(engine_type *gen)
|
|
: generator(gen, [](auto) {}) {}
|
|
|
|
[[nodiscard]] uuid operator()() {
|
|
alignas(uint32_t) uint8_t bytes[16];
|
|
for (int i = 0; i < 16; i += 4)
|
|
*reinterpret_cast<uint32_t *>(bytes + i) = distribution(*generator);
|
|
|
|
// variant must be 10xxxxxx
|
|
bytes[8] &= 0xBF;
|
|
bytes[8] |= 0x80;
|
|
|
|
// version must be 0100xxxx
|
|
bytes[6] &= 0x4F;
|
|
bytes[6] |= 0x40;
|
|
|
|
return uuid{std::begin(bytes), std::end(bytes)};
|
|
}
|
|
|
|
private:
|
|
std::uniform_int_distribution<uint32_t> distribution;
|
|
std::shared_ptr<UniformRandomNumberGenerator> generator;
|
|
};
|
|
|
|
using uuid_random_generator = basic_uuid_random_generator<std::mt19937>;
|
|
|
|
class uuid_name_generator {
|
|
public:
|
|
explicit uuid_name_generator(uuid const &namespace_uuid) noexcept
|
|
: nsuuid(namespace_uuid) {}
|
|
|
|
template <typename StringType>
|
|
[[nodiscard]] uuid operator()(StringType const &name) {
|
|
reset();
|
|
process_characters(detail::to_string_view(name));
|
|
return make_uuid();
|
|
}
|
|
|
|
private:
|
|
void reset() {
|
|
hasher.reset();
|
|
std::byte bytes[16];
|
|
auto nsbytes = nsuuid.as_bytes();
|
|
std::copy(std::cbegin(nsbytes), std::cend(nsbytes), bytes);
|
|
hasher.process_bytes(bytes, 16);
|
|
}
|
|
|
|
template <typename CharT, typename Traits>
|
|
void process_characters(std::basic_string_view<CharT, Traits> const str) {
|
|
for (uint32_t c : str) {
|
|
hasher.process_byte(static_cast<uint8_t>(c & 0xFF));
|
|
if constexpr (!std::is_same_v<CharT, char>) {
|
|
hasher.process_byte(static_cast<uint8_t>((c >> 8) & 0xFF));
|
|
hasher.process_byte(static_cast<uint8_t>((c >> 16) & 0xFF));
|
|
hasher.process_byte(static_cast<uint8_t>((c >> 24) & 0xFF));
|
|
}
|
|
}
|
|
}
|
|
|
|
[[nodiscard]] uuid make_uuid() {
|
|
detail::sha1::digest8_t digest;
|
|
hasher.get_digest_bytes(digest);
|
|
|
|
// variant must be 0b10xxxxxx
|
|
digest[8] &= 0xBF;
|
|
digest[8] |= 0x80;
|
|
|
|
// version must be 0b0101xxxx
|
|
digest[6] &= 0x5F;
|
|
digest[6] |= 0x50;
|
|
|
|
return uuid{digest, digest + 16};
|
|
}
|
|
|
|
private:
|
|
uuid nsuuid;
|
|
detail::sha1 hasher;
|
|
};
|
|
|
|
#ifdef UUID_TIME_GENERATOR
|
|
// !!! DO NOT USE THIS IN PRODUCTION
|
|
// this implementation is unreliable for good uuids
|
|
class uuid_time_generator {
|
|
using mac_address = std::array<unsigned char, 6>;
|
|
|
|
std::optional<mac_address> device_address;
|
|
|
|
[[nodiscard]] bool get_mac_address() {
|
|
if (device_address.has_value()) {
|
|
return true;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
DWORD len = 0;
|
|
auto ret = GetAdaptersInfo(nullptr, &len);
|
|
if (ret != ERROR_BUFFER_OVERFLOW)
|
|
return false;
|
|
std::vector<unsigned char> buf(len);
|
|
auto pips = reinterpret_cast<PIP_ADAPTER_INFO>(&buf.front());
|
|
ret = GetAdaptersInfo(pips, &len);
|
|
if (ret != ERROR_SUCCESS)
|
|
return false;
|
|
mac_address addr;
|
|
std::copy(pips->Address, pips->Address + 6, std::begin(addr));
|
|
device_address = addr;
|
|
#endif
|
|
|
|
return device_address.has_value();
|
|
}
|
|
|
|
[[nodiscard]] long long get_time_intervals() {
|
|
auto start = std::chrono::system_clock::from_time_t(time_t(-12219292800));
|
|
auto diff = std::chrono::system_clock::now() - start;
|
|
auto ns =
|
|
std::chrono::duration_cast<std::chrono::nanoseconds>(diff).count();
|
|
return ns / 100;
|
|
}
|
|
|
|
[[nodiscard]] static unsigned short get_clock_sequence() {
|
|
static std::mt19937 clock_gen(std::random_device{}());
|
|
static std::uniform_int_distribution<unsigned short> clock_dis;
|
|
static std::atomic_ushort clock_sequence = clock_dis(clock_gen);
|
|
return clock_sequence++;
|
|
}
|
|
|
|
public:
|
|
[[nodiscard]] uuid operator()() {
|
|
if (get_mac_address()) {
|
|
std::array<uuids::uuid::value_type, 16> data;
|
|
|
|
auto tm = get_time_intervals();
|
|
|
|
auto clock_seq = get_clock_sequence();
|
|
|
|
auto ptm = reinterpret_cast<uuids::uuid::value_type *>(&tm);
|
|
|
|
memcpy(&data[0], ptm + 4, 4);
|
|
memcpy(&data[4], ptm + 2, 2);
|
|
memcpy(&data[6], ptm, 2);
|
|
|
|
memcpy(&data[8], &clock_seq, 2);
|
|
|
|
// variant must be 0b10xxxxxx
|
|
data[8] &= 0xBF;
|
|
data[8] |= 0x80;
|
|
|
|
// version must be 0b0001xxxx
|
|
data[6] &= 0x1F;
|
|
data[6] |= 0x10;
|
|
|
|
memcpy(&data[10], &device_address.value()[0], 6);
|
|
|
|
return uuids::uuid{std::cbegin(data), std::cend(data)};
|
|
}
|
|
|
|
return {};
|
|
}
|
|
};
|
|
#endif
|
|
} // namespace uuids
|
|
|
|
namespace std {
|
|
template <> struct hash<uuids::uuid> {
|
|
using argument_type = uuids::uuid;
|
|
using result_type = std::size_t;
|
|
|
|
[[nodiscard]] result_type operator()(argument_type const &uuid) const {
|
|
#ifdef UUID_HASH_STRING_BASED
|
|
std::hash<std::string> hasher;
|
|
return static_cast<result_type>(hasher(uuids::to_string(uuid)));
|
|
#else
|
|
uint64_t l = static_cast<uint64_t>(uuid.data[0]) << 56 |
|
|
static_cast<uint64_t>(uuid.data[1]) << 48 |
|
|
static_cast<uint64_t>(uuid.data[2]) << 40 |
|
|
static_cast<uint64_t>(uuid.data[3]) << 32 |
|
|
static_cast<uint64_t>(uuid.data[4]) << 24 |
|
|
static_cast<uint64_t>(uuid.data[5]) << 16 |
|
|
static_cast<uint64_t>(uuid.data[6]) << 8 |
|
|
static_cast<uint64_t>(uuid.data[7]);
|
|
uint64_t h = static_cast<uint64_t>(uuid.data[8]) << 56 |
|
|
static_cast<uint64_t>(uuid.data[9]) << 48 |
|
|
static_cast<uint64_t>(uuid.data[10]) << 40 |
|
|
static_cast<uint64_t>(uuid.data[11]) << 32 |
|
|
static_cast<uint64_t>(uuid.data[12]) << 24 |
|
|
static_cast<uint64_t>(uuid.data[13]) << 16 |
|
|
static_cast<uint64_t>(uuid.data[14]) << 8 |
|
|
static_cast<uint64_t>(uuid.data[15]);
|
|
|
|
if constexpr (sizeof(result_type) > 4) {
|
|
return result_type(l ^ h);
|
|
} else {
|
|
uint64_t hash64 = l ^ h;
|
|
return result_type(uint32_t(hash64 >> 32) ^ uint32_t(hash64));
|
|
}
|
|
#endif
|
|
}
|
|
};
|
|
} // namespace std
|
|
|
|
#endif /* STDUUID_H */
|