util.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <bit>
#include <charconv>
#include <cstddef>
#include <cstdint>
#include <format>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace mm::core {
 
inline bool isUrlSafeId(std::string_view s) {
  constexpr std::size_t kMaxLength = 64;
  if (s.empty() || s.size() > kMaxLength) {
    return false;
  }
  return std::all_of(s.begin(), s.end(), [](const char c) {
    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '.' ||
           c == '_' || c == '-';
  });
}
 
template <typename T>
std::optional<T> parseHexOrDec(std::string_view s) {
  T value{};
  std::from_chars_result r;
  if (s.size() >= 2 && (s[0] == '0' || s[0] == '#') && (s[1] == 'x' || s[1] == 'X')) {
    r = std::from_chars(s.data() + 2, s.data() + s.size(), value, 16);
  } else {
    r = std::from_chars(s.data(), s.data() + s.size(), value);
  }
  if (r.ec != std::errc{} || r.ptr != s.data() + s.size()) {  // NOLINT(whitespace/braces)
    return std::nullopt;
  }
  return value;
}
 
inline std::string toHex(std::span<const uint8_t> bytes, std::string_view separator = {}) {
  std::string out;
  out.reserve(bytes.size() * (2 + separator.size()));
  for (std::size_t i = 0; i < bytes.size(); ++i) {
    if (i != 0) {
      out += separator;
    }
    out += std::format("{:02X}", bytes[i]);
  }
  return out;
}
 
inline std::optional<std::vector<uint8_t>> fromHex(std::string_view hex) {
  if (hex.size() % 2 != 0) {
    return std::nullopt;
  }
  const auto digit = [](char c) -> int {
    if (c >= '0' && c <= '9') {
      return c - '0';
    }
    if (c >= 'a' && c <= 'f') {
      return c - 'a' + 10;
    }
    if (c >= 'A' && c <= 'F') {
      return c - 'A' + 10;
    }
    return -1;
  };
  std::vector<uint8_t> out;
  out.reserve(hex.size() / 2);
  for (std::size_t i = 0; i < hex.size(); i += 2) {
    const int hi = digit(hex[i]);
    const int lo = digit(hex[i + 1]);
    if (hi < 0 || lo < 0) {
      return std::nullopt;
    }
    out.push_back(static_cast<uint8_t>((hi << 4) | lo));
  }
  return out;
}
 
template <typename T>
std::array<uint8_t, sizeof(T)> toBytes(T value, std::endian order = std::endian::little) {
  static_assert(std::is_integral_v<T>, "toBytes is for integral types");
  using U = std::make_unsigned_t<T>;
  const auto u = static_cast<U>(value);
  std::array<uint8_t, sizeof(T)> out{};
  for (std::size_t i = 0; i < sizeof(T); ++i) {
    const std::size_t byte = (order == std::endian::little) ? i : (sizeof(T) - 1 - i);
    out[byte] = static_cast<uint8_t>((u >> (8 * i)) & 0xFFu);
  }
  return out;
}
 
template <typename T>
T fromBytes(std::span<const uint8_t> bytes, std::endian order = std::endian::little) {
  static_assert(std::is_integral_v<T>, "fromBytes is for integral types");
  using U = std::make_unsigned_t<T>;
  U v = 0;
  const std::size_t n = std::min(sizeof(T), bytes.size());
  for (std::size_t i = 0; i < n; ++i) {
    const std::size_t shift = (order == std::endian::little) ? (8 * i) : (8 * (n - 1 - i));
    v |= static_cast<U>(bytes[i]) << shift;
  }
  return static_cast<T>(v);
}
 
}  // namespace mm::core