fixed review findings

Author: StephanKa

src/boost.beast/data.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <nlohmann/json.hpp>
+#include <string>
 
 namespace data {
 // a simple struct to model a person
@@ -20,5 +21,4 @@ inline void from_json(const nlohmann::json &j, person &p)
     j.at("age").get_to(p.age);
     j.at("id").get_to(p.id);
 }
-
-}// namespace data
+}// namespace data

src/boost.beast/error_handling.h

@@ -0,0 +1,15 @@
+#pragma once
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/version.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/strand.hpp>
+#include <fmt/format.h>
+
+namespace beast = boost::beast;// from <boost/beast.hpp>
+namespace http = beast::http;// from <boost/beast/http.hpp>
+namespace asio = boost::asio;// from <boost/asio.hpp>
+using tcp = boost::asio::ip::tcp;// from <boost/asio/ip/tcp.hpp>
+
+
+inline void fail(beast::error_code ec, char const *what) { fmt::format("FAILED {0}: {1}", what, ec.message()); }

src/boost.beast/helper.h

@@ -1,13 +1,13 @@
 #pragma once
-#include "helper.h"
+#include "error_handling.h"
 #include "data.h"
 #include "session.h"
 
 // Accepts incoming connections and launches the sessions
 class Listener : public std::enable_shared_from_this<Listener>
 {
   public:
-    Listener(net::io_context &ioc, const tcp::endpoint &endpoint) : m_ioc(ioc), m_acceptor(net::make_strand(ioc))
+    Listener(asio::io_context &ioc, const tcp::endpoint &endpoint) : m_ioc(ioc), m_acceptor(asio::make_strand(ioc))
     {
         beast::error_code ec;
 
@@ -20,7 +20,7 @@ class Listener : public std::enable_shared_from_this<Listener>
         }
 
         // Allow address reuse
-        m_acceptor.set_option(net::socket_base::reuse_address(true), ec);
+        m_acceptor.set_option(asio::socket_base::reuse_address(true), ec);
         if (ec)
         {
             fail(ec, "set_option");
@@ -36,7 +36,7 @@ class Listener : public std::enable_shared_from_this<Listener>
         }
 
         // Start listening for connections
-        m_acceptor.listen(net::socket_base::max_listen_connections, ec);
+        m_acceptor.listen(asio::socket_base::max_listen_connections, ec);
         if (ec)
         {
             fail(ec, "listen");
@@ -45,13 +45,13 @@ class Listener : public std::enable_shared_from_this<Listener>
     }
 
     // Start accepting incoming connections
-    void run() { doAccept(); }
+    void run() { acceptNextConnection(); }
 
   private:
-    void doAccept()
+    void acceptNextConnection()
     {
         // The new connection gets its own strand
-        m_acceptor.async_accept(net::make_strand(m_ioc), beast::bind_front_handler(&Listener::onAccept, shared_from_this()));
+        m_acceptor.async_accept(asio::make_strand(m_ioc), beast::bind_front_handler(&Listener::onAccept, shared_from_this()));
     }
 
     void onAccept(beast::error_code ec, tcp::socket socket)
@@ -67,10 +67,10 @@ class Listener : public std::enable_shared_from_this<Listener>
         }
 
         // Accept another connection
-        doAccept();
+        acceptNextConnection();
     }
 
-    net::io_context &m_ioc;
+    asio::io_context &m_ioc;
     tcp::acceptor m_acceptor;
     std::vector<data::person> m_persons;
 };

src/boost.beast/listener.h

@@ -1,10 +1,4 @@
-#include <boost/beast/core.hpp>
-#include <boost/beast/http.hpp>
-#include <boost/beast/version.hpp>
-#include <boost/asio/dispatch.hpp>
-#include <boost/asio/strand.hpp>
 #include <cstdlib>
-#include <iostream>
 #include <memory>
 #include <string>
 #include <thread>
@@ -14,19 +8,19 @@
 
 int main()
 {
-    auto const address = net::ip::make_address("0.0.0.0");
-    auto const port = static_cast<unsigned short>(8080);
-    auto const threads = 1;
+    const auto address = asio::ip::make_address("0.0.0.0");
+    const uint16_t port = 8080u;
+    const auto threads = 1;
 
     // The io_context is required for all I/O
-    net::io_context ioc{ threads };
+    asio::io_context ioc{ threads };
 
     // Create and launch a listening port
     std::make_shared<Listener>(ioc, tcp::endpoint{ address, port })->run();
 
     // Run the I/O service on the requested number of threads
     std::vector<std::thread> v;
-    v.reserve(threads - 1);
+    v.reserve(threads);
     for (auto i = 0; i < threads; i++)
     {
         v.emplace_back([&ioc] { ioc.run(); });

src/boost.beast/main.cpp

@@ -1,6 +1,7 @@
 #pragma once
+#include "error_handling.h"
 
-template<typename Request> http::response<http::string_body> createResponse(Request &&req, http::status status, const nlohmann::json &jsonResponse)
+template<typename Request> http::response<http::string_body> inline createResponse(Request &&req, http::status status, const nlohmann::json &jsonResponse)
 {
     http::response<http::string_body> res{ status, req.version() };
     res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
@@ -11,18 +12,19 @@ template<typename Request> http::response<http::string_body> createResponse(Requ
     return res;
 }
 
-// Returns a bad request response
-const auto badRequest = [&req](beast::string_view why) {
-    const auto j = nlohmann::json::parse(std::string(why));
-    return createResponse(req, http::status::bad_request, j);
-};
 
 // This function produces an HTTP response for the given
 // request. The type of the response object depends on the
 // contents of the request, so the interface requires the
 // caller to pass a generic lambda for receiving the response.
-template<class Body, class Allocator, class Send> void handleRequest(http::request<Body, http::basic_fields<Allocator>> &&req, Send &&send, std::vector<data::person> &data)
+template<class Body, class Allocator, class Send> inline void handleRequest(http::request<Body, http::basic_fields<Allocator>> &&req, Send &&send, std::vector<data::person> &data)
 {
+    // Returns a bad request response
+    const auto badRequest = [&req](beast::string_view why) {
+        const auto j = nlohmann::json::parse(std::string(why));
+        return createResponse(req, http::status::bad_request, j);
+    };
+
     // Make sure we can handle the method
     switch (req.method())
     {

src/boost.beast/request.h

@@ -1,5 +1,5 @@
 #pragma once
-#include "helper.h"
+#include "error_handling.h"
 #include "request.h"
 
 // Handles an HTTP server connection
@@ -16,7 +16,7 @@ class Session : public std::enable_shared_from_this<Session>
         // on the I/O objects in this session. Although not strictly necessary
         // for single-threaded contexts, this example code is written to be
         // thread-safe by default.
-        net::dispatch(m_stream.get_executor(), beast::bind_front_handler(&Session::doRead, shared_from_this()));
+        asio::dispatch(m_stream.get_executor(), beast::bind_front_handler(&Session::doRead, shared_from_this()));
     }
 
     void doRead()
@@ -85,7 +85,7 @@ class Session : public std::enable_shared_from_this<Session>
 
   private:
     std::vector<data::person> &m_person;
-    // This is the C++11 equivalent of a generic lambda.
+
     // The function object is used to send an HTTP message.
     struct sendLambda
     {