nihil: move uuid to its own module

1 files changed, 760 insertions, 0 deletions

diff --git a/nihil.uuid/uuid.ccm b/nihil.uuid/uuid.ccm
new file mode 100644
index 0000000..0c46b60
--- /dev/null
+++ b/nihil.uuid/uuid.ccm
@@ -0,0 +1,760 @@
+/*
+ * From https://github.com/mariusbancila/stduuid
+ *
+ * Copyright (c) 2017
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+module;
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <cstring>
+#include <functional>
+#include <iomanip>
+#include <iterator>
+#include <memory>
+#include <numeric>
+#include <optional>
+#include <random>
+#include <ranges>
+#include <span>
+#include <string>
+#include <sstream>
+#include <string_view>
+#include <type_traits>
+
+export module nihil.uuid;
+
+namespace nihil {
+
+template <typename TChar>
+[[nodiscard]] constexpr 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 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;
+}
+
+struct sha1
+{
+	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) 
+	{
+		auto *begin = static_cast<const uint8_t*>(start);
+		auto *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)
+	{
+		auto *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));
+
+		std::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;
+	}
+
+	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
+export enum struct 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   
+export enum struct 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.
+export struct uuid;
+export template <typename CharT = char,
+	  typename Traits = std::char_traits<CharT>,
+	  typename Allocator = std::allocator<CharT>>
+std::basic_string<CharT, Traits, Allocator> to_string(uuid const &id);
+
+// --------------------------------------------------------------------------------------------------------------------------
+// uuid class
+// --------------------------------------------------------------------------------------------------------------------------
+export struct uuid {
+	using value_type = uint8_t;
+
+	constexpr uuid() noexcept = default;
+
+	uuid(value_type(&arr)[16]) noexcept
+	{
+		std::ranges::copy(arr, std::ranges::begin(data));
+	}
+
+	constexpr uuid(std::array<value_type, 16> const & arr) noexcept
+		: data{arr}
+	{
+	}
+
+	explicit uuid(std::span<value_type, 16> bytes)
+	{
+		std::ranges::copy(bytes, std::ranges::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 std::span<std::byte const, 16> as_bytes() const
+	{
+		return std::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 = 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 || !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 = 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 || !is_hex(str[i])) {
+				return {};
+			}
+
+			if (firstDigit) {
+				data[index] = static_cast<uint8_t>(hex2char(str[i]) << 4);
+				firstDigit = false;
+			} else {
+				data[index] = static_cast<uint8_t>(data[index] | 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
+// --------------------------------------------------------------------------------------------------------------------------
+
+export [[nodiscard]]
+auto operator== (uuid const& lhs, uuid const& rhs) noexcept -> bool
+{
+	return lhs.data == rhs.data;
+}
+
+export [[nodiscard]] 
+auto operator!= (uuid const& lhs, uuid const& rhs) noexcept -> bool
+{
+	return !(lhs == rhs);
+}
+
+export [[nodiscard]]
+auto operator< (uuid const& lhs, uuid const& rhs) noexcept -> bool
+{
+	return lhs.data < rhs.data;
+}
+
+export template <typename CharT, typename Traits, typename Allocator>
+[[nodiscard]] auto to_string(uuid const &id)
+	-> std::basic_string<CharT, Traits, Allocator>
+{
+	std::basic_string<CharT, Traits, Allocator> uustr{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] = guid_encoder<CharT>[id.data[index] >> 4 & 0x0f];
+		uustr[++i] = guid_encoder<CharT>[id.data[index] & 0x0f];
+		index++;
+	}
+
+	return uustr;
+}
+
+export template <class Elem, class Traits>
+auto operator<<(std::basic_ostream<Elem, Traits>& s, uuid const &id)
+	-> std::basic_ostream<Elem, Traits>&
+{
+	s << to_string(id);
+	return s;
+}
+
+export void swap(uuid & lhs, 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
+export 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
+export 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)
+export 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)
+export uuid uuid_namespace_x500{{
+	0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1,
+	0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
+}};
+
+/***********************************************************************
+ * uuid generators
+ */
+
+export template <typename UniformRandomNumberGenerator>
+struct basic_uuid_random_generator
+{
+	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;
+};
+
+export using uuid_random_generator = basic_uuid_random_generator<std::mt19937>;
+
+export struct uuid_name_generator
+{
+	explicit uuid_name_generator(uuid const& namespace_uuid) noexcept
+		: nsuuid(namespace_uuid)
+	{
+	}
+
+	template <typename StringType>
+	[[nodiscard]] uuid operator()(StringType const & name)
+	{
+		reset();
+		process_characters(to_string_view(name));
+		return make_uuid();
+	}
+
+private:
+	void reset() 
+	{
+		hasher.reset();
+		std::byte bytes[16];
+		auto nsbytes = nsuuid.as_bytes();
+		std::ranges::copy(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()
+	{
+		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;
+	sha1 hasher;
+};
+
+/*
+ * Create a random UUID.
+ */
+export auto random_uuid() -> uuid
+{
+	auto rd = std::random_device();
+	auto seed_data = std::array<int, std::mt19937::state_size> {};
+
+	std::ranges::generate(seed_data, std::ref(rd));
+	auto seq = std::seed_seq(std::begin(seed_data), std::end(seed_data));
+	auto generator = std::mt19937(seq);
+	auto gen = uuid_random_generator{generator};
+
+	return gen();	
+}
+
+} // namespace nihil
+
+namespace std {
+
+export template <>
+struct hash<nihil::uuid>
+{
+	using argument_type = nihil::uuid;
+	using result_type   = std::size_t;
+
+	[[nodiscard]] result_type operator()(argument_type const &uuid) const
+	{
+		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));
+		}
+	}
+};
+
+} // namespace std