Merge pull request #63 from boostorg/62-let-the-implementation-call-adaptresp-automatically

async_exec accepts response now instead of adapter.

Author: mzimbres

README.md

@@ -15,7 +15,7 @@ concerned with only three library entities
   [pipelines](https://redis.io/docs/manual/pipelining/).
 * `boost::redis::request`: A container of Redis commands that supports
   STL containers and user defined data types.
-* `boost::redis::adapt()`: A function that adapts data structures to receive responses.
+* `boost::redis::response`: Container of Redis responses.
 
 In the next sections we will cover all those points in detail with
 examples. The requirements for using Boost.Redis are
@@ -62,7 +62,7 @@ auto co_main() -> net::awaitable<void>
    // The tuple elements will store the responses to each individual
    // command. The responses to HELLO and QUIT are being ignored for
    // simplicity.
-   response<ignore, std::map<std::string, std::string>, ignore> resp;
+   response<ignore_t, std::map<std::string, std::string>, ignore_t> resp;
 
    // Executes the request. See below why we are using operator ||.
    co_await (conn.async_run() || conn.async_exec(req, adapt(resp)));
@@ -364,11 +364,11 @@ have as many elements as the request has commands (exceptions below).
 It is also necessary that each tuple element is capable of storing the
 response to the command it refers to, otherwise an error will occur.
 To ignore responses to individual commands in the request use the tag
-`boost::redis::ignore`
+`boost::redis::ignore_t`
 
 ```cpp
 // Ignore the second and last responses.
-response<std::string, boost::redis::ignore, std::string, boost::redis::ignore>
+response<std::string, boost::redis::ignore_t, std::string, boost::redis::ignore_t>
 ```
 
 The following table provides the resp3-types returned by some Redis
@@ -416,12 +416,12 @@ can be read in the tuple below
 
 ```cpp
 response<
-   redis::ignore,  // hello
-   int,            // rpush
-   int,            // hset
-   std::vector<T>, // lrange
-   std::map<U, V>, // hgetall
-   std::string     // quit
+   redis::ignore_t,  // hello
+   int,              // rpush
+   int,              // hset
+   std::vector<T>,   // lrange
+   std::map<U, V>,   // hgetall
+   std::string       // quit
 > resp;
 ```
 
@@ -515,10 +515,10 @@ using exec_resp_type =
    >;
 
 response<
-   boost::redis::ignore,  // multi
-   boost::redis::ignore,  // get
-   boost::redis::ignore,  // lrange
-   boost::redis::ignore,  // hgetall
+   boost::redis::ignore_t,  // multi
+   boost::redis::ignore_t,  // get
+   boost::redis::ignore_t,  // lrange
+   boost::redis::ignore_t,  // hgetall
    exec_resp_type,        // exec
 > resp;
 
@@ -868,6 +868,8 @@ Acknowledgement to people that helped shape Boost.Redis
 * Moves `boost::redis::resp3::request` to `boost::redis::request`.
 * Adds new typedef `boost::redis::response` that should be used instead of `std::tuple`.
 * Adds new typedef `boost::redis::generic_response` that should be used instead of `std::vector<resp3::node<std::string>>`.
+* Renames `redis::ignore` to `redis::ignore_t`.
+* Changes the signature from `async_exec` to receive a `redis::response` instead of an adapter.
 
 ### v1.4.0-1
 

examples/common/common.cpp

@@ -16,7 +16,6 @@ using namespace net::experimental::awaitable_operators;
 using resolver = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::resolver>;
 using timer_type = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
 using boost::redis::request;
-using boost::redis::adapt;
 using boost::redis::operation;
 
 namespace
@@ -35,7 +34,7 @@ auto healthy_checker(std::shared_ptr<connection> conn) -> net::awaitable<void>
 
       for (boost::system::error_code ec;;) {
          timer.expires_after(std::chrono::seconds{1});
-         co_await (conn->async_exec(req, adapt()) || timer.async_wait(redir(ec)));
+         co_await (conn->async_exec(req) || timer.async_wait(redir(ec)));
 
          if (!ec) {
             co_return;

examples/cpp17_intro.cpp

@@ -11,7 +11,6 @@
 
 namespace net = boost::asio;
 namespace redis = boost::redis;
-using redis::adapt;
 using redis::operation;
 using redis::request;
 using redis::response;
@@ -39,7 +38,7 @@ auto main(int argc, char * argv[]) -> int
       req.push("QUIT");
 
       // The response.
-      response<redis::ignore, std::string, redis::ignore> resp;
+      response<redis::ignore_t, std::string, redis::ignore_t> resp;
 
       net::io_context ioc;
 
@@ -75,7 +74,7 @@ auto main(int argc, char * argv[]) -> int
             return log(ec, "on_connect: ");
 
          conn.async_run(on_run);
-         conn.async_exec(req, adapt(resp), on_exec);
+         conn.async_exec(req, resp, on_exec);
       };
 
       // Resolve callback.

examples/cpp17_intro_sync.cpp

@@ -16,17 +16,16 @@
 
 namespace net = boost::asio;
 namespace redis = boost::redis;
-using redis::adapt;
 using connection = redis::connection;
 using boost::redis::request;
 using boost::redis::response;
 
-template <class Adapter>
-auto exec(std::shared_ptr<connection> conn, request const& req, Adapter adapter)
+template <class Response>
+auto exec(std::shared_ptr<connection> conn, request const& req, Response& resp)
 {
    net::dispatch(
       conn->get_executor(),
-      net::deferred([&]() { return conn->async_exec(req, adapter, net::deferred); }))
+      net::deferred([&]() { return conn->async_exec(req, resp, net::deferred); }))
       (net::use_future).get();
 }
 
@@ -67,10 +66,10 @@ auto main(int argc, char * argv[]) -> int
       req.push("PING");
       req.push("QUIT");
 
-      response<boost::redis::ignore, std::string, boost::redis::ignore> resp;
+      response<boost::redis::ignore_t, std::string, boost::redis::ignore_t> resp;
 
       // Executes commands synchronously.
-      exec(conn, req, adapt(resp));
+      exec(conn, req, resp);
 
       std::cout << "Response: " << std::get<1>(resp) << std::endl;
 

examples/cpp20_chat_room.cpp

@@ -18,7 +18,6 @@ namespace net = boost::asio;
 using namespace net::experimental::awaitable_operators;
 using stream_descriptor = net::use_awaitable_t<>::as_default_on_t<net::posix::stream_descriptor>;
 using signal_set = net::use_awaitable_t<>::as_default_on_t<net::signal_set>;
-using boost::redis::adapt;
 using boost::redis::request;
 using boost::redis::generic_response;
 
@@ -29,7 +28,7 @@ using boost::redis::generic_response;
 auto receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
    for (generic_response resp;;) {
-      co_await conn->async_receive(adapt(resp));
+      co_await conn->async_receive(resp);
       std::cout << resp.at(1).value << " " << resp.at(2).value << " " << resp.at(3).value << std::endl;
       resp.clear();
    }

examples/cpp20_containers.cpp

@@ -16,7 +16,6 @@
 namespace net = boost::asio;
 namespace redis = boost::redis;
 using namespace net::experimental::awaitable_operators;
-using redis::adapt;
 using boost::redis::request;
 using boost::redis::response;
 
@@ -63,10 +62,10 @@ auto hgetall(std::shared_ptr<connection> conn) -> net::awaitable<void>
    req.push("HGETALL", "hset-key");
 
    // Responses as tuple elements.
-   response<redis::ignore, std::map<std::string, std::string>> resp;
+   response<redis::ignore_t, std::map<std::string, std::string>> resp;
 
    // Executes the request and reads the response.
-   co_await conn->async_exec(req, adapt(resp));
+   co_await conn->async_exec(req, resp);
 
    print(std::get<1>(resp));
 }
