Adds cpp17 async example.

Author: mzimbres

CMakeLists.txt

@@ -73,92 +73,100 @@ endif()
 # Executables
 #=======================================================================
 
-add_executable(intro examples/intro.cpp)
-target_link_libraries(intro common)
-target_compile_features(intro PUBLIC cxx_std_20)
-add_test(intro intro)
+add_executable(cpp20_intro examples/cpp20_intro.cpp)
+target_link_libraries(cpp20_intro common)
+target_compile_features(cpp20_intro PUBLIC cxx_std_20)
+add_test(cpp20_intro cpp20_intro)
 if (MSVC)
-    target_compile_options(intro PRIVATE /bigobj)
-    target_compile_definitions(intro PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_intro PRIVATE /bigobj)
+    target_compile_definitions(cpp20_intro PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(intro_sync examples/intro_sync.cpp)
-target_compile_features(intro_sync PUBLIC cxx_std_20)
-add_test(intro_sync intro_sync)
-add_test(intro_sync intro_sync)
+add_executable(cpp17_intro examples/cpp17_intro.cpp)
+target_compile_features(cpp17_intro PUBLIC cxx_std_17)
+add_test(cpp17_intro cpp17_intro)
 if (MSVC)
-    target_compile_options(intro_sync PRIVATE /bigobj)
-    target_compile_definitions(intro_sync PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp17_intro PRIVATE /bigobj)
+    target_compile_definitions(cpp17_intro PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(chat_room examples/chat_room.cpp)
-target_compile_features(chat_room PUBLIC cxx_std_20)
-target_link_libraries(chat_room common)
+add_executable(cpp17_intro_sync examples/cpp17_intro_sync.cpp)
+target_compile_features(cpp17_intro_sync PUBLIC cxx_std_17)
+add_test(cpp17_intro_sync cpp17_intro_sync)
+add_test(cpp17_intro_sync cpp17_intro_sync)
 if (MSVC)
-    target_compile_options(chat_room PRIVATE /bigobj)
-    target_compile_definitions(chat_room PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp17_intro_sync PRIVATE /bigobj)
+    target_compile_definitions(cpp17_intro_sync PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(containers examples/containers.cpp)
-target_compile_features(containers PUBLIC cxx_std_20)
-target_link_libraries(containers common)
-add_test(containers containers)
+add_executable(cpp20_chat_room examples/cpp20_chat_room.cpp)
+target_compile_features(cpp20_chat_room PUBLIC cxx_std_20)
+target_link_libraries(cpp20_chat_room common)
 if (MSVC)
-    target_compile_options(containers PRIVATE /bigobj)
-    target_compile_definitions(containers PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_chat_room PRIVATE /bigobj)
+    target_compile_definitions(cpp20_chat_room PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(echo_server examples/echo_server.cpp)
-target_compile_features(echo_server PUBLIC cxx_std_20)
-target_link_libraries(echo_server common)
+add_executable(cpp20_containers examples/cpp20_containers.cpp)
+target_compile_features(cpp20_containers PUBLIC cxx_std_20)
+target_link_libraries(cpp20_containers common)
+add_test(cpp20_containers cpp20_containers)
 if (MSVC)
-    target_compile_options(echo_server PRIVATE /bigobj)
-    target_compile_definitions(echo_server PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_containers PRIVATE /bigobj)
+    target_compile_definitions(cpp20_containers PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(resolve_with_sentinel examples/resolve_with_sentinel.cpp)
-target_compile_features(resolve_with_sentinel PUBLIC cxx_std_20)
-target_link_libraries(resolve_with_sentinel common)
-#add_test(resolve_with_sentinel resolve_with_sentinel)
+add_executable(cpp20_echo_server examples/cpp20_echo_server.cpp)
+target_compile_features(cpp20_echo_server PUBLIC cxx_std_20)
+target_link_libraries(cpp20_echo_server common)
 if (MSVC)
-    target_compile_options(resolve_with_sentinel PRIVATE /bigobj)
-    target_compile_definitions(resolve_with_sentinel PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_echo_server PRIVATE /bigobj)
+    target_compile_definitions(cpp20_echo_server PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(serialization examples/serialization.cpp)
-target_compile_features(serialization PUBLIC cxx_std_20)
-target_link_libraries(serialization common)
-add_test(serialization serialization)
+add_executable(cpp20_resolve_with_sentinel examples/cpp20_resolve_with_sentinel.cpp)
+target_compile_features(cpp20_resolve_with_sentinel PUBLIC cxx_std_20)
+target_link_libraries(cpp20_resolve_with_sentinel common)
+#add_test(cpp20_resolve_with_sentinel cpp20_resolve_with_sentinel)
 if (MSVC)
-    target_compile_options(serialization PRIVATE /bigobj)
-    target_compile_definitions(serialization PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_resolve_with_sentinel PRIVATE /bigobj)
+    target_compile_definitions(cpp20_resolve_with_sentinel PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(subscriber examples/subscriber.cpp)
-target_compile_features(subscriber PUBLIC cxx_std_20)
-target_link_libraries(subscriber common)
+add_executable(cpp20_serialization examples/cpp20_serialization.cpp)
+target_compile_features(cpp20_serialization PUBLIC cxx_std_20)
+target_link_libraries(cpp20_serialization common)
+add_test(cpp20_serialization cpp20_serialization)
 if (MSVC)
-    target_compile_options(subscriber PRIVATE /bigobj)
-    target_compile_definitions(subscriber PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_serialization PRIVATE /bigobj)
+    target_compile_definitions(cpp20_serialization PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(intro_tls examples/intro_tls.cpp)
-target_compile_features(intro_tls PUBLIC cxx_std_20)
-add_test(intro_tls intro_tls)
-target_link_libraries(intro_tls OpenSSL::Crypto OpenSSL::SSL)
-target_link_libraries(intro_tls common)
+add_executable(cpp20_subscriber examples/cpp20_subscriber.cpp)
+target_compile_features(cpp20_subscriber PUBLIC cxx_std_20)
+target_link_libraries(cpp20_subscriber common)
 if (MSVC)
-    target_compile_options(intro_tls PRIVATE /bigobj)
-    target_compile_definitions(intro_tls PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_subscriber PRIVATE /bigobj)
+    target_compile_definitions(cpp20_subscriber PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(low_level_async examples/low_level_async.cpp)
-target_compile_features(low_level_async PUBLIC cxx_std_20)
-add_test(low_level_async low_level_async)
-target_link_libraries(low_level_async common)
+add_executable(cpp20_intro_tls examples/cpp20_intro_tls.cpp)
+target_compile_features(cpp20_intro_tls PUBLIC cxx_std_20)
+add_test(cpp20_intro_tls cpp20_intro_tls)
+target_link_libraries(cpp20_intro_tls OpenSSL::Crypto OpenSSL::SSL)
+target_link_libraries(cpp20_intro_tls common)
 if (MSVC)
-    target_compile_options(low_level_async PRIVATE /bigobj)
-    target_compile_definitions(low_level_async PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_intro_tls PRIVATE /bigobj)
+    target_compile_definitions(cpp20_intro_tls PRIVATE _WIN32_WINNT=0x0601)
+endif()
+
+add_executable(cpp20_low_level_async examples/cpp20_low_level_async.cpp)
+target_compile_features(cpp20_low_level_async PUBLIC cxx_std_20)
+add_test(cpp20_low_level_async cpp20_low_level_async)
+target_link_libraries(cpp20_low_level_async common)
+if (MSVC)
+    target_compile_options(cpp20_low_level_async PRIVATE /bigobj)
+    target_compile_definitions(cpp20_low_level_async PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
 add_executable(echo_server_client benchmarks/cpp/asio/echo_server_client.cpp)
@@ -175,12 +183,12 @@ if (MSVC)
     target_compile_definitions(echo_server_direct PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(low_level_sync examples/low_level_sync.cpp)
-target_compile_features(low_level_sync PUBLIC cxx_std_17)
-add_test(low_level_sync low_level_sync)
+add_executable(cpp17_low_level_sync examples/cpp17_low_level_sync.cpp)
+target_compile_features(cpp17_low_level_sync PUBLIC cxx_std_17)
+add_test(cpp17_low_level_sync cpp17_low_level_sync)
 if (MSVC)
-    target_compile_options(low_level_sync PRIVATE /bigobj)
-    target_compile_definitions(low_level_sync PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp17_low_level_sync PRIVATE /bigobj)
+    target_compile_definitions(cpp17_low_level_sync PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
 add_executable(test_conn_exec tests/conn_exec.cpp)

README.md

@@ -15,7 +15,7 @@ the cases will be concerned with only three library entities
 
 For example, the coroutine below uses a short-lived connection to read Redis
 [hashes](https://redis.io/docs/data-types/hashes/)
-in a `std::map` (see intro.cpp and containers.cpp)
+in a `std::map` (see cpp20_intro.cpp, cpp17_intro.cpp and containers.cpp)
 
 ```cpp
 auto async_main() -> net::awaitable<void>
@@ -51,30 +51,27 @@ completes, these functions play the following roles
      called from multiple places in your code concurrently.
 * `connection::async_run`: Coordinate low-level read and write
   operations. More specifically, it will hand IO control to
-  `async_exec` when a response arrives and to
-  `aedis::connection::async_receive` when a server-push is received.
-  It will also trigger writes of pending requests when a reconnection
-  occurs. It remains suspended until the connection is lost.
-
-By carefully choosing the flags `aedis::resp3::request::config` users
-can also express their desire to not automatically cancel pending
-requests when the connection is lost, giving the opportunity to
-reconnect and call `async_run` again after a failover to trigger their
-execution, perhaps in another Redis instance.  Before we approach
-long-lived connections in the next section users will find it helpful
-to skim over the examples
-
-* intro.cpp: The Aedis hello-world program. Sends one command and quits the connection.
-* intro_tls.cpp: Same as intro.cpp but over TLS.
-* intro_sync.cpp: Shows how to use the connection class synchronously.
-* containers.cpp: Shows how to send and receive STL containers and how to use transactions.
-* serialization.cpp: Shows how to serialize types using Boost.Json.
-* resolve_with_sentinel.cpp: Shows how to resolve a master address using sentinels.
-* subscriber.cpp: Shows how to implement pubsub with reconnection re-subscription.
-* echo_server.cpp: A simple TCP echo server.
-* chat_room.cpp: A command line chat built on Redis pubsub.
-* low_level_sync.cpp: Sends a ping synchronously using the low-level API.
-* low_level_async.cpp: Sends a ping asynchronously using the low-level API.
+  `async_exec` when a response arrives, to
+  `aedis::connection::async_receive` when a server-push is received
+  and will trigger writes of pending requests when a reconnection
+  occurs.
+
+The role played by `async_run` can be better understood in the context
+of long-lived connections, which we will cover in the next section.
+Before that however, the reader might want to skim over the examples
+
+* cpp17_intro.cpp:  The Aedis hello-world program. Sends one command and quits the connection.
+* cpp17_intro_sync.cpp: Shows how to use the connection class synchronously.
+* cpp17_low_level_sync.cpp: Sends a ping synchronously using the low-level API.
+* cpp20_intro.cpp: Like cpp17_intro.cpp but uses awaitable operators.
+* cpp20_intro_tls.cpp: Same as intro.cpp but over TLS.
+* cpp20_containers.cpp: Shows how to send and receive STL containers and how to use transactions.
+* cpp20_serialization.cpp: Shows how to serialize types using Boost.Json.
+* cpp20_resolve_with_sentinel.cpp: Shows how to resolve a master address using sentinels.
+* cpp20_subscriber.cpp: Shows how to implement pubsub with reconnection re-subscription.
+* cpp20_echo_server.cpp: A simple TCP echo server.
+* cpp20_chat_room.cpp: A command line chat built on Redis pubsub.
+* cpp20_low_level_async.cpp: Sends a ping asynchronously using the low-level API.
 
 To avoid repetition code that is common to some examples has been
 grouped in common.hpp. The main function used in some async examples

examples/cpp17_intro.cpp

@@ -0,0 +1,93 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva ([email protected])
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <iostream>
+#include <boost/asio.hpp>
+#include <aedis.hpp>
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+using aedis::resp3::request;
+using aedis::adapt;
+using aedis::operation;
+
+void log(boost::system::error_code const& ec, char const* prefix)
+{
+   std::clog << prefix << ec.message() << std::endl;
+}
+
+auto main() -> int
+{
+   try {
+      // The request
+      resp3::request req;
+      req.push("HELLO", 3);
+      req.push("PING", "Hello world");
+      req.push("QUIT");
+
+      // The response.
+      std::tuple<aedis::ignore, std::string, aedis::ignore> resp;
+
+      net::io_context ioc;
+
+      // IO objects.
+      net::ip::tcp::resolver resv{ioc};
+      aedis::connection conn{ioc};
+
+      // Resolve endpoints.
+      net::ip::tcp::resolver::results_type endpoints;
+
+      // async_run callback.
+      auto on_run = [](auto ec)
+      {
+         if (ec)
+            return log(ec, "on_exec: ");
+      };
+
+      // async_exec callback.
+      auto on_exec = [&](auto ec, auto)
+      {
+         if (ec) {
+            conn.cancel(operation::run);
+            return log(ec, "on_exec: ");
+         }
+
+         std::cout << "PING: " << std::get<1>(resp) << std::endl;
+      };
+
+      // Connect callback.
+      auto on_connect = [&](auto ec, auto)
+      {
+         if (ec)
+            return log(ec, "on_connect: ");
+
+         conn.async_run(on_run);
+         conn.async_exec(req, adapt(resp), on_exec);
+      };
+
+      // Resolve callback.
+      auto on_resolve = [&](auto ec, auto const& addrs)
+      {
+         if (ec)
+            return log(ec, "on_resolve: ");
+
+         endpoints = addrs;
+         net::async_connect(conn.next_layer(), endpoints, on_connect);
+      };
+
+      resv.async_resolve("127.0.0.1", "6379", on_resolve);
+
+      ioc.run();
+      return 0;
+
+   } catch (std::exception const& e) {
+      std::cerr << "Error: " << e.what() << std::endl;
+   }
+
+   return 1;
+}
+