Import from e4b104792206ee7ea64bf39c6b7d2c0c230f9d14

1 files changed, 139 insertions, 0 deletions

diff --git a/server/src/http_common.cppm b/server/src/http_common.cppm
new file mode 100644
index 0000000..3c38da7
--- /dev/null
+++ b/server/src/http_common.cppm
@@ -0,0 +1,139 @@
+module;
+
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+
+export module routemon:http.common;
+
+namespace beast = boost::beast;
+export namespace bhttp = beast::http;
+
+namespace boost::beast {
+
+  namespace concepts {
+
+    template<class T>
+    concept buffers_generator = beast::is_buffers_generator<T>::value;
+
+    template<class T>
+    concept const_buffer_sequence = beast::is_const_buffer_sequence<T>::value;
+
+  } // namespace concepts
+
+  namespace http::concepts {
+
+    template<class T>
+    concept fields = is_fields<T>::value;
+
+    template<class T>
+    concept body = is_body<T>::value;
+
+    template<class T>
+    concept body_reader = is_body_reader<T>::value;
+
+  } // namespace http::concepts
+
+} // namespace boost::beast
+
+namespace routemon::http {
+
+  struct supported_verb {
+    enum supported_verb_t : std::uint8_t {
+      options,
+      delete_,
+      get,
+      head,
+      post,
+      put,
+    };
+
+    supported_verb_t value;
+
+    supported_verb(supported_verb_t value) : value{value} {}
+
+    static auto from(bhttp::verb v) -> std::optional<supported_verb> {
+      switch (v) {
+      case bhttp::verb::options: return supported_verb::options;
+      case bhttp::verb::delete_: return supported_verb::delete_;
+      case bhttp::verb::get:     return supported_verb::get;
+      case bhttp::verb::head:    return supported_verb::head;
+      case bhttp::verb::post:    return supported_verb::post;
+      case bhttp::verb::put:     return supported_verb::put;
+      default:                   return std::nullopt;
+      }
+    }
+
+    operator bhttp::verb() const {
+      switch (value) {
+      case supported_verb::options: return bhttp::verb::options;
+      case supported_verb::delete_: return bhttp::verb::delete_;
+      case supported_verb::get:     return bhttp::verb::get;
+      case supported_verb::head:    return bhttp::verb::head;
+      case supported_verb::post:    return bhttp::verb::post;
+      case supported_verb::put:     return bhttp::verb::put;
+      }
+    }
+  };
+
+  export struct verb_set {
+    bool delete_ : 1 = false;
+    bool get     : 1 = false;
+    bool head    : 1 = false;
+    bool post    : 1 = false;
+    bool put     : 1 = false;
+    bool options : 1 = false;
+
+    auto enable(supported_verb v) -> void {
+      switch (v.value) {
+      case supported_verb::delete_:
+        delete_ = true;
+        break;
+      case supported_verb::get:
+        get = true;
+        break;
+      case supported_verb::head:
+        head = true;
+        break;
+      case supported_verb::post:
+        post = true;
+        break;
+      case supported_verb::put:
+        put = true;
+        break;
+      case supported_verb::options:
+        options = true;
+        break;
+      default:;
+      }
+    }
+
+    auto operator==(verb_set const& rhs) const noexcept -> bool = default;
+
+    auto empty() const -> bool {
+      return *this == verb_set{};
+    }
+
+    verb_set(std::initializer_list<supported_verb> vs) {
+      for (auto const v : vs) enable(v);
+    }
+
+    auto to_string() const -> std::string {
+      std::ostringstream ss;
+      bool wrote = false;
+      auto write = [&](bhttp::verb v) {
+        if (wrote)
+          ss << ", ";
+        ss << v;
+        wrote = true;
+      };
+      if (delete_) write(bhttp::verb::delete_);
+      if (get)     write(bhttp::verb::get);
+      if (head)    write(bhttp::verb::head);
+      if (post)    write(bhttp::verb::post);
+      if (put)     write(bhttp::verb::put);
+      if (options) write(bhttp::verb::options);
+      return ss.str();
+    }
+  };
+
+} // namespace routemon::http