fixup

Author: mzimbres

example/cpp20_chat_room.cpp

@@ -32,7 +32,7 @@ using boost::asio::dynamic_buffer;
 using boost::asio::redirect_error;
 using boost::redis::config;
 using boost::redis::connection;
-using boost::redis::generic_response;
+using boost::redis::resp3::flat_tree;
 using boost::redis::request;
 using boost::system::error_code;
 using namespace std::chrono_literals;
@@ -45,7 +45,7 @@ auto receiver(std::shared_ptr<connection> conn) -> awaitable<void>
    request req;
    req.push("SUBSCRIBE", "channel");
 
-   generic_response resp;
+   flat_tree resp;
    conn->set_receive_response(resp);
 
    while (conn->will_reconnect()) {
@@ -57,9 +57,13 @@ auto receiver(std::shared_ptr<connection> conn) -> awaitable<void>
          co_await conn->async_receive2(redirect_error(ec));
          if (ec)
             break;  // Connection lost, break so we can reconnect to channels.
-         std::cout << resp.value().at(1).value << " " << resp.value().at(2).value << " "
-                   << resp.value().at(3).value << std::endl;
-         resp.value().clear();
+
+         for (auto const& elem: resp.get_view())
+            std::cout << elem.value << "\n";
+
+         std::cout << std::endl;
+
+         resp.clear();
       }
    }
 }

include/boost/redis/adapter/detail/adapters.hpp

@@ -177,6 +177,34 @@ class general_aggregate {
    }
 };
 
