uuid.h

Go to the documentation of this file.

#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";
    }
 
    // --------------------------------------------------------------------------------------------------------------------------
    // 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 Photon
{
    using UUID = uuids::uuid;
}
 
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
        }
    };
}
 
#endif /* STDUUID_H */