util.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <bit>
#include <charconv>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
#include <string_view>
#include <type_traits>
 
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;
}
 
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