Import from e4b104792206ee7ea64bf39c6b7d2c0c230f9d14

1 files changed, 254 insertions, 0 deletions

diff --git a/server/src/util.cppm b/server/src/util.cppm
new file mode 100644
index 0000000..65f4d67
--- /dev/null
+++ b/server/src/util.cppm
@@ -0,0 +1,254 @@
+// 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