Source repositoryuuid.h

Go to the documentation of this file.

#pragma once
 
// standard includes
#include <array>
#include <cstddef>
#include <random>

namespace uuid_util {
  union uuid_t {
    std::array<std::uint8_t, 16> b8;  
    std::array<std::uint16_t, 8> b16;  
    std::array<std::uint32_t, 4> b32;  
    std::array<std::uint64_t, 2> b64;  

    static uuid_t generate(std::default_random_engine &engine) {
      std::uniform_int_distribution<std::uint8_t> dist(0, std::numeric_limits<std::uint8_t>::max());
 
      uuid_t buf;
      for (auto &el : buf.b8) {
        el = dist(engine);
      }
 
      buf.b8[7] = std::to_integer<std::uint8_t>(std::byte {buf.b8[7]} & std::byte {0b00101111});
      buf.b8[9] = std::to_integer<std::uint8_t>(std::byte {buf.b8[9]} & std::byte {0b10011111});
 
      return buf;
    }

    static uuid_t generate() {
      std::random_device r;
 
      std::default_random_engine engine {r()};
 
      return generate(engine);
    }

    [[nodiscard]] std::string string() const {
      std::string result;
 
      result.reserve(sizeof(uuid_t) * 2 + 4);
 
      auto hex = util::hex(*this, true);
      auto hex_view = hex.to_string_view();
 
      std::array<std::string_view, 4> slices = {
        hex_view.substr(0, 8),
        hex_view.substr(8, 4),
        hex_view.substr(12, 4),
        hex_view.substr(16, 4)
      };
      auto last_slice = hex_view.substr(20, 12);
 
      for (auto &slice : slices) {
        std::ranges::copy(slice, std::back_inserter(result));
 
        result.push_back('-');
      }
 
      std::ranges::copy(last_slice, std::back_inserter(result));
 
      return result;
    }

    constexpr bool operator==(const uuid_t &other) const {
      return b64[0] == other.b64[0] && b64[1] == other.b64[1];
    }

    constexpr bool operator<(const uuid_t &other) const {
      return (b64[0] < other.b64[0] || (b64[0] == other.b64[0] && b64[1] < other.b64[1]));
    }

    constexpr bool operator>(const uuid_t &other) const {
      return (b64[0] > other.b64[0] || (b64[0] == other.b64[0] && b64[1] > other.b64[1]));
    }
  };
}  // namespace uuid_util