Merge pull request #71 from boostorg/70-rename-node-to-basic_node-and-add-typedef-for-nodestdstring

70 rename node to basic node and add typedef for nodestdstring

Author: mzimbres

.github/workflows/ci.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        boost_version: ["1.80.0"]
+        boost_version: ["1.81.0"]
         os: [windows-2019, windows-2022]
         toolset: [v142, v143]
         build_type: [Release]
@@ -25,7 +25,7 @@ jobs:
           - { os: windows-2019, generator: "Visual Studio 17 2022" }
           - { os: windows-2022, generator: "Visual Studio 16 2019" }
           # The following combinations are not available through install-boost
-          - { boost_version: "1.80.0", toolset: v143 }
+          - { boost_version: "1.81.0", toolset: v143 }
 
     steps:
     - name: Checkout
@@ -34,7 +34,7 @@ jobs:
         fetch-depth: 0
 
     - name: Add boost toolset to environment
-      if: contains(fromJson('["1.80.0"]'), matrix.boost_version)
+      if: contains(fromJson('["1.81.0"]'), matrix.boost_version)
       run: echo BOOST_TOOLSET=$(echo "msvc") >> $GITHUB_ENV
 
     # The platform_version passed to boost-install determines the msvc toolset version for which static libs are installed.
@@ -120,7 +120,7 @@ jobs:
       uses: MarkusJx/[email protected]
       id: install-boost
       with:
-        boost_version: 1.80.0
+        boost_version: 1.81.0
         platform_version: 22.04
     - name: Run CMake
       run: |

.github/workflows/coverage.yml

@@ -30,7 +30,7 @@ jobs:
       uses: MarkusJx/[email protected]
       id: install-boost
       with:
-        boost_version: 1.80.0
+        boost_version: 1.81.0
         platform_version: 22.04
     - name: Run CMake
       run: |

CMakeLists.txt

@@ -134,13 +134,13 @@ if (MSVC)
     target_compile_definitions(cpp20_resolve_with_sentinel PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-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)
+add_executable(cpp20_json_serialization examples/cpp20_json_serialization.cpp)
+target_compile_features(cpp20_json_serialization PUBLIC cxx_std_20)
+target_link_libraries(cpp20_json_serialization common)
+add_test(cpp20_json_serialization cpp20_json_serialization)
 if (MSVC)