@@ -82,14 +81,14 @@ auto transaction(std::shared_ptr<connection> conn) -> net::awaitable<void>
    req.push("EXEC");
 
    response<
-      redis::ignore, // hello
-      redis::ignore, // multi
-      redis::ignore, // lrange
-      redis::ignore, // hgetall
+      redis::ignore_t, // hello
+      redis::ignore_t, // multi
+      redis::ignore_t, // lrange
+      redis::ignore_t, // hgetall
       response<std::optional<std::vector<int>>, std::optional<std::map<std::string, std::string>>> // exec
    > resp;
 
-   co_await conn->async_exec(req, adapt(resp));
+   co_await conn->async_exec(req, resp);
 
    print(std::get<0>(std::get<4>(resp)).value());
    print(std::get<1>(std::get<4>(resp)).value());

examples/cpp20_echo_server.cpp

@@ -15,22 +15,20 @@ using namespace net::experimental::awaitable_operators;
 using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
 using tcp_acceptor = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::acceptor>;
 using signal_set = net::use_awaitable_t<>::as_default_on_t<net::signal_set>;
-using boost::redis::adapt;
 using boost::redis::request;
 using boost::redis::response;
 
 auto echo_server_session(tcp_socket socket, std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
    request req;
-   std::string resp;
+   response<std::string> resp;
 
    for (std::string buffer;;) {
       auto n = co_await net::async_read_until(socket, net::dynamic_buffer(buffer, 1024), "\n");
       req.push("PING", buffer);
-      auto tmp = std::tie(resp);
-      co_await conn->async_exec(req, adapt(tmp));
-      co_await net::async_write(socket, net::buffer(resp));
-      resp.clear();
+      co_await conn->async_exec(req, resp);
+      co_await net::async_write(socket, net::buffer(std::get<0>(resp)));
+      std::get<0>(resp).clear();
       req.clear();
       buffer.erase(0, n);
    }

examples/cpp20_intro.cpp

@@ -10,7 +10,6 @@
 #include "common/common.hpp"
 
 namespace net = boost::asio;
-using boost::redis::adapt;
 using boost::redis::operation;
 using boost::redis::request;
 using boost::redis::response;
@@ -35,7 +34,7 @@ auto ping(std::shared_ptr<connection> conn) -> net::awaitable<void>
    req.push("PING", "Hello world");
 
    response<std::string> resp;
-   co_await conn->async_exec(req, adapt(resp));
+   co_await conn->async_exec(req, resp);
 
    std::cout << "PING: " << std::get<0>(resp) << std::endl;
 }

