From 712edacbc75e6dc98c11b3c5f6c52f823c747e2f Mon Sep 17 00:00:00 2001 From: Lexi Winter Date: Wed, 2 Jul 2025 03:28:45 +0100 Subject: move uuid to util --- CMakeLists.txt | 1 - nihil.util/CMakeLists.txt | 9 +- nihil.util/nihil.util.ccm | 1 + nihil.util/uuid.ccm | 768 ++++++++++++++++++++++++++++++++++++++ nihil.util/uuid.test.cc | 923 ++++++++++++++++++++++++++++++++++++++++++++++ nihil.uuid/CMakeLists.txt | 22 -- nihil.uuid/test.cc | 923 ---------------------------------------------- nihil.uuid/uuid.ccm | 768 -------------------------------------- 8 files changed, 1700 insertions(+), 1715 deletions(-) create mode 100644 nihil.util/uuid.ccm create mode 100644 nihil.util/uuid.test.cc delete mode 100644 nihil.uuid/CMakeLists.txt delete mode 100644 nihil.uuid/test.cc delete mode 100644 nihil.uuid/uuid.ccm diff --git a/CMakeLists.txt b/CMakeLists.txt index d417178..da623af 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -69,7 +69,6 @@ add_subdirectory(nihil.generator) add_subdirectory(nihil.match) add_subdirectory(nihil.posix) add_subdirectory(nihil.util) -add_subdirectory(nihil.uuid) if(NIHIL_UCL) add_subdirectory(nihil.ucl) diff --git a/nihil.util/CMakeLists.txt b/nihil.util/CMakeLists.txt index 4c832c8..486a082 100644 --- a/nihil.util/CMakeLists.txt +++ b/nihil.util/CMakeLists.txt @@ -1,11 +1,13 @@ # This source code is released into the public domain. add_library(nihil.util STATIC) + target_link_libraries(nihil.util PRIVATE nihil.std nihil.core nihil.error ) + target_sources(nihil.util PUBLIC FILE_SET modules TYPE CXX_MODULES FILES nihil.util.ccm @@ -21,6 +23,7 @@ target_sources(nihil.util save_errno.ccm skipws.ccm tabulate.ccm + uuid.ccm ) if(NIHIL_TESTS) @@ -36,9 +39,13 @@ if(NIHIL_TESTS) next_word.test.cc skipws.test.cc tabulate.test.cc + uuid.test.cc ) + target_link_libraries(nihil.util.test PRIVATE - nihil.std nihil.util + nihil.std + nihil.core + nihil.util Catch2::Catch2WithMain ) diff --git a/nihil.util/nihil.util.ccm b/nihil.util/nihil.util.ccm index de88f8c..9e4795b 100644 --- a/nihil.util/nihil.util.ccm +++ b/nihil.util/nihil.util.ccm @@ -12,3 +12,4 @@ export import :next_word; export import :save_errno; export import :skipws; export import :tabulate; +export import :uuid; diff --git a/nihil.util/uuid.ccm b/nihil.util/uuid.ccm new file mode 100644 index 0000000..7b5727c --- /dev/null +++ b/nihil.util/uuid.ccm @@ -0,0 +1,768 @@ +// 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. + +export module nihil.util:uuid; + +import nihil.std; + +namespace nihil { + +template +[[nodiscard]] constexpr auto hex2char(TChar const ch) noexcept -> unsigned char +{ + if (ch >= static_cast('0') && ch <= static_cast('9')) + return static_cast(ch - static_cast('0')); + + if (ch >= static_cast('a') && ch <= static_cast('f')) + return static_cast(10 + ch - static_cast('a')); + + if (ch >= static_cast('A') && ch <= static_cast('F')) + return static_cast(10 + ch - static_cast('A')); + + return 0; +} + +template +[[nodiscard]] constexpr auto is_hex(TChar const ch) noexcept -> bool +{ + return (ch >= static_cast('0') && ch <= static_cast('9')) || + (ch >= static_cast('a') && ch <= static_cast('f')) || + (ch >= static_cast('A') && ch <= static_cast('F')); +} + +template +[[nodiscard]] constexpr auto +to_string_view(TChar const *str) noexcept -> std::basic_string_view +{ + if (str) + return str; + return {}; +} + +template +[[nodiscard]] constexpr auto to_string_view(StringType const &str) noexcept + -> std::basic_string_view +{ + return str; +} + +struct sha1 +{ + using digest32_t = std::array; + using digest8_t = std::array; + + static constexpr unsigned int block_bytes = 64; + + sha1() + { + reset(); + } + + [[nodiscard]] static auto + left_rotate(std::uint32_t value, std::size_t const count) noexcept -> std::uint32_t + { + return (value << count) ^ (value >> (32 - count)); + } + + auto reset(this sha1 &self) noexcept -> void + { + self.m_digest[0] = 0x67452301; + self.m_digest[1] = 0xEFCDAB89; + self.m_digest[2] = 0x98BADCFE; + self.m_digest[3] = 0x10325476; + self.m_digest[4] = 0xC3D2E1F0; + self.m_blockByteIndex = 0; + self.m_byteCount = 0; + } + + auto process_byte(this sha1 &self, std::uint8_t octet) -> void + { + self.m_block.at(self.m_blockByteIndex++) = octet; + ++self.m_byteCount; + + if (self.m_blockByteIndex == block_bytes) { + self.m_blockByteIndex = 0; + self.process_block(); + } + } + + auto process_block(this sha1 &self, void const *const start, void const *const end) -> void + { + auto const *first = static_cast(start); + auto const *last = static_cast(end); + + while (first != last) { + self.process_byte(*first); + first++; + } + } + + auto process_bytes(this sha1 &self, void const *const data, std::size_t const len) -> void + { + auto *block = static_cast(data); + self.process_block(block, block + len); + } + + auto get_digest(this sha1 &self) -> digest32_t + { + auto const bit_count = self.m_byteCount * 8; + + self.process_byte(0x80); + if (self.m_blockByteIndex > 56) { + while (self.m_blockByteIndex != 0) + self.process_byte(0); + + while (self.m_blockByteIndex < 56) + self.process_byte(0); + } else { + while (self.m_blockByteIndex < 56) + self.process_byte(0); + } + + self.process_byte(0); + self.process_byte(0); + self.process_byte(0); + self.process_byte(0); + self.process_byte(static_cast((bit_count >> 24U) & 0xFFU)); + self.process_byte(static_cast((bit_count >> 16U) & 0xFFU)); + self.process_byte(static_cast((bit_count >> 8U) & 0xFFU)); + self.process_byte(static_cast((bit_count) & 0xFFU)); + + return self.m_digest; + } + + auto get_digest_bytes(this sha1 &self) -> digest8_t + { + auto d32 = self.get_digest(); + + return { + static_cast(d32[0] >> 24U), + static_cast(d32[0] >> 16U), + static_cast(d32[0] >> 8U), + static_cast(d32[0] >> 0U), + + static_cast(d32[1] >> 24U), + static_cast(d32[1] >> 16U), + static_cast(d32[1] >> 8U), + static_cast(d32[1] >> 0U), + + static_cast(d32[2] >> 24U), + static_cast(d32[2] >> 16U), + static_cast(d32[2] >> 8U), + static_cast(d32[2] >> 0U), + + static_cast(d32[3] >> 24U), + static_cast(d32[3] >> 16U), + static_cast(d32[3] >> 8U), + static_cast(d32[3] >> 0U), + + static_cast(d32[4] >> 24U), + static_cast(d32[4] >> 16U), + static_cast(d32[4] >> 8U), + static_cast(d32[4] >> 0U), + }; + } + +private: + auto process_block(this sha1 &self) -> void + { + auto w = std::array{}; + + for (std::size_t i = 0; i < 16; i++) { + w.at(i) = static_cast(self.m_block.at((i * 4) + 0)) << 24U; + w.at(i) |= static_cast(self.m_block.at((i * 4) + 1)) << 16U; + w.at(i) |= static_cast(self.m_block.at((i * 4) + 2)) << 8U; + w.at(i) |= static_cast(self.m_block.at((i * 4) + 3)); + } + + for (std::size_t i = 16; i < 80; i++) { + w.at(i) = left_rotate( + (w.at(i - 3) ^ w.at(i - 8) ^ w.at(i - 14) ^ w.at(i - 16)), 1); + } + + auto a = self.m_digest[0]; + auto b = self.m_digest[1]; + auto c = self.m_digest[2]; + auto d = self.m_digest[3]; + auto e = self.m_digest[4]; + + for (std::size_t i = 0; i < 80; ++i) { + auto f = std::uint32_t{0}; + auto k = std::uint32_t{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; + } + + auto temp = std::uint32_t{left_rotate(a, 5) + f + e + k + w.at(i)}; + e = d; + d = c; + c = left_rotate(b, 30); + b = a; + a = temp; + } + + self.m_digest[0] += a; + self.m_digest[1] += b; + self.m_digest[2] += c; + self.m_digest[3] += d; + self.m_digest[4] += e; + } + + digest32_t m_digest{}; + std::array m_block{}; + std::size_t m_blockByteIndex{}; + std::size_t m_byteCount{}; +}; + +template +inline constexpr std::string_view empty_guid = "00000000-0000-0000-0000-000000000000"; + +template <> +inline constexpr std::wstring_view empty_guid = L"00000000-0000-0000-0000-000000000000"; + +template +inline constexpr std::string_view guid_encoder = "0123456789abcdef"; + +template <> +inline constexpr std::wstring_view guid_encoder = L"0123456789abcdef"; + +// --------------------------------------------------------------------- +// UUID format https://tools.ietf.org/html/rfc4122 +// --------------------------------------------------------------------- + +// --------------------------------------------------------------------- +// Field NDR Data Type Octet # Note +// 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 : std::uint8_t { + // 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 : std::uint8_t { + // only possible for nil or invalid uuids + none = 0, + // The time-based version specified in RFC 4122 + time_based = 1, + // DCE Security version, with embedded POSIX UIDs. + dce_security = 2, + // The name-based version specified in RFS 4122 with MD5 hashing + name_based_md5 = 3, + // The randomly or pseudo-randomly generated version specified in RFS 4122 + random_number_based = 4, + // The name-based version specified in RFS 4122 with SHA1 hashing + name_based_sha1 = 5 +}; + +// Forward declare uuid and to_string so that we can declare to_string as a +// friend later. +export struct uuid; +export template , + typename Allocator = std::allocator> +auto to_string(uuid const &id) -> std::basic_string; + +// -------------------------------------------------------------------------------------------------------------------------- +// uuid class +// -------------------------------------------------------------------------------------------------------------------------- +export struct uuid +{ + using value_type = std::uint8_t; + + constexpr uuid() noexcept = default; + + uuid(value_type (&arr)[16]) noexcept // NOLINT + { + std::ranges::copy(arr, std::ranges::begin(data)); + } + + explicit constexpr uuid(std::array const &arr) noexcept + : data{arr} + { + } + + explicit uuid(std::span bytes) + { + std::ranges::copy(bytes, std::ranges::begin(data)); + } + + explicit uuid(std::span bytes) + { + if (bytes.size() != 16) + throw std::logic_error("wrong size for uuid"); + std::ranges::copy(bytes, std::ranges::begin(data)); + } + + template + explicit uuid(ForwardIterator first, ForwardIterator last) + { + if (std::distance(first, last) != 16) + throw std::logic_error("wrong size for uuid"); + + std::copy(first, last, std::begin(data)); + } + + [[nodiscard]] constexpr auto variant() const noexcept -> uuid_variant + { + if ((data[8] & 0x80U) == 0x00U) + return uuid_variant::ncs; + else if ((data[8] & 0xC0U) == 0x80U) + return uuid_variant::rfc; + else if ((data[8] & 0xE0U) == 0xC0U) + return uuid_variant::microsoft; + else + return uuid_variant::reserved; + } + + [[nodiscard]] constexpr auto version() const noexcept -> uuid_version + { + if ((data[6] & 0xF0U) == 0x10U) + return uuid_version::time_based; + else if ((data[6] & 0xF0U) == 0x20U) + return uuid_version::dce_security; + else if ((data[6] & 0xF0U) == 0x30U) + return uuid_version::name_based_md5; + else if ((data[6] & 0xF0U) == 0x40U) + return uuid_version::random_number_based; + else if ((data[6] & 0xF0U) == 0x50U) + return uuid_version::name_based_sha1; + else + return uuid_version::none; + } + + [[nodiscard]] constexpr auto is_nil() const noexcept -> bool + { + return std::ranges::all_of(data, [](auto i) { return i == 0; }); + } + + auto swap(uuid &other) noexcept -> void + { + data.swap(other.data); + } + + [[nodiscard]] auto as_bytes() const -> std::span + { + return std::span( + reinterpret_cast(data.data()), 16); + } + + template + [[nodiscard]] constexpr static auto is_valid_uuid(StringType const &in_str) noexcept -> bool + { + auto str = to_string_view(in_str); + auto firstDigit = true; + auto hasBraces = std::size_t{0}; + auto index = std::size_t{0}; + + if (str.empty()) + return false; + + if (str.front() == '{') + hasBraces = 1; + + if (hasBraces && str.back() != '}') + return false; + + for (std::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 + [[nodiscard]] constexpr static auto + from_string(StringType const &in_str) -> std::optional + { + auto str = to_string_view(in_str); + bool firstDigit = true; + auto hasBraces = std::size_t{0}; + auto index = std::size_t{0}; + + auto data = std::array{}; + + if (str.empty()) + return {}; + + if (str.front() == '{') + hasBraces = 1; + if (hasBraces && str.back() != '}') + return {}; + + for (std::size_t i = hasBraces; i < str.size() - hasBraces; ++i) { + if (str[i] == '-') + continue; + + if (index >= 16 || !is_hex(str[i])) { + return {}; + } + + if (firstDigit) { + data.at(index) = static_cast(hex2char(str[i]) << 4); + firstDigit = false; + } else { + data.at(index) = + static_cast(data.at(index) | hex2char(str[i])); + index++; + firstDigit = true; + } + } + + if (index < 16) { + return {}; + } + + return uuid{data}; + } + +private: + std::array data{{0}}; + + friend auto operator==(uuid const &, uuid const &) noexcept -> bool; + friend auto operator<(uuid const &, uuid const &) noexcept -> bool; + + template + friend auto operator<<(std::basic_ostream &s, uuid const &id) + -> std::basic_ostream &; + + template + friend auto to_string(uuid const &id) -> std::basic_string; + + friend std::hash; +}; + +// -------------------------------------------------------------------------------------------------------------------------- +// 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 +[[nodiscard]] auto to_string(uuid const &id) -> std::basic_string +{ + auto uustr = + std::basic_string(std::from_range, empty_guid); + + for (std::size_t i = 0, index = 0; i < 36; ++i) { + if (i == 8 || i == 13 || i == 18 || i == 23) + continue; + + uustr[i] = guid_encoder[id.data.at(index) >> 4U & 0x0FU]; + uustr[++i] = guid_encoder[id.data.at(index) & 0x0FU]; + index++; + } + + return uustr; +} + +export template +auto operator<<(std::basic_ostream &s, uuid const &id) + -> std::basic_ostream & +{ + return s << to_string(id); +} + +export auto swap(uuid &lhs, uuid &rhs) noexcept -> void +{ + 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 +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]] auto operator()() -> uuid + { + auto bytes = std::array{}; + std::ranges::generate(bytes, [&] { return distribution(*generator); }); + + // variant must be 10xxxxxx + bytes[8] &= 0xBFU; + bytes[8] |= 0x80U; + + // version must be 0100xxxx + bytes[6] &= 0x4FU; + bytes[6] |= 0x40U; + + return uuid{std::begin(bytes), std::end(bytes)}; + } + +private: + std::uniform_int_distribution distribution; + std::shared_ptr generator; +}; + +export using uuid_random_generator = basic_uuid_random_generator; + +export struct uuid_name_generator +{ + explicit uuid_name_generator(uuid const &namespace_uuid) noexcept + : nsuuid(namespace_uuid) + { + } + + template + [[nodiscard]] auto operator()(StringType const &name) -> uuid + { + reset(); + process_characters(to_string_view(name)); + return make_uuid(); + } + +private: + auto reset() -> void + { + hasher.reset(); + + auto nsbytes = nsuuid.as_bytes(); + + auto bytes = std::array(); + std::ranges::copy(nsbytes, std::ranges::begin(bytes)); + + hasher.process_bytes(bytes.data(), bytes.size()); + } + + template + auto process_characters(std::basic_string_view const str) -> void + { + for (std::uint32_t c : str) { + hasher.process_byte(static_cast(c & 0xFFU)); + if constexpr (!std::is_same_v) { + hasher.process_byte(static_cast((c >> 8U) & 0xFFU)); + hasher.process_byte(static_cast((c >> 16U) & 0xFFU)); + hasher.process_byte(static_cast((c >> 24U) & 0xFFU)); + } + } + } + + [[nodiscard]] auto make_uuid() -> uuid + { + auto digest = hasher.get_digest_bytes(); + + // variant must be 0b10xxxxxx + digest[8] &= 0xBFU; + digest[8] |= 0x80U; + + // version must be 0b0101xxxx + digest[6] &= 0x5FU; + digest[6] |= 0x50U; + + return uuid(std::span(digest).subspan(0, 16)); + } + + uuid nsuuid; + sha1 hasher; +}; + +/* + * Create a random UUID. + */ +export auto random_uuid() -> uuid +{ + auto rd = std::random_device(); + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + + auto seq = std::seed_seq(std::ranges::begin(seed_data), std::ranges::end(seed_data)); + auto generator = std::mt19937(seq); + auto gen = uuid_random_generator{generator}; + + return gen(); +} + +} // namespace nihil + +namespace std { + +export template <> +struct hash +{ + using argument_type = nihil::uuid; + using result_type = std::size_t; + + [[nodiscard]] auto operator()(argument_type const &uuid) const noexcept -> result_type + { + auto const l = static_cast(uuid.data[0]) << 56U | + static_cast(uuid.data[1]) << 48U | + static_cast(uuid.data[2]) << 40U | + static_cast(uuid.data[3]) << 32U | + static_cast(uuid.data[4]) << 24U | + static_cast(uuid.data[5]) << 16U | + static_cast(uuid.data[6]) << 8U | + static_cast(uuid.data[7]); + + auto const h = static_cast(uuid.data[8]) << 56U | + static_cast(uuid.data[9]) << 48U | + static_cast(uuid.data[10]) << 40U | + static_cast(uuid.data[11]) << 32U | + static_cast(uuid.data[12]) << 24U | + static_cast(uuid.data[13]) << 16U | + static_cast(uuid.data[14]) << 8U | + static_cast(uuid.data[15]); + + return std::hash{}(l ^ h); + } +}; + +} // namespace std diff --git a/nihil.util/uuid.test.cc b/nihil.util/uuid.test.cc new file mode 100644 index 0000000..eca94d1 --- /dev/null +++ b/nihil.util/uuid.test.cc @@ -0,0 +1,923 @@ +/* + * 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. + */ + +#include + +import nihil.std; +import nihil.util; + +// NOLINTBEGIN(bugprone-unchecked-optional-access) + +namespace { +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0205r0.html +template +void seed_rng(EngineT &engine) +{ + using engine_type = typename EngineT::result_type; + using device_type = std::random_device::result_type; + using seedseq_type = std::seed_seq::result_type; + + constexpr auto bytes_needed = StateSize * sizeof(engine_type); + constexpr auto numbers_needed = (sizeof(device_type) < sizeof(seedseq_type)) + ? (bytes_needed / sizeof(device_type)) + : (bytes_needed / sizeof(seedseq_type)); + + auto numbers = std::array{}; + auto rnddev = std::random_device{}; + std::ranges::generate(numbers, std::ref(rnddev)); + + auto seedseq = std::seed_seq(std::cbegin(numbers), std::cend(numbers)); + engine.seed(seedseq); +} + +using namespace nihil; + +TEST_CASE("uuid: Test multiple default generators", "[uuid]") +{ + uuid id1; + uuid id2; + + { + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + std::mt19937 generator(seq); + + id1 = uuid_random_generator{generator}(); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::random_number_based); + REQUIRE(id1.variant() == uuid_variant::rfc); + } + + { + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + std::mt19937 generator(seq); + + id2 = uuid_random_generator{generator}(); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::random_number_based); + REQUIRE(id2.variant() == uuid_variant::rfc); + } + + REQUIRE(id1 != id2); +} + +TEST_CASE("uuid: Test default generator", "[uuid]") +{ + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + std::mt19937 generator(seq); + + uuid const guid = uuid_random_generator{generator}(); + REQUIRE(!guid.is_nil()); + REQUIRE(guid.version() == uuid_version::random_number_based); + REQUIRE(guid.variant() == uuid_variant::rfc); +} + +TEST_CASE("uuid: Test random generator (conversion ctor w/ smart ptr)", "[uuid]") +{ + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + std::mt19937 generator(seq); + + uuid_random_generator dgen(&generator); + auto id1 = dgen(); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::random_number_based); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen(); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::random_number_based); + REQUIRE(id2.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); +} + +TEST_CASE("uuid: Test random generator (conversion ctor w/ ptr)", "[uuid]") +{ + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + auto generator = std::make_unique(seq); + + uuid_random_generator dgen(generator.get()); + auto id1 = dgen(); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::random_number_based); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen(); + REQUIRE(!id1.is_nil()); + REQUIRE(id2.version() == uuid_version::random_number_based); + REQUIRE(id2.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); +} + +TEST_CASE("uuid: Test random generator (conversion ctor w/ ref)", "[uuid]") +{ + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + std::mt19937 generator(seq); + + uuid_random_generator dgen(generator); + auto id1 = dgen(); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::random_number_based); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen(); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::random_number_based); + REQUIRE(id2.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); +} + +TEST_CASE("uuid: Test basic random generator (conversion ctor w/ ptr) " + "w/ ranlux48_base", + "[uuid]") +{ + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + std::ranlux48_base generator(seq); + + basic_uuid_random_generator dgen(&generator); + auto id1 = dgen(); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::random_number_based); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen(); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::random_number_based); + REQUIRE(id2.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); +} + +TEST_CASE("uuid: Test basic random generator (conversion ctor w/ smart ptr) " + "w/ ranlux48_base", + "[uuid]") +{ + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + auto generator = std::make_unique(seq); + + basic_uuid_random_generator dgen(generator.get()); + auto id1 = dgen(); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::random_number_based); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen(); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::random_number_based); + REQUIRE(id2.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); +} + +TEST_CASE("uuid: Test basic random generator (conversion ctor w/ ref) " + "w/ ranlux48_base", + "[uuid]") +{ + std::random_device rd; + auto seed_data = std::array{}; + std::ranges::generate(seed_data, std::ref(rd)); + std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); + std::ranlux48_base generator(seq); + + basic_uuid_random_generator dgen(generator); + auto id1 = dgen(); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::random_number_based); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen(); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::random_number_based); + REQUIRE(id2.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); +} + +TEST_CASE("uuid: Test namespaces", "[uuid]") +{ + REQUIRE(uuid_namespace_dns == uuid::from_string("6ba7b810-9dad-11d1-80b4-00c04fd430c8")); + REQUIRE(uuid_namespace_url == uuid::from_string("6ba7b811-9dad-11d1-80b4-00c04fd430c8")); + REQUIRE(uuid_namespace_oid == uuid::from_string("6ba7b812-9dad-11d1-80b4-00c04fd430c8")); + REQUIRE(uuid_namespace_x500 == uuid::from_string("6ba7b814-9dad-11d1-80b4-00c04fd430c8")); +} + +TEST_CASE("uuid: Test name generator (char*)", "[uuid]") +{ + uuid_name_generator dgen(uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()); + + auto id1 = dgen("john"); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::name_based_sha1); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen("jane"); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::name_based_sha1); + REQUIRE(id2.variant() == uuid_variant::rfc); + + auto id3 = dgen("jane"); + REQUIRE(!id3.is_nil()); + REQUIRE(id3.version() == uuid_version::name_based_sha1); + REQUIRE(id3.variant() == uuid_variant::rfc); + + auto id4 = dgen(L"jane"); + REQUIRE(!id4.is_nil()); + REQUIRE(id4.version() == uuid_version::name_based_sha1); + REQUIRE(id4.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); + REQUIRE(id2 == id3); + REQUIRE(id3 != id4); +} + +TEST_CASE("uuid: Test name generator (std::string)", "[uuid]") +{ + using namespace std::string_literals; + + uuid_name_generator dgen(uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()); + auto id1 = dgen("john"s); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::name_based_sha1); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen("jane"s); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::name_based_sha1); + REQUIRE(id2.variant() == uuid_variant::rfc); + + auto id3 = dgen("jane"s); + REQUIRE(!id3.is_nil()); + REQUIRE(id3.version() == uuid_version::name_based_sha1); + REQUIRE(id3.variant() == uuid_variant::rfc); + + auto id4 = dgen(L"jane"s); + REQUIRE(!id4.is_nil()); + REQUIRE(id4.version() == uuid_version::name_based_sha1); + REQUIRE(id4.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); + REQUIRE(id2 == id3); + REQUIRE(id3 != id4); +} + +TEST_CASE("uuid: Test name generator (std::string_view)", "[uuid]") +{ + using namespace std::string_view_literals; + + uuid_name_generator dgen(uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()); + auto id1 = dgen("john"sv); + REQUIRE(!id1.is_nil()); + REQUIRE(id1.version() == uuid_version::name_based_sha1); + REQUIRE(id1.variant() == uuid_variant::rfc); + + auto id2 = dgen("jane"sv); + REQUIRE(!id2.is_nil()); + REQUIRE(id2.version() == uuid_version::name_based_sha1); + REQUIRE(id2.variant() == uuid_variant::rfc); + + auto id3 = dgen("jane"sv); + REQUIRE(!id3.is_nil()); + REQUIRE(id3.version() == uuid_version::name_based_sha1); + REQUIRE(id3.variant() == uuid_variant::rfc); + + auto id4 = dgen(L"jane"sv); + REQUIRE(!id4.is_nil()); + REQUIRE(id4.version() == uuid_version::name_based_sha1); + REQUIRE(id4.variant() == uuid_variant::rfc); + + REQUIRE(id1 != id2); + REQUIRE(id2 == id3); + REQUIRE(id3 != id4); +} + +TEST_CASE("uuid: Test name generator equality (char const*, std::string, " + "std::string_view)", + "[uuid]") +{ + using namespace std::literals; + + auto dgen = uuid_name_generator( + uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()); + auto id1 = dgen("john"); + auto id2 = dgen("john"s); + auto id3 = dgen("john"sv); + + REQUIRE(id1 == id2); + REQUIRE(id2 == id3); +} + +TEST_CASE("uuid: Test default constructor", "[uuid]") +{ + auto empty = uuid(); + REQUIRE(empty.is_nil()); +} + +TEST_CASE("uuid: Test string conversion", "[uuid]") +{ + auto empty = uuid(); + REQUIRE(to_string(empty) == "00000000-0000-0000-0000-000000000000"); + REQUIRE(to_string(empty) == L"00000000-0000-0000-0000-000000000000"); +} + +TEST_CASE("uuid: Test is_valid_uuid(char*)", "[uuid]") +{ + REQUIRE(uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43")); + REQUIRE(uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43}")); + REQUIRE(uuid::is_valid_uuid(L"47183823-2574-4bfd-b411-99ed177d3e43")); + REQUIRE(uuid::is_valid_uuid(L"{47183823-2574-4bfd-b411-99ed177d3e43}")); + REQUIRE(uuid::is_valid_uuid("00000000-0000-0000-0000-000000000000")); + REQUIRE(uuid::is_valid_uuid("{00000000-0000-0000-0000-000000000000}")); + REQUIRE(uuid::is_valid_uuid(L"00000000-0000-0000-0000-000000000000")); + REQUIRE(uuid::is_valid_uuid(L"{00000000-0000-0000-0000-000000000000}")); +} + +TEST_CASE("uuid: Test is_valid_uuid(basic_string)", "[uuid]") +{ + using namespace std::string_literals; + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e43"s; + REQUIRE(uuid::is_valid_uuid(str)); + } + + { + auto str = "{47183823-2574-4bfd-b411-99ed177d3e43}"s; + REQUIRE(uuid::is_valid_uuid(str)); + } + + { + auto str = L"47183823-2574-4bfd-b411-99ed177d3e43"s; + REQUIRE(uuid::is_valid_uuid(str)); + } + + { + auto str = L"{47183823-2574-4bfd-b411-99ed177d3e43}"s; + REQUIRE(uuid::is_valid_uuid(str)); + } + + { + auto str = "00000000-0000-0000-0000-000000000000"s; + REQUIRE(uuid::is_valid_uuid(str)); + } + + { + auto str = "{00000000-0000-0000-0000-000000000000}"s; + REQUIRE(uuid::is_valid_uuid(str)); + } + + { + auto str = L"00000000-0000-0000-0000-000000000000"s; + REQUIRE(uuid::is_valid_uuid(str)); + } + + { + auto str = L"{00000000-0000-0000-0000-000000000000}"s; + REQUIRE(uuid::is_valid_uuid(str)); + } +} + +TEST_CASE("uuid: Test is_valid_uuid(basic_string_view)", "[uuid]") +{ + using namespace std::string_view_literals; + + REQUIRE(uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43"sv)); + REQUIRE(uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43}"sv)); + REQUIRE(uuid::is_valid_uuid(L"47183823-2574-4bfd-b411-99ed177d3e43"sv)); + REQUIRE(uuid::is_valid_uuid(L"{47183823-2574-4bfd-b411-99ed177d3e43}"sv)); + REQUIRE(uuid::is_valid_uuid("00000000-0000-0000-0000-000000000000"sv)); + REQUIRE(uuid::is_valid_uuid("{00000000-0000-0000-0000-000000000000}"sv)); + REQUIRE(uuid::is_valid_uuid(L"00000000-0000-0000-0000-000000000000"sv)); + REQUIRE(uuid::is_valid_uuid(L"{00000000-0000-0000-0000-000000000000}"sv)); +} + +TEST_CASE("uuid: Test is_valid_uuid(char*) invalid format", "[uuid]") +{ + REQUIRE(!uuid::is_valid_uuid("")); + REQUIRE(!uuid::is_valid_uuid("{}")); + REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e4")); + REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e430")); + REQUIRE(!uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43")); + REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43}")); +} + +TEST_CASE("uuid: Test is_valid_uuid(basic_string) invalid format", "[uuid]") +{ + using namespace std::string_literals; + + { + auto str = ""s; + REQUIRE(!uuid::is_valid_uuid(str)); + } + + { + auto str = "{}"s; + REQUIRE(!uuid::is_valid_uuid(str)); + } + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e4"s; + REQUIRE(!uuid::is_valid_uuid(str)); + } + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e430"s; + REQUIRE(!uuid::is_valid_uuid(str)); + } + + { + auto str = "{47183823-2574-4bfd-b411-99ed177d3e43"s; + REQUIRE(!uuid::is_valid_uuid(str)); + } + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e43}"s; + REQUIRE(!uuid::is_valid_uuid(str)); + } +} + +TEST_CASE("uuid: Test is_valid_uuid(basic_string_view) invalid format", "[uuid]") +{ + using namespace std::string_view_literals; + + REQUIRE(!uuid::is_valid_uuid(""sv)); + REQUIRE(!uuid::is_valid_uuid("{}"sv)); + REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e4"sv)); + REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e430"sv)); + REQUIRE(!uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43"sv)); + REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43}"sv)); +} + +TEST_CASE("uuid: Test from_string(char*)", "[uuid]") +{ + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e43"; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == str); + } + + { + auto str = "{47183823-2574-4bfd-b411-99ed177d3e43}"; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); + } + + { + auto guid = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value(); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); + REQUIRE(to_string(guid) == L"47183823-2574-4bfd-b411-99ed177d3e43"); + } + + { + auto str = L"47183823-2574-4bfd-b411-99ed177d3e43"; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == str); + } + + { + auto str = "4718382325744bfdb41199ed177d3e43"; + REQUIRE_NOTHROW(uuid::from_string(str)); + REQUIRE(uuid::from_string(str).has_value()); + } + + { + auto str = "00000000-0000-0000-0000-000000000000"; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = "{00000000-0000-0000-0000-000000000000}"; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = L"00000000-0000-0000-0000-000000000000"; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = L"{00000000-0000-0000-0000-000000000000}"; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } +} + +TEST_CASE("uuid: Test from_string(basic_string)", "[uuid]") +{ + using namespace std::string_literals; + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e43"s; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == str); + } + + { + auto str = "{47183823-2574-4bfd-b411-99ed177d3e43}"s; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); + } + + { + auto guid = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43"s).value(); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); + REQUIRE(to_string(guid) == L"47183823-2574-4bfd-b411-99ed177d3e43"); + } + + { + auto str = L"47183823-2574-4bfd-b411-99ed177d3e43"s; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == str); + } + + { + auto str = "4718382325744bfdb41199ed177d3e43"s; + REQUIRE_NOTHROW(uuid::from_string(str)); + REQUIRE(uuid::from_string(str).has_value()); + } + + { + auto str = "00000000-0000-0000-0000-000000000000"s; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = "{00000000-0000-0000-0000-000000000000}"s; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = L"00000000-0000-0000-0000-000000000000"s; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = L"{00000000-0000-0000-0000-000000000000}"s; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } +} + +TEST_CASE("uuid: Test from_string(basic_string_view)", "[uuid]") +{ + using namespace std::string_view_literals; + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e43"sv; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == str); + } + + { + auto str = "{47183823-2574-4bfd-b411-99ed177d3e43}"sv; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); + } + + { + auto guid = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43"sv).value(); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); + REQUIRE(to_string(guid) == L"47183823-2574-4bfd-b411-99ed177d3e43"); + } + + { + auto str = L"47183823-2574-4bfd-b411-99ed177d3e43"sv; + auto guid = uuid::from_string(str).value(); + REQUIRE(to_string(guid) == str); + } + + { + auto str = "4718382325744bfdb41199ed177d3e43"sv; + REQUIRE_NOTHROW(uuid::from_string(str)); + REQUIRE(uuid::from_string(str).has_value()); + } + + { + auto str = "00000000-0000-0000-0000-000000000000"sv; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = "{00000000-0000-0000-0000-000000000000}"sv; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = L"00000000-0000-0000-0000-000000000000"sv; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } + + { + auto str = L"{00000000-0000-0000-0000-000000000000}"sv; + auto guid = uuid::from_string(str).value(); + REQUIRE(guid.is_nil()); + } +} + +TEST_CASE("uuid: Test constexpr from_string", "[uuid]") +{ + constexpr uuid value = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value(); + static_assert(!value.is_nil()); + static_assert(value.variant() == uuid_variant::rfc); + static_assert(value.version() != uuid_version::none); +} + +TEST_CASE("uuid: Test from_string(char*) invalid format", "[uuid]") +{ + REQUIRE(!uuid::from_string("").has_value()); + REQUIRE(!uuid::from_string("{}").has_value()); + REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e4").has_value()); + REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e430").has_value()); + REQUIRE(!uuid::from_string("{47183823-2574-4bfd-b411-99ed177d3e43").has_value()); + REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43}").has_value()); +} + +TEST_CASE("uuid: Test from_string(basic_string) invalid format", "[uuid]") +{ + using namespace std::string_literals; + + { + auto str = ""s; + REQUIRE(!uuid::from_string(str).has_value()); + } + + { + auto str = "{}"s; + REQUIRE(!uuid::from_string(str).has_value()); + } + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e4"s; + REQUIRE(!uuid::from_string(str).has_value()); + } + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e430"s; + REQUIRE(!uuid::from_string(str).has_value()); + } + + { + auto str = "{47183823-2574-4bfd-b411-99ed177d3e43"s; + REQUIRE(!uuid::from_string(str).has_value()); + } + + { + auto str = "47183823-2574-4bfd-b411-99ed177d3e43}"s; + REQUIRE(!uuid::from_string(str).has_value()); + } +} + +TEST_CASE("uuid: Test from_string(basic_string_view) invalid format", "[uuid]") +{ + using namespace std::string_view_literals; + + REQUIRE(!uuid::from_string(""sv).has_value()); + REQUIRE(!uuid::from_string("{}"sv).has_value()); + REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e4"sv).has_value()); + REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e430"sv).has_value()); + REQUIRE(!uuid::from_string("{47183823-2574-4bfd-b411-99ed177d3e43"sv).has_value()); + REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43}"sv).has_value()); +} + +TEST_CASE("uuid: Test iterators constructor", "[uuid]") +{ + using namespace std::string_literals; + + { + std::array arr{ + {0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, + 0x17, 0x7d, 0x3e, 0x43} + }; + + auto const guid = uuid(std::begin(arr), std::end(arr)); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); + } + + { + uuid::value_type arr[16] = {// NOLINT + 0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, + 0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43}; + + auto const guid = uuid(std::begin(arr), std::end(arr)); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); + } +} + +TEST_CASE("uuid: Test array constructors", "[uuid]") +{ + using namespace std::string_literals; + + { + auto const guid = uuid { + {0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, + 0x17, 0x7d, 0x3e, 0x43} + }; + + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); + } + + { + auto arr = std::array{ + {0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, + 0x17, 0x7d, 0x3e, 0x43} + }; + + auto const guid = uuid(arr); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); + } + + { + uuid::value_type arr[16]{// NOLINT + 0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, + 0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43}; + + auto const guid = uuid(arr); + REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); + } +} + +TEST_CASE("uuid: Test equality", "[uuid]") +{ + uuid empty; + + auto engine = uuid_random_generator::engine_type{}; + seed_rng(engine); + uuid guid = uuid_random_generator{engine}(); + + REQUIRE(empty == empty); + REQUIRE(guid == guid); + REQUIRE(empty != guid); +} + +TEST_CASE("Test comparison", "[uuid]") +{ + auto empty = uuid{}; + + auto engine = uuid_random_generator::engine_type{}; + seed_rng(engine); + + auto gen = uuid_random_generator{engine}; + auto id = gen(); + + REQUIRE(empty < id); + + auto ids = std::set{uuid{}, gen(), gen(), gen(), gen()}; + + REQUIRE(ids.size() == 5); + REQUIRE(ids.contains(uuid{}) == true); +} + +TEST_CASE("uuid: Test hashing", "[uuid]") +{ + using namespace std::string_literals; + + auto str = "47183823-2574-4bfd-b411-99ed177d3e43"s; + auto guid = uuid::from_string(str).value(); + + auto h1 = std::hash{}; + auto h2 = std::hash{}; + REQUIRE(h1(str) != h2(guid)); + + auto engine = uuid_random_generator::engine_type{}; + seed_rng(engine); + uuid_random_generator gen{engine}; + + std::unordered_set ids{uuid{}, gen(), gen(), gen(), gen()}; + + REQUIRE(ids.size() == 5); + REQUIRE(ids.find(uuid{}) != ids.end()); +} + +TEST_CASE("uuid: Test swap", "[uuid]") +{ + uuid empty; + + auto engine = uuid_random_generator::engine_type{}; + seed_rng(engine); + uuid guid = uuid_random_generator{engine}(); + + REQUIRE(empty.is_nil()); + REQUIRE(!guid.is_nil()); + + std::swap(empty, guid); + + REQUIRE(!empty.is_nil()); + REQUIRE(guid.is_nil()); + + empty.swap(guid); + + REQUIRE(empty.is_nil()); + REQUIRE(!guid.is_nil()); +} + +TEST_CASE("uuid: Test constexpr", "[uuid]") +{ + constexpr uuid empty; + static_assert(empty.is_nil()); + static_assert(empty.variant() == uuid_variant::ncs); + static_assert(empty.version() == uuid_version::none); +} + +TEST_CASE("uuid: Test size", "[uuid]") +{ + REQUIRE(sizeof(uuid) == 16); +} + +TEST_CASE("uuid: Test assignment", "[uuid]") +{ + auto id1 = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value(); + auto id2 = id1; + REQUIRE(id1 == id2); + + id1 = uuid::from_string("{fea43102-064f-4444-adc2-02cec42623f8}").value(); + REQUIRE(id1 != id2); + + auto id3 = std::move(id2); + REQUIRE(to_string(id3) == "47183823-2574-4bfd-b411-99ed177d3e43"); +} + +TEST_CASE("uuid: Test trivial", "[uuid]") +{ + REQUIRE(std::is_trivially_copyable_v); +} + +TEST_CASE("uuid: Test as_bytes", "[uuid]") +{ + std::array arr{ + {0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d, + 0x3e, 0x43} + }; + + { + uuid id{arr}; + REQUIRE(!id.is_nil()); + + auto view = id.as_bytes(); + REQUIRE(memcmp(view.data(), arr.data(), arr.size()) == 0); + } + + { + const uuid id{arr}; + REQUIRE(!id.is_nil()); + + auto view = id.as_bytes(); + REQUIRE(memcmp(view.data(), arr.data(), arr.size()) == 0); + } +} +} // anonymous namespace + +// NOLINTEND(bugprone-unchecked-optional-access) diff --git a/nihil.uuid/CMakeLists.txt b/nihil.uuid/CMakeLists.txt deleted file mode 100644 index a210322..0000000 --- a/nihil.uuid/CMakeLists.txt +++ /dev/null @@ -1,22 +0,0 @@ -# This source code is released into the public domain. - -add_library(nihil.uuid STATIC) -target_link_libraries(nihil.uuid PRIVATE nihil.std) -target_sources(nihil.uuid - PUBLIC FILE_SET modules TYPE CXX_MODULES FILES - uuid.ccm -) - -if(NIHIL_TESTS) - enable_testing() - - add_executable(nihil.uuid.test test.cc) - target_link_libraries(nihil.uuid.test PRIVATE - nihil.uuid - Catch2::Catch2WithMain - ) - - include(CTest) - include(Catch) - catch_discover_tests(nihil.uuid.test) -endif() diff --git a/nihil.uuid/test.cc b/nihil.uuid/test.cc deleted file mode 100644 index 551c491..0000000 --- a/nihil.uuid/test.cc +++ /dev/null @@ -1,923 +0,0 @@ -/* - * 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. - */ - -#include - -import nihil.std; -import nihil.uuid; - -// NOLINTBEGIN(bugprone-unchecked-optional-access) - -namespace { -// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0205r0.html -template -void seed_rng(EngineT &engine) -{ - using engine_type = typename EngineT::result_type; - using device_type = std::random_device::result_type; - using seedseq_type = std::seed_seq::result_type; - - constexpr auto bytes_needed = StateSize * sizeof(engine_type); - constexpr auto numbers_needed = (sizeof(device_type) < sizeof(seedseq_type)) - ? (bytes_needed / sizeof(device_type)) - : (bytes_needed / sizeof(seedseq_type)); - - auto numbers = std::array{}; - auto rnddev = std::random_device{}; - std::ranges::generate(numbers, std::ref(rnddev)); - - auto seedseq = std::seed_seq(std::cbegin(numbers), std::cend(numbers)); - engine.seed(seedseq); -} - -using namespace nihil; - -TEST_CASE("uuid: Test multiple default generators", "[uuid]") -{ - uuid id1; - uuid id2; - - { - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - std::mt19937 generator(seq); - - id1 = uuid_random_generator{generator}(); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::random_number_based); - REQUIRE(id1.variant() == uuid_variant::rfc); - } - - { - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - std::mt19937 generator(seq); - - id2 = uuid_random_generator{generator}(); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::random_number_based); - REQUIRE(id2.variant() == uuid_variant::rfc); - } - - REQUIRE(id1 != id2); -} - -TEST_CASE("uuid: Test default generator", "[uuid]") -{ - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - std::mt19937 generator(seq); - - uuid const guid = uuid_random_generator{generator}(); - REQUIRE(!guid.is_nil()); - REQUIRE(guid.version() == uuid_version::random_number_based); - REQUIRE(guid.variant() == uuid_variant::rfc); -} - -TEST_CASE("uuid: Test random generator (conversion ctor w/ smart ptr)", "[uuid]") -{ - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - std::mt19937 generator(seq); - - uuid_random_generator dgen(&generator); - auto id1 = dgen(); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::random_number_based); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen(); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::random_number_based); - REQUIRE(id2.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); -} - -TEST_CASE("uuid: Test random generator (conversion ctor w/ ptr)", "[uuid]") -{ - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - auto generator = std::make_unique(seq); - - uuid_random_generator dgen(generator.get()); - auto id1 = dgen(); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::random_number_based); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen(); - REQUIRE(!id1.is_nil()); - REQUIRE(id2.version() == uuid_version::random_number_based); - REQUIRE(id2.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); -} - -TEST_CASE("uuid: Test random generator (conversion ctor w/ ref)", "[uuid]") -{ - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - std::mt19937 generator(seq); - - uuid_random_generator dgen(generator); - auto id1 = dgen(); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::random_number_based); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen(); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::random_number_based); - REQUIRE(id2.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); -} - -TEST_CASE("uuid: Test basic random generator (conversion ctor w/ ptr) " - "w/ ranlux48_base", - "[uuid]") -{ - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - std::ranlux48_base generator(seq); - - basic_uuid_random_generator dgen(&generator); - auto id1 = dgen(); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::random_number_based); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen(); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::random_number_based); - REQUIRE(id2.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); -} - -TEST_CASE("uuid: Test basic random generator (conversion ctor w/ smart ptr) " - "w/ ranlux48_base", - "[uuid]") -{ - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - auto generator = std::make_unique(seq); - - basic_uuid_random_generator dgen(generator.get()); - auto id1 = dgen(); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::random_number_based); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen(); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::random_number_based); - REQUIRE(id2.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); -} - -TEST_CASE("uuid: Test basic random generator (conversion ctor w/ ref) " - "w/ ranlux48_base", - "[uuid]") -{ - std::random_device rd; - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - std::seed_seq seq(std::begin(seed_data), std::end(seed_data)); - std::ranlux48_base generator(seq); - - basic_uuid_random_generator dgen(generator); - auto id1 = dgen(); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::random_number_based); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen(); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::random_number_based); - REQUIRE(id2.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); -} - -TEST_CASE("uuid: Test namespaces", "[uuid]") -{ - REQUIRE(uuid_namespace_dns == uuid::from_string("6ba7b810-9dad-11d1-80b4-00c04fd430c8")); - REQUIRE(uuid_namespace_url == uuid::from_string("6ba7b811-9dad-11d1-80b4-00c04fd430c8")); - REQUIRE(uuid_namespace_oid == uuid::from_string("6ba7b812-9dad-11d1-80b4-00c04fd430c8")); - REQUIRE(uuid_namespace_x500 == uuid::from_string("6ba7b814-9dad-11d1-80b4-00c04fd430c8")); -} - -TEST_CASE("uuid: Test name generator (char*)", "[uuid]") -{ - uuid_name_generator dgen(uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()); - - auto id1 = dgen("john"); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::name_based_sha1); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen("jane"); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::name_based_sha1); - REQUIRE(id2.variant() == uuid_variant::rfc); - - auto id3 = dgen("jane"); - REQUIRE(!id3.is_nil()); - REQUIRE(id3.version() == uuid_version::name_based_sha1); - REQUIRE(id3.variant() == uuid_variant::rfc); - - auto id4 = dgen(L"jane"); - REQUIRE(!id4.is_nil()); - REQUIRE(id4.version() == uuid_version::name_based_sha1); - REQUIRE(id4.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); - REQUIRE(id2 == id3); - REQUIRE(id3 != id4); -} - -TEST_CASE("uuid: Test name generator (std::string)", "[uuid]") -{ - using namespace std::string_literals; - - uuid_name_generator dgen(uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()); - auto id1 = dgen("john"s); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::name_based_sha1); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen("jane"s); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::name_based_sha1); - REQUIRE(id2.variant() == uuid_variant::rfc); - - auto id3 = dgen("jane"s); - REQUIRE(!id3.is_nil()); - REQUIRE(id3.version() == uuid_version::name_based_sha1); - REQUIRE(id3.variant() == uuid_variant::rfc); - - auto id4 = dgen(L"jane"s); - REQUIRE(!id4.is_nil()); - REQUIRE(id4.version() == uuid_version::name_based_sha1); - REQUIRE(id4.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); - REQUIRE(id2 == id3); - REQUIRE(id3 != id4); -} - -TEST_CASE("uuid: Test name generator (std::string_view)", "[uuid]") -{ - using namespace std::string_view_literals; - - uuid_name_generator dgen(uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()); - auto id1 = dgen("john"sv); - REQUIRE(!id1.is_nil()); - REQUIRE(id1.version() == uuid_version::name_based_sha1); - REQUIRE(id1.variant() == uuid_variant::rfc); - - auto id2 = dgen("jane"sv); - REQUIRE(!id2.is_nil()); - REQUIRE(id2.version() == uuid_version::name_based_sha1); - REQUIRE(id2.variant() == uuid_variant::rfc); - - auto id3 = dgen("jane"sv); - REQUIRE(!id3.is_nil()); - REQUIRE(id3.version() == uuid_version::name_based_sha1); - REQUIRE(id3.variant() == uuid_variant::rfc); - - auto id4 = dgen(L"jane"sv); - REQUIRE(!id4.is_nil()); - REQUIRE(id4.version() == uuid_version::name_based_sha1); - REQUIRE(id4.variant() == uuid_variant::rfc); - - REQUIRE(id1 != id2); - REQUIRE(id2 == id3); - REQUIRE(id3 != id4); -} - -TEST_CASE("uuid: Test name generator equality (char const*, std::string, " - "std::string_view)", - "[uuid]") -{ - using namespace std::literals; - - auto dgen = uuid_name_generator( - uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value()); - auto id1 = dgen("john"); - auto id2 = dgen("john"s); - auto id3 = dgen("john"sv); - - REQUIRE(id1 == id2); - REQUIRE(id2 == id3); -} - -TEST_CASE("uuid: Test default constructor", "[uuid]") -{ - auto empty = uuid(); - REQUIRE(empty.is_nil()); -} - -TEST_CASE("uuid: Test string conversion", "[uuid]") -{ - auto empty = uuid(); - REQUIRE(to_string(empty) == "00000000-0000-0000-0000-000000000000"); - REQUIRE(to_string(empty) == L"00000000-0000-0000-0000-000000000000"); -} - -TEST_CASE("uuid: Test is_valid_uuid(char*)", "[uuid]") -{ - REQUIRE(uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43")); - REQUIRE(uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43}")); - REQUIRE(uuid::is_valid_uuid(L"47183823-2574-4bfd-b411-99ed177d3e43")); - REQUIRE(uuid::is_valid_uuid(L"{47183823-2574-4bfd-b411-99ed177d3e43}")); - REQUIRE(uuid::is_valid_uuid("00000000-0000-0000-0000-000000000000")); - REQUIRE(uuid::is_valid_uuid("{00000000-0000-0000-0000-000000000000}")); - REQUIRE(uuid::is_valid_uuid(L"00000000-0000-0000-0000-000000000000")); - REQUIRE(uuid::is_valid_uuid(L"{00000000-0000-0000-0000-000000000000}")); -} - -TEST_CASE("uuid: Test is_valid_uuid(basic_string)", "[uuid]") -{ - using namespace std::string_literals; - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e43"s; - REQUIRE(uuid::is_valid_uuid(str)); - } - - { - auto str = "{47183823-2574-4bfd-b411-99ed177d3e43}"s; - REQUIRE(uuid::is_valid_uuid(str)); - } - - { - auto str = L"47183823-2574-4bfd-b411-99ed177d3e43"s; - REQUIRE(uuid::is_valid_uuid(str)); - } - - { - auto str = L"{47183823-2574-4bfd-b411-99ed177d3e43}"s; - REQUIRE(uuid::is_valid_uuid(str)); - } - - { - auto str = "00000000-0000-0000-0000-000000000000"s; - REQUIRE(uuid::is_valid_uuid(str)); - } - - { - auto str = "{00000000-0000-0000-0000-000000000000}"s; - REQUIRE(uuid::is_valid_uuid(str)); - } - - { - auto str = L"00000000-0000-0000-0000-000000000000"s; - REQUIRE(uuid::is_valid_uuid(str)); - } - - { - auto str = L"{00000000-0000-0000-0000-000000000000}"s; - REQUIRE(uuid::is_valid_uuid(str)); - } -} - -TEST_CASE("uuid: Test is_valid_uuid(basic_string_view)", "[uuid]") -{ - using namespace std::string_view_literals; - - REQUIRE(uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43"sv)); - REQUIRE(uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43}"sv)); - REQUIRE(uuid::is_valid_uuid(L"47183823-2574-4bfd-b411-99ed177d3e43"sv)); - REQUIRE(uuid::is_valid_uuid(L"{47183823-2574-4bfd-b411-99ed177d3e43}"sv)); - REQUIRE(uuid::is_valid_uuid("00000000-0000-0000-0000-000000000000"sv)); - REQUIRE(uuid::is_valid_uuid("{00000000-0000-0000-0000-000000000000}"sv)); - REQUIRE(uuid::is_valid_uuid(L"00000000-0000-0000-0000-000000000000"sv)); - REQUIRE(uuid::is_valid_uuid(L"{00000000-0000-0000-0000-000000000000}"sv)); -} - -TEST_CASE("uuid: Test is_valid_uuid(char*) invalid format", "[uuid]") -{ - REQUIRE(!uuid::is_valid_uuid("")); - REQUIRE(!uuid::is_valid_uuid("{}")); - REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e4")); - REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e430")); - REQUIRE(!uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43")); - REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43}")); -} - -TEST_CASE("uuid: Test is_valid_uuid(basic_string) invalid format", "[uuid]") -{ - using namespace std::string_literals; - - { - auto str = ""s; - REQUIRE(!uuid::is_valid_uuid(str)); - } - - { - auto str = "{}"s; - REQUIRE(!uuid::is_valid_uuid(str)); - } - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e4"s; - REQUIRE(!uuid::is_valid_uuid(str)); - } - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e430"s; - REQUIRE(!uuid::is_valid_uuid(str)); - } - - { - auto str = "{47183823-2574-4bfd-b411-99ed177d3e43"s; - REQUIRE(!uuid::is_valid_uuid(str)); - } - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e43}"s; - REQUIRE(!uuid::is_valid_uuid(str)); - } -} - -TEST_CASE("uuid: Test is_valid_uuid(basic_string_view) invalid format", "[uuid]") -{ - using namespace std::string_view_literals; - - REQUIRE(!uuid::is_valid_uuid(""sv)); - REQUIRE(!uuid::is_valid_uuid("{}"sv)); - REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e4"sv)); - REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e430"sv)); - REQUIRE(!uuid::is_valid_uuid("{47183823-2574-4bfd-b411-99ed177d3e43"sv)); - REQUIRE(!uuid::is_valid_uuid("47183823-2574-4bfd-b411-99ed177d3e43}"sv)); -} - -TEST_CASE("uuid: Test from_string(char*)", "[uuid]") -{ - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e43"; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == str); - } - - { - auto str = "{47183823-2574-4bfd-b411-99ed177d3e43}"; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); - } - - { - auto guid = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value(); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); - REQUIRE(to_string(guid) == L"47183823-2574-4bfd-b411-99ed177d3e43"); - } - - { - auto str = L"47183823-2574-4bfd-b411-99ed177d3e43"; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == str); - } - - { - auto str = "4718382325744bfdb41199ed177d3e43"; - REQUIRE_NOTHROW(uuid::from_string(str)); - REQUIRE(uuid::from_string(str).has_value()); - } - - { - auto str = "00000000-0000-0000-0000-000000000000"; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = "{00000000-0000-0000-0000-000000000000}"; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = L"00000000-0000-0000-0000-000000000000"; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = L"{00000000-0000-0000-0000-000000000000}"; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } -} - -TEST_CASE("uuid: Test from_string(basic_string)", "[uuid]") -{ - using namespace std::string_literals; - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e43"s; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == str); - } - - { - auto str = "{47183823-2574-4bfd-b411-99ed177d3e43}"s; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); - } - - { - auto guid = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43"s).value(); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); - REQUIRE(to_string(guid) == L"47183823-2574-4bfd-b411-99ed177d3e43"); - } - - { - auto str = L"47183823-2574-4bfd-b411-99ed177d3e43"s; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == str); - } - - { - auto str = "4718382325744bfdb41199ed177d3e43"s; - REQUIRE_NOTHROW(uuid::from_string(str)); - REQUIRE(uuid::from_string(str).has_value()); - } - - { - auto str = "00000000-0000-0000-0000-000000000000"s; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = "{00000000-0000-0000-0000-000000000000}"s; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = L"00000000-0000-0000-0000-000000000000"s; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = L"{00000000-0000-0000-0000-000000000000}"s; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } -} - -TEST_CASE("uuid: Test from_string(basic_string_view)", "[uuid]") -{ - using namespace std::string_view_literals; - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e43"sv; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == str); - } - - { - auto str = "{47183823-2574-4bfd-b411-99ed177d3e43}"sv; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); - } - - { - auto guid = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43"sv).value(); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"); - REQUIRE(to_string(guid) == L"47183823-2574-4bfd-b411-99ed177d3e43"); - } - - { - auto str = L"47183823-2574-4bfd-b411-99ed177d3e43"sv; - auto guid = uuid::from_string(str).value(); - REQUIRE(to_string(guid) == str); - } - - { - auto str = "4718382325744bfdb41199ed177d3e43"sv; - REQUIRE_NOTHROW(uuid::from_string(str)); - REQUIRE(uuid::from_string(str).has_value()); - } - - { - auto str = "00000000-0000-0000-0000-000000000000"sv; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = "{00000000-0000-0000-0000-000000000000}"sv; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = L"00000000-0000-0000-0000-000000000000"sv; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } - - { - auto str = L"{00000000-0000-0000-0000-000000000000}"sv; - auto guid = uuid::from_string(str).value(); - REQUIRE(guid.is_nil()); - } -} - -TEST_CASE("uuid: Test constexpr from_string", "[uuid]") -{ - constexpr uuid value = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value(); - static_assert(!value.is_nil()); - static_assert(value.variant() == uuid_variant::rfc); - static_assert(value.version() != uuid_version::none); -} - -TEST_CASE("uuid: Test from_string(char*) invalid format", "[uuid]") -{ - REQUIRE(!uuid::from_string("").has_value()); - REQUIRE(!uuid::from_string("{}").has_value()); - REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e4").has_value()); - REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e430").has_value()); - REQUIRE(!uuid::from_string("{47183823-2574-4bfd-b411-99ed177d3e43").has_value()); - REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43}").has_value()); -} - -TEST_CASE("uuid: Test from_string(basic_string) invalid format", "[uuid]") -{ - using namespace std::string_literals; - - { - auto str = ""s; - REQUIRE(!uuid::from_string(str).has_value()); - } - - { - auto str = "{}"s; - REQUIRE(!uuid::from_string(str).has_value()); - } - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e4"s; - REQUIRE(!uuid::from_string(str).has_value()); - } - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e430"s; - REQUIRE(!uuid::from_string(str).has_value()); - } - - { - auto str = "{47183823-2574-4bfd-b411-99ed177d3e43"s; - REQUIRE(!uuid::from_string(str).has_value()); - } - - { - auto str = "47183823-2574-4bfd-b411-99ed177d3e43}"s; - REQUIRE(!uuid::from_string(str).has_value()); - } -} - -TEST_CASE("uuid: Test from_string(basic_string_view) invalid format", "[uuid]") -{ - using namespace std::string_view_literals; - - REQUIRE(!uuid::from_string(""sv).has_value()); - REQUIRE(!uuid::from_string("{}"sv).has_value()); - REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e4"sv).has_value()); - REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e430"sv).has_value()); - REQUIRE(!uuid::from_string("{47183823-2574-4bfd-b411-99ed177d3e43"sv).has_value()); - REQUIRE(!uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43}"sv).has_value()); -} - -TEST_CASE("uuid: Test iterators constructor", "[uuid]") -{ - using namespace std::string_literals; - - { - std::array arr{ - {0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, - 0x17, 0x7d, 0x3e, 0x43} - }; - - auto const guid = uuid(std::begin(arr), std::end(arr)); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); - } - - { - uuid::value_type arr[16] = {// NOLINT - 0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, - 0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43}; - - auto const guid = uuid(std::begin(arr), std::end(arr)); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); - } -} - -TEST_CASE("uuid: Test array constructors", "[uuid]") -{ - using namespace std::string_literals; - - { - auto const guid = uuid { - {0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, - 0x17, 0x7d, 0x3e, 0x43} - }; - - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); - } - - { - auto arr = std::array{ - {0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, - 0x17, 0x7d, 0x3e, 0x43} - }; - - auto const guid = uuid(arr); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); - } - - { - uuid::value_type arr[16]{// NOLINT - 0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, - 0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d, 0x3e, 0x43}; - - auto const guid = uuid(arr); - REQUIRE(to_string(guid) == "47183823-2574-4bfd-b411-99ed177d3e43"s); - } -} - -TEST_CASE("uuid: Test equality", "[uuid]") -{ - uuid empty; - - auto engine = uuid_random_generator::engine_type{}; - seed_rng(engine); - uuid guid = uuid_random_generator{engine}(); - - REQUIRE(empty == empty); - REQUIRE(guid == guid); - REQUIRE(empty != guid); -} - -TEST_CASE("Test comparison", "[uuid]") -{ - auto empty = uuid{}; - - auto engine = uuid_random_generator::engine_type{}; - seed_rng(engine); - - auto gen = uuid_random_generator{engine}; - auto id = gen(); - - REQUIRE(empty < id); - - auto ids = std::set{uuid{}, gen(), gen(), gen(), gen()}; - - REQUIRE(ids.size() == 5); - REQUIRE(ids.contains(uuid{}) == true); -} - -TEST_CASE("uuid: Test hashing", "[uuid]") -{ - using namespace std::string_literals; - - auto str = "47183823-2574-4bfd-b411-99ed177d3e43"s; - auto guid = uuid::from_string(str).value(); - - auto h1 = std::hash{}; - auto h2 = std::hash{}; - REQUIRE(h1(str) != h2(guid)); - - auto engine = uuid_random_generator::engine_type{}; - seed_rng(engine); - uuid_random_generator gen{engine}; - - std::unordered_set ids{uuid{}, gen(), gen(), gen(), gen()}; - - REQUIRE(ids.size() == 5); - REQUIRE(ids.find(uuid{}) != ids.end()); -} - -TEST_CASE("uuid: Test swap", "[uuid]") -{ - uuid empty; - - auto engine = uuid_random_generator::engine_type{}; - seed_rng(engine); - uuid guid = uuid_random_generator{engine}(); - - REQUIRE(empty.is_nil()); - REQUIRE(!guid.is_nil()); - - std::swap(empty, guid); - - REQUIRE(!empty.is_nil()); - REQUIRE(guid.is_nil()); - - empty.swap(guid); - - REQUIRE(empty.is_nil()); - REQUIRE(!guid.is_nil()); -} - -TEST_CASE("uuid: Test constexpr", "[uuid]") -{ - constexpr uuid empty; - static_assert(empty.is_nil()); - static_assert(empty.variant() == uuid_variant::ncs); - static_assert(empty.version() == uuid_version::none); -} - -TEST_CASE("uuid: Test size", "[uuid]") -{ - REQUIRE(sizeof(uuid) == 16); -} - -TEST_CASE("uuid: Test assignment", "[uuid]") -{ - auto id1 = uuid::from_string("47183823-2574-4bfd-b411-99ed177d3e43").value(); - auto id2 = id1; - REQUIRE(id1 == id2); - - id1 = uuid::from_string("{fea43102-064f-4444-adc2-02cec42623f8}").value(); - REQUIRE(id1 != id2); - - auto id3 = std::move(id2); - REQUIRE(to_string(id3) == "47183823-2574-4bfd-b411-99ed177d3e43"); -} - -TEST_CASE("uuid: Test trivial", "[uuid]") -{ - REQUIRE(std::is_trivially_copyable_v); -} - -TEST_CASE("uuid: Test as_bytes", "[uuid]") -{ - std::array arr{ - {0x47, 0x18, 0x38, 0x23, 0x25, 0x74, 0x4b, 0xfd, 0xb4, 0x11, 0x99, 0xed, 0x17, 0x7d, - 0x3e, 0x43} - }; - - { - uuid id{arr}; - REQUIRE(!id.is_nil()); - - auto view = id.as_bytes(); - REQUIRE(memcmp(view.data(), arr.data(), arr.size()) == 0); - } - - { - const uuid id{arr}; - REQUIRE(!id.is_nil()); - - auto view = id.as_bytes(); - REQUIRE(memcmp(view.data(), arr.data(), arr.size()) == 0); - } -} -} // anonymous namespace - -// NOLINTEND(bugprone-unchecked-optional-access) diff --git a/nihil.uuid/uuid.ccm b/nihil.uuid/uuid.ccm deleted file mode 100644 index a7a4770..0000000 --- a/nihil.uuid/uuid.ccm +++ /dev/null @@ -1,768 +0,0 @@ -// 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. - -export module nihil.uuid; - -import nihil.std; - -namespace nihil { - -template -[[nodiscard]] constexpr auto hex2char(TChar const ch) noexcept -> unsigned char -{ - if (ch >= static_cast('0') && ch <= static_cast('9')) - return static_cast(ch - static_cast('0')); - - if (ch >= static_cast('a') && ch <= static_cast('f')) - return static_cast(10 + ch - static_cast('a')); - - if (ch >= static_cast('A') && ch <= static_cast('F')) - return static_cast(10 + ch - static_cast('A')); - - return 0; -} - -template -[[nodiscard]] constexpr auto is_hex(TChar const ch) noexcept -> bool -{ - return (ch >= static_cast('0') && ch <= static_cast('9')) || - (ch >= static_cast('a') && ch <= static_cast('f')) || - (ch >= static_cast('A') && ch <= static_cast('F')); -} - -template -[[nodiscard]] constexpr auto -to_string_view(TChar const *str) noexcept -> std::basic_string_view -{ - if (str) - return str; - return {}; -} - -template -[[nodiscard]] constexpr auto to_string_view(StringType const &str) noexcept - -> std::basic_string_view -{ - return str; -} - -struct sha1 -{ - using digest32_t = std::array; - using digest8_t = std::array; - - static constexpr unsigned int block_bytes = 64; - - sha1() - { - reset(); - } - - [[nodiscard]] static auto - left_rotate(std::uint32_t value, std::size_t const count) noexcept -> std::uint32_t - { - return (value << count) ^ (value >> (32 - count)); - } - - auto reset(this sha1 &self) noexcept -> void - { - self.m_digest[0] = 0x67452301; - self.m_digest[1] = 0xEFCDAB89; - self.m_digest[2] = 0x98BADCFE; - self.m_digest[3] = 0x10325476; - self.m_digest[4] = 0xC3D2E1F0; - self.m_blockByteIndex = 0; - self.m_byteCount = 0; - } - - auto process_byte(this sha1 &self, std::uint8_t octet) -> void - { - self.m_block.at(self.m_blockByteIndex++) = octet; - ++self.m_byteCount; - - if (self.m_blockByteIndex == block_bytes) { - self.m_blockByteIndex = 0; - self.process_block(); - } - } - - auto process_block(this sha1 &self, void const *const start, void const *const end) -> void - { - auto const *first = static_cast(start); - auto const *last = static_cast(end); - - while (first != last) { - self.process_byte(*first); - first++; - } - } - - auto process_bytes(this sha1 &self, void const *const data, std::size_t const len) -> void - { - auto *block = static_cast(data); - self.process_block(block, block + len); - } - - auto get_digest(this sha1 &self) -> digest32_t - { - auto const bit_count = self.m_byteCount * 8; - - self.process_byte(0x80); - if (self.m_blockByteIndex > 56) { - while (self.m_blockByteIndex != 0) - self.process_byte(0); - - while (self.m_blockByteIndex < 56) - self.process_byte(0); - } else { - while (self.m_blockByteIndex < 56) - self.process_byte(0); - } - - self.process_byte(0); - self.process_byte(0); - self.process_byte(0); - self.process_byte(0); - self.process_byte(static_cast((bit_count >> 24U) & 0xFFU)); - self.process_byte(static_cast((bit_count >> 16U) & 0xFFU)); - self.process_byte(static_cast((bit_count >> 8U) & 0xFFU)); - self.process_byte(static_cast((bit_count) & 0xFFU)); - - return self.m_digest; - } - - auto get_digest_bytes(this sha1 &self) -> digest8_t - { - auto d32 = self.get_digest(); - - return { - static_cast(d32[0] >> 24U), - static_cast(d32[0] >> 16U), - static_cast(d32[0] >> 8U), - static_cast(d32[0] >> 0U), - - static_cast(d32[1] >> 24U), - static_cast(d32[1] >> 16U), - static_cast(d32[1] >> 8U), - static_cast(d32[1] >> 0U), - - static_cast(d32[2] >> 24U), - static_cast(d32[2] >> 16U), - static_cast(d32[2] >> 8U), - static_cast(d32[2] >> 0U), - - static_cast(d32[3] >> 24U), - static_cast(d32[3] >> 16U), - static_cast(d32[3] >> 8U), - static_cast(d32[3] >> 0U), - - static_cast(d32[4] >> 24U), - static_cast(d32[4] >> 16U), - static_cast(d32[4] >> 8U), - static_cast(d32[4] >> 0U), - }; - } - -private: - auto process_block(this sha1 &self) -> void - { - auto w = std::array{}; - - for (std::size_t i = 0; i < 16; i++) { - w.at(i) = static_cast(self.m_block.at((i * 4) + 0)) << 24U; - w.at(i) |= static_cast(self.m_block.at((i * 4) + 1)) << 16U; - w.at(i) |= static_cast(self.m_block.at((i * 4) + 2)) << 8U; - w.at(i) |= static_cast(self.m_block.at((i * 4) + 3)); - } - - for (std::size_t i = 16; i < 80; i++) { - w.at(i) = left_rotate( - (w.at(i - 3) ^ w.at(i - 8) ^ w.at(i - 14) ^ w.at(i - 16)), 1); - } - - auto a = self.m_digest[0]; - auto b = self.m_digest[1]; - auto c = self.m_digest[2]; - auto d = self.m_digest[3]; - auto e = self.m_digest[4]; - - for (std::size_t i = 0; i < 80; ++i) { - auto f = std::uint32_t{0}; - auto k = std::uint32_t{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; - } - - auto temp = std::uint32_t{left_rotate(a, 5) + f + e + k + w.at(i)}; - e = d; - d = c; - c = left_rotate(b, 30); - b = a; - a = temp; - } - - self.m_digest[0] += a; - self.m_digest[1] += b; - self.m_digest[2] += c; - self.m_digest[3] += d; - self.m_digest[4] += e; - } - - digest32_t m_digest{}; - std::array m_block{}; - std::size_t m_blockByteIndex{}; - std::size_t m_byteCount{}; -}; - -template -inline constexpr std::string_view empty_guid = "00000000-0000-0000-0000-000000000000"; - -template <> -inline constexpr std::wstring_view empty_guid = L"00000000-0000-0000-0000-000000000000"; - -template -inline constexpr std::string_view guid_encoder = "0123456789abcdef"; - -template <> -inline constexpr std::wstring_view guid_encoder = L"0123456789abcdef"; - -// --------------------------------------------------------------------- -// UUID format https://tools.ietf.org/html/rfc4122 -// --------------------------------------------------------------------- - -// --------------------------------------------------------------------- -// Field NDR Data Type Octet # Note -// 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 : std::uint8_t { - // 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 : std::uint8_t { - // only possible for nil or invalid uuids - none = 0, - // The time-based version specified in RFC 4122 - time_based = 1, - // DCE Security version, with embedded POSIX UIDs. - dce_security = 2, - // The name-based version specified in RFS 4122 with MD5 hashing - name_based_md5 = 3, - // The randomly or pseudo-randomly generated version specified in RFS 4122 - random_number_based = 4, - // The name-based version specified in RFS 4122 with SHA1 hashing - name_based_sha1 = 5 -}; - -// Forward declare uuid and to_string so that we can declare to_string as a -// friend later. -export struct uuid; -export template , - typename Allocator = std::allocator> -auto to_string(uuid const &id) -> std::basic_string; - -// -------------------------------------------------------------------------------------------------------------------------- -// uuid class -// -------------------------------------------------------------------------------------------------------------------------- -export struct uuid -{ - using value_type = std::uint8_t; - - constexpr uuid() noexcept = default; - - uuid(value_type (&arr)[16]) noexcept // NOLINT - { - std::ranges::copy(arr, std::ranges::begin(data)); - } - - explicit constexpr uuid(std::array const &arr) noexcept - : data{arr} - { - } - - explicit uuid(std::span bytes) - { - std::ranges::copy(bytes, std::ranges::begin(data)); - } - - explicit uuid(std::span bytes) - { - if (bytes.size() != 16) - throw std::logic_error("wrong size for uuid"); - std::ranges::copy(bytes, std::ranges::begin(data)); - } - - template - explicit uuid(ForwardIterator first, ForwardIterator last) - { - if (std::distance(first, last) != 16) - throw std::logic_error("wrong size for uuid"); - - std::copy(first, last, std::begin(data)); - } - - [[nodiscard]] constexpr auto variant() const noexcept -> uuid_variant - { - if ((data[8] & 0x80U) == 0x00U) - return uuid_variant::ncs; - else if ((data[8] & 0xC0U) == 0x80U) - return uuid_variant::rfc; - else if ((data[8] & 0xE0U) == 0xC0U) - return uuid_variant::microsoft; - else - return uuid_variant::reserved; - } - - [[nodiscard]] constexpr auto version() const noexcept -> uuid_version - { - if ((data[6] & 0xF0U) == 0x10U) - return uuid_version::time_based; - else if ((data[6] & 0xF0U) == 0x20U) - return uuid_version::dce_security; - else if ((data[6] & 0xF0U) == 0x30U) - return uuid_version::name_based_md5; - else if ((data[6] & 0xF0U) == 0x40U) - return uuid_version::random_number_based; - else if ((data[6] & 0xF0U) == 0x50U) - return uuid_version::name_based_sha1; - else - return uuid_version::none; - } - - [[nodiscard]] constexpr auto is_nil() const noexcept -> bool - { - return std::ranges::all_of(data, [](auto i) { return i == 0; }); - } - - auto swap(uuid &other) noexcept -> void - { - data.swap(other.data); - } - - [[nodiscard]] auto as_bytes() const -> std::span - { - return std::span( - reinterpret_cast(data.data()), 16); - } - - template - [[nodiscard]] constexpr static auto is_valid_uuid(StringType const &in_str) noexcept -> bool - { - auto str = to_string_view(in_str); - auto firstDigit = true; - auto hasBraces = std::size_t{0}; - auto index = std::size_t{0}; - - if (str.empty()) - return false; - - if (str.front() == '{') - hasBraces = 1; - - if (hasBraces && str.back() != '}') - return false; - - for (std::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 - [[nodiscard]] constexpr static auto - from_string(StringType const &in_str) -> std::optional - { - auto str = to_string_view(in_str); - bool firstDigit = true; - auto hasBraces = std::size_t{0}; - auto index = std::size_t{0}; - - auto data = std::array{}; - - if (str.empty()) - return {}; - - if (str.front() == '{') - hasBraces = 1; - if (hasBraces && str.back() != '}') - return {}; - - for (std::size_t i = hasBraces; i < str.size() - hasBraces; ++i) { - if (str[i] == '-') - continue; - - if (index >= 16 || !is_hex(str[i])) { - return {}; - } - - if (firstDigit) { - data.at(index) = static_cast(hex2char(str[i]) << 4); - firstDigit = false; - } else { - data.at(index) = - static_cast(data.at(index) | hex2char(str[i])); - index++; - firstDigit = true; - } - } - - if (index < 16) { - return {}; - } - - return uuid{data}; - } - -private: - std::array data{{0}}; - - friend auto operator==(uuid const &, uuid const &) noexcept -> bool; - friend auto operator<(uuid const &, uuid const &) noexcept -> bool; - - template - friend auto operator<<(std::basic_ostream &s, uuid const &id) - -> std::basic_ostream &; - - template - friend auto to_string(uuid const &id) -> std::basic_string; - - friend std::hash; -}; - -// -------------------------------------------------------------------------------------------------------------------------- -// 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 -[[nodiscard]] auto to_string(uuid const &id) -> std::basic_string -{ - auto uustr = - std::basic_string(std::from_range, empty_guid); - - for (std::size_t i = 0, index = 0; i < 36; ++i) { - if (i == 8 || i == 13 || i == 18 || i == 23) - continue; - - uustr[i] = guid_encoder[id.data.at(index) >> 4U & 0x0FU]; - uustr[++i] = guid_encoder[id.data.at(index) & 0x0FU]; - index++; - } - - return uustr; -} - -export template -auto operator<<(std::basic_ostream &s, uuid const &id) - -> std::basic_ostream & -{ - return s << to_string(id); -} - -export auto swap(uuid &lhs, uuid &rhs) noexcept -> void -{ - 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 -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]] auto operator()() -> uuid - { - auto bytes = std::array{}; - std::ranges::generate(bytes, [&] { return distribution(*generator); }); - - // variant must be 10xxxxxx - bytes[8] &= 0xBFU; - bytes[8] |= 0x80U; - - // version must be 0100xxxx - bytes[6] &= 0x4FU; - bytes[6] |= 0x40U; - - return uuid{std::begin(bytes), std::end(bytes)}; - } - -private: - std::uniform_int_distribution distribution; - std::shared_ptr generator; -}; - -export using uuid_random_generator = basic_uuid_random_generator; - -export struct uuid_name_generator -{ - explicit uuid_name_generator(uuid const &namespace_uuid) noexcept - : nsuuid(namespace_uuid) - { - } - - template - [[nodiscard]] auto operator()(StringType const &name) -> uuid - { - reset(); - process_characters(to_string_view(name)); - return make_uuid(); - } - -private: - auto reset() -> void - { - hasher.reset(); - - auto nsbytes = nsuuid.as_bytes(); - - auto bytes = std::array(); - std::ranges::copy(nsbytes, std::ranges::begin(bytes)); - - hasher.process_bytes(bytes.data(), bytes.size()); - } - - template - auto process_characters(std::basic_string_view const str) -> void - { - for (std::uint32_t c : str) { - hasher.process_byte(static_cast(c & 0xFFU)); - if constexpr (!std::is_same_v) { - hasher.process_byte(static_cast((c >> 8U) & 0xFFU)); - hasher.process_byte(static_cast((c >> 16U) & 0xFFU)); - hasher.process_byte(static_cast((c >> 24U) & 0xFFU)); - } - } - } - - [[nodiscard]] auto make_uuid() -> uuid - { - auto digest = hasher.get_digest_bytes(); - - // variant must be 0b10xxxxxx - digest[8] &= 0xBFU; - digest[8] |= 0x80U; - - // version must be 0b0101xxxx - digest[6] &= 0x5FU; - digest[6] |= 0x50U; - - return uuid(std::span(digest).subspan(0, 16)); - } - - uuid nsuuid; - sha1 hasher; -}; - -/* - * Create a random UUID. - */ -export auto random_uuid() -> uuid -{ - auto rd = std::random_device(); - auto seed_data = std::array{}; - std::ranges::generate(seed_data, std::ref(rd)); - - auto seq = std::seed_seq(std::ranges::begin(seed_data), std::ranges::end(seed_data)); - auto generator = std::mt19937(seq); - auto gen = uuid_random_generator{generator}; - - return gen(); -} - -} // namespace nihil - -namespace std { - -export template <> -struct hash -{ - using argument_type = nihil::uuid; - using result_type = std::size_t; - - [[nodiscard]] auto operator()(argument_type const &uuid) const noexcept -> result_type - { - auto const l = static_cast(uuid.data[0]) << 56U | - static_cast(uuid.data[1]) << 48U | - static_cast(uuid.data[2]) << 40U | - static_cast(uuid.data[3]) << 32U | - static_cast(uuid.data[4]) << 24U | - static_cast(uuid.data[5]) << 16U | - static_cast(uuid.data[6]) << 8U | - static_cast(uuid.data[7]); - - auto const h = static_cast(uuid.data[8]) << 56U | - static_cast(uuid.data[9]) << 48U | - static_cast(uuid.data[10]) << 40U | - static_cast(uuid.data[11]) << 32U | - static_cast(uuid.data[12]) << 24U | - static_cast(uuid.data[13]) << 16U | - static_cast(uuid.data[14]) << 8U | - static_cast(uuid.data[15]); - - return std::hash{}(l ^ h); - } -}; - -} // namespace std -- cgit v1.2.3