-    target_compile_options(cpp20_serialization PRIVATE /bigobj)
-    target_compile_definitions(cpp20_serialization PRIVATE _WIN32_WINNT=0x0601)
+    target_compile_options(cpp20_json_serialization PRIVATE /bigobj)
+    target_compile_definitions(cpp20_json_serialization PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
 add_executable(cpp20_subscriber examples/cpp20_subscriber.cpp)
@@ -161,7 +161,7 @@ if (MSVC)
     target_compile_definitions(cpp20_intro_tls PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(cpp20_low_level_async examples/cpp20_low_level_async.cpp)
+add_executable(cpp20_low_level_async tests/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)
@@ -184,7 +184,7 @@ if (MSVC)
     target_compile_definitions(echo_server_direct PRIVATE _WIN32_WINNT=0x0601)
 endif()
 
-add_executable(cpp17_low_level_sync examples/cpp17_low_level_sync.cpp)
+add_executable(cpp17_low_level_sync tests/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)

README.md

@@ -20,7 +20,7 @@ concerned with only three library entities
 In the next sections we will cover all those points in detail with
 examples. The requirements for using Boost.Redis are
 
-* Boost 1.80 or greater.
+* Boost 1.81 or greater.
 * C++17 minimum.
 * Redis 6 or higher (must support RESP3).
 * Gcc (10, 11, 12), Clang (11, 13, 14) and Visual Studio (16 2019, 17 2022).
@@ -844,7 +844,11 @@ in no more than one source file in your applications. To build the
 examples and tests cmake is supported, for example
 
 ```cpp
-BOOST_ROOT=/opt/boost_1_80_0 cmake --preset dev
+# Linux
+$ BOOST_ROOT=/opt/boost_1_81_0 cmake --preset dev
+
+# Windows 
+$ cmake -G "Visual Studio 17 2022" -A x64 -B bin64 -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake
 ```
 ## Acknowledgement
 
@@ -862,21 +866,16 @@ Acknowledgement to people that helped shape Boost.Redis
 ### master (incorporates many suggestions from the boost review)
 
 * Renames the project to Boost.Redis and moves the code into namespace `boost::redis`.
-* As pointed out in the reviews `to_buld` and `from_buld` were too generic for ADL customization. They gained the prefix `boost_redis_`.
+* As pointed out in the reviews the `to_buld` and `from_buld` names were too generic for ADL customization points. They gained the prefix `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.
-* Adds `boost::redis::adapter::result` to store responses to commands
-  including possible resp3 errors without losing the error diagnostic
-  part. Basicaly instead of accessing values as `std::get<N>(resp)`
-  users have to type `std::get<N>(resp).value()`
-* Implements full-duplex communication. Before these changes the
-  connection would wait for a response to arrive before sending the
-  next. Now requests are continuously coalesced and written to the
-  socket. This made the request::coalesce unnecessary and threfore it
-  was removed.
+* Adds `boost::redis::adapter::result` to store responses to commands including possible resp3 errors without losing the error diagnostic part. Basicaly instead of accessing values as `std::get<N>(resp)` users have to type `std::get<N>(resp).value()`
+* Implements full-duplex communication. Before these changes the connection would wait for a response to arrive before sending the next one. Now requests are continuously coalesced and written to the socket. This made the request::coalesce unnecessary and threfore it was removed.
+* Adds native json support for Boost.Describe'd classes, see cpp20_json_serialization.cpp for how to use it.
+* Upgrades to Boost 1.81.0.
 
 ### v1.4.0-1
 

examples/common/common.cpp

@@ -24,7 +24,7 @@ auto redir(boost::system::error_code& ec)
    { return net::redirect_error(net::use_awaitable, ec); }
 }
 
-auto healthy_checker(std::shared_ptr<connection> conn) -> net::awaitable<void>
+auto health_check(std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
    try {
       request req;

examples/common/common.hpp

@@ -26,7 +26,7 @@ connect(
    std::string const& host,
    std::string const& port) -> boost::asio::awaitable<void>;
 
-auto healthy_checker(std::shared_ptr<connection> conn) -> boost::asio::awaitable<void>;
+auto health_check(std::shared_ptr<connection> conn) -> boost::asio::awaitable<void>;
 
 auto run(boost::asio::awaitable<void> op) -> int;
 

examples/common/serialization.hpp

@@ -60,7 +60,7 @@ auto co_main(std::string host, std::string port) -> net::awaitable<void>
 
    co_await connect(conn, host, port);
    co_await ((conn->async_run() || publisher(stream, conn) || receiver(conn) ||
-         healthy_checker(conn) || sig.async_wait()) && conn->async_exec(req));
+         health_check(conn) || sig.async_wait()) && conn->async_exec(req));
 }
 
 #else // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)

examples/cpp20_chat_room.cpp

@@ -54,7 +54,7 @@ auto co_main(std::string host, std::string port) -> net::awaitable<void>
    req.push("HELLO", 3);
 
    co_await connect(conn, host, port);
-   co_await ((conn->async_run() || listener(conn) || healthy_checker(conn) ||
+   co_await ((conn->async_run() || listener(conn) || health_check(conn) ||
             sig.async_wait()) && conn->async_exec(req));
 }
 

examples/cpp20_echo_server.cpp

@@ -6,22 +6,26 @@
 
 #include <boost/asio.hpp>
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#define BOOST_JSON_NO_LIB
+#define BOOST_CONTAINER_NO_LIB
 #include <boost/redis.hpp>
-#include <iostream>
+#include <boost/describe.hpp>
+#include <boost/redis/json.hpp>
 #include <set>
 #include <string>
+#include <iostream>
 #include "common/common.hpp"
-#include "common/serialization.hpp"
 
 // Include this in no more than one .cpp file.
 #include <boost/json/src.hpp>
 
 namespace net = boost::asio;
 namespace redis = boost::redis;
+using namespace boost::describe;
 using boost::redis::request;
 using boost::redis::response;
-using boost::redis::ignore_t;
 using boost::redis::operation;
+using boost::redis::ignore_t;
 
 struct user {
    std::string name;
@@ -41,46 +45,34 @@ auto run(std::shared_ptr<connection> conn, std::string host, std::string port) -
    co_await conn->async_run();
 }
 
-auto hello(std::shared_ptr<connection> conn) -> net::awaitable<void>
+net::awaitable<void> co_main(std::string host, std::string port)
 {
-   request req;
-   req.push("HELLO", 3);
-
-   co_await conn->async_exec(req);
-}
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   net::co_spawn(ex, run(conn, host, port), net::detached);
 
-auto sadd(std::shared_ptr<connection> conn) -> net::awaitable<void>
-{
+   // A set of users that will be automatically serialized to json.
    std::set<user> users
       {{"Joao", "58", "Brazil"} , {"Serge", "60", "France"}};
 
+   // To simplify we send the set and retrieve it in the same
+   // resquest.
    request req;
-   req.push_range("SADD", "sadd-key", users); // Sends
-
-   co_await conn->async_exec(req);
-}
-
-auto smembers(std::shared_ptr<connection> conn) -> net::awaitable<void>
-{
-   request req;
+   req.push("HELLO", 3);
+   req.push_range("SADD", "sadd-key", users);
    req.push("SMEMBERS", "sadd-key");
 
-   response<std::set<user>> resp;
+   // The response will contain the deserialized set, which should
+   // match the one we sent.
+   response<ignore_t, ignore_t, std::set<user>> resp;
 
+   // Sends the request and receives the response.
    co_await conn->async_exec(req, resp);
 
-   for (auto const& e: std::get<0>(resp).value())
-      std::cout << e << "\n";
-}
+   // Print.
+   for (auto const& e: std::get<2>(resp).value())
+      std::cout << e.name << " " << e.age << " " << e.country << "\n";
 
-net::awaitable<void> co_main(std::string host, std::string port)
-{
-   auto ex = co_await net::this_coro::executor;
-   auto conn = std::make_shared<connection>(ex);
-   net::co_spawn(ex, run(conn, host, port), net::detached);
-   co_await hello(conn);
-   co_await sadd(conn);
-   co_await smembers(conn);
    conn->cancel(operation::run);
 }