+template <>
+class general_aggregate<resp3::tree> {
+private:
+   resp3::tree* tree_ = nullptr;
+
+public:
+   explicit general_aggregate(resp3::tree* c = nullptr)
+   : tree_(c)
+   { }
+
+   void on_init() { }
+   void on_done() { }
+
+   template <class String>
+   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
+   {
+      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
+
+      resp3::node tmp;
+      tmp.data_type = nd.data_type;
+      tmp.aggregate_size = nd.aggregate_size;
+      tmp.depth = nd.depth;
+      tmp.value = std::string{std::cbegin(nd.value), std::cend(nd.value)};
+
+      tree_->push_back(std::move(tmp));
+   }
+};
+
 template <>
 class general_aggregate<resp3::flat_tree> {
 private:
@@ -197,7 +225,6 @@ class general_aggregate<resp3::flat_tree> {
    void on_node(resp3::basic_node<String> const& nd, system::error_code&)
    {
       BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
-
       tree_->push(nd);
    }
 };

include/boost/redis/adapter/detail/response_traits.hpp

@@ -92,19 +92,19 @@ struct response_traits<result<ignore_t>> {
 };
 
 template <class String, class Allocator>
-struct response_traits<result<std::vector<resp3::basic_node<String>, Allocator>>> {
-   using response_type = result<std::vector<resp3::basic_node<String>, Allocator>>;
+struct response_traits<result<resp3::basic_tree<String, Allocator>>> {
+   using response_type = result<resp3::basic_tree<String, Allocator>>;
    using adapter_type = general_aggregate<response_type>;
 
    static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
 };
 
-template <class... Ts>
-struct response_traits<response<Ts...>> {
-   using response_type = response<Ts...>;
-   using adapter_type = static_adapter<response_type>;
+template <class String>
+struct response_traits<resp3::basic_tree<String>> {
+   using response_type = resp3::basic_tree<String>;
+   using adapter_type = general_aggregate<response_type>;
 
-   static auto adapt(response_type& r) noexcept { return adapter_type{r}; }
+   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
 };
 
 template <>
@@ -114,6 +114,15 @@ struct response_traits<resp3::flat_tree> {
 
    static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
 };
+
+template <class... Ts>
+struct response_traits<response<Ts...>> {
+   using response_type = response<Ts...>;
+   using adapter_type = static_adapter<response_type>;
+
+   static auto adapt(response_type& r) noexcept { return adapter_type{r}; }
+};
+
 }  // namespace boost::redis::adapter::detail
 
 #endif  // BOOST_REDIS_ADAPTER_DETAIL_RESPONSE_TRAITS_HPP

include/boost/redis/adapter/detail/result_traits.hpp

@@ -13,6 +13,7 @@
 #include <boost/redis/error.hpp>
 #include <boost/redis/ignore.hpp>
 #include <boost/redis/resp3/type.hpp>
+#include <boost/redis/resp3/tree.hpp>
 #include <boost/redis/response.hpp>
 
 #include <boost/mp11.hpp>
@@ -57,12 +58,19 @@ struct result_traits<result<resp3::basic_node<T>>> {
 };
 
 template <class String, class Allocator>
-struct result_traits<result<std::vector<resp3::basic_node<String>, Allocator>>> {
+struct result_traits<result<resp3::basic_tree<String, Allocator>>> {
    using response_type = result<std::vector<resp3::basic_node<String>, Allocator>>;
    using adapter_type = adapter::detail::general_aggregate<response_type>;
    static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
 };
 
+template <class String>
+struct result_traits<resp3::basic_tree<String>> {
+   using response_type = resp3::basic_tree<String>;
+   using adapter_type = adapter::detail::general_aggregate<response_type>;
+   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
+};
+
 template <>
 struct result_traits<resp3::flat_tree> {
    using response_type = resp3::flat_tree;

include/boost/redis/resp3/tree.hpp

@@ -15,8 +15,8 @@
 namespace boost::redis::resp3 {
 
 /// A RESP3 tree that owns its data.
-template <class String>
-using basic_tree = std::vector<basic_node<String>>;
+template <class String, class Allocator = std::allocator<basic_node<String>>>
+using basic_tree = std::vector<basic_node<String>, Allocator>;
 
 /// A RESP3 tree that owns its data.
 using tree = basic_tree<std::string>;

test/test_low_level_sync_sans_io.cpp

@@ -22,7 +22,7 @@
 using boost::redis::request;
 using boost::redis::adapter::adapt2;
 using boost::redis::adapter::result;
-using boost::redis::generic_response;
+using boost::redis::resp3::tree;
 using boost::redis::resp3::flat_tree;
 using boost::redis::ignore_t;
 using boost::redis::resp3::detail::deserialize;
@@ -350,43 +350,35 @@ node from_node_view(node_view const& v)
    return ret;
 }
 
-generic_response from_flat(flat_tree const& resp)
+tree from_flat(flat_tree const& resp)
 {
-   generic_response ret;
+   tree ret;
    for (auto const& e: resp.get_view())
-      ret.value().push_back(from_node_view(e));
+      ret.push_back(from_node_view(e));
 
    return ret;
 }
 
-// Parses the same data into a generic_response and a
+// Parses the same data into a tree and a
 // flat_tree, they should be equal to each other.
-BOOST_AUTO_TEST_CASE(generic_flat_resps_views_are_set)
+BOOST_AUTO_TEST_CASE(flat_tree_views_are_set)
 {
-   using boost::redis::resp3::node_view;
-   using boost::redis::resp3::type;
-
-   generic_response resp1;
+   tree resp1;
    flat_tree fresp;
 
    deserialize(resp3_set, adapt2(resp1));
    deserialize(resp3_set, adapt2(fresp));
 
-   BOOST_TEST(resp1.has_value());
-
    BOOST_CHECK_EQUAL(fresp.get_reallocs(), 1u);
    BOOST_CHECK_EQUAL(fresp.get_total_msgs(), 1u);
 
    auto const resp2 = from_flat(fresp);
-   BOOST_CHECK_EQUAL(resp1.value(), resp2.value());
+   BOOST_CHECK_EQUAL(resp1, resp2);
 }
 
 // The response should be reusable.
-BOOST_AUTO_TEST_CASE(generic_flat_resp_reuse)
+BOOST_AUTO_TEST_CASE(flat_tree_reuse)
 {
-   using boost::redis::resp3::node_view;
-   using boost::redis::resp3::type;
-
    flat_tree tmp;
 
    // First use
@@ -408,11 +400,8 @@ BOOST_AUTO_TEST_CASE(generic_flat_resp_reuse)
    BOOST_CHECK_EQUAL(resp1, tmp.get_view());
 }
 
-BOOST_AUTO_TEST_CASE(generic_flat_resp_copy_assign)
+BOOST_AUTO_TEST_CASE(flat_tree_copy_assign)
 {
-   using boost::redis::resp3::node_view;
-   using boost::redis::resp3::type;
-
    flat_tree resp;
    deserialize(resp3_set, adapt2(resp));