fixed indentation for uuid class

include/matador/utils/uuid.hpp

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

source/core/utils/uuid.cpp

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