Refactor json/rpc body to remove rpc request/response redundancy.

Author: evoskuil

include/bitcoin/network/messages/json/body.hpp

@@ -27,27 +27,30 @@ namespace libbitcoin {
 namespace network {
 namespace json {
 
+/// Content passed to/from reader/writer via request/response.
+/// `static uint64_t size(const value_type&)` must be defined for beast to 
+/// produce `content_length`, otherwise the response is chunked. Predeter-
+/// mining size would have the effect of eliminating the benefit of
+/// streaming serialize.
+struct json_value
+{
+    /// JSON document object model to parse/serialize.
+    boost::json::value model{};
+
+    /// Used by channel to resize reusable buffer.
+    size_t size_hint{};
+
+    /// Writer serialization buffer (max size, allocated on write).
+    mutable http::flat_buffer_ptr buffer{};
+};
+
 /// boost::beast::http body for JSON messages.
 /// Because of the parser and serializer members, neither the reader nor writer
 /// is movable and as such must be in-place contructed (e.g. variant contruct).
+template <typename Value = json_value>
 struct BCT_API body
 {
-    /// Content passed to/from reader/writer via request/response.
-    /// `static uint64_t size(const value_type&)` must be defined for beast to 
-    /// produce `content_length`, otherwise the response is chunked. Predeter-
-    /// mining size would have the effect of eliminating the benefit of
-    /// streaming serialize.
-    struct value_type
-    {
-        /// JSON DOM.
-        boost::json::value model{};
-
-        /// Used by channel to resize reusable buffer.
-        size_t size_hint{};
-
-        /// Writer serialization buffer (max size, allocated on write).
-        mutable http::flat_buffer_ptr buffer{};
-    };
+    using value_type = Value;
 
     class reader
     {
@@ -117,7 +120,7 @@ namespace libbitcoin {
 namespace network {
 namespace http {
 
-using json_body = json::body;
+using json_body = json::body<>;
 
 } // namespace http
 } // namespace network

include/bitcoin/network/messages/monad/body.hpp

@@ -32,7 +32,7 @@ namespace network {
 namespace monad {
 
 using empty_reader = http::empty_body::reader;
-using json_reader = json::body::reader;
+using json_reader = http::json_body::reader;
 using data_reader = http::chunk_body::reader;
 using file_reader = http::file_body::reader;
 using span_reader = http::span_body::reader;
@@ -51,7 +51,7 @@ using body_reader = std::variant
 >;
 
 using empty_writer = http::empty_body::writer;
-using json_writer = json::body::writer;
+using json_writer = http::json_body::writer;
 using data_writer = http::chunk_body::writer;
 using file_writer = http::file_body::writer;
 using span_writer = http::span_body::writer;
@@ -69,7 +69,7 @@ using body_writer = std::variant
 >;
 
 using empty_value = http::empty_body::value_type;
-using json_value = json::body::value_type;
+using json_value = http::json_body::value_type;
 using data_value = http::chunk_body::value_type;
 using file_value = http::file_body::value_type;
 using span_value = http::span_body::value_type;

include/bitcoin/network/messages/rpc/body.hpp

@@ -27,56 +27,66 @@ namespace libbitcoin {
 namespace network {
 namespace rpc {
 
+template <typename Type>
+struct value_type
+  : public json::json_value
+{
+    Type message{};
+};
+
 /// Derived boost::beast::http body for JSON-RPC messages.
 /// Extends json::body with JSON-RPC validation.
+template <typename Message>
 struct BCT_API body
-  : public json::body
+  : public json::body<value_type<Message>>
 {
-    struct value_type
-      : json::body::value_type
-    {
-        request_t request{};
-        response_t response{};
-    };
+    using message_value = value_type<Message>;
+    using base = typename json::body<message_value>;
+    using value_type = base::value_type;
 
     class reader
-      : public json::body::reader
+      : public json::body<message_value>::reader
     {
     public:
+        using reader_type = base::reader;
+        using buffer_type = reader_type::buffer_type;
+
         inline explicit reader(value_type& value) NOEXCEPT
-          : json::body::reader{ value }, terminated_{ true }
+          : reader_type{ value }, terminated_{ true }
         {
         }
 
         template <bool IsRequest, class Fields>
         inline explicit reader(http::message_header<IsRequest, Fields>& header,
             value_type& value) NOEXCEPT
-          : json::body::reader{ header, value }
+          : reader_type{ header, value }
         {
         }
 
         size_t put(const buffer_type& buffer, boost_code& ec) NOEXCEPT override;
         void finish(boost_code& ec) NOEXCEPT override;
-        bool is_done() const NOEXCEPT;
 
     private:
         const bool terminated_{};
         bool has_terminator_{};
     };
 
     class writer
-      : public json::body::writer
+      : public json::body<message_value>::writer
     {
     public:
+        using writer_type = base::writer;
+        using out_buffer = writer_type::out_buffer;
+
         inline explicit writer(value_type& value) NOEXCEPT
-          : json::body::writer{ value }, terminate_{ true }
+          : writer_type{ value }, terminate_{ true }
         {
         }
 
         template <bool IsRequest, class Fields>
         inline explicit writer(http::message_header<IsRequest, Fields>& header,
             value_type& value) NOEXCEPT
-          : json::body::writer{ header, value }
+          : writer_type{ header, value }
         {
         }
 
@@ -96,9 +106,11 @@ namespace libbitcoin {
 namespace network {
 namespace http {
 
-using rpc_body = rpc::body;
-using rpc_request = boost::beast::http::request<rpc_body>;
-using rpc_response = boost::beast::http::response<rpc_body>;
+using rpc_request_body = rpc::body<rpc::request_t>;
+using rpc_response_body = rpc::body<rpc::response_t>;
+
+using rpc_request = boost::beast::http::request<rpc_request_body>;
+using rpc_response = boost::beast::http::response<rpc_response_body>;
 
 } // namespace http
 } // namespace network

src/messages/json/body.cpp

@@ -29,10 +29,10 @@ namespace json {
 using namespace system;
 using namespace network::error;
 
-// json::body::reader
+// json::body<>::reader
 // ----------------------------------------------------------------------------
 
-void body::reader::init(const http::length_type& length,
+void body<>::reader::init(const http::length_type& length,
     boost_code& ec) NOEXCEPT
 {
     BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)
@@ -54,7 +54,7 @@ void body::reader::init(const http::length_type& length,
     ec.clear();
 }
 
-size_t body::reader::put(const buffer_type& buffer, boost_code& ec) NOEXCEPT
+size_t body<>::reader::put(const buffer_type& buffer, boost_code& ec) NOEXCEPT
 {
     try
     {
@@ -81,7 +81,7 @@ size_t body::reader::put(const buffer_type& buffer, boost_code& ec) NOEXCEPT
     return {};
 }
 
-void body::reader::finish(boost_code& ec) NOEXCEPT
+void body<>::reader::finish(boost_code& ec) NOEXCEPT
 {
     BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)
     parser_.finish(ec);
@@ -107,10 +107,10 @@ void body::reader::finish(boost_code& ec) NOEXCEPT
     parser_.reset();
 }
 
-// json::body::writer
+// json::body<>::writer
 // ----------------------------------------------------------------------------
 
-void body::writer::init(boost_code& ec) NOEXCEPT
+void body<>::writer::init(boost_code& ec) NOEXCEPT
 {
     if (!value_.buffer)
     {
@@ -127,7 +127,7 @@ void body::writer::init(boost_code& ec) NOEXCEPT
     serializer_.reset(&value_.model);
 }
 
-body::writer::out_buffer body::writer::get(boost_code& ec) NOEXCEPT
+body<>::writer::out_buffer body<>::writer::get(boost_code& ec) NOEXCEPT
 {
     ec.clear();
     if (serializer_.done())

src/messages/rpc/body.cpp

@@ -21,6 +21,8 @@
 #include <memory>
 #include <utility>
 #include <bitcoin/network/define.hpp>
+#include <bitcoin/network/messages/json/json.hpp>
+#include <bitcoin/network/rpc/rpc.hpp>
 
 namespace libbitcoin {
 namespace network {
@@ -36,7 +38,8 @@ BC_PUSH_WARNING(NO_POINTER_ARITHMETIC)
 // rpc::body::reader
 // ----------------------------------------------------------------------------
 
-size_t body::reader::put(const buffer_type& buffer, boost_code& ec) NOEXCEPT
+size_t body<rpc::request_t>::reader::
+put(const buffer_type& buffer, boost_code& ec) NOEXCEPT
 {
     const auto size = buffer.size();
     if (is_zero(size))
@@ -51,7 +54,7 @@ size_t body::reader::put(const buffer_type& buffer, boost_code& ec) NOEXCEPT
         return {};
     }
 
-    const auto parsed = json::body::reader::put(buffer, ec);
+    const auto parsed = base::reader::put(buffer, ec);
     if (ec || !parser_.done())
         return parsed;
 
@@ -87,9 +90,10 @@ size_t body::reader::put(const buffer_type& buffer, boost_code& ec) NOEXCEPT
     return parsed;
 }
 
-void body::reader::finish(boost_code& ec) NOEXCEPT
+void body<rpc::request_t>::reader::
+finish(boost_code& ec) NOEXCEPT
 {
-    json::body::reader::finish(ec);
+    base::reader::finish(ec);
     if (ec) return;
 
     if (terminated_ && !has_terminator_)
@@ -98,11 +102,10 @@ void body::reader::finish(boost_code& ec) NOEXCEPT
         return;
     }
 
-    auto& derived = static_cast<body::value_type&>(value_);
     try
     {
-        derived.request = value_to<rpc::request_t>(derived.model);
-        derived.model.emplace_null();
+        value_.message = value_to<rpc::request_t>(value_.model);
+        value_.model.emplace_null();
     }
     catch (const boost::system::system_error& e)
     {
@@ -116,23 +119,31 @@ void body::reader::finish(boost_code& ec) NOEXCEPT
     }
 }
 
-bool body::reader::is_done() const NOEXCEPT
+size_t body<rpc::response_t>::reader::
+put(const buffer_type&, boost_code&) NOEXCEPT
 {
-    return parser_.done() && has_terminator_;
+    BC_ASSERT(false);
+    return {};
+}
+
+void body<rpc::response_t>::reader::
+finish(boost_code&) NOEXCEPT
+{
+    BC_ASSERT(false);
 }
 
 // rpc::body::writer
 // ----------------------------------------------------------------------------
 
-void body::writer::init(boost_code& ec) NOEXCEPT
+void body<rpc::response_t>::writer::
+init(boost_code& ec) NOEXCEPT
 {
-    json::body::writer::init(ec);
+    base::writer::init(ec);
     if (ec) return;
 
-    auto& derived = static_cast<body::value_type&>(value_);
     try
     {
-        boost::json::value_from(derived.response, value_.model);
+        boost::json::value_from(value_.message, value_.model);
     }
     catch (const boost::system::system_error& e)
     {
@@ -150,9 +161,11 @@ void body::writer::init(boost_code& ec) NOEXCEPT
     serializer_.reset(&value_.model);
 }
 
-body::writer::out_buffer body::writer::get(boost_code& ec) NOEXCEPT
+body<rpc::response_t>::writer::out_buffer
+body<rpc::response_t>::writer::
+get(boost_code& ec) NOEXCEPT
 {
-    auto out = json::body::writer::get(ec);
+    auto out = base::writer::get(ec);
     if (ec || !terminate_) return out;
 
     constexpr char more = true;
@@ -167,6 +180,20 @@ body::writer::out_buffer body::writer::get(boost_code& ec) NOEXCEPT
     return out_buffer{ std::make_pair(buffer(&line, sizeof(line)), !more) };
 }
 
+void body<rpc::request_t>::writer::
+init(boost_code&) NOEXCEPT
+{
+    BC_ASSERT(false);
+}
+
+body<rpc::request_t>::writer::out_buffer
+body<rpc::request_t>::writer::
+get(boost_code&) NOEXCEPT
+{
+    BC_ASSERT(false);
+    return {};
+}
+
 BC_POP_WARNING()
 BC_POP_WARNING()
 BC_POP_WARNING()