sascha
/
query
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

fixed indentation for uuid class

This commit is contained in:
Sascha Kühl 2026-04-03 19:14:38 +02:00
parent 920fdc68ed
commit 40dfc30dae
2 changed files with 73 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
include/matador/utils/uuid.hpp
View File

@ -6,46 +6,39 @@
#include <cstdint> #include <cstdint>
namespace matador::utils { namespace matador::utils {
class uuid { class uuid {
public: public:
using uuid_array = std::array<uint32_t, 4>; using uuid_array = std::array<uint32_t, 4>;
// Default constructor initializes to zero // Default constructor initializes to zero
uuid() = default; uuid() = default;
// Static UUID v4 generator // Static UUID v4 generator
static uuid generate(); static uuid generate();
// Returns UUID as a string // Returns UUID as a string
[[nodiscard]] std::string str() const; [[nodiscard]] std::string str() const;
// Access to internal data // Access to internal data
[[nodiscard]] const uuid_array& data() const; [[nodiscard]] const uuid_array &data() const;
// Reset UUID to zero // Reset UUID to zero
void clear() { _data.fill(0); } void clear() { _data.fill(0); }
// Comparisons // Comparisons
friend bool operator==(const uuid& lhs, const uuid& rhs); friend bool operator==(const uuid &lhs, const uuid &rhs);
friend bool operator!=(const uuid& lhs, const uuid& rhs); friend bool operator!=(const uuid &lhs, const uuid &rhs);
friend bool operator<(const uuid& lhs, const uuid& rhs); friend bool operator<(const uuid &lhs, const uuid &rhs);
private: private:
uuid_array _data{0, 0, 0, 0}; uuid_array _data{0, 0, 0, 0};
}; };
} }
// Hash specialization to allow use in unordered containers // Hash specialization to allow use in unordered containers
template <> template<>
struct std::hash<matador::utils::uuid> { struct std::hash<matador::utils::uuid> {
std::size_t operator()(const matador::utils::uuid& u) const noexcept { std::size_t operator()(const matador::utils::uuid &u) const noexcept;
std::size_t h = 0;
for (const uint32_t val : u.data()) {
h ^= std::hash<uint32_t>{}(val) + 0x9e3779b9 + (h << 6) + (h >> 2);
}
return h;
}
}; };
#endif //MATADOR_UUID_HPP #endif //MATADOR_UUID_HPP

103
source/core/utils/uuid.cpp
View File

@ -3,73 +3,80 @@
#include <random> #include <random>
namespace matador::utils { namespace matador::utils {
uuid uuid::generate() { uuid uuid::generate() {
std::random_device rd; std::random_device rd;
std::mt19937_64 gen(rd()); std::mt19937_64 gen(rd());
std::uniform_int_distribution<uint64_t> dist; std::uniform_int_distribution<uint64_t> dist;
uint64_t high = dist(gen); uint64_t high = dist(gen);
uint64_t low = dist(gen); uint64_t low = dist(gen);
// Set version to 4 (UUID v4) // Set version to 4 (UUID v4)
high &= 0xFFFFFFFFFFFF0FFFULL; high &= 0xFFFFFFFFFFFF0FFFULL;
high |= 0x0000000000004000ULL; high |= 0x0000000000004000ULL;
// Set variant to 10xx (RFC 4122) // Set variant to 10xx (RFC 4122)
low &= 0x3FFFFFFFFFFFFFFFULL; low &= 0x3FFFFFFFFFFFFFFFULL;
low |= 0x8000000000000000ULL; low |= 0x8000000000000000ULL;
uuid result; uuid result;
result._data[0] = static_cast<uint32_t>(high >> 32); result._data[0] = static_cast<uint32_t>(high >> 32);
result._data[1] = static_cast<uint32_t>(high & 0xFFFFFFFF); result._data[1] = static_cast<uint32_t>(high & 0xFFFFFFFF);
result._data[2] = static_cast<uint32_t>(low >> 32); result._data[2] = static_cast<uint32_t>(low >> 32);
result._data[3] = static_cast<uint32_t>(low & 0xFFFFFFFF); result._data[3] = static_cast<uint32_t>(low & 0xFFFFFFFF);
return result; return result;
} }
std::string uuid::str() const { std::string uuid::str() const {
const char* hex = "0123456789abcdef"; const char *hex = "0123456789abcdef";
char out[36]; // UUID string format is 36 characters char out[36]; // UUID string format is 36 characters
int pos = 0; int pos = 0;
auto write_hex = [&](uint32_t value, int digits) { auto write_hex = [&](uint32_t value, int digits) {
for (int i = digits - 1; i >= 0; --i) { for (int i = digits - 1; i >= 0; --i) {
out[pos + i] = hex[value & 0xF]; out[pos + i] = hex[value & 0xF];
value >>= 4; value >>= 4;
} }
pos += digits; pos += digits;
}; };
write_hex(_data[0] >> 16, 8); write_hex(_data[0] >> 16, 8);
out[pos++] = '-'; out[pos++] = '-';
write_hex(_data[0] & 0xFFFF, 4); write_hex(_data[0] & 0xFFFF, 4);
out[pos++] = '-'; out[pos++] = '-';
write_hex(_data[1] >> 16, 4); write_hex(_data[1] >> 16, 4);
out[pos++] = '-'; out[pos++] = '-';
write_hex(_data[1] & 0xFFFF, 4); write_hex(_data[1] & 0xFFFF, 4);
out[pos++] = '-'; out[pos++] = '-';
write_hex(_data[2] >> 16, 4); write_hex(_data[2] >> 16, 4);
write_hex(_data[2] & 0xFFFF, 4); write_hex(_data[2] & 0xFFFF, 4);
write_hex(_data[3], 4); write_hex(_data[3], 4);
return {out, 36}; return {out, 36};
} }
const uuid::uuid_array& uuid::data() const { const uuid::uuid_array &uuid::data() const {
return _data; return _data;
} }
bool operator==( const uuid& lhs, const uuid& rhs ) { bool operator==(const uuid &lhs, const uuid &rhs) {
return lhs._data == rhs._data; return lhs._data == rhs._data;
} }
bool operator!=( const uuid& lhs, const uuid& rhs ) { bool operator!=(const uuid &lhs, const uuid &rhs) {
return !(lhs == rhs); return !(lhs == rhs);
} }
bool operator<( const uuid& lhs, const uuid& rhs ) { bool operator<(const uuid &lhs, const uuid &rhs) {
return lhs._data < rhs._data; return lhs._data < rhs._data;
} }
} }
std::size_t std::hash<matador::utils::uuid>::operator()(const matador::utils::uuid &u) const noexcept {
std::size_t h = 0;
for (const uint32_t val: u.data()) {
h ^= std::hash<uint32_t>{}(val) + 0x9e3779b9 + (h << 6) + (h >> 2);
}
return h;
}