uuid.h

// Copyright 2025 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <string_view>
 
#include "pw_assert/assert.h"
#include "pw_bytes/span.h"
#include "pw_containers/algorithm.h"
#include "pw_result/result.h"
#include "pw_status/status.h"
#include "pw_string/hex.h"
#include "pw_string/string.h"
 
namespace pw::uuid {
 
 
class Uuid {
 public:
  static constexpr size_t kSizeBytes = 16;
  static constexpr size_t kStringSize =
      std::string_view{"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}.size();
 
  // Default constructor initializes the uuid to the Nil UUID
  constexpr explicit Uuid() : uuid_() {}
 
  constexpr explicit Uuid(span<const uint8_t, kSizeBytes> uuid_span) : uuid_() {
    pw::copy(uuid_span.begin(), uuid_span.end(), uuid_.begin());
  }
 
  constexpr explicit Uuid(span<const std::byte, kSizeBytes> uuid_span)
      : uuid_() {
    // Manually copy to use static_cast which is constexpr
    for (size_t i = 0; i < uuid_.size(); i++) {
      uuid_[i] = static_cast<uint8_t>(uuid_span[i]);
    }
  }
 
  static constexpr Result<Uuid> FromSpan(span<const uint8_t> uuid_span) {
    if (uuid_span.size() != kSizeBytes) {
      return Status::FailedPrecondition();
    }
    return Uuid(
        span<const uint8_t, kSizeBytes>(uuid_span.data(), uuid_span.size()));
  }
 
  static constexpr Result<Uuid> FromSpan(ConstByteSpan uuid_span) {
    if (uuid_span.size() != kSizeBytes) {
      return Status::FailedPrecondition();
    }
    return Uuid(
        span<const std::byte, kSizeBytes>(uuid_span.data(), uuid_span.size()));
  }
 
  template <size_t kSize, typename = std::enable_if_t<kSize == kSizeBytes>>
  static constexpr Uuid FromSpan(const std::array<uint8_t, kSize>& uuid_array) {
    return Uuid(uuid_array);
  }
 
  template <size_t kSize, typename = std::enable_if_t<kSize == kSizeBytes>>
  static constexpr Uuid FromSpan(
      const std::array<std::byte, kSize>& uuid_array) {
    return Uuid(uuid_array);
  }
 
  template <size_t kSize, typename = std::enable_if_t<kSize == kSizeBytes>>
  static constexpr Uuid FromSpan(const uint8_t (&uuid_array)[kSize]) {
    return Uuid(span<const uint8_t, kSizeBytes>(uuid_array));
  }
 
  template <size_t kSize, typename = std::enable_if_t<kSize == kSizeBytes>>
  static constexpr Uuid FromSpan(const std::byte (&uuid_array)[kSize]) {
    return Uuid(span<const std::byte, kSizeBytes>(uuid_array));
  }
 
  static constexpr Result<Uuid> FromString(std::string_view string) {
    Status status = ValidateString(string);
    if (!status.ok()) {
      return status;
    }
    return Uuid(string);
  }
 
  constexpr span<const uint8_t, kSizeBytes> GetSpan() const { return uuid_; }
 
  constexpr bool operator==(const Uuid& other) const {
    for (size_t i = 0; i < kSizeBytes; i++) {
      if (uuid_[i] != other.uuid_[i]) {
        return false;
      }
    }
    return true;
  }
 
  constexpr bool operator!=(const Uuid& other) const {
    return !(*this == other);
  }
 
  constexpr InlineString<kStringSize> ToString() const {
    InlineString<kStringSize> out = {};
 
    for (size_t i = uuid_.size(); i-- != 0;) {
      out += string::NibbleToHex(uuid_[i] >> 4);
      out += string::NibbleToHex(uuid_[i] & 0xf);
      if ((i == 12) || (i == 10) || (i == 8) || (i == 6)) {
        out += '-';
      }
    }
    return out;
  }
 
 private:
  constexpr explicit Uuid(std::string_view uuid_str) : uuid_() {
    size_t out_hex_index = 2 * uuid_.size();  // UUID is stored little-endian.
    for (size_t i = 0; i < kStringSize; i++) {
      // Indices at which we expect to find a hyphen ('-') in a UUID string.
      if (i == 8 || i == 13 || i == 18 || i == 23) {
        PW_ASSERT(uuid_str[i] == '-');
        continue;
      }
      PW_ASSERT(uuid_str[i] != '\0');
 
      out_hex_index--;
      uint16_t value = string::HexToNibble(uuid_str[i]);
      PW_ASSERT(value <= 0xf);
      if (out_hex_index % 2 == 0) {
        uuid_[out_hex_index / 2] |= static_cast<uint8_t>(value);
      } else {
        uuid_[out_hex_index / 2] = static_cast<uint8_t>(value << 4);
      }
    }
  }
 
  static constexpr Status ValidateString(std::string_view uuid_str) {
    if (kStringSize != uuid_str.size()) {
      return Status::FailedPrecondition();
    }
    for (size_t i = 0; i < uuid_str.size(); i++) {
      if (i == 8 || i == 13 || i == 18 || i == 23) {
        if (uuid_str[i] != '-') {
          return Status::InvalidArgument();
        }
        continue;
      }
      if (string::IsHexDigit(uuid_str[i]) == 0) {
        return Status::InvalidArgument();
      }
    }
    return OkStatus();
  }
 
  std::array<uint8_t, kSizeBytes> uuid_;
};
 
}  // namespace pw::uuid