path: root/server/src/util.cppm

// Stuff that doesn't really have a place right now, but that is
// broadly useful.
export module routemon:util;

import std;

namespace routemon::util {

// For use with e.g. std::visit (on std::variant).
template <class... Ts>
struct overloaded : Ts...
{
  using Ts::operator()...;
};

export constexpr auto parse_double(
    std::string_view s,
    std::chars_format fmt = std::chars_format::general) noexcept
    -> std::optional<double>
{
  auto x = 0.0;
  auto [_, ec] = std::from_chars(s.data(), s.data() + s.size(), x, fmt);
  if (ec == std::errc{})
  {
    return x;
  }
  else
  {
    return std::nullopt;
  }
}

export constexpr auto parse_float(
    std::string_view s,
    std::chars_format fmt = std::chars_format::general) noexcept
    -> std::optional<float>
{
  auto x = 0.0;
  auto [_, ec] = std::from_chars(s.data(), s.data() + s.size(), x, fmt);
  if (ec == std::errc{})
  {
    return x;
  }
  else
  {
    return std::nullopt;
  }
}

export template <class T>
class aolist : public std::enable_shared_from_this<aolist<T>>
{
  T v_;
  std::shared_ptr<aolist<T> const> next_;

  explicit aolist(T v, std::shared_ptr<aolist<T> const> next)
    : v_{v}, next_{next}
  {
  }

public:
  static auto nil() -> std::shared_ptr<aolist<T>> { return nullptr; }

  static auto cons(T v, std::shared_ptr<aolist<T> const> l)
      -> std::shared_ptr<aolist<T>>
  {
    return std::shared_ptr<aolist<T>>{new aolist<T>{v, l}};
  }

  auto next() const -> std::shared_ptr<aolist<T> const> { return next_; }

  auto value() const noexcept -> T const& { return v_; }
};

export constexpr auto size_from_int(int x) -> std::optional<std::size_t>
{
  static_assert(
      sizeof(int) <= sizeof(std::size_t),
      "cannot cast int to smaller size_t type");
  if (x < 0)
    return std::nullopt;
  return static_cast<std::size_t>(x);
}

export constexpr auto int_from_size(std::size_t x) -> std::optional<int>
{
  constexpr auto int_max = size_from_int(std::numeric_limits<int>::max());
  static_assert(int_max.has_value());
  if (x > *int_max)
    return std::nullopt;
  return static_cast<int>(x);
}

export class zstring_view
{
  char const* s_;
  std::size_t length_;

public:
  constexpr explicit zstring_view(char const* s, std::size_t length)
    : s_{s}, length_{length}
  {
  }

  constexpr zstring_view(char const* s)
    : zstring_view{s, std::char_traits<char>::length(s)}
  {
  }

  auto length() const -> std::size_t { return length_; }

  auto c_str() const -> char const* { return s_; }

  operator std::string_view() const { return std::string_view{s_, length_}; }

  operator char const*() const { return s_; }
};

// View for null-terminated strings for which we might not
// necessarily be interested in the length. String length is only
// calculated on demand, at most once on each thread (on more than
// one thread when racing). May be null.
//
// It is undefined behavior to assign to a lazy_zstring_view when
// it is in use by other threads.
export class lazy_zstring_view
{
  static constexpr auto unset_length = std::numeric_limits<std::size_t>::max();

  char const* s_; // nullable
  mutable std::atomic<std::size_t> length_;
  static_assert(decltype(length_)::is_always_lock_free);

public:
  constexpr explicit lazy_zstring_view(char const* s)
    : s_{s}, length_{s ? unset_length : 0}
  {
  }

  ~lazy_zstring_view() = default;

  lazy_zstring_view(lazy_zstring_view const& sv) noexcept
    : s_{sv.s_}, length_{sv.length_.load(std::memory_order_acquire)}
  {
  }

  lazy_zstring_view(lazy_zstring_view&& sv) noexcept
    : s_{sv.s_}, length_{sv.length_.load(std::memory_order_acquire)}
  {
  }

