oak: Use fable and cloe namespace for respective types

Additionally:
- Add required includes
- Sort includes

Author: cassava

oak/include/oak/registrar.hpp

@@ -29,19 +29,15 @@
 #include <string>
 #include <utility>
 
-#include <cloe/handler.hpp>  // for Handler
+#include <cloe/handler.hpp>  // for Handler, Response
 
 #include "oak/route_muxer.hpp"  // for Muxer
 
 namespace oak {
 
-class Server;
+class Server; // from oak/server.hpp
 
-using Handler = cloe::Handler;
-
-using Response = cloe::Response;
-
-using Middleware = std::function<Handler(Handler)>;
+using Middleware = std::function<cloe::Handler(cloe::Handler)>;
 
 using Logger = std::function<void(const std::string&)>;
 
@@ -72,7 +68,7 @@ class Registrar {
   Registrar with_middleware(Middleware m) const;
   std::string prefix() const { return prefix_; }
   Middleware middleware() const { return middleware_; }
-  virtual void register_handler(const std::string& route, Handler h);
+  virtual void register_handler(const std::string& route, cloe::Handler h);
 
  protected:
   Registrar(const std::string& prefix, Middleware m) : prefix_(prefix), middleware_(m) {}
@@ -112,7 +108,7 @@ class ProxyRegistrar {
   std::string prefix() const { return prefix_; }
   Middleware middleware() const { return middleware_; }
 
-  void register_handler(const std::string& route, T select, Handler h) {
+  void register_handler(const std::string& route, T select, cloe::Handler h) {
     assert(route.size() != 0 && route[0] == '/');
     assert(registrars_.size() != 0);
     if (middleware_) {
@@ -150,7 +146,7 @@ class StaticRegistrar : public Registrar {
   }
   virtual ~StaticRegistrar() = default;
 
-  void register_handler(const std::string& route, Handler h) override;
+  void register_handler(const std::string& route, cloe::Handler h) override;
 
   void set_prefix(const std::string& prefix) { prefix_ = prefix; }
   void set_logger(Logger logger) { logger_ = logger; }
@@ -185,7 +181,7 @@ class LockedRegistrar : public StaticRegistrar {
  public:
   using StaticRegistrar::StaticRegistrar;
 
-  void register_handler(const std::string& route, Handler h) override;
+  void register_handler(const std::string& route, cloe::Handler h) override;
 
   /**
    * Return a unique lock guard so that the backing data can be modified.
@@ -225,7 +221,7 @@ class BufferRegistrar : public StaticRegistrar {
   /**
    * Do not register handlers that want to make use of Request.
    */
-  void register_handler(const std::string& route, Handler h) override;
+  void register_handler(const std::string& route, cloe::Handler h) override;
 
   /**
    * Refresh the entire buffer by calling every single registered
@@ -247,8 +243,8 @@ class BufferRegistrar : public StaticRegistrar {
 
  protected:
   mutable std::shared_mutex access_;
-  Muxer<Response> buffer_;
-  Muxer<Handler> handlers_;
+  Muxer<cloe::Response> buffer_;
+  Muxer<cloe::Handler> handlers_;
 };
 
 }  // namespace oak

oak/include/oak/server.hpp

@@ -26,9 +26,11 @@
 #include <string>  // for string
 #include <vector>  // for vector<>
 
-#include <oatpp/network/Server.hpp>
+#include <cloe/cloe_fwd.hpp>         // for Handler
+#include <fable/fable_fwd.hpp>       // for Json
+#include <oatpp/network/Server.hpp>  // for Server
 
-#include "oak/registrar.hpp"    // for StaticRegistrar, BufferRegistrar
+#include "oak/registrar.hpp"  // for StaticRegistrar, BufferRegistrar
 
 namespace oak {
 
@@ -91,7 +93,7 @@ class Server {
   /**
    * Return endpoint data in json format.
    */
-  cloe::Json endpoints_to_json(const std::vector<std::string>& endpoints) const;
+  fable::Json endpoints_to_json(const std::vector<std::string>& endpoints) const;
 
   /**
    * Stop the server.
@@ -111,7 +113,7 @@ class Server {
   /**
    * Add a handler with the route muxer in the internal handler routine.
    */
-  void add_handler(const std::string& key, Handler h);
+  void add_handler(const std::string& key, cloe::Handler h);
 
  private:
   // Configuration

oak/src/oak/registrar.cpp

@@ -23,14 +23,15 @@
 #include "oak/registrar.hpp"
 
 #include <map>
+#include <memory>
 #include <mutex>
 #include <shared_mutex>
-#include <memory>
 #include <string>
 
-#include <cloe/core.hpp>   // for Json, logger::get
-#include "oak/server.hpp"  // for Server
+#include <cloe/handler.hpp>  // for Request, Response, Handler
+
 #include "oak/request_stub.hpp"  // for RequestStub
+#include "oak/server.hpp"        // for Server
 
 namespace oak {
 
@@ -40,7 +41,7 @@ Middleware chain_middleware(Middleware x, Middleware y) {
   } else if (y == nullptr) {
     return x;
   } else {
-    return [x, y](Handler h) -> Handler { return y(x(h)); };
+    return [x, y](cloe::Handler h) -> cloe::Handler { return y(x(h)); };
   }
 }
 
@@ -65,7 +66,7 @@ Registrar Registrar::with_middleware(Middleware m) const {
   return Registrar(this, prefix_, chain_middleware(middleware_, m));
 }
 
-void Registrar::register_handler(const std::string& route, Handler h) {
+void Registrar::register_handler(const std::string& route, cloe::Handler h) {
   assert(route.size() != 0 && route[0] == '/');
   assert(proxy_ != nullptr);
   if (middleware_) {
@@ -78,7 +79,7 @@ void Registrar::register_handler(const std::string& route, Handler h) {
   proxy_->register_handler(endpoint, h);
 }
 
-void StaticRegistrar::register_handler(const std::string& route, Handler h) {
+void StaticRegistrar::register_handler(const std::string& route, cloe::Handler h) {
   assert(route.size() != 0 && route[0] == '/');
   assert(proxy_ == nullptr);
   auto endpoint = prefix_ + route;
@@ -91,21 +92,21 @@ void StaticRegistrar::register_handler(const std::string& route, Handler h) {
   endpoints_.push_back(endpoint);
 }
 
-void LockedRegistrar::register_handler(const std::string& route, Handler h) {
+void LockedRegistrar::register_handler(const std::string& route, cloe::Handler h) {
   assert(route.size() != 0 && route[0] == '/');
   assert(proxy_ == nullptr);
-  h = [this, h](const cloe::Request& q, Response& r) {
+  h = [this, h](const cloe::Request& q, cloe::Response& r) {
     std::shared_lock read_lock(this->access_);
     h(q, r);
   };
 
   StaticRegistrar::register_handler(route, h);
 }
 
-void BufferRegistrar::register_handler(const std::string& route, Handler h) {
+void BufferRegistrar::register_handler(const std::string& route, cloe::Handler h) {
   assert(route.size() != 0 && route[0] == '/');
   assert(proxy_ == nullptr);
-  auto key = Muxer<Handler>::normalize(prefix_ + route);
+  auto key = Muxer<cloe::Handler>::normalize(prefix_ + route);
   log(key);
   if (middleware_) {
     handlers_.add(key, middleware_(h));
@@ -116,7 +117,7 @@ void BufferRegistrar::register_handler(const std::string& route, Handler h) {
   // Since it's not available to the server yet, we don't need to
   // lock for refreshing the route.
   refresh_route(key);
-  server_->add_handler(key, [this, key](const cloe::Request&, Response& r) {
+  server_->add_handler(key, [this, key](const cloe::Request&, cloe::Response& r) {
     // Technically it's not necessary to lock, but when we are updating the
     // buffers, we do not want any requests to get through.
     std::shared_lock read_lock(this->access_);
@@ -136,7 +137,7 @@ void BufferRegistrar::refresh_buffer() {
 void BufferRegistrar::refresh_route(const std::string& key) {
   const RequestStub q;
   auto handler = handlers_.get_unsafe(key).first;
-  Response r;
+  cloe::Response r;
   handler(q, r);
   buffer_.set_unsafe(key, r);
 }

oak/src/oak/request_stub.hpp

@@ -21,7 +21,11 @@
 
 #pragma once
 
-#include <cloe/handler.hpp> // for Request
+#include <map>        // for map<>
+#include <stdexcept>  // for logic_error
+#include <string>     // for string
+
+#include <cloe/handler.hpp>  // for Request, RequestMethod, ContentType
 
 namespace oak {
 

oak/src/oak/server.cpp

@@ -30,15 +30,16 @@
 #include <sstream>             // for stringstream
 #include <string>              // for string
 
-#include <oatpp/web/server/HttpConnectionHandler.hpp>
 #include <oatpp/network/tcp/server/ConnectionProvider.hpp>
+#include <oatpp/web/server/HttpConnectionHandler.hpp>
 
-#include <cloe/core.hpp>     // for logger::get
-#include <cloe/handler.hpp>  // for Request
-using namespace cloe;        // NOLINT(build/namespaces)
+#include <cloe/core/logger.hpp>  // for logger::get
+#include <cloe/handler.hpp>      // for Request
+#include <fable/json.hpp>        // for Json
+using namespace cloe;            // NOLINT(build/namespaces)
 
-#include "oak/route_muxer.hpp"  // for Muxer<>
 #include "oak/request_stub.hpp"  // for RequestStub
+#include "oak/route_muxer.hpp"   // for Muxer<>
 
 namespace oak {
 
@@ -62,7 +63,7 @@ class Request : public cloe::Request {
   explicit Request(const oatpp::web::protocol::http::incoming::Request& req) {
     auto head = req.getStartingLine();
     dest_ = head.path.std_str();
-    endpoint_ = Muxer<Handler>::normalize(dest_);
+    endpoint_ = Muxer<cloe::Handler>::normalize(dest_);
     for (const auto& [k, v] : req.getQueryParameters().getAll()) {
       queries_[k.std_str()] = v.std_str();
     }
@@ -94,9 +95,9 @@ class GreedyHandler : public oatpp::web::server::HttpRequestHandler {
   GreedyHandler() {
     muxer.set_default([this](const cloe::Request& q, cloe::Response& r) {
       logger()->debug("404 {}", q.endpoint());
-      r.not_found(Json{
+      r.not_found(fable::Json{
           {"error", "cannot find handler"},
-          {"endpoints", Json(this->muxer.routes())},
+          {"endpoints", fable::Json(this->muxer.routes())},
       });
     });
   }
@@ -109,7 +110,8 @@ class GreedyHandler : public oatpp::web::server::HttpRequestHandler {
    * gets passed through. The muxer has a default endpoint, so the nominal case
    * is that every request is passed to some handler from the muxer.
    */
-  std::shared_ptr<OutgoingResponse> handle(const std::shared_ptr<IncomingRequest>& request) override {
+  std::shared_ptr<OutgoingResponse> handle(
+      const std::shared_ptr<IncomingRequest>& request) override {
     auto to_response_impl = [](const cloe::Response& r) -> std::shared_ptr<OutgoingResponse> {
       auto code = Status(static_cast<int>(r.status()), "");
       auto type = cloe::as_cstr(r.type());
@@ -127,11 +129,11 @@ class GreedyHandler : public oatpp::web::server::HttpRequestHandler {
       muxer.get(q.endpoint()).first(q, r);
       return to_response_impl(r);
     } catch (const std::exception& e) {
-      Response err;
+      cloe::Response err;
       err.error(StatusCode::SERVER_ERROR, std::string(e.what()));
       return to_response_impl(err);
     } catch (...) {
-      Response err;
+      cloe::Response err;
       err.error(StatusCode::SERVER_ERROR, std::string("unknown error occurred"));
       return to_response_impl(err);
     }
@@ -140,7 +142,7 @@ class GreedyHandler : public oatpp::web::server::HttpRequestHandler {
   /**
    * Add a handler for a specific endpoint.
    */
-  void add(const std::string& key, Handler h) { muxer.add(key, h); }
+  void add(const std::string& key, cloe::Handler h) { muxer.add(key, h); }
 
   /**
    * Return a list of all registered endpoints.
@@ -150,11 +152,11 @@ class GreedyHandler : public oatpp::web::server::HttpRequestHandler {
   /**
    * Return endpoint data in json format.
    */
-  cloe::Json endpoints_to_json(const std::vector<std::string>& endpoints) const {
-    cloe::Json j;
+  fable::Json endpoints_to_json(const std::vector<std::string>& endpoints) const {
+    fable::Json j;
     for (const auto& endpoint : endpoints) {
       const RequestStub q;
-      Response r;
+      cloe::Response r;
       try {
         muxer.get(endpoint).first(q, r);
       } catch (std::logic_error& e) {
@@ -163,7 +165,7 @@ class GreedyHandler : public oatpp::web::server::HttpRequestHandler {
         continue;
       }
       if (r.status() == cloe::StatusCode::OK && r.type() == cloe::ContentType::JSON) {
-        j[endpoint] = cloe::Json(r.body());
+        j[endpoint] = fable::Json(r.body());
       }
     }
     return j;
@@ -173,7 +175,7 @@ class GreedyHandler : public oatpp::web::server::HttpRequestHandler {
   cloe::Logger logger() { return cloe::logger::get("cloe-server"); }
 
  private:
-  Muxer<Handler> muxer;
+  Muxer<cloe::Handler> muxer;
 };
 
 void Server::listen() {
@@ -191,11 +193,8 @@ void Server::listen() {
   router->route("DELETE", "/*", handler_);
 
   auto handler = oatpp::web::server::HttpConnectionHandler::createShared(router);
-  auto provider = oatpp::network::tcp::server::ConnectionProvider::createShared({
-    listen_addr_,
-    static_cast<v_uint16>(listen_port_),
-    oatpp::network::Address::IP_4
-  });
+  auto provider = oatpp::network::tcp::server::ConnectionProvider::createShared(
+      {listen_addr_, static_cast<v_uint16>(listen_port_), oatpp::network::Address::IP_4});
 
   server_ = oatpp::network::Server::createShared(provider, handler);
   server_->run(true);
@@ -213,23 +212,27 @@ void Server::stop() {
   listening_ = false;
 }
 
-void Server::add_handler(const std::string& key, Handler h) {
-  handler_->add(key, std::move(h));
-}
+void Server::add_handler(const std::string& key, cloe::Handler h) { handler_->add(key, std::move(h)); }
 
-std::vector<std::string> Server::endpoints() const {
-  return handler_->endpoints();
-}
+std::vector<std::string> Server::endpoints() const { return handler_->endpoints(); }
 
-cloe::Json Server::endpoints_to_json(const std::vector<std::string>& endpoints) const {
+fable::Json Server::endpoints_to_json(const std::vector<std::string>& endpoints) const {
   return handler_->endpoints_to_json(endpoints);
 }
 
 Server::Server(const std::string& addr, int port)
-  : listen_addr_(addr), listen_port_(port), listen_threads_(3), listening_(false), handler_(new GreedyHandler()) {}
+    : listen_addr_(addr)
+    , listen_port_(port)
+    , listen_threads_(3)
+    , listening_(false)
+    , handler_(new GreedyHandler()) {}
 
 Server::Server()
-  : listen_addr_("127.0.0.1"), listen_port_(8080), listen_threads_(3), listening_(false), handler_(new GreedyHandler()) {}
+    : listen_addr_("127.0.0.1")
+    , listen_port_(8080)
+    , listen_threads_(3)
+    , listening_(false)
+    , handler_(new GreedyHandler()) {}
 
 Server::~Server() {
   if (this->is_listening()) {