Change codeStyle

src/http_server.h

@@ -14,10 +14,14 @@
 namespace http_server
 {
 template<typename RequestHandler>
-void ServeHttp(net::io_context& ioc, const tcp::endpoint& endpoint, RequestHandler&& handler)
+void ServeHttp(net::io_context& ioc,
+               const tcp::endpoint& endpoint,
+               RequestHandler&& handler)
 {
-  using MyListener = Listener<std::decay_t<RequestHandler>>;
+  using MyListener = Listener<std::decay_t < RequestHandler>>;
 
-  std::make_shared<MyListener>(ioc, endpoint, std::forward<RequestHandler>(handler))->Run();
+  std::make_shared<MyListener>(ioc,
+                               endpoint,
+                               std::forward<RequestHandler>(handler))->Run();
 }
 }

src/session.h

@@ -10,22 +10,25 @@
 
 #include "session_base.h"
 
-namespace http_server {
+namespace http_server
+{
 
 namespace net = boost::asio;
 using tcp = net::ip::tcp;
 namespace beast = boost::beast;
 namespace http = beast::http;
 
-template <typename RequestHandler>
-class Session : public SessionBase, public std::enable_shared_from_this<Session<RequestHandler>> {
+template<typename RequestHandler>
+class Session
+  : public SessionBase,
+    public std::enable_shared_from_this<Session<RequestHandler>>
+{
   RequestHandler request_handler_;
 
  public:
   template<class Handler>
   Session(tcp::socket&& socket, Handler&& request_handler)
-  : SessionBase(std::move(socket)), request_handler_(request_handler)
-  {}
+    : SessionBase(std::move(socket)), request_handler_(request_handler) {}
 
   std::shared_ptr<SessionBase> GetSharedThis() override
   {
@@ -33,13 +36,16 @@ class Session : public SessionBase, public std::enable_shared_from_this<Session<
   }
 
  private:
-  void HandleRequest(HttpRequest&& request) override {
+  void HandleRequest(HttpRequest&& request) override
+  {
     // Захватываем умный указатель на текущий объект Session в лямбде,
     // чтобы продлить время жизни сессии до вызова лямбды.
     // Используется generic-лямбда функция, способная принять response произвольного типа
-    request_handler_(std::move(request), [self = this->shared_from_this()](auto&& response) {
-      self->Write(std::move(response));
-    });
+    request_handler_(std::move(request),
+                     [self = this->shared_from_this()](auto&& response)
+                     {
+                       self->Write(std::move(response));
+                     });
   }
 };
 }  // namespace http_server

src/session_base.cpp

@@ -27,7 +27,8 @@ void SessionBase::Read()
   request_ = {};
   stream_.expires_after(30s);
   http::async_read(stream_, buffer_, request_,
-                   beast::bind_front_handler(&SessionBase::OnRead, GetSharedThis()));
+                   beast::bind_front_handler(&SessionBase::OnRead,
+                                             GetSharedThis()));
 }
 void SessionBase::OnRead(beast::error_code ec, size_t bytes_read)
 {
@@ -54,11 +55,13 @@ void SessionBase::OnWrite(bool close,
                           boost::beast::error_code ec,
                           std::size_t bytes_written)
 {
-  if (ec) {
+  if (ec)
+  {
     return ReportError(ec, "write"sv);
   }
 
-  if (close) {
+  if (close)
+  {
     // Семантика ответа требует закрыть соединение
     return Close();
   }

src/session_base.h

@@ -11,8 +11,8 @@
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
 
-namespace http_server {
-
+namespace http_server
+{
 namespace net = boost::asio;
 using tcp = net::ip::tcp;
 namespace beast = boost::beast;
@@ -22,7 +22,8 @@ using namespace std::literals;
 
 void ReportError(beast::error_code ec, std::string_view what);
 
-class SessionBase {
+class SessionBase
+{
  protected:
   using HttpRequest = http::request<http::string_body>;
 
@@ -40,22 +41,28 @@ class SessionBase {
  protected:
   explicit SessionBase(tcp::socket&& socket);
 
-  template <typename Body, typename Fields>
-  void Write(http::response<Body, Fields>&& response) {
+  template<typename Body, typename Fields>
+  void Write(http::response<Body, Fields>&& response)
+  {
     // Запись выполняется асинхронно, поэтому response перемещаем в область кучи
-    auto safe_response = std::make_shared<http::response<Body, Fields>>(std::move(response));
+    auto      safe_response = std::make_shared < http::response
+      < Body, Fields>>(std::move(response));
 
     auto self = GetSharedThis();
     http::async_write(stream_, *safe_response,
-                      [safe_response, self](beast::error_code ec, std::size_t bytes_written) {
-                        self->OnWrite(safe_response->need_eof(), ec, bytes_written);
+                      [safe_response, self](beast::error_code ec,
+                                            std::size_t bytes_written)
+                      {
+                        self->OnWrite(safe_response->need_eof(),
+                                      ec,
+                                      bytes_written);
                       });
   }
 
  private:
-  beast::tcp_stream stream_;
+  beast::tcp_stream  stream_;
   beast::flat_buffer buffer_;
-  HttpRequest request_;
+  HttpRequest        request_;
 
   void OnRead(beast::error_code ec, [[maybe_unused]] size_t bytes_read);
 
@@ -63,6 +70,8 @@ class SessionBase {
 
   virtual void HandleRequest(HttpRequest&& request) = 0;
 
-  void OnWrite(bool close, beast::error_code ec, [[maybe_unused]] std::size_t bytes_written);
+  void OnWrite(bool close,
+               beast::error_code ec,
+               [[maybe_unused]] std::size_t bytes_written);
 };
 }  // namespace http_server