  auto operator=(lazy_zstring_view const& rhs) noexcept -> lazy_zstring_view&
  {
    if (this != &rhs)
    {
      s_ = rhs.s_;
      length_.store(
          rhs.length_.load(std::memory_order_acquire),
          std::memory_order_release);
    }
    return *this;
  }

  auto operator=(lazy_zstring_view&& rhs) noexcept -> lazy_zstring_view&
  {
    return *this = rhs; // use the copy assignment operator
  }

  auto length() const noexcept -> std::size_t
  {
    if (auto v = length_.load(std::memory_order_acquire); v != unset_length)
      return v;
    auto l = std::char_traits<char>::length(s_);
    length_.store(l, std::memory_order_release);
    return l;
  }

  auto c_str() const noexcept -> char const* { return s_; }

  operator std::string_view() const noexcept
  {
    return std::string_view{s_, length()};
  }

  operator char const*() const noexcept { return s_; }

  auto operator==(std::string_view sv) const noexcept -> bool
  {
    if (auto v = length_.load(std::memory_order_acquire); v != unset_length)
      if (sv.length() != v)
        return false;
    auto res = std::char_traits<char>::compare(s_, sv.data(), sv.length());
    if (res != 0)
      return false;
    // Strings are equal for sv.length() characters.
    if (s_[sv.length()] != '\0')
      return false;
    // Strings are actually equal, and we have just found out the
    // length of this string, so we might as well set it.
    length_.store(sv.length(), std::memory_order_release);
    return true;
  }
};

constexpr auto operator""_zsv(char const* s, std::size_t length) noexcept
    -> zstring_view
{
  return zstring_view{s, length};
}

auto operator==(zstring_view lhs, zstring_view rhs) -> bool
{
  return std::string_view{lhs} == std::string_view{rhs};
}

export constexpr auto split_on(std::string_view s, char c)
    -> std::pair<std::string_view, std::optional<std::string_view>>
{
  if (auto i = s.find(c); i != std::string_view::npos)
    return std::make_pair(s.substr(0, i), s.substr(i + 1));
  return std::make_pair(s, std::nullopt);
}

export template <class T>
class not_null;

export template <class T>
class not_null<T*>
{
  T* p_;

  struct guaranteed_not_null_t
  {
  };
  explicit not_null(T* p, guaranteed_not_null_t) noexcept : p_{p} {}

public:
  explicit not_null(T* p) : p_{p}
  {
    if (!p_)
      throw std::runtime_error{"not_null constructed with null pointer"};
  }
  ~not_null() = default;

  not_null(not_null const& other) = default;
  not_null(not_null&& other) noexcept = default;
  auto operator=(not_null const& rhs) noexcept -> not_null& = default;
  auto operator=(not_null&& rhs) noexcept -> not_null& = default;

  friend auto make_not_null(T* p) noexcept -> std::optional<not_null>
  {
    if (p)
      return not_null(p, guaranteed_not_null_t{});
    else
      return std::nullopt;
  }

  [[nodiscard]] auto get() const noexcept -> T* { return p_; }

  auto operator*() const noexcept -> std::add_lvalue_reference_t<T>
  {
    return *p_;
  }

  auto operator->() const noexcept -> T* { return p_; }
};
export template <class T>
explicit not_null(T*) -> not_null<T*>;

export template <>
class not_null<lazy_zstring_view>
{
  lazy_zstring_view s_;

public:
  explicit not_null(lazy_zstring_view s) : s_{std::move(s)}
  {
    if (!s_)
      throw std::runtime_error{"not_null constructed with null pointer"};
  }

  [[nodiscard]] auto get() const noexcept -> lazy_zstring_view { return s_; }

  operator lazy_zstring_view() const noexcept { return s_; }
  operator std::string_view() const noexcept { return s_; }
  operator char const*() const noexcept { return s_; }
};
export explicit not_null(lazy_zstring_view s) -> not_null<lazy_zstring_view>;

} // namespace routemon::util