examples/cpp20_intro_awaitable_ops.cpp

@@ -12,7 +12,6 @@
 
 namespace net = boost::asio;
 using namespace net::experimental::awaitable_operators;
-using boost::redis::adapt;
 using boost::redis::request;
 using boost::redis::response;
 
@@ -24,11 +23,11 @@ auto co_main(std::string host, std::string port) -> net::awaitable<void>
    req.push("PING", "Hello world");
    req.push("QUIT");
 
-   response<boost::redis::ignore, std::string, boost::redis::ignore> resp;
+   response<boost::redis::ignore_t, std::string, boost::redis::ignore_t> resp;
 
    auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
    co_await connect(conn, host, port);
-   co_await (conn->async_run() || conn->async_exec(req, adapt(resp)));
+   co_await (conn->async_run() || conn->async_exec(req, resp));
 
    std::cout << "PING: " << std::get<1>(resp) << std::endl;
 }

examples/cpp20_intro_tls.cpp

@@ -20,7 +20,6 @@ namespace net = boost::asio;
 namespace redis = boost::redis;
 using namespace net::experimental::awaitable_operators;
 using resolver = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::resolver>;
-using redis::adapt;
 using connection = net::use_awaitable_t<>::as_default_on_t<redis::ssl::connection>;
 using boost::redis::request;
 using boost::redis::response;
@@ -38,7 +37,7 @@ net::awaitable<void> co_main(std::string, std::string)
    req.push("PING");
    req.push("QUIT");
 
-   response<redis::ignore, std::string, redis::ignore> resp;
+   response<redis::ignore_t, std::string, redis::ignore_t> resp;
 
    // Resolve
    auto ex = co_await net::this_coro::executor;
@@ -52,7 +51,7 @@ net::awaitable<void> co_main(std::string, std::string)
 
    co_await net::async_connect(conn.lowest_layer(), endpoints);
    co_await conn.next_layer().async_handshake(net::ssl::stream_base::client);
-   co_await (conn.async_run() || conn.async_exec(req, adapt(resp)));
+   co_await (conn.async_run() || conn.async_exec(req, resp));
 
    std::cout << "Response: " << std::get<1>(resp) << std::endl;
 }