Test improvements.

- Simplifications.
- Refactors read operaitons for useability.
- Better naming.
- Simplification of write operations.
- Adds a push communication channel.

INSTALL

@@ -1 +1 @@
-See file:///tmp/aedis/html/installation.html
+See https://mzimbres.github.io/aedis/#using-aedis

LICENSE

@@ -1,373 +0,0 @@
-Mozilla Public License Version 2.0
-==================================
-
-1. Definitions
---------------
-
-1.1. "Contributor"
-    means each individual or legal entity that creates, contributes to
-    the creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
-    means the combination of the Contributions of others (if any) used
-    by a Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
-    means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
-    means Source Code Form to which the initial Contributor has attached
-    the notice in Exhibit A, the Executable Form of such Source Code
-    Form, and Modifications of such Source Code Form, in each case
-    including portions thereof.
-
-1.5. "Incompatible With Secondary Licenses"
-    means
-
-    (a) that the initial Contributor has attached the notice described
-        in Exhibit B to the Covered Software; or
-
-    (b) that the Covered Software was made available under the terms of
-        version 1.1 or earlier of the License, but not also under the
-        terms of a Secondary License.
-
-1.6. "Executable Form"
-    means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
-    means a work that combines Covered Software with other material, in
-    a separate file or files, that is not Covered Software.
-
-1.8. "License"
-    means this document.
-
-1.9. "Licensable"
-    means having the right to grant, to the maximum extent possible,
-    whether at the time of the initial grant or subsequently, any and
-    all of the rights conveyed by this License.
-
-1.10. "Modifications"
-    means any of the following:
-
-    (a) any file in Source Code Form that results from an addition to,
-        deletion from, or modification of the contents of Covered
-        Software; or
-
-    (b) any new file in Source Code Form that contains any Covered
-        Software.
-
-1.11. "Patent Claims" of a Contributor
-    means any patent claim(s), including without limitation, method,
-    process, and apparatus claims, in any patent Licensable by such
-    Contributor that would be infringed, but for the grant of the
-    License, by the making, using, selling, offering for sale, having
-    made, import, or transfer of either its Contributions or its
-    Contributor Version.
-
-1.12. "Secondary License"
-    means either the GNU General Public License, Version 2.0, the GNU
-    Lesser General Public License, Version 2.1, the GNU Affero General
-    Public License, Version 3.0, or any later versions of those
-    licenses.
-
-1.13. "Source Code Form"
-    means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
-    means an individual or a legal entity exercising rights under this
-    License. For legal entities, "You" includes any entity that
-    controls, is controlled by, or is under common control with You. For
-    purposes of this definition, "control" means (a) the power, direct
-    or indirect, to cause the direction or management of such entity,
-    whether by contract or otherwise, or (b) ownership of more than
-    fifty percent (50%) of the outstanding shares or beneficial
-    ownership of such entity.
-
-2. License Grants and Conditions
---------------------------------
-
-2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free,
-non-exclusive license:
-
-(a) under intellectual property rights (other than patent or trademark)
-    Licensable by such Contributor to use, reproduce, make available,
-    modify, display, perform, distribute, and otherwise exploit its
-    Contributions, either on an unmodified basis, with Modifications, or
-    as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer
-    for sale, have made, import, and otherwise transfer either its
-    Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution
-become effective for each Contribution on the date the Contributor first
-distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under
-this License. No additional rights or licenses will be implied from the
-distribution or licensing of Covered Software under this License.
-Notwithstanding Section 2.1(b) above, no patent license is granted by a
-Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software;
-    or
-
-(b) for infringements caused by: (i) Your and any other third party's
-    modifications of Covered Software, or (ii) the combination of its
-    Contributions with other software (except as part of its Contributor
-    Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of
-    its Contributions.
-
-This License does not grant any rights in the trademarks, service marks,
-or logos of any Contributor (except as may be necessary to comply with
-the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to
-distribute the Covered Software under a subsequent version of this
-License (see Section 10.2) or under the terms of a Secondary License (if
-permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-Each Contributor represents that the Contributor believes its
-Contributions are its original creation(s) or it has sufficient rights
-to grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-This License is not intended to limit any rights You have under
-applicable copyright doctrines of fair use, fair dealing, or other
-equivalents.
-
-2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
-in Section 2.1.
-
-3. Responsibilities
--------------------
-
-3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any
-Modifications that You create or to which You contribute, must be under
-the terms of this License. You must inform recipients that the Source
-Code Form of the Covered Software is governed by the terms of this
-License, and how they can obtain a copy of this License. You may not
-attempt to alter or restrict the recipients' rights in the Source Code
-Form.
-
-3.2. Distribution of Executable Form
-
-If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code
-    Form, as described in Section 3.1, and You must inform recipients of
-    the Executable Form how they can obtain a copy of such Source Code
-    Form by reasonable means in a timely manner, at a charge no more
-    than the cost of distribution to the recipient; and
-
-(b) You may distribute such Executable Form under the terms of this
-    License, or sublicense it under different terms, provided that the
-    license for the Executable Form does not attempt to limit or alter
-    the recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice,
-provided that You also comply with the requirements of this License for
-the Covered Software. If the Larger Work is a combination of Covered
-Software with a work governed by one or more Secondary Licenses, and the
-Covered Software is not Incompatible With Secondary Licenses, this
-License permits You to additionally distribute such Covered Software
-under the terms of such Secondary License(s), so that the recipient of
-the Larger Work may, at their option, further distribute the Covered
-Software under the terms of either this License or such Secondary
-License(s).
-
-3.4. Notices
-
-You may not remove or alter the substance of any license notices
-(including copyright notices, patent notices, disclaimers of warranty,
-or limitations of liability) contained within the Source Code Form of
-the Covered Software, except that You may alter any license notices to
-the extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support,
-indemnity or liability obligations to one or more recipients of Covered
-Software. However, You may do so only on Your own behalf, and not on
-behalf of any Contributor. You must make it absolutely clear that any
-such warranty, support, indemnity, or liability obligation is offered by
-You alone, and You hereby agree to indemnify every Contributor for any
-liability incurred by such Contributor as a result of warranty, support,
-indemnity or liability terms You offer. You may include additional
-disclaimers of warranty and limitations of liability specific to any
-jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
----------------------------------------------------
-
-If it is impossible for You to comply with any of the terms of this
-License with respect to some or all of the Covered Software due to
-statute, judicial order, or regulation then You must: (a) comply with
-the terms of this License to the maximum extent possible; and (b)
-describe the limitations and the code they affect. Such description must
-be placed in a text file included with all distributions of the Covered
-Software under this License. Except to the extent prohibited by statute
-or regulation, such description must be sufficiently detailed for a
-recipient of ordinary skill to be able to understand it.
-
-5. Termination
---------------
-
-5.1. The rights granted under this License will terminate automatically
-if You fail to comply with any of its terms. However, if You become
-compliant, then the rights granted under this License from a particular
-Contributor are reinstated (a) provisionally, unless and until such
-Contributor explicitly and finally terminates Your grants, and (b) on an
-ongoing basis, if such Contributor fails to notify You of the
-non-compliance by some reasonable means prior to 60 days after You have
-come back into compliance. Moreover, Your grants from a particular
-Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the
-first time You have received notice of non-compliance with this License
-from such Contributor, and You become compliant prior to 30 days after
-Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-infringement claim (excluding declaratory judgment actions,
-counter-claims, and cross-claims) alleging that a Contributor Version
-directly or indirectly infringes any patent, then the rights granted to
-You by any and all Contributors for the Covered Software under Section
-2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all
-end user license agreements (excluding distributors and resellers) which
-have been validly granted by You or Your distributors under this License
-prior to termination shall survive termination.
-
-************************************************************************
-*                                                                      *
-*  6. Disclaimer of Warranty                                           *
-*  -------------------------                                           *
-*                                                                      *
-*  Covered Software is provided under this License on an "as is"       *
-*  basis, without warranty of any kind, either expressed, implied, or  *
-*  statutory, including, without limitation, warranties that the       *
-*  Covered Software is free of defects, merchantable, fit for a        *
-*  particular purpose or non-infringing. The entire risk as to the     *
-*  quality and performance of the Covered Software is with You.        *
-*  Should any Covered Software prove defective in any respect, You     *
-*  (not any Contributor) assume the cost of any necessary servicing,   *
-*  repair, or correction. This disclaimer of warranty constitutes an   *
-*  essential part of this License. No use of any Covered Software is   *
-*  authorized under this License except under this disclaimer.         *
-*                                                                      *
-************************************************************************
-
-************************************************************************
-*                                                                      *
-*  7. Limitation of Liability                                          *
-*  --------------------------                                          *
-*                                                                      *
-*  Under no circumstances and under no legal theory, whether tort      *
-*  (including negligence), contract, or otherwise, shall any           *
-*  Contributor, or anyone who distributes Covered Software as          *
-*  permitted above, be liable to You for any direct, indirect,         *
-*  special, incidental, or consequential damages of any character      *
-*  including, without limitation, damages for lost profits, loss of    *
-*  goodwill, work stoppage, computer failure or malfunction, or any    *
-*  and all other commercial damages or losses, even if such party      *
-*  shall have been informed of the possibility of such damages. This   *
-*  limitation of liability shall not apply to liability for death or   *
-*  personal injury resulting from such party's negligence to the       *
-*  extent applicable law prohibits such limitation. Some               *
-*  jurisdictions do not allow the exclusion or limitation of           *
-*  incidental or consequential damages, so this exclusion and          *
-*  limitation may not apply to You.                                    *
-*                                                                      *
-************************************************************************
-
-8. Litigation
--------------
-
-Any litigation relating to this License may be brought only in the
-courts of a jurisdiction where the defendant maintains its principal
-place of business and such litigation shall be governed by laws of that
-jurisdiction, without reference to its conflict-of-law provisions.
-Nothing in this Section shall prevent a party's ability to bring
-cross-claims or counter-claims.
-
-9. Miscellaneous
-----------------
-
-This License represents the complete agreement concerning the subject
-matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent
-necessary to make it enforceable. Any law or regulation which provides
-that the language of a contract shall be construed against the drafter
-shall not be used to construe this License against a Contributor.
-
-10. Versions of the License
----------------------------
-
-10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section
-10.3, no one other than the license steward has the right to modify or
-publish new versions of this License. Each version will be given a
-distinguishing version number.
-
-10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version
-of the License under which You originally received the Covered Software,
-or under the terms of any subsequent version published by the license
-steward.
-
-10.3. Modified Versions
-
-If you create software not governed by this License, and you want to
-create a new license for such software, you may create and use a
-modified version of this License if you rename the license and remove
-any references to the name of the license steward (except to note that
-such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With
-Secondary Licenses under the terms of this version of the License, the
-notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
--------------------------------------------
-
-  This Source Code Form is subject to the terms of the Mozilla Public
-  License, v. 2.0. If a copy of the MPL was not distributed with this
-  file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular
-file, then You may include the notice in a location (such as a LICENSE
-file in a relevant directory) where a recipient would be likely to look
-for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
----------------------------------------------------------
-
-  This Source Code Form is "Incompatible With Secondary Licenses", as
-  defined by the Mozilla Public License, v. 2.0.

LICENSE.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

Makefile.am

@@ -12,25 +12,22 @@ AM_LDFLAGS =
 AM_LDFLAGS += -pthread
 
 check_PROGRAMS =
-check_PROGRAMS += low_level_sync_intro
-check_PROGRAMS += high_level_intro
-check_PROGRAMS += high_level_aggregates
-check_PROGRAMS += high_level_stl_containers
-check_PROGRAMS += high_level_serialization
+check_PROGRAMS += intro_sync
+check_PROGRAMS += intro
+check_PROGRAMS += containers
+check_PROGRAMS += serialization
 check_PROGRAMS += test_low_level
 if HAVE_CXX20
-check_PROGRAMS += low_level_async_intro
-check_PROGRAMS += low_level_adapter
-check_PROGRAMS += test_online
+check_PROGRAMS += test_high_level
 endif
 
 EXTRA_PROGRAMS =
-EXTRA_PROGRAMS += high_level_subscriber
-EXTRA_PROGRAMS += commands
+EXTRA_PROGRAMS += subscriber
 if HAVE_CXX20
-EXTRA_PROGRAMS += low_level_subscriber
-EXTRA_PROGRAMS += high_level_echo_server
-EXTRA_PROGRAMS += high_level_chat_room
+EXTRA_PROGRAMS += echo_server
+EXTRA_PROGRAMS += echo_server_direct
+EXTRA_PROGRAMS += chat_room
+EXTRA_PROGRAMS += echo_server_client
 endif
 
 CLEANFILES =
@@ -39,51 +36,48 @@ CLEANFILES += $(EXTRA_PROGRAMS)
 .PHONY: all
 all: $(check_PROGRAMS) $(EXTRA_PROGRAMS)
 
-high_level_intro_SOURCES = $(top_srcdir)/examples/high_level/intro.cpp
-high_level_aggregates_SOURCES = $(top_srcdir)/examples/high_level/aggregates.cpp
-high_level_stl_containers_SOURCES = $(top_srcdir)/examples/high_level/stl_containers.cpp
-high_level_serialization_SOURCES = $(top_srcdir)/examples/high_level/serialization.cpp
-low_level_sync_intro_SOURCES = $(top_srcdir)/examples/low_level/sync_intro.cpp
-commands_SOURCES = $(top_srcdir)/tools/commands.cpp
-high_level_subscriber_SOURCES = $(top_srcdir)/examples/high_level/subscriber.cpp
+intro_sync_SOURCES = $(top_srcdir)/tests/intro_sync.cpp
+subscriber_SOURCES = $(top_srcdir)/examples/subscriber.cpp
 test_low_level_SOURCES = $(top_srcdir)/tests/low_level.cpp
+intro_SOURCES = $(top_srcdir)/examples/intro.cpp
+containers_SOURCES = $(top_srcdir)/examples/containers.cpp
+serialization_SOURCES = $(top_srcdir)/examples/serialization.cpp
 if HAVE_CXX20
-test_online_SOURCES = $(top_srcdir)/tests/online.cpp
-low_level_async_intro_SOURCES = $(top_srcdir)/examples/low_level/async_intro.cpp
-low_level_subscriber_SOURCES = $(top_srcdir)/examples/low_level/subscriber.cpp
-low_level_adapter_SOURCES = $(top_srcdir)/examples/low_level/adapter.cpp
-high_level_echo_server_SOURCES = $(top_srcdir)/examples/high_level/echo_server.cpp
-high_level_chat_room_SOURCES = $(top_srcdir)/examples/high_level/chat_room.cpp
+test_high_level_SOURCES = $(top_srcdir)/tests/high_level.cpp
+chat_room_SOURCES = $(top_srcdir)/examples/chat_room.cpp
+echo_server_SOURCES = $(top_srcdir)/examples/echo_server.cpp
+echo_server_direct_SOURCES = $(top_srcdir)/benchmarks/cpp/asio/echo_server_direct.cpp
+echo_server_client_SOURCES = $(top_srcdir)/benchmarks/cpp/asio/echo_server_client.cpp
 endif
 
 nobase_include_HEADERS =\
   $(top_srcdir)/aedis/src.hpp\
-  $(top_srcdir)/aedis/redis/command.hpp\
-  $(top_srcdir)/aedis/generic/client.hpp\
-  $(top_srcdir)/aedis/generic/serializer.hpp\
-  $(top_srcdir)/aedis/generic/detail/client_ops.hpp\
-  $(top_srcdir)/aedis/sentinel/command.hpp\
+  $(top_srcdir)/aedis/error.hpp\
+  $(top_srcdir)/aedis/impl/error.ipp\
+  $(top_srcdir)/aedis/detail/net.hpp\
+  $(top_srcdir)/aedis/command.hpp\
+  $(top_srcdir)/aedis/impl/command.ipp\
+  $(top_srcdir)/aedis/connection.hpp\
+  $(top_srcdir)/aedis/adapt.hpp\
+  $(top_srcdir)/aedis/detail/connection_ops.hpp\
   $(top_srcdir)/aedis/aedis.hpp\
   $(top_srcdir)/aedis/adapter/detail/adapters.hpp\
-  $(top_srcdir)/aedis/adapter/error.hpp\
-  $(top_srcdir)/aedis/adapter/impl/error.ipp\
   $(top_srcdir)/aedis/adapter/adapt.hpp\
-  $(top_srcdir)/aedis/adapter/response_traits.hpp\
+  $(top_srcdir)/aedis/adapter/detail/response_traits.hpp\
   $(top_srcdir)/aedis/resp3/node.hpp\
   $(top_srcdir)/aedis/resp3/compose.hpp\
   $(top_srcdir)/aedis/resp3/detail/read_ops.hpp\
   $(top_srcdir)/aedis/resp3/detail/parser.hpp\
-  $(top_srcdir)/aedis/resp3/error.hpp\
-  $(top_srcdir)/aedis/resp3/impl/error.ipp\
   $(top_srcdir)/aedis/resp3/type.hpp\
   $(top_srcdir)/aedis/resp3/read.hpp\
-  $(top_srcdir)/aedis/redis/impl/command.ipp\
-  $(top_srcdir)/aedis/sentinel/impl/command.ipp\
+  $(top_srcdir)/aedis/resp3/exec.hpp\
+  $(top_srcdir)/aedis/resp3/write.hpp\
+  $(top_srcdir)/aedis/resp3/request.hpp\
   $(top_srcdir)/aedis/resp3/detail/impl/parser.ipp\
   $(top_srcdir)/aedis/resp3/impl/type.ipp
 
 nobase_noinst_HEADERS =\
-  $(top_srcdir)/examples/high_level/user_session.hpp\
+  $(top_srcdir)/examples/print.hpp\
   $(top_srcdir)/tests/check.hpp
 
 TESTS = $(check_PROGRAMS)
@@ -94,6 +88,19 @@ EXTRA_DIST += $(top_srcdir)/doc/DoxygenLayout.xml
 EXTRA_DIST += $(top_srcdir)/doc/aedis.css
 EXTRA_DIST += $(top_srcdir)/doc/htmlfooter.html
 EXTRA_DIST += $(top_srcdir)/doc/htmlheader.html
+EXTRA_DIST += $(top_srcdir)/benchmarks/cpp/libuv/echo_server_direct.c
+EXTRA_DIST += $(top_srcdir)/benchmarks/cpp/libuv/README.md
+EXTRA_DIST += $(top_srcdir)/benchmarks/go/echo_server_direct.go
+EXTRA_DIST += $(top_srcdir)/benchmarks/nodejs/echo_server_direct.js
+EXTRA_DIST += $(top_srcdir)/benchmarks/nodejs/echo_server_over_redis.js
+EXTRA_DIST += $(top_srcdir)/benchmarks/nodejs/package.json
+EXTRA_DIST += $(top_srcdir)/benchmarks/nodejs/package-lock.json
+EXTRA_DIST += $(top_srcdir)/benchmarks/rust/echo_server_direct/Cargo.lock
+EXTRA_DIST += $(top_srcdir)/benchmarks/rust/echo_server_direct/Cargo.toml
+EXTRA_DIST += $(top_srcdir)/benchmarks/rust/echo_server_direct/src/main.rs
+EXTRA_DIST += $(top_srcdir)/benchmarks/rust/echo_server_over_redis/Cargo.lock
+EXTRA_DIST += $(top_srcdir)/benchmarks/rust/echo_server_over_redis/Cargo.toml
+EXTRA_DIST += $(top_srcdir)/benchmarks/rust/echo_server_over_redis/src/main.rs
 
 .PHONY: doc
 doc:

aedis/adapt.hpp

@@ -0,0 +1,129 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_ADAPT_HPP
+#define AEDIS_ADAPT_HPP
+
+#include <tuple>
+
+#include <boost/mp11.hpp>
+#include <boost/variant2.hpp>
+#include <boost/utility/string_view.hpp>
+#include <boost/system.hpp>
+
+#include <aedis/resp3/node.hpp>
+#include <aedis/adapter/adapt.hpp>
+#include <aedis/adapter/detail/response_traits.hpp>
+
+namespace aedis {
+
+using ignore = adapter::detail::ignore;
+
+namespace detail {
+
+struct ignore_adapter {
+   void
+   operator()(
+      std::size_t i,
+      resp3::node<boost::string_view> const& nd,
+      boost::system::error_code& ec)
+   {
+   }
+};
+
+template <class Tuple>
+class static_adapter {
+private:
+   static constexpr auto size = std::tuple_size<Tuple>::value;
+   using adapter_tuple = boost::mp11::mp_transform<adapter::adapter_t, Tuple>;
+   using variant_type = boost::mp11::mp_rename<adapter_tuple, boost::variant2::variant>;
+   using adapters_array_type = std::array<variant_type, size>;
+
+   adapters_array_type adapters_;
+
+public:
+   static_adapter(Tuple& r = nullptr)
+   {
+      adapter::detail::assigner<std::tuple_size<Tuple>::value - 1>::assign(adapters_, r);
+   }
+
+   void
+   operator()(
+      std::size_t i,
+      resp3::node<boost::string_view> const& nd,
+      boost::system::error_code& ec)
+   {
+      using boost::variant2::visit;
+      BOOST_ASSERT(i < adapters_.size());
+      visit([&](auto& arg){arg(nd, ec);}, adapters_.at(i));
+   }
+};
+
+template <class Vector>
+class vector_adapter {
+private:
+   using adapter_type = typename adapter::detail::response_traits<Vector>::adapter_type;
+   adapter_type adapter_;
+
+public:
+   vector_adapter(Vector& v) : adapter_{adapter::adapt(v)} { }
+
+   void
+   operator()(
+      std::size_t i,
+      resp3::node<boost::string_view> const& nd,
+      boost::system::error_code& ec)
+   {
+      adapter_(nd, ec);
+   }
+};
+
+template <class>
+struct response_traits;
+
+template <>
+struct response_traits<void> {
+   using response_type = void;
+   using adapter_type = detail::ignore_adapter;
+
+   static auto adapt() noexcept
+      { return detail::ignore_adapter{}; }
+};
+
+template <class String, class Allocator>
+struct response_traits<std::vector<resp3::node<String>, Allocator>> {
+   using response_type = std::vector<resp3::node<String>, Allocator>;
+   using adapter_type = vector_adapter<response_type>;
+
+   static auto adapt(response_type& v) noexcept
+      { return adapter_type{v}; }
+};
+
+template <class ...Ts>
+struct response_traits<std::tuple<Ts...>> {
+   using response_type = std::tuple<Ts...>;
+   using adapter_type = static_adapter<response_type>;
+
+   static auto adapt(response_type& r) noexcept
+      { return adapter_type{r}; }
+};
+
+} // detail
+
+auto adapt() noexcept
+{
+   return detail::response_traits<void>::adapt();
+}
+
+template<class T>
+auto adapt(T& t) noexcept
+{
+   return detail::response_traits<T>::adapt(t);
+}
+
+} // aedis
+
+#endif // AEDIS_ADAPT_HPP

aedis/adapter/adapt.hpp

@@ -1,38 +1,52 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_ADAPTER_ADAPT_HPP
+#define AEDIS_ADAPTER_ADAPT_HPP
 
-#include <aedis/adapter/response_traits.hpp>
+#include <aedis/adapter/detail/response_traits.hpp>
 
 namespace aedis {
 namespace adapter {
 
-/** \brief Creates a void response adapter.
+template <class T>
+using adapter_t = typename detail::adapter_t<T>;
+
+/** \internal
+    \brief Creates a dummy response adapter.
     \ingroup any
   
-    The adapter returned by this function ignores responses and is
-    useful to avoid wasting time with responses on which the user is
-    not insterested in.
+    The adapter returned by this function ignores responses. It is
+    useful to avoid wasting time with responses which are not needed.
 
-    Example usage:
+    Example:
 
     @code
-    co_await async_read(socket, buffer, adapt());
+    // Pushes and writes some commands to the server.
+    sr.push(command::hello, 3);
+    sr.push(command::ping);
+    sr.push(command::quit);
+    net::write(socket, net::buffer(request));
+
+    // Ignores all responses except for the response to ping.
+    std::string buffer;
+    resp3::read(socket, dynamic_buffer(buffer), adapt());     // hello
+    resp3::read(socket, dynamic_buffer(buffer), adapt(resp)); // ping
+    resp3::read(socket, dynamic_buffer(buffer, adapt()));     // quit
     @endcode
  */
 inline
 auto adapt() noexcept
-   { return response_traits<void>::adapt(); }
+   { return detail::response_traits<void>::adapt(); }
 
-/** \brief Adapts user data to read operations.
+/** \internal
+ *  \brief Adapts user data to read operations.
  *  \ingroup any
  *
- *  All STL containers, \c std::tuple and built-in types are supported and
+ *  STL containers, \c std::tuple and built-in types are supported and
  *  can be used in conjunction with \c boost::optional<T>.
  *
  *  Example usage:
@@ -62,7 +76,9 @@ auto adapt() noexcept
  */
 template<class T>
 auto adapt(T& t) noexcept
-   { return response_traits<T>::adapt(t); }
+   { return detail::response_traits<T>::adapt(t); }
 
 } // adapter
 } // aedis
+
+#endif // AEDIS_ADAPTER_ADAPT_HPP

aedis/adapter/detail/adapters.hpp

@@ -1,11 +1,11 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_ADAPTER_ADAPTERS_HPP
+#define AEDIS_ADAPTER_ADAPTERS_HPP
 
 #include <set>
 #include <unordered_set>
@@ -18,24 +18,41 @@
 #include <vector>
 #include <array>
 
+#include <boost/assert.hpp>
 #include <boost/optional.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/home/x3.hpp>
 #include <boost/utility/string_view.hpp>
 
+#include <aedis/error.hpp>
 #include <aedis/resp3/type.hpp>
+#include <aedis/resp3/request.hpp>
 #include <aedis/resp3/detail/parser.hpp>
-#include <aedis/generic/serializer.hpp>
 #include <aedis/resp3/node.hpp>
-#include <aedis/adapter/error.hpp>
 
 namespace aedis {
 namespace adapter {
 namespace detail {
 
+double
+parse_double(
+   char const* data,
+   std::size_t size,
+   boost::system::error_code& ec)
+{
+   static constexpr boost::spirit::x3::real_parser<double> p{};
+   double ret;
+   if (!parse(data, data + size, p, ret))
+      ec = error::not_a_double;
+
+   return ret;
+}
+
 // Serialization.
 
 template <class T>
 typename std::enable_if<std::is_integral<T>::value, void>::type
-from_string(
+from_bulk(
    T& i,
    boost::string_view sv,
    boost::system::error_code& ec)
@@ -43,7 +60,7 @@ from_string(
    i = resp3::detail::parse_uint(sv.data(), sv.size(), ec);
 }
 
-void from_string(
+void from_bulk(
    bool& t,
    boost::string_view sv,
    boost::system::error_code& ec)
@@ -51,9 +68,17 @@ void from_string(
    t = *sv.data() == 't';
 }
 
+void from_bulk(
+   double& d,
+   boost::string_view sv,
+   boost::system::error_code& ec)
+{
+   d = parse_double(sv.data(), sv.size(), ec);
+}
+
 template <class CharT, class Traits, class Allocator>
 void
-from_string(
+from_bulk(
    std::basic_string<CharT, Traits, Allocator>& s,
    boost::string_view sv,
    boost::system::error_code&)
@@ -66,9 +91,9 @@ from_string(
 void set_on_resp3_error(resp3::type t, boost::system::error_code& ec)
 {
    switch (t) {
-      case resp3::type::simple_error: ec = adapter::error::simple_error; return;
-      case resp3::type::blob_error: ec = adapter::error::blob_error; return;
-      case resp3::type::null: ec = adapter::error::null; return;
+      case resp3::type::simple_error: ec = error::simple_error; return;
+      case resp3::type::blob_error: ec = error::blob_error; return;
+      case resp3::type::null: ec = error::null; return;
       default: return;
    }
 }
@@ -80,9 +105,10 @@ private:
 
 public:
    general_aggregate(Result* c = nullptr): result_(c) {}
-   void operator()(resp3::node<boost::string_view> const& n, boost::system::error_code&)
+   void operator()(resp3::node<boost::string_view> const& n, boost::system::error_code& ec)
    {
       result_->push_back({n.data_type, n.aggregate_size, n.depth, std::string{std::cbegin(n.value), std::cend(n.value)}});
+      set_on_resp3_error(n.data_type, ec);
    }
 };
 
@@ -94,12 +120,13 @@ private:
 public:
    general_simple(Node* t = nullptr) : result_(t) {}
 
-   void operator()(resp3::node<boost::string_view> const& n, boost::system::error_code&)
+   void operator()(resp3::node<boost::string_view> const& n, boost::system::error_code& ec)
    {
-     result_->data_type = n.data_type;
-     result_->aggregate_size = n.aggregate_size;
-     result_->depth = n.depth;
-     result_->value.assign(n.value.data(), n.value.size());
+      result_->data_type = n.data_type;
+      result_->aggregate_size = n.aggregate_size;
+      result_->depth = n.depth;
+      result_->value.assign(n.value.data(), n.value.size());
+      set_on_resp3_error(n.data_type, ec);
    }
 };
 
@@ -119,11 +146,11 @@ public:
          return;
 
       if (is_aggregate(n.data_type)) {
-         ec = adapter::error::expects_simple_type;
+         ec = error::expects_simple_type;
          return;
       }
 
-      from_string(result, n.value, ec);
+      from_bulk(result, n.value, ec);
    }
 };
 
@@ -148,19 +175,19 @@ public:
 
       if (is_aggregate(nd.data_type)) {
          if (nd.data_type != resp3::type::set)
-            ec = error::expects_set_aggregate;
+            ec = error::expects_set_type;
          return;
       }
 
-      assert(nd.aggregate_size == 1);
+      BOOST_ASSERT(nd.aggregate_size == 1);
 
       if (nd.depth < 1) {
-	 ec = adapter::error::expects_set_aggregate;
+	 ec = error::expects_set_type;
 	 return;
       }
 
       typename Result::key_type obj;
-      from_string(obj, nd.value, ec);
+      from_bulk(obj, nd.value, ec);
       hint_ = result.insert(hint_, std::move(obj));
    }
 };
@@ -187,24 +214,24 @@ public:
 
       if (is_aggregate(nd.data_type)) {
          if (element_multiplicity(nd.data_type) != 2)
-           ec = error::expects_map_like_aggregate;
+           ec = error::expects_map_type;
          return;
       }
 
-      assert(nd.aggregate_size == 1);
+      BOOST_ASSERT(nd.aggregate_size == 1);
 
       if (nd.depth < 1) {
-	 ec = adapter::error::expects_map_like_aggregate;
+	 ec = error::expects_map_type;
 	 return;
       }
 
       if (on_key_) {
          typename Result::key_type obj;
-         from_string(obj, nd.value, ec);
+         from_bulk(obj, nd.value, ec);
          current_ = result.insert(current_, {std::move(obj), {}});
       } else {
          typename Result::mapped_type obj;
-         from_string(obj, nd.value, ec);
+         from_bulk(obj, nd.value, ec);
          current_->second = std::move(obj);
       }
 
@@ -232,7 +259,7 @@ public:
          result.reserve(result.size() + m * nd.aggregate_size);
       } else {
          result.push_back({});
-         from_string(result.back(), nd.value, ec);
+         from_bulk(result.back(), nd.value, ec);
       }
    }
 };
@@ -257,7 +284,7 @@ public:
 
       if (is_aggregate(nd.data_type)) {
 	 if (i_ != -1) {
-            ec = adapter::error::nested_aggregate_unsupported;
+            ec = error::nested_aggregate_unsupported;
             return;
          }
 
@@ -267,12 +294,12 @@ public:
          }
       } else {
          if (i_ == -1) {
-            ec = adapter::error::expects_aggregate;
+            ec = error::expects_aggregate_type;
             return;
          }
 
-         assert(nd.aggregate_size == 1);
-         from_string(result.at(i_), nd.value, ec);
+         BOOST_ASSERT(nd.aggregate_size == 1);
+         from_bulk(result.at(i_), nd.value, ec);
       }
 
       ++i_;
@@ -295,14 +322,14 @@ struct list_impl {
          return;
 
       if (!is_aggregate(nd.data_type)) {
-        assert(nd.aggregate_size == 1);
+        BOOST_ASSERT(nd.aggregate_size == 1);
         if (nd.depth < 1) {
-           ec = adapter::error::expects_aggregate;
+           ec = error::expects_aggregate_type;
            return;
         }
 
         result.push_back({});
-        from_string(result.back(), nd.value, ec);
+        from_bulk(result.back(), nd.value, ec);
       }
    }
 };
@@ -365,7 +392,7 @@ public:
       resp3::node<boost::string_view> const& nd,
       boost::system::error_code& ec)
    {
-      assert(result_);
+      BOOST_ASSERT(result_);
       impl_(*result_, nd, ec);
    }
 };
@@ -399,3 +426,5 @@ public:
 } // detail
 } // adapter
 } // aedis
+
+#endif // AEDIS_ADAPTER_ADAPTERS_HPP

aedis/adapter/detail/response_traits.hpp

@@ -1,11 +1,11 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_ADAPTER_RESPONSE_TRAITS_HPP
+#define AEDIS_ADAPTER_RESPONSE_TRAITS_HPP
 
 #include <vector>
 #include <tuple>
@@ -13,65 +13,59 @@
 #include <boost/mp11.hpp>
 #include <boost/variant2.hpp>
 
+#include <aedis/error.hpp>
 #include <aedis/resp3/type.hpp>
 #include <aedis/resp3/read.hpp>
 #include <aedis/adapter/detail/adapters.hpp>
-#include <aedis/adapter/error.hpp>
 
 namespace aedis {
 namespace adapter {
+namespace detail {
 
-/** @brief Traits class for response objects.
- *  @ingroup any
+struct ignore {};
+
+/* Traits class for response objects.
  *
- *  Provides traits for all supported response types i.e. all STL containers
- *  and C++ buil-in types.
+ * Provides traits for all supported response types i.e. all STL
+ * containers and C++ buil-in types.
  */
 template <class ResponseType>
-struct response_traits
-{
-   /// The adapter type.
+struct response_traits {
    using adapter_type = adapter::detail::wrapper<ResponseType>;
-
-   /** @brief Returns an adapter for the reponse r
-    *
-    *  @param r The response object e.g a C++ container.
-    *  @return An adapter suitable for use in resp3::read or resp3::async_read.
-    *  @remark Users can also use the free adapt function for type deduction.
-    */
    static auto adapt(ResponseType& r) noexcept { return adapter_type{&r}; }
 };
 
-/// Template typedef for response_traits.
 template <class T>
 using adapter_t = typename response_traits<T>::adapter_type;
 
+template <>
+struct response_traits<ignore> {
+   using response_type = ignore;
+   using adapter_type = resp3::detail::ignore_response;
+   static auto adapt(response_type&) noexcept { return adapter_type{}; }
+};
+
 template <class T>
-struct response_traits<resp3::node<T>>
-{
+struct response_traits<resp3::node<T>> {
    using response_type = resp3::node<T>;
    using adapter_type = adapter::detail::general_simple<response_type>;
    static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
 };
 
 template <class String, class Allocator>
-struct response_traits<std::vector<resp3::node<String>, Allocator>>
-{
+struct response_traits<std::vector<resp3::node<String>, Allocator>> {
    using response_type = std::vector<resp3::node<String>, Allocator>;
    using adapter_type = adapter::detail::general_aggregate<response_type>;
    static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
 };
 
 template <>
-struct response_traits<void>
-{
+struct response_traits<void> {
    using response_type = void;
    using adapter_type = resp3::detail::ignore_response;
    static auto adapt() noexcept { return adapter_type{}; }
 };
 
-namespace detail {
-
 // Duplicated here to avoid circular include dependency.
 template<class T>
 auto internal_adapt(T& t) noexcept
@@ -96,94 +90,28 @@ struct assigner<0> {
   }
 };
 
-template <std::size_t N>
-struct assigner2 {
-  template <class T1, class T2>
-  static void assign(T1& dest, T2& from)
-  {
-     std::get<N>(dest) = internal_adapt(std::get<N>(from));
-     assigner2<N - 1>::assign(dest, from);
-  }
-};
-
-template <>
-struct assigner2<0> {
-  template <class T1, class T2>
-  static void assign(T1& dest, T2& from)
-  {
-     std::get<0>(dest) = internal_adapt(std::get<0>(from));
-  }
-};
-
-} // detail
-
-/** @brief Return a specific adapter from the tuple.
- *  
- *  \param t A tuple of response adapters.
- *  \return The adapter that corresponds to type T.
- */
-template <class T, class Tuple>
-auto& get(Tuple& t)
-{
-   return std::get<typename response_traits<T>::adapter_type>(t);
-}
-
-template <class Tuple>
-using adapters_array_t = 
-   std::array<
-      boost::mp11::mp_unique<
-         boost::mp11::mp_rename<
-            boost::mp11::mp_transform<
-               adapter_t, Tuple>,
-               boost::variant2::variant>>,
-      std::tuple_size<Tuple>::value>;
-
-template <class Tuple>
-adapters_array_t<Tuple> make_adapters_array(Tuple& t)
-{
-   adapters_array_t<Tuple> ret;
-   detail::assigner<std::tuple_size<Tuple>::value - 1>::assign(ret, t);
-   return ret;
-}
-
-/** @brief Transaforms a tuple of responses.
- *
- *  @return Transaforms a tuple of responses into a tuple of adapters.
- */
-template <class Tuple>
-using adapters_tuple_t = 
-         boost::mp11::mp_rename<
-            boost::mp11::mp_transform<
-               adapter_t, Tuple>,
-               std::tuple>;
-
-/** @brief Make a tuple of adapters.
- *  
- *  \param t Tuple of responses.
- *  \return Tuple of adapters.
- */
-template <class Tuple>
-auto
-make_adapters_tuple(Tuple& t)
-{
-   adapters_tuple_t<Tuple> ret;
-   detail::assigner2<std::tuple_size<Tuple>::value - 1>::assign(ret, t);
-   return ret;
-}
-
-namespace detail {
-
+// TODO: I am not sure we need the mp_unique below.
 template <class Tuple>
 class static_aggregate_adapter {
 private:
+   using adapters_array_type = 
+      std::array<
+         boost::mp11::mp_unique<
+            boost::mp11::mp_rename<
+               boost::mp11::mp_transform<
+                  adapter_t, Tuple>,
+                  boost::variant2::variant>>,
+         std::tuple_size<Tuple>::value>;
+
    std::size_t i_ = 0;
    std::size_t aggregate_size_ = 0;
-   adapters_array_t<Tuple> adapters_;
+   adapters_array_type adapters_;
 
 public:
    static_aggregate_adapter(Tuple* r = nullptr)
-   : adapters_(make_adapters_array(*r))
-   {}
+   {
+      detail::assigner<std::tuple_size<Tuple>::value - 1>::assign(adapters_, *r);
+   }
 
    void count(resp3::node<boost::string_view> const& nd)
    {
@@ -220,15 +148,16 @@ public:
    }
 };
 
-} // detail
-
 template <class... Ts>
 struct response_traits<std::tuple<Ts...>>
 {
    using response_type = std::tuple<Ts...>;
-   using adapter_type = detail::static_aggregate_adapter<response_type>;
+   using adapter_type = static_aggregate_adapter<response_type>;
    static auto adapt(response_type& r) noexcept { return adapter_type{&r}; }
 };
 
+} // detail
 } // adapter
 } // aedis
+
+#endif // AEDIS_ADAPTER_RESPONSE_TRAITS_HPP

aedis/adapter/error.hpp

@@ -1,66 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <system_error>
-
-namespace aedis {
-namespace adapter {
-
-/** \brief Errors that may occurr when reading a response.
- *  \ingroup any
- */
-enum class error
-{
-   /// Expects a simple RESP3 type but got an aggregate.
-   expects_simple_type = 1,
-
-   /// Expects aggregate type.
-   expects_aggregate,
-
-   /// Expects a map but got other aggregate.
-   expects_map_like_aggregate,
-
-   /// Expects a set aggregate but got something else.
-   expects_set_aggregate,
-
-   /// Nested response not supported.
-   nested_aggregate_unsupported,
-
-   /// Got RESP3 simple error.
-   simple_error,
-
-   /// Got RESP3 blob_error.
-   blob_error,
-
-   /// Aggregate container has incompatible size.
-   incompatible_size,
-
-   /// Got RESP3 null type.
-   null
-};
-
-/** \brief todo
- *  \ingroup any
- */
-boost::system::error_code make_error_code(error e);
-
-/** \brief todo
- *  \ingroup any
- */
-boost::system::error_condition make_error_condition(error e);
-
-} // adapter
-} // aedis
-
-namespace std {
-
-template<>
-struct is_error_code_enum<::aedis::adapter::error> : std::true_type {};
-
-} // std

aedis/adapter/impl/error.ipp

@@ -1,59 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <system_error>
-
-namespace aedis {
-namespace adapter {
-namespace detail {
-
-struct error_category_impl : boost::system::error_category {
-
-   char const* name() const noexcept override
-   {
-      return "aedis.adapter";
-   }
-
-   std::string message(int ev) const override
-   {
-      switch(static_cast<error>(ev)) {
-	 case error::expects_simple_type: return "Expects a simple RESP3 type";
-	 case error::expects_aggregate: return "Expects aggregate type";
-	 case error::expects_map_like_aggregate: return "Expects map aggregate";
-	 case error::expects_set_aggregate: return "Expects set aggregate";
-	 case error::nested_aggregate_unsupported: return "Nested aggregate unsupported.";
-	 case error::simple_error: return "Got RESP3 simple-error.";
-	 case error::blob_error: return "Got RESP3 blob-error.";
-	 case error::incompatible_size: return "Aggregate container has incompatible size.";
-	 case error::null: return "Got RESP3 null.";
-	 default: assert(false);
-      }
-   }
-};
-
-boost::system::error_category const& category()
-{
-  static error_category_impl instance;
-  return instance;
-}
-
-} // detail
-
-boost::system::error_code make_error_code(error e)
-{
-    return boost::system::error_code{static_cast<int>(e), detail::category()};
-}
-
-boost::system::error_condition make_error_condition(error e)
-{
-  return boost::system::error_condition(static_cast<int>(e), detail::category());
-}
-
-} // adapter
-} // aedis

aedis/aedis.hpp

@@ -1,247 +1,216 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_HPP
+#define AEDIS_HPP
 
+#include <aedis/error.hpp>
+#include <aedis/command.hpp>
+#include <aedis/adapt.hpp>
+#include <aedis/connection.hpp>
 #include <aedis/resp3/read.hpp>
+#include <aedis/resp3/write.hpp>
+#include <aedis/resp3/exec.hpp>
+#include <aedis/resp3/request.hpp>
 #include <aedis/adapter/adapt.hpp>
-#include <aedis/adapter/error.hpp>
-#include <aedis/redis/command.hpp>
-#include <aedis/sentinel/command.hpp>
-#include <aedis/generic/client.hpp>
-#include <aedis/generic/serializer.hpp>
+
+// \li Support for Redis [sentinel](https://redis.io/docs/manual/sentinel).
+// TODO: Reconnect support.
+// TODO: Remove conflicts of the adapt function.
 
 /** \mainpage Documentation
     \tableofcontents
   
     \section Overview
   
-    Aedis is a [Redis](https://redis.io/) client library built on top
-    of [Asio](https://www.boost.org/doc/libs/release/doc/html/boost_asio.html)
+    Aedis is a high-level [Redis](https://redis.io/) client library
+    built on top of [Asio](https://www.boost.org/doc/libs/release/doc/html/boost_asio.html)
     that provides simple and efficient communication with a Redis
     server. Some of its distinctive features are
 
-    @li Support for the latest version of the Redis communication protocol [RESP3](https://github.com/antirez/RESP3/blob/master/spec.md).
-    @li First class support for STL containers and C++ built-in types.
-    @li Serialization and deserialization of your own data types that avoid unnecessary copies.
-    @li Support for Redis [sentinel](https://redis.io/docs/manual/sentinel).
-    @li Sync and async API.
+    \li Support for the latest version of the Redis communication protocol [RESP3](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md).
+    \li First class support for STL containers and C++ built-in types.
+    \li Serialization and deserialization of your own data types.
+    \li Zero asymptotic allocations by means of memory reuse.
+    \li Healthy checks, back pressure and low latency.
 
-    In addition to that, Aedis provides a high level client that offers the following functionality
+    The Aedis API hides most of the low level asynchronous operations
+    away from the user, for example, the code below pings a message to
+    the server
 
-    @li Management of message queues.
-    @li Simplified handling of server pushes.
-    @li Zero asymptotic allocations by means of memory reuse.
-
-    If you never heard about Redis the best place to start is on
-    https://redis.io.  Now let us have a look at the low-level API.
-
-    \section low-level-api Low-level API
-
-    The low-level API is very useful for simple tasks, for example,
-    assume we want to perform the following steps
-
-    @li Set the value of a Redis key.
-    @li Set the expiration of that key to two seconds.
-    @li Get and return its old value.
-    @li Quit
-
-    The async coroutine-based implementation of the steps above look like
-
-    @code
-    net::awaitable<std::string> set(net::ip::tcp::endpoint ep)
+    \code
+    int main()
     {
-       // To make code less verbose
-       using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
+       request req;
+       req.push("PING");
+       req.push("QUIT");
 
-       tcp_socket socket{co_await net::this_coro::executor};
-       co_await socket.async_connect(ep);
-    
-       std::string request, read_buffer, response;
+       std::tuple<std::string, std::string> resp;
 
-       auto sr = make_serializer(request);
-       sr.push(command::hello, 3);
-       sr.push(command::set, "key", "Value", "EX", "2", "get");
-       sr.push(command::quit);
-       co_await net::async_write(socket, net::buffer(request));
-    
-       co_await resp3::async_read(socket, dynamic_buffer(read_buffer)); // Hello (ignored).
-       co_await resp3::async_read(socket, dynamic_buffer(read_buffer), adapt(response)); // Set
-       co_await resp3::async_read(socket, dynamic_buffer(read_buffer)); // Quit (ignored)
-    
-       co_return response;
+       net::io_context ioc;
+
+       connection db{ioc};
+       db.async_exec("127.0.0.1", "6379", req, adapt(resp),
+          [](auto ec, auto) { std::cout << ec.message() << std::endl; });
+
+       ioc.run();
+
+       // Print
+       std::cout << std::get<0>(resp) << std::endl;
+       std::cout << std::get<1>(resp) << std::endl;
     }
-    @endcode
+    \endcode
 
-    The simplicity of the code above makes it self explanatory
+    For a detailed comparison of Redis clients and the design
+    rationale behind Aedis jump to \ref why-aedis.
 
-    @li Connect to the Redis server.
-    @li Declare a \c std::string to hold the request and add some commands in it with a serializer.
-    @li Write the payload to the socket and read the responses in the same order they were sent.
-    @li Return the response to the user.
+    \section requests Requests
 
-    The @c hello command above is always required and must be sent
-    first as it informs we want to communicate over RESP3.
-
-    \subsection requests Requests
-
-    As stated above, request are created by defining a storage object
-    and a serializer that knowns how to convert user data into valid
-    RESP3 wire-format.  Redis request are composed of one or more
-    commands (in Redis documentation they are called [pipelines](https://redis.io/topics/pipelining)),
-    which means users can add
-    as many commands to the request as they like, a feature that aids
-    performance.
-
-    The individual commands in a request assume many
-    different forms: with and without keys, variable length arguments,
-    ranges etc.  To account for all these variations, the \c
-    serializer class offers some member functions, each of
-    them with a couple of overloads, for example
+    Redis requests are composed of one of more Redis commands (in
+    Redis documentation they are called
+    [pipelines](https://redis.io/topics/pipelining)). For example
 
     @code
-    // Some data to send to Redis.
-    std::string value = "some value";
+    request req;
 
-    std::list<std::string> list {"channel1", "channel2", "channel3"};
+    // Command with variable length of arguments.
+    req.push("SET", "key", "some value", value, "EX", "2");
 
+    // Pushes a set.
+    std::list<std::string> list
+       {"channel1", "channel2", "channel3"};
+    req.push_range("SUBSCRIBE", list);
+
+    // Same as above but as an iterator range.
+    req.push_range2("SUBSCRIBE", std::cbegin(list), std::cend(list));
+
+    // Sends a map.
     std::map<std::string, mystruct> map
        { {"key1", "value1"}
        , {"key2", "value2"}
        , {"key3", "value3"}};
-
-    // Command with no arguments
-    sr.push(command::quit);
-
-    // Command with variable lenght arguments.
-    sr.push(command::set, "key", value, "EX", "2");
-
-    // Sends a container, no key.
-    sr.push_range(command::subscribe, list);
-
-    // Same as above but an iterator range.
-    sr.push_range2(command::subscribe, std::cbegin(list), std::cend(list));
-
-    // Sends a container, with key.
-    sr.push_range(command::hset, "key", map);
-
-    // Same as above but as iterator range.
-    sr.push_range2(command::hset, "key", std::cbegin(map), std::cend(map));
+    req.push_range("HSET", "key", map);
     @endcode
 
-    Once all commands we want to send have been added to the
-    request, we can write it as usual to the socket.
+    Sending a request to Redis is then peformed with the following function
 
     @code
-    co_await net::async_write(socket, buffer(request));
+    co_await db->async_exec(req, adapt(resp));
     @endcode
 
-    \subsubsection requests-serialization Serialization
+    The second argument \c adapt(resp) will be explained in \ref requests.
 
-    The \c send and \c send_range functions above work with integers
+    \subsection requests-serialization Serialization
+
+    The \c push and \c push_range functions above work with integers
     e.g. \c int and \c std::string out of the box. To send your own
-    data type defined the \c to_bulk function like this
+    data type defined a \c to_bulk function like this
 
     @code
-    // Example struct.
     struct mystruct {
-      // ...
+       // Example struct.
     };
     
     void to_bulk(std::string& to, mystruct const& obj)
     {
-       // Convert to obj string and call
-       aedis::resp3::to_bulk(to, "Dummy serializaiton string.");
+       // Convert to obj string and call to_bulk.
+       std::string dummy = "Dummy serializaiton string.";
+       aedis::resp3::to_bulk(to, dummy);
     }
+    @endcode
 
-    std::map<std::string, mystruct> map
-       { {"key1", {...}}
-       , {"key2", {...}}
-       , {"key3", {...}}};
+    Once \c to_bulk is defined and accessible over ADL \c mystruct can
+    be passed to the \c request
 
-    db.send_range(command::hset, "key", map);
+    @code
+    request req;
+
+    std::map<std::string, mystruct> map {...};
+
+    req.push_range("HSET", "key", map);
     @endcode
 
     It is quite common to store json string in Redis for example.
 
-    \subsection responses Responses
+    \section low-level-responses Responses
 
     To read responses effectively, users must know their RESP3 type,
-    this can be found in the Redis documentation of each command
+    this can be found in the Redis documentation for each command
     (https://redis.io/commands). For example
 
     Command  | RESP3 type                          | Documentation
     ---------|-------------------------------------|--------------
     lpush    | Number                              | https://redis.io/commands/lpush
     lrange   | Array                               | https://redis.io/commands/lrange
-    set      | Simple string, null or blob string  | https://redis.io/commands/set
-    get      | Blob string                         | https://redis.io/commands/get
+    set      | Simple-string, null or blob-string  | https://redis.io/commands/set
+    get      | Blob-string                         | https://redis.io/commands/get
     smembers | Set                                 | https://redis.io/commands/smembers
     hgetall  | Map                                 | https://redis.io/commands/hgetall
 
     Once the RESP3 type of a given response is known we can choose a
-    proper C++ data structure to receive it in. Fortunately,
-    this is a simple task for most types, for example
+    proper C++ data structure to receive it in. Fortunately, this is a
+    simple task for most types. The table below summarises the options
 
     RESP3 type     | C++                                                          | Type
     ---------------|--------------------------------------------------------------|------------------
-    Simple string  | \c std::string                                             | Simple
-    Simple error   | \c std::string                                             | Simple
-    Blob string    | \c std::string, \c std::vector                             | Simple
-    Blob error     | \c std::string, \c std::vector                             | Simple
-    Number         | `long long`, `int`, \c std::string                         | Simple
+    Simple-string  | \c std::string                                             | Simple
+    Simple-error   | \c std::string                                             | Simple
+    Blob-string    | \c std::string, \c std::vector                             | Simple
+    Blob-error     | \c std::string, \c std::vector                             | Simple
+    Number         | `long long`, `int`, `std::size_t`, \c std::string          | Simple
+    Double         | `double`, \c std::string                                   | Simple
     Null           | `boost::optional<T>`                                       | Simple
     Array          | \c std::vector, \c std::list, \c std::array, \c std::deque | Aggregate
     Map            | \c std::vector, \c std::map, \c std::unordered_map         | Aggregate
     Set            | \c std::vector, \c std::set, \c std::unordered_set         | Aggregate
     Push           | \c std::vector, \c std::map, \c std::unordered_map         | Aggregate
 
-    Exceptions to this rule are responses that contain nested
-    aggregates or heterogeneous data types, those will be treated
-    later.  As of this writing, not all RESP3 types are used by the
-    Redis server, which means in practice users will be concerned with
-    a reduced subset of the RESP3 specification. Now let us see some
-    examples
+    Responses that contain nested aggregates or heterogeneous data
+    types will be given special treatment later in \ref gen-case.  As
+    of this writing, not all RESP3 types are used by the Redis server,
+    which means in practice users will be concerned with a reduced
+    subset of the RESP3 specification. Now let us see some examples
 
     @code
+    auto dbuffer = dynamic_buffer(buffer);
+
     // To ignore the response.
-    co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt());
+    co_await resp3::async_read(socket, dbuffer, adapt());
 
     // Read in a std::string e.g. get.
     std::string str;
-    co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(str));
+    co_await resp3::async_read(socket, dbuffer, adapt(str));
 
     // Read in a long long e.g. rpush.
     long long number;
-    co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(number));
+    co_await resp3::async_read(socket, dbuffer, adapt(number));
 
     // Read in a std::set e.g. smembers.
     std::set<T, U> set;
-    co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(set));
+    co_await resp3::async_read(socket, dbuffer, adapt(set));
 
     // Read in a std::map e.g. hgetall.
     std::map<T, U> set;
-    co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(map));
+    co_await resp3::async_read(socket, dbuffer, adapt(map));
 
     // Read in a std::unordered_map e.g. hgetall.
     std::unordered_map<T, U> umap;
-    co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(umap));
+    co_await resp3::async_read(socket, dbuffer, adapt(umap));
 
     // Read in a std::vector e.g. lrange.
     std::vector<T> vec;
-    co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(vec));
+    co_await resp3::async_read(socket, dbuffer, adapt(vec));
     @endcode
 
-    In other words, it is pretty straightforward, just pass the result
-    of \c adapt to the read function and make sure the response RESP3
-    type fits in the type you are calling @c adapter(...) with. All
-    standard C++ containers are supported by aedis.
+    In other words, it is straightforward, just pass the result of \c
+    adapt to the read function and make sure the response data type is
+    compatible with the data structure you are calling @c adapter(...)
+    with. All standard C++ containers are supported by Aedis.
 
-    \subsubsection Optional
+    \subsection Optional
 
     It is not uncommon for apps to access keys that do not exist or
     that have already expired in the Redis server, to deal with these
@@ -253,17 +222,16 @@
     co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(umap));
     @endcode
 
-    Everything else stays pretty much the same, before accessing data
-    users will have to check (or assert) the optional contains a
-    value.
+    Everything else stays the same, before accessing data, users will
+    have to check or assert the optional contains a value.
 
-    \subsubsection heterogeneous_aggregates Heterogeneous aggregates
+    \subsection heterogeneous_aggregates Heterogeneous aggregates
 
     There are cases where Redis returns aggregates that
     contain heterogeneous data, for example, an array that contains
     integers, strings nested sets etc. Aedis supports reading such
     aggregates in a \c std::tuple efficiently as long as the they
-    don't contain 2-order nested aggregates e.g. an array that
+    don't contain 3-order nested aggregates e.g. an array that
     contains an array of arrays. For example, to read the response to
     a \c hello command we can use the following response type.
 
@@ -282,11 +250,11 @@
     example, the response to the transaction below
 
     @code
-    db.send(command::multi);
-    db.send(command::get, "key1");
-    db.send(command::lrange, "key2", 0, -1);
-    db.send(command::hgetall, "key3");
-    db.send(command::exec);
+    db.send("MULTI");
+    db.send("GET", "key1");
+    db.send("LRANGE", "key2", 0, -1);
+    db.send("HGETALL", "key3");
+    db.send("EXEC");
     @endcode
 
     can be read in the following way
@@ -305,27 +273,26 @@
     co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(trans));
     @endcode
 
-    Note that we are not ignoring the response to the commands
-    themselves above but whether they have been successfully queued.
-    Only after @c exec is received Redis will execute them in
-    sequence. The response will then be sent in a single chunk to the
-    client.
+    Note that above we are not ignoring the response to the commands
+    themselves but whether they have been successfully queued.  Only
+    after @c exec is received Redis will execute them in sequence and
+    send all responses together in an array.
 
-    \subsubsection Serialization
+    \subsection Serialization
 
     As mentioned in \ref requests-serialization, it is common for
     users to serialized data before sending it to Redis e.g.  json
     strings, for example
 
     @code
-    sr.push(command::set, "key", "json-string")
-    sr.push(command::get, "key")
+    sr.push("SET", "key", "{"Server": "Redis"}"); // Unquoted for readability.
+    sr.push("GET", "key")
     @endcode
 
     For performance and convenience reasons, we may want to avoid
     receiving the response to the \c get command above as a string
     just to convert it later to a e.g. deserialized json. To support
-    this, Aedis calls a user defined \c from_string function while
+    this, Aedis calls a user defined \c from_bulk function while
     parsing the response. In simple terms, define your type
 
     @code
@@ -334,11 +301,11 @@
     };
     @endcode
 
-    and deserialize it from a string in a function \c from_string with
+    and deserialize it from a string in a function \c from_bulk with
     the following signature
 
     @code
-    void from_string(mystruct& obj, char const* p, std::size_t size, boost::system::error_code& ec)
+    void from_bulk(mystruct& obj, char const* p, std::size_t size, boost::system::error_code& ec)
     {
        // Deserializes p into obj.
     }
@@ -347,16 +314,15 @@
     After that, you can start receiving data efficiently in the desired
     types e.g. \c mystruct, \c std::map<std::string, mystruct> etc.
 
-    \subsubsection gen-case The general case
+    \subsection gen-case The general case
 
-    As already mentioned, there are cases where the response to Redis
+    As already mentioned, there are cases where responses to Redis
     commands won't fit in the model presented above, some examples are
 
     @li Commands (like \c set) whose response don't have a fixed
-    RESP3 type. Expecting an \c int and receiving a blob string
+    RESP3 type. Expecting an \c int and receiving a blob-string
     will result in error.
-    @li RESP3 responses that contain three levels of (nested) aggregates can't be
-    read in STL containers.
+    @li RESP3 aggregates that contain nested aggregates can't be read in STL containers.
     @li Transactions with a dynamic number of commands can't be read in a \c std::tuple.
 
     To deal with these cases Aedis provides the \c resp3::node
@@ -402,181 +368,27 @@
     @li \c std::vector<node<std::string>: Works always.
     @li \c std::vector<std::string>: Efficient and flat, all elements as string.
     @li \c std::map<std::string, std::string>: Efficient if you need the data as a \c std::map
-    @li \c std::map<U, V>: Efficient if you are storing serialized data. Avoids temporaries and requires \c from_string for \c U and \c V.
+    @li \c std::map<U, V>: Efficient if you are storing serialized data. Avoids temporaries and requires \c from_bulk for \c U and \c V.
 
     In addition to the above users can also use unordered versions of the containers. The same reasoning also applies to sets e.g. \c smembers.
 
-    \subsubsection low-level-adapters Adapters
-
-    Users that are not satisfied with any of the options above can
-    write their own adapters very easily. For example, the adapter below
-    can be used to print incoming data to the screen.
-
-    @code
-    auto adapter = [](resp3::node<boost::string_view> const& nd, boost::system::error_code&)
-    {
-       std::cout << nd << std::endl;
-    };
-
-    co_await resp3::async_read(socket, dynamic_buffer(buffer), adapter);
-    @endcode
-
-    See more in the \ref examples section.
-
-    \section high-level-api High-level API
-
-    It requires a lot of further work to make use of many important features
-    of the Redis server while using the low-level API, for example
-
-    @li \b Server \b pushes: Short lived connections can't handle server pushes (e.g. https://redis.io/topics/client-side-caching and https://redis.io/topics/notifications).
-    @li \b Pubsub: Just like server pushes, to use Redis pubsub users need long lasting connections (https://redis.io/topics/pubsub).
-    @li \b Performance: Keep opening and closing connections impact performance.
-    @li \b Pipeline: Code such as shown in \ref low-level-api don't
-    support pipelines well since it can only send a fixed number of
-    commands at time. It misses important optimization opportunities
-    (https://redis.io/topics/pipelining).
-
-    To avoid these drawbacks users will address the points above
-    reinventing the high-level API here and there over and over again,
-    to prevent that from happening Aedis provides its own. The general
-    form of a program that uses the high-level api looks like this
-
-    @code
-    int main()
-    {
-       net::io_context ioc;
-       client<net::ip::tcp::socket> db{ioc.get_executor()};
-       receiver recv;
-
-       db.async_run(
-           recv,
-           {net::ip::make_address("127.0.0.1"), 6379},
-           [](auto ec){ ... });
-
-       // Pass db around to other objects so we can send commands.
-
-       ioc.run();
-    }
-    @endcode
-
-    The only thing users have to care about is with the implementation
-    of the \c receiver class, everything else will be performed
-    automatically by the client class. The general form of a receiver
-    looks like this
-
-    @code
-    class receiver {
-    public:
-       // Called when a new chunck of user data becomes available.
-       void on_resp3(command cmd, node<boost::string_view> const& nd, boost::system::error_code& ec);
-    
-       // Called when a response becomes available.
-       void on_read(command cmd);
-    
-       // Called when a request has been writen to the socket.
-       void on_write(std::size_t n);
-    
-       // Called when a server push is received.
-       void on_push();
-    };
-    @endcode
-
-    Sending commands is also similar to what has been discussed before.
-
-    @code
-    void foo(client<net::ip::tcp::socket>& db)
-    {
-       db.send(command::ping, "O rato roeu a roupa do rei de Roma");
-       db.send(command::incr, "counter");
-       db.send(command::set, "key", "Três pratos de trigo para três tigres");
-       db.send(command::get, "key");
-       ...
-    }
-    @endcode
-
-    The \c send functions in this case will add commands to the output
-    queue and send them only if there is no pending response of a
-    previously sent command. This is so because RESP3 is a
-    request/response protocol, which means clients must wait for the
-    response to a command before proceeding with the next one.
-
-    \subsection high-level-responses Responses
-
-    Aedis also provides some facilities to use use custom responses with the
-    high-level API. Assume for example you have many different custom
-    response types \c T1, \c T2 etc, a receiver that makes use of this looks
-    like
-
-    @code
-    using responses_tuple_type = std::tuple<T1, T2, T3>;
-    using adapters_tuple_type = adapters_t<responses_tuple_type>;
-
-    class myreceiver {
-    public:
-       myreceiver(...) : adapters_(make_adapters_tuple(resps_)) , {}
-
-       void
-       on_resp3( command cmd, node<boost::string_view> const& nd, boost::system::error_code& ec)
-       {
-          // Direct the responses to the desired adapter.
-          switch (cmd) {
-             case cmd1: adapter::get<T1>(adapters_)(nd, ec);
-             case cmd2: adapter::get<T2>(adapters_)(nd, ec);
-             case cmd3: adapter::get<T2>(adapters_)(nd, ec);
-             default:;
-          }
-       }
-
-       void on_read(command cmd)
-       {
-          switch (cmd) {
-             case cmd1: // Data on std::get<T1>(resps_); break;
-             case cmd2: // Data on std::get<T2>(resps_); break;
-             case cmd3: // Data on std::get<T3>(resps_); break;
-             default:;
-          }
-       }
-
-       void on_write(std::size_t n) { ... }
-
-       void on_push() { ... }
-
-    private:
-       responses_tuple_type resps_;
-       adapters_tuple_type adapters_;
-    };
-    @endcode
-
     \section examples Examples
 
-    To better fix what has been said above, users should have a look at some simple examples.
+    The examples listed below cover most use cases presented in the documentation above.
 
-    \b Low \b level \b API
-
-    @li low_level/sync_intro.cpp: Shows how to use the Aedis synchronous api.
-    @li low_level/async_intro.cpp: Show how to use the low level async api.
-    @li low_level/subscriber.cpp: Shows how channel subscription works at the low level.
-    @li low_level/adapter.cpp: Shows how to write a response adapter that prints to the screen, see \ref low-level-adapters.
-
-    \b High \b level \b API
-
-    @li high_level/intro.cpp: Some commands are sent to the Redis server and the responses are printed to screen. 
-    @li high_level/aggregates.cpp: Shows how receive RESP3 aggregate data types in a general way.
-    @li high_level/stl_containers.cpp: Shows how to read responses in STL containers.
-    @li high_level/serialization.cpp: Shows how to de/serialize your own data types.
-    @li high_level/subscriber.cpp: Shows how channel subscription works at a high level. See also https://redis.io/topics/pubsub.
-
-    \b Asynchronous \b Servers
-
-    @li high_level/echo_server.cpp: Shows the basic principles behind asynchronous communication with a database in an asynchronous server.
-    @li high_level/chat_room.cpp: Shows how to build a scalable chat room that scales to millions of users.
+    @li intro.cpp: Basic steps with Aedis.
+    @li containers.cpp: Shows how to send and receive stl containers.
+    @li serialization.cpp: Shows the \c request support to serialization of user types.
+    @li subscriber.cpp: Shows how channel subscription works.
+    @li echo_server.cpp: A simple TCP echo server that users coroutines.
+    @li chat_room.cpp: A simple chat room that uses coroutines.
 
     \section using-aedis Using Aedis
 
     To install and use Aedis you will need
   
     - Boost 1.78 or greater.
-    - Unix Shell and Make.
+    - Unix Shell and Make (for linux users).
     - C++14. Some examples require C++20 with coroutine support.
     - Redis server.
 
@@ -590,7 +402,7 @@
     - Tested with gcc: 7.5.0, 8.4.0, 9.3.0, 10.3.0.
     - Tested with clang: 11.0.0, 10.0.0, 9.0.1, 8.0.1, 7.0.1.
   
-    \subsection Installation
+    \section Installation
 
     The first thing to do is to download and unpack Aedis
 
@@ -603,7 +415,7 @@
     ```
 
     If you can't use \c configure and \c make (e.g. Windows users)
-    you can already add the directory where you unpacked aedis to the
+    add the directory where you unpacked Aedis to the
     include directories in your project, otherwise run
   
     ```
@@ -633,7 +445,7 @@
     $ make check
     ```
 
-    \subsection Developers
+    \section Developers
   
     To generate the build system run
   
@@ -650,11 +462,179 @@
     $ make distcheck
     ```
 
-    \section Referece
+    \section why-aedis Why Aedis
+
+    At the time of this writing there are seventeen Redis clients
+    listed in the [official](https://redis.io/docs/clients/#cpp) list.
+    With so many clients available it is not unlikely that users are
+    asking themselves why yet another one.  In this section I will try
+    to compare Aedis to the most popular clients and why we need
+    Aedis. Notice however that this is ongoing work as comparing
+    client objectively is difficult and time consuming.
+
+    The most popular client at the moment of this writing ranked by
+    github stars is
+
+    @li https://github.com/sewenew/redis-plus-plus
+
+    Before we start it is worth mentioning some of the things it does
+    not support
+
+    @li RESP3. Without RESP3 is impossible to support some important Redis features like client side caching, among other things.
+    @li The Asio asynchronous model.
+    @li Reading response diretly in user data structures avoiding temporaries.
+    @li Error handling with error-code and exception overloads.
+    @li Healthy checks.
+
+    The remaining points will be addressed individually.
+
+    @subsection redis-plus-plus
+
+    Let us first have a look at what sending a command a pipeline and a
+    transaction look like
+
+    @code
+    auto redis = Redis("tcp://127.0.0.1:6379");
+
+    // Send commands
+    redis.set("key", "val");
+    auto val = redis.get("key"); // val is of type OptionalString.
+    if (val)
+        std::cout << *val << std::endl;
+
+    // Sending pipelines
+    auto pipe = redis.pipeline();
+    auto pipe_replies = pipe.set("key", "value")
+                            .get("key")
+                            .rename("key", "new-key")
+                            .rpush("list", {"a", "b", "c"})
+                            .lrange("list", 0, -1)
+                            .exec();
+
+    // Parse reply with reply type and index.
+    auto set_cmd_result = pipe_replies.get<bool>(0);
+    // ...
+
+    // Sending a transaction
+    auto tx = redis.transaction();
+    auto tx_replies = tx.incr("num0")
+                        .incr("num1")
+                        .mget({"num0", "num1"})
+                        .exec();
+
+    auto incr_result0 = tx_replies.get<long long>(0);
+    // ...
+    @endcode
+
+    Some of the problems with this API are
+
+    @li Heterogeneous treatment of commands, pipelines and transaction.
+    @li Any Api that sends individual commands has a very restricted scope of usability and should be avoided for performance reasons.
+    @li The API imposes exceptions on users, no error-code overload is provided.
+    @li No way to reuse the buffer for new calls to e.g. \c redis.get in order to avoid further dynamic memory allocations.
+    @li Error handling of resolve and connection no clear.
+
+    According to the documentation, pipelines in redis-plus-plus have
+    the following characteristics
+
+    > NOTE: By default, creating a Pipeline object is NOT cheap, since
+    > it creates a new connection.
+
+    This is clearly a downside of the API as pipelines should be the
+    default way of communicating and not an exception, paying such a
+    high price for each pipeline imposes a severe cost in performance.
+    Transactions also suffer from the very same problem
+
+    > NOTE: Creating a Transaction object is NOT cheap, since it
+    > creates a new connection.
+
+    In Aedis there is no difference between sending one command, a
+    pipeline or a transaction because creating the request is decoupled
+    from the IO objects, for example
+
+    @code
+    std::string request;
+    auto sr = make_serializer(request);
+    sr.push("HELLO", 3);
+    sr.push("MULTI");
+    sr.push("PING");
+    sr.push("SET", "low-level-key", "some content", "EX", "2");
+    sr.push("EXEC");
+    sr.push("PING", "Another message.");
+    net::write(socket, net::buffer(request));
+    @endcode
+
+    The request created above will be sent to Redis in a single
+    pipeline and imposes no restriction on what it contains e.g. the
+    number of commands, transactions etc. The problems mentioned above
+    simply do not exist in Aedis. The way responses are read is
+    also more flexible
+
+    @code
+    std::string buffer;
+    auto dbuffer = net::dynamic_buffer(buffer);
+
+    std::tuple<std::string, boost::optional<std::string>> response;
+    resp3::read(socket, dbuffer); // hellp
+    resp3::read(socket, dbuffer); // multi
+    resp3::read(socket, dbuffer); // ping
+    resp3::read(socket, dbuffer); // set
+    resp3::read(socket, dbuffer, adapt(response));
+    resp3::read(socket, dbuffer); // quit
+    @endcode
+
+    @li The response objects are passed by the caller to the read
+    functions so that he has fine control over memory allocations and
+    object lifetime.
+    @li The user can either use error-code or exceptions.
+    @li Each response can be read individually in the response object
+    avoiding temporaries.
+    @li It is possible to ignore responses.
+
+    This was the blocking API, now let us compare the async interface
+
+    > redis-plus-plus also supports async interface, however, async
+    > support for Transaction and Subscriber is still on the way.
+    > 
+    > The async interface depends on third-party event library, and so
+    > far, only libuv is supported.
+
+    Async code in redis-plus-plus looks like the following
+
+    @code
+    auto async_redis = AsyncRedis(opts, pool_opts);
+    
+    Future<string> ping_res = async_redis.ping();
+    
+    cout << ping_res.get() << endl;
+    @endcode
+
+    As the reader can see, the async interface is based on futures
+    which is also known to have a bad performance.  The biggest
+    problem however with this async design is that it makes it
+    impossible to write asynchronous programs correctly since it
+    starts an async operation on every command sent instead of
+    enqueueing a message and triggering a write when it can be sent.
+    It is also not clear how are pipelines realised with the design
+    (if at all).
+
+    \section Acknowledgement
+
+    Some people that were helpful in the development of Aedis
+
+    @li Richard Hodges ([madmongo1](https://github.com/madmongo1)): For helping me with Asio and the design of asynchronous programs in general.
+    @li Vinícius dos Santos Oliveira ([vinipsmaker](https://github.com/vinipsmaker)): For useful discussion about how Aedis consumes buffers in the read operation (among other things).
+    @li Petr Dannhofer ([Eddie-cz](https://github.com/Eddie-cz)): For helping me understand how the `AUTH` and `HELLO` command can influence each other.
+
+    \section Reference
   
     See \subpage any.
+
  */
 
 /** \defgroup any Reference
+ *
+ *  This page contains the documentation of all user facing code.
  */
 
+#endif // AEDIS_HPP

aedis/command.hpp

@@ -0,0 +1,18 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_COMMAND_HPP
+#define AEDIS_COMMAND_HPP
+
+#include <boost/utility/string_view.hpp>
+
+namespace aedis {
+
+bool has_push_response(boost::string_view cmd);
+
+} // aedis
+
+#endif // AEDIS_COMMAND_HPP

aedis/connection.hpp

@@ -0,0 +1,472 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_CONNECTION_HPP
+#define AEDIS_CONNECTION_HPP
+
+#include <vector>
+#include <queue>
+#include <limits>
+#include <chrono>
+#include <memory>
+#include <type_traits>
+
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <boost/asio/experimental/channel.hpp>
+
+#include <aedis/adapt.hpp>
+#include <aedis/resp3/request.hpp>
+#include <aedis/detail/connection_ops.hpp>
+
+namespace aedis {
+
+// https://redis.io/docs/reference/sentinel-clients
+
+/** \brief A high level Redis connection.
+ *  \ingroup any
+ *
+ *  This class keeps a healthy connection to the Redis instance where
+ *  commands can be sent at any time. For more details, please see the
+ *  documentation of each individual function.
+ *
+ */
+template <class AsyncReadWriteStream = boost::asio::ip::tcp::socket>
+class connection {
+public:
+   /// Executor type.
+   using executor_type = typename AsyncReadWriteStream::executor_type;
+
+   /// Type of the next layer
+   using next_layer_type = AsyncReadWriteStream;
+
+   using default_completion_token_type = boost::asio::default_completion_token_t<executor_type>;
+
+   /** @brief Configuration parameters.
+    */
+   struct config {
+      /// Timeout of the resolve operation.
+      std::chrono::milliseconds resolve_timeout = std::chrono::seconds{10};
+
+      /// Timeout of the connect operation.
+      std::chrono::milliseconds connect_timeout = std::chrono::seconds{10};
+
+      /// Time interval ping operations.
+      std::chrono::milliseconds ping_interval = std::chrono::seconds{1};
+
+      /// The maximum size allowed of read operations.
+      std::size_t max_read_size = (std::numeric_limits<std::size_t>::max)();
+
+      /// Whether to coalesce requests or not.
+      bool coalesce_requests = true;
+   };
+
+   /** \brief Constructor.
+    *
+    *  \param ex The executor.
+    *  \param cfg Configuration parameters.
+    */
+   connection(boost::asio::any_io_executor ex, config cfg = config{})
+   : resv_{ex}
+   , ping_timer_{ex}
+   , check_idle_timer_{ex}
+   , writer_timer_{ex}
+   , read_timer_{ex}
+   , push_channel_{ex}
+   , cfg_{cfg}
+   , last_data_{std::chrono::time_point<std::chrono::steady_clock>::min()}
+   {
+      writer_timer_.expires_at(std::chrono::steady_clock::time_point::max());
+      read_timer_.expires_at(std::chrono::steady_clock::time_point::max());
+   }
+
+   connection(boost::asio::io_context& ioc, config cfg = config{})
+   : connection(ioc.get_executor(), cfg)
+   { }
+
+   /// Returns the executor.
+   auto get_executor() {return resv_.get_executor();}
+
+   /** @brief Starts communication with the Redis server asynchronously.
+    *
+    *  This function performs the following steps
+    *
+    *  \li Resolves the Redis host as of \c async_resolve with the
+    *  timeout passed in connection::config::resolve_timeout.
+    *
+    *  \li Connects to one of the endpoints returned by the resolve
+    *  operation with the timeout passed in connection::config::connect_timeout.
+    *
+    *  \li Starts the idle check operation with the timeout of twice
+    *  the value of connection::config::ping_interval. If no data is
+    *  received during that time interval \c async_run completes with
+    *  error::idle_timeout.
+    *
+    *  \li Starts the healthy check operation that sends command::ping
+    *  to Redis with a frequency equal to
+    *  connection::config::ping_interval.
+    *
+    *  \li Starts reading from the socket and delivering events to the
+    *  request started with \c async_exec or \c async_read_push.
+    *
+    * For an example see echo_server.cpp.
+    *
+    *  \param host Redis address.
+    *  \param port Redis port.
+    *  \param token Completion token.
+    *
+    *  The completion token must have the following signature
+    *
+    *  @code
+    *  void f(boost::system::error_code);
+    *  @endcode
+    *
+    *  \return This function returns only when there is an error.
+    */
+   template <class CompletionToken = default_completion_token_type>
+   auto
+   async_run(
+      boost::string_view host = "127.0.0.1",
+      boost::string_view port = "6379",
+      CompletionToken token = CompletionToken{})
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(detail::run_op<connection>{this, host, port}, token, resv_);
+   }
+
+   /** @brief Executes a request on the redis server.
+    *
+    *  \param req Request object.
+    *  \param adapter Response adapter.
+    *  \param token Asio completion token.
+    *
+    *  For an example see containers.cpp. The completion token must
+    *  have the following signature
+    *
+    *  @code
+    *  void f(boost::system::error_code, std::size_t);
+    *  @endcode
+    *
+    *  Where the second parameter is the size of the response that has
+    *  just been read.
+    */
+   template <
+      class Adapter = detail::response_traits<void>::adapter_type,
+      class CompletionToken = default_completion_token_type>
+   auto async_exec(
+      resp3::request const& req,
+      Adapter adapter = adapt(),
+      CompletionToken token = CompletionToken{})
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code, std::size_t)
+         >(detail::exec_op<connection, Adapter>{this, &req, adapter}, token, resv_);
+   }
+
+   /** @brief Connects and executes a single request.
+    *
+    *  Combines \c async_run and the other \c async_exec overload in a
+    *  single function. This function is useful for users that want to
+    *  send a single request to the server.
+    *
+    *  \param host Address of the Redis server.
+    *  \param port Port of the Redis server.
+    *  \param req Request object.
+    *  \param adapter Response adapter.
+    *  \param token Asio completion token.
+    *
+    *  For an example see intro.cpp. The completion token must have the following signature
+    *
+    *  @code
+    *  void f(boost::system::error_code, std::size_t);
+    *  @endcode
+    *
+    *  Where the second parameter is the size of the response that has
+    *  just been read.
+    */
+   template <
+      class Adapter = detail::response_traits<void>::adapter_type,
+      class CompletionToken = default_completion_token_type>
+   auto async_exec(
+      boost::string_view host,
+      boost::string_view port,
+      resp3::request const& req,
+      Adapter adapter = adapt(),
+      CompletionToken token = CompletionToken{})
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code, std::size_t)
+         >(detail::runexec_op<connection, Adapter>
+            {this, host, port, &req, adapter}, token, resv_);
+   }
+
+   /** @brief Receives Redis unsolicited events like pushes.
+    *
+    *  Users that expect unsolicited events should call this function
+    *  in a loop. If an unsolicited events comes in and there is no
+    *  reader, the connection will hang and eventually timeout.
+    *
+    *  \param adapter The response adapter.
+    *  \param token The Asio completion token.
+    *
+    *  For an example see subscriber.cpp. The completion token must
+    *  have the following signature
+    *
+    *  @code
+    *  void f(boost::system::error_code, std::size_t);
+    *  @endcode
+    *
+    *  Where the second parameter is the size of the response that has
+    *  just been read.
+    */
+   template <
+      class Adapter = detail::response_traits<void>::adapter_type,
+      class CompletionToken = default_completion_token_type>
+   auto async_read_push(
+      Adapter adapter = adapt(),
+      CompletionToken token = CompletionToken{})
+   {
+      auto f =
+         [adapter]
+         (resp3::node<boost::string_view> const& node, boost::system::error_code& ec) mutable
+      {
+         adapter(std::size_t(-1), node, ec);
+      };
+
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code, std::size_t)
+         >(detail::read_push_op<connection, decltype(f)>{this, f}, token, resv_);
+   }
+
+   /** @brief Cancel all pending sessions and push operations to return
+    *
+    * \returns The number of requests that have been canceled.
+    */
+   std::size_t cancel_requests()
+   {
+      for (auto& e: reqs_) {
+         e->stop = true;
+         e->timer.cancel_one();
+      }
+
+      auto const ret = reqs_.size();
+      reqs_ = {};
+      return ret;
+   }
+
+   /** @brief Closes the connection with the database.
+    *
+    *  Calling this function will cause \c async_run to return. It is
+    *  safe to try a reconnect after that i.e. calling it again.
+    *  
+    *  Note however that the prefered way to close a connection is to
+    *  send a \c quit command if you are actively closing it.
+    *  Otherwise an unresponsive Redis server will cause the
+    *  idle-checks to fail, which will also lead to \c async_run
+    *  returning.
+    *
+    *  @remark This function won't cancel pending requests, see
+    *  \c cancel_requests.
+    */
+   void cancel_run()
+   {
+      socket_->close();
+      read_timer_.cancel();
+      check_idle_timer_.cancel();
+      writer_timer_.cancel();
+      ping_timer_.cancel();
+
+      // TODO: How to avoid calling this here.
+      push_channel_.cancel();
+
+      // Cancel own pings if there is any waiting.
+      auto point = std::stable_partition(std::begin(reqs_), std::end(reqs_), [](auto const& ptr) {
+         return !ptr->req->is_internal();
+      });
+
+      std::for_each(point, std::end(reqs_), [](auto const& ptr) {
+         ptr->stop = true;
+         ptr->timer.cancel();
+      });
+
+      reqs_.erase(point, std::end(reqs_));
+   }
+
+private:
+   struct req_info {
+      req_info(boost::asio::any_io_executor ex) : timer{ex} {}
+      boost::asio::steady_timer timer;
+      resp3::request const* req = nullptr;
+      std::size_t cmds = 0;
+      bool stop = false;
+   };
+
+   using time_point_type = std::chrono::time_point<std::chrono::steady_clock>;
+   using reqs_type = std::deque<std::shared_ptr<req_info>>;
+
+   template <class T, class U> friend struct detail::read_push_op;
+   template <class T> friend struct detail::reader_op;
+   template <class T> friend struct detail::writer_op;
+   template <class T> friend struct detail::ping_op;
+   template <class T> friend struct detail::run_op;
+   template <class T, class U> friend struct detail::exec_op;
+   template <class T, class U> friend struct detail::exec_read_op;
+   template <class T, class U> friend struct detail::runexec_op;
+   template <class T> friend struct detail::connect_with_timeout_op;
+   template <class T> friend struct detail::resolve_with_timeout_op;
+   template <class T> friend struct detail::check_idle_op;
+   template <class T> friend struct detail::start_op;
+
+   void cancel_push_requests(typename reqs_type::iterator end)
+   {
+      auto point = std::stable_partition(std::begin(reqs_), end, [](auto const& ptr) {
+         return ptr->req->commands() != 0;
+      });
+
+      std::for_each(point, end, [](auto const& ptr) {
+            ptr->timer.cancel();
+      });
+
+      reqs_.erase(point, end);
+   }
+
+   void add_request_info(std::shared_ptr<req_info> const& info)
+   {
+      reqs_.push_back(info);
+      if (socket_ != nullptr && socket_->is_open() && cmds_ == 0 && write_buffer_.empty())
+         writer_timer_.cancel();
+   }
+
+   auto make_dynamic_buffer()
+      { return boost::asio::dynamic_buffer(read_buffer_, cfg_.max_read_size); }
+
+   template <class CompletionToken>
+   auto
+   async_resolve_with_timeout(
+      boost::string_view host,
+      boost::string_view port,
+      CompletionToken&& token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(detail::resolve_with_timeout_op<connection>{this, host, port},
+            token, resv_);
+   }
+
+   template <class CompletionToken>
+   auto async_connect_with_timeout(CompletionToken&& token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(detail::connect_with_timeout_op<connection>{this}, token, resv_);
+   }
+
+   // Loops on async_read_with_timeout described above.
+   template <class CompletionToken>
+   auto reader(CompletionToken&& token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(detail::reader_op<connection>{this}, token, resv_.get_executor());
+   }
+
+   template <class CompletionToken>
+   auto writer(CompletionToken&& token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(detail::writer_op<connection>{this}, token, resv_.get_executor());
+   }
+
+   template <class CompletionToken>
+   auto
+   async_start(CompletionToken&& token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(detail::start_op<connection>{this}, token, resv_);
+   }
+
+   template <class CompletionToken>
+   auto async_ping(CompletionToken&& token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(detail::ping_op<connection>{this}, token, resv_);
+   }
+
+   template <class CompletionToken>
+   auto async_check_idle(CompletionToken&& token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code)
+         >(detail::check_idle_op<connection>{this}, token, check_idle_timer_);
+   }
+
+   template <class Adapter, class CompletionToken>
+   auto async_exec_read(Adapter adapter, CompletionToken token)
+   {
+      return boost::asio::async_compose
+         < CompletionToken
+         , void(boost::system::error_code, std::size_t)
+         >(detail::exec_read_op<connection, Adapter>{this, adapter}, token, resv_);
+   }
+
+   void coalesce_requests()
+   {
+      // Coaleces all requests: Copies the request to the variables
+      // that won't be touched while async_write is suspended.
+      BOOST_ASSERT(write_buffer_.empty());
+      BOOST_ASSERT(!reqs_.empty());
+
+      auto const size = cfg_.coalesce_requests ? reqs_.size() : 1;
+      for (auto i = 0UL; i < size; ++i) {
+         write_buffer_ += reqs_.at(i)->req->payload();
+         cmds_ += reqs_.at(i)->req->commands();
+      }
+   }
+
+   using channel_type = boost::asio::experimental::channel<void(boost::system::error_code, std::size_t)>;
+
+   // IO objects
+   boost::asio::ip::tcp::resolver resv_;
+   std::shared_ptr<AsyncReadWriteStream> socket_;
+   boost::asio::steady_timer ping_timer_;
+   boost::asio::steady_timer check_idle_timer_;
+   boost::asio::steady_timer writer_timer_;
+   boost::asio::steady_timer read_timer_;
+   channel_type push_channel_;
+
+   config cfg_;
+   std::string read_buffer_;
+   std::string write_buffer_;
+   std::size_t cmds_ = 0;
+   reqs_type reqs_;
+
+   // Last time we received data.
+   time_point_type last_data_;
+
+   // The result of async_resolve.
+   boost::asio::ip::tcp::resolver::results_type endpoints_;
+
+   resp3::request req_;
+};
+
+} // aedis
+
+#endif // AEDIS_CONNECTION_HPP

aedis/detail/connection_ops.hpp

@@ -0,0 +1,563 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_CONNECTION_OPS_HPP
+#define AEDIS_CONNECTION_OPS_HPP
+
+#include <array>
+#include <algorithm>
+
+#include <boost/assert.hpp>
+#include <boost/system.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/core/ignore_unused.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+
+#include <aedis/adapt.hpp>
+#include <aedis/error.hpp>
+#include <aedis/detail/net.hpp>
+#include <aedis/resp3/type.hpp>
+#include <aedis/resp3/detail/parser.hpp>
+#include <aedis/resp3/read.hpp>
+#include <aedis/resp3/exec.hpp>
+#include <aedis/resp3/write.hpp>
+#include <aedis/resp3/request.hpp>
+
+#define HANDLER_LOCATION \
+  BOOST_ASIO_HANDLER_LOCATION((__FILE__, __LINE__, __func__))
+
+namespace aedis {
+namespace detail {
+
+#include <boost/asio/yield.hpp>
+
+template <class Conn>
+struct connect_with_timeout_op {
+   Conn* conn;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , boost::system::error_code ec = {}
+                  , boost::asio::ip::tcp::endpoint const& ep = {})
+   {
+      reenter (coro)
+      {
+         BOOST_ASSERT(conn->socket_ != nullptr);
+         conn->ping_timer_.expires_after(conn->cfg_.connect_timeout);
+         yield aedis::detail::async_connect(*conn->socket_, conn->ping_timer_, conn->endpoints_, std::move(self));
+         self.complete(ec);
+      }
+   }
+};
+
+template <class Conn>
+struct resolve_with_timeout_op {
+   Conn* conn;
+   boost::string_view host;
+   boost::string_view port;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , boost::system::error_code ec = {}
+                  , boost::asio::ip::tcp::resolver::results_type res = {})
+   {
+      reenter (coro)
+      {
+         conn->ping_timer_.expires_after(conn->cfg_.resolve_timeout);
+         yield aedis::detail::async_resolve(conn->resv_, conn->ping_timer_, host, port, std::move(self));
+         conn->endpoints_ = res;
+         self.complete(ec);
+      }
+   }
+};
+
+template <class Conn, class Adapter>
+struct read_push_op {
+   Conn* conn;
+   Adapter adapter;
+   std::size_t read_size;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void
+   operator()( Self& self
+             , boost::system::error_code ec = {}
+             , std::size_t n = 0)
+   {
+      reenter (coro)
+      {
+         yield conn->push_channel_.async_receive(std::move(self));
+         if (ec) {
+            self.complete(ec, 0);
+            return;
+         }
+
+         BOOST_ASSERT(conn->socket_ != nullptr);
+         yield resp3::async_read(*conn->socket_, conn->make_dynamic_buffer(), adapter, std::move(self));
+         if (ec) {
+            conn->cancel_run();
+            self.complete(ec, 0);
+            return;
+         }
+
+         read_size = n;
+
+         yield conn->push_channel_.async_send({}, 0, std::move(self));
+         self.complete(ec, read_size);
+         return;
+      }
+   }
+};
+
+template <class Conn, class Adapter>
+struct exec_read_op {
+   Conn* conn;
+   Adapter adapter;
+   std::size_t read_size = 0;
+   std::size_t index = 0;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void
+   operator()( Self& self
+             , boost::system::error_code ec = {}
+             , std::size_t n = 0)
+   {
+      reenter (coro)
+      {
+         // Loop reading the responses to this request.
+         BOOST_ASSERT(!conn->reqs_.empty());
+         while (conn->reqs_.front()->cmds != 0) {
+            BOOST_ASSERT(conn->cmds_ != 0);
+
+            //-----------------------------------
+            // If we detect a push in the middle of a request we have
+            // to hand it to the push consumer. To do that we need
+            // some data in the read bufer.
+            if (conn->read_buffer_.empty()) {
+               BOOST_ASSERT(conn->socket_ != nullptr);
+               yield boost::asio::async_read_until(*conn->socket_, conn->make_dynamic_buffer(), "\r\n", std::move(self));
+               if (ec) {
+                  conn->cancel_run();
+                  self.complete(ec, 0);
+                  return;
+               }
+            }
+
+            // If the next request is a push we have to handle it to
+            // the read_push_op wait for it to be done and continue.
+            if (resp3::to_type(conn->read_buffer_.front()) == resp3::type::push) {
+               yield async_send_receive(conn->push_channel_, std::move(self));
+               if (ec) {
+                  // Notice we don't call cancel_run() as that is the
+                  // responsability of the read_push_op.
+                  self.complete(ec, 0);
+                  return;
+               }
+            }
+            //-----------------------------------
+
+            yield
+            resp3::async_read(*conn->socket_, conn->make_dynamic_buffer(),
+               [i = index, adpt = adapter] (resp3::node<boost::string_view> const& nd, boost::system::error_code& ec) mutable { adpt(i, nd, ec); },
+               std::move(self));
+
+            ++index;
+
+            if (ec) {
+               conn->cancel_run();
+               self.complete(ec, 0);
+               return;
+            }
+
+            read_size += n;
+
+            BOOST_ASSERT(conn->reqs_.front()->cmds != 0);
+            --conn->reqs_.front()->cmds;
+
+            BOOST_ASSERT(conn->cmds_ != 0);
+            --conn->cmds_;
+         }
+
+         self.complete({}, read_size);
+      }
+   }
+};
+
+template <class Conn, class Adapter>
+struct exec_op {
+   using req_info_type = typename Conn::req_info;
+
+   Conn* conn;
+   resp3::request const* req;
+   Adapter adapter;
+   std::shared_ptr<req_info_type> info;
+   std::size_t read_size = 0;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void
+   operator()( Self& self
+             , boost::system::error_code ec = {}
+             , std::size_t n = 0)
+   {
+      reenter (coro)
+      {
+         info = std::allocate_shared<req_info_type>(boost::asio::get_associated_allocator(self), conn->resv_.get_executor());
+         info->timer.expires_at(std::chrono::steady_clock::time_point::max());
+         info->req = req;
+         info->cmds = req->commands();
+         info->stop = false;
+
+         conn->add_request_info(info);
+         yield info->timer.async_wait(std::move(self));
+         BOOST_ASSERT(conn->socket_ != nullptr);
+         BOOST_ASSERT(!!ec);
+         if (info->stop) {
+            self.complete(ec, 0);
+            return;
+         }
+
+         BOOST_ASSERT(conn->socket_->is_open());
+          
+         if (req->commands() == 0) {
+            self.complete({}, 0);
+            return;
+         }
+
+         yield conn->async_exec_read(adapter, std::move(self));
+         if (ec) {
+            self.complete(ec, 0);
+            return;
+         }
+
+         read_size = n;
+
+         BOOST_ASSERT(!conn->reqs_.empty());
+         conn->reqs_.pop_front();
+
+         if (conn->cmds_ == 0) {
+            conn->read_timer_.cancel();
+            if (!conn->reqs_.empty())
+               conn->writer_timer_.cancel();
+         } else {
+            BOOST_ASSERT(!conn->reqs_.empty());
+            conn->reqs_.front()->timer.cancel_one();
+         }
+
+         self.complete({}, read_size);
+      }
+   }
+};
+
+template <class Conn>
+struct ping_op {
+   Conn* conn;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void
+   operator()( Self& self
+             , boost::system::error_code ec = {}
+             , std::size_t read_size = 0)
+   {
+      reenter (coro) for (;;)
+      {
+         conn->ping_timer_.expires_after(conn->cfg_.ping_interval);
+         yield conn->ping_timer_.async_wait(std::move(self));
+         BOOST_ASSERT(conn->socket_ != nullptr);
+         if (ec || !conn->socket_->is_open()) {
+            self.complete(ec);
+            return;
+         }
+
+         conn->req_.clear();
+         conn->req_.push("PING");
+         conn->req_.set_internal();
+         yield conn->async_exec(conn->req_, aedis::adapt(), std::move(self));
+         if (ec) {
+            // Notice we don't report error but let the idle check
+            // timeout. It is enough to finish the op.
+            self.complete({});
+            return;
+         }
+      }
+   }
+};
+
+template <class Conn>
+struct check_idle_op {
+   Conn* conn;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()(Self& self, boost::system::error_code ec = {})
+   {
+      reenter (coro) for (;;)
+      {
+         conn->check_idle_timer_.expires_after(2 * conn->cfg_.ping_interval);
+         yield conn->check_idle_timer_.async_wait(std::move(self));
+         BOOST_ASSERT(conn->socket_ != nullptr);
+         if (ec || !conn->socket_->is_open()) {
+            // Notice this is not an error, it was requested from an
+            // external op.
+            self.complete({});
+            return;
+         }
+
+         auto const now = std::chrono::steady_clock::now();
+         if (conn->last_data_ +  (2 * conn->cfg_.ping_interval) < now) {
+            conn->cancel_run();
+            self.complete(error::idle_timeout);
+            return;
+         }
+
+         conn->last_data_ = now;
+      }
+   }
+};
+
+template <class Conn>
+struct start_op {
+   Conn* conn;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 4> order = {}
+                  , boost::system::error_code ec0 = {}
+                  , boost::system::error_code ec1 = {}
+                  , boost::system::error_code ec2 = {}
+                  , boost::system::error_code ec3 = {})
+   {
+      reenter (coro)
+      {
+         yield
+         boost::asio::experimental::make_parallel_group(
+            [this](auto token) { return conn->reader(token);},
+            [this](auto token) { return conn->writer(token);},
+            [this](auto token) { return conn->async_check_idle(token);},
+            [this](auto token) { return conn->async_ping(token);}
+         ).async_wait(
+            boost::asio::experimental::wait_for_one_error(),
+            std::move(self));
+
+         switch (order[0]) {
+           case 0:
+           {
+              self.complete(ec0);
+           } break;
+           case 1:
+           {
+              self.complete(ec1);
+           } break;
+           case 2:
+           {
+              self.complete(ec2);
+           } break;
+           case 3:
+           {
+              self.complete(ec3);
+           } break;
+           default: BOOST_ASSERT(false);
+         }
+      }
+   }
+};
+
+template <class Conn>
+struct run_op {
+   Conn* conn;
+   boost::string_view host;
+   boost::string_view port;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()(Self& self, boost::system::error_code ec = {})
+   {
+      reenter (coro)
+      {
+         yield conn->async_resolve_with_timeout(host, port, std::move(self));
+         if (ec) {
+            self.complete(ec);
+            return;
+         }
+
+         conn->socket_ = std::make_shared<typename Conn::next_layer_type>(conn->resv_.get_executor());
+
+         yield conn->async_connect_with_timeout(std::move(self));
+         if (ec) {
+            self.complete(ec);
+            return;
+         }
+
+         yield conn->async_start(std::move(self));
+         self.complete(ec);
+      }
+   }
+};
+
+template <class Conn>
+struct writer_op {
+   Conn* conn;
+   typename Conn::reqs_type::iterator end;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , boost::system::error_code ec = {}
+                  , std::size_t n = 0)
+   {
+      boost::ignore_unused(n);
+
+      reenter (coro) for (;;)
+      {
+         while (!conn->reqs_.empty() && conn->cmds_ == 0 && conn->write_buffer_.empty()) {
+            conn->coalesce_requests();
+            end = conn->reqs_.end();
+            yield boost::asio::async_write(*conn->socket_, boost::asio::buffer(conn->write_buffer_), std::move(self));
+            if (ec) {
+               self.complete(ec);
+               return;
+            }
+
+            // We have to clear the payload right after the read op in
+            // order to to use it as a flag that informs there is no
+            // ongoing write.
+            conn->write_buffer_.clear();
+            conn->cancel_push_requests(end);
+         }
+
+         if (conn->socket_->is_open()) {
+            yield conn->writer_timer_.async_wait(std::move(self));
+            // The timer may be canceled either to stop the write op
+            // or to proceed to the next write, the difference between
+            // the two is that for the former the socket will be
+            // closed first. We check for that below.
+         }
+
+         if (!conn->socket_->is_open()) {
+            // Notice this is not an error of the op, stoping was
+            // requested from the outside, so we complete with
+            // success.
+            self.complete({});
+            return;
+         }
+      }
+   }
+};
+
+template <class Conn>
+struct reader_op {
+   Conn* conn;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , boost::system::error_code ec = {}
+                  , std::size_t n = 0)
+   {
+      boost::ignore_unused(n);
+
+      reenter (coro) for (;;)
+      {
+         BOOST_ASSERT(conn->socket_->is_open());
+         yield boost::asio::async_read_until(*conn->socket_, conn->make_dynamic_buffer(), "\r\n", std::move(self));
+         if (ec) {
+            conn->cancel_run();
+            self.complete(ec);
+            return;
+         }
+
+         conn->last_data_ = std::chrono::steady_clock::now();
+
+         // We handle unsolicited events in the following way
+         //
+         // 1. Its resp3 type is a push.
+         //
+         // 2. A non-push type is received with an empty requests
+         //    queue. I have noticed this is possible (e.g. -MISCONF).
+         //    I expect them to have type push so we can distinguish
+         //    them from responses to commands, but it is a
+         //    simple-error. If we are lucky enough to receive them
+         //    when the command queue is empty we can treat them as
+         //    server pushes, otherwise it is impossible to handle
+         //    them properly
+         //
+         // 3. The request does not expect any response but we got
+         //    one. This may happen if for example, subscribe with
+         //    wrong syntax.
+         //
+         BOOST_ASSERT(!conn->read_buffer_.empty());
+         if (resp3::to_type(conn->read_buffer_.front()) == resp3::type::push
+             || conn->reqs_.empty()
+             || (!conn->reqs_.empty() && conn->reqs_.front()->cmds == 0)) {
+            yield async_send_receive(conn->push_channel_, std::move(self));
+            if (ec) {
+               self.complete(ec);
+               return;
+            }
+         } else {
+            BOOST_ASSERT(conn->cmds_ != 0);
+            BOOST_ASSERT(!conn->reqs_.empty());
+            BOOST_ASSERT(conn->reqs_.front()->cmds != 0);
+            conn->reqs_.front()->timer.cancel();
+            yield conn->read_timer_.async_wait(std::move(self));
+            if (!conn->socket_->is_open()) {
+               self.complete({});
+               return;
+            }
+         }
+
+      }
+   }
+};
+
+template <class Conn, class Adapter>
+struct runexec_op {
+   Conn* conn;
+   boost::string_view host;
+   boost::string_view port;
+   resp3::request const* req;
+   Adapter adapter;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 2> order = {}
+                  , boost::system::error_code ec1 = {}
+                  , boost::system::error_code ec2 = {}
+                  , std::size_t n = 0)
+   {
+      reenter (coro)
+      {
+         yield
+         boost::asio::experimental::make_parallel_group(
+            [this](auto token) { return conn->async_run(host, port, token);},
+            [this](auto token) { return conn->async_exec(*req, adapter, token);}
+         ).async_wait(
+            boost::asio::experimental::wait_for_one_error(),
+            std::move(self));
+
+         if (ec2) {
+            self.complete(ec2, n);
+         } else {
+            // If there was no error in the async_exec we complete
+            // with the async_run error, if any.
+            self.complete(ec1, n);
+         }
+      }
+   }
+};
+
+#include <boost/asio/unyield.hpp>
+
+} // detail
+} // aedis
+
+#endif // AEDIS_CONNECTION_OPS_HPP

aedis/detail/net.hpp

@@ -0,0 +1,206 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_NET_HPP
+#define AEDIS_NET_HPP
+
+#include <array>
+
+#include <boost/system.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/connect.hpp>
+#include <boost/assert.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+
+namespace aedis {
+namespace detail {
+
+#include <boost/asio/yield.hpp>
+
+template <
+   class Protocol,
+   class Executor,
+   class EndpointSequence
+   >
+struct connect_op {
+   boost::asio::basic_socket<Protocol, Executor>* socket;
+   boost::asio::steady_timer* timer;
+   EndpointSequence* endpoints;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 2> order = {}
+                  , boost::system::error_code ec1 = {}
+                  , typename Protocol::endpoint const& ep = {}
+                  , boost::system::error_code ec2 = {})
+   {
+      reenter (coro)
+      {
+         yield
+         boost::asio::experimental::make_parallel_group(
+            [this](auto token)
+            {
+               auto f = [](boost::system::error_code const&, typename Protocol::endpoint const&) { return true; };
+               return boost::asio::async_connect(*socket, *endpoints, f, token);
+            },
+            [this](auto token) { return timer->async_wait(token);}
+         ).async_wait(
+            boost::asio::experimental::wait_for_one(),
+            std::move(self));
+
+         switch (order[0]) {
+            case 0:
+            {
+               if (ec1) {
+                  self.complete(ec1, ep);
+                  return;
+               }
+            } break;
+
+            case 1:
+            {
+               if (!ec2) {
+                  self.complete(error::connect_timeout, ep);
+                  return;
+               }
+            } break;
+
+            default: BOOST_ASSERT(false);
+         }
+
+         self.complete({}, ep);
+      }
+   }
+};
+
+struct resolve_op {
+   boost::asio::ip::tcp::resolver* resv;
+   boost::asio::steady_timer* timer;
+   boost::string_view host;
+   boost::string_view port;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 2> order = {}
+                  , boost::system::error_code ec1 = {}
+                  , boost::asio::ip::tcp::resolver::results_type res = {}
+                  , boost::system::error_code ec2 = {})
+   {
+      reenter (coro)
+      {
+         yield
+         boost::asio::experimental::make_parallel_group(
+            [this](auto token) { return resv->async_resolve(host.data(), port.data(), token);},
+            [this](auto token) { return timer->async_wait(token);}
+         ).async_wait(
+            boost::asio::experimental::wait_for_one(),
+            std::move(self));
+
+         switch (order[0]) {
+            case 0:
+            {
+               if (ec1) {
+                  self.complete(ec1, {});
+                  return;
+               }
+            } break;
+
+            case 1:
+            {
+               if (!ec2) {
+                  self.complete(error::resolve_timeout, {});
+                  return;
+               }
+            } break;
+
+            default: BOOST_ASSERT(false);
+         }
+
+         self.complete({}, res);
+      }
+   }
+};
+
+template <class Channel>
+struct send_receive_op {
+   Channel* channel;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , boost::system::error_code ec = {}
+                  , std::size_t n = 0)
+   {
+      reenter (coro)
+      {
+         yield channel->async_send(boost::system::error_code{}, 0, std::move(self));
+         if (ec) {
+            self.complete(ec, 0);
+            return;
+         }
+
+         yield channel->async_receive(std::move(self));
+         self.complete(ec, 0);
+      }
+   }
+};
+
+#include <boost/asio/unyield.hpp>
+
+template <
+   class Protocol,
+   class Executor,
+   class EndpointSequence,
+   class CompletionToken = boost::asio::default_completion_token_t<Executor>
+   >
+auto async_connect(
+      boost::asio::basic_socket<Protocol, Executor>& socket,
+      boost::asio::steady_timer& timer,
+      EndpointSequence ep,
+      CompletionToken&& token = boost::asio::default_completion_token_t<Executor>{})
+{
+   return boost::asio::async_compose
+      < CompletionToken
+      , void(boost::system::error_code, typename Protocol::endpoint const&)
+      >(connect_op<Protocol, Executor, EndpointSequence>
+            {&socket, &timer, &ep}, token, socket, timer);
+}
+
+template <
+   class CompletionToken =
+      boost::asio::default_completion_token_t<boost::asio::ip::tcp::resolver::executor_type>
+   >
+auto async_resolve(
+      boost::asio::ip::tcp::resolver& resv,
+      boost::asio::steady_timer& timer,
+      boost::string_view host,
+      boost::string_view port,
+      CompletionToken&& token = CompletionToken{})
+{
+   return boost::asio::async_compose
+      < CompletionToken
+      , void(boost::system::error_code, boost::asio::ip::tcp::resolver::results_type)
+      >(resolve_op{&resv, &timer, host, port}, token, resv, timer);
+}
+
+template <
+   class Channel,
+   class CompletionToken =
+      boost::asio::default_completion_token_t<typename Channel::executor_type>
+   >
+auto async_send_receive(Channel& channel, CompletionToken&& token = CompletionToken{})
+{
+   return boost::asio::async_compose
+      < CompletionToken
+      , void(boost::system::error_code, std::size_t)
+      >(send_receive_op<Channel>{&channel}, token, channel);
+}
+} // detail
+} // aedis
+
+#endif // AEDIS_NET_HPP

aedis/error.hpp

@@ -0,0 +1,93 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_ERROR_HPP
+#define AEDIS_ERROR_HPP
+
+#include <boost/system/error_code.hpp>
+
+namespace aedis {
+
+/** \brief Generic errors.
+ *  \ingroup any
+ */
+enum class error
+{
+   /// Resolve timeout.
+   resolve_timeout = 1,
+
+   /// Connect timeout.
+   connect_timeout,
+
+   /// Idle timeout.
+   idle_timeout,
+
+   /// Invalid RESP3 type.
+   invalid_data_type,
+
+   /// Can't parse the string as a number.
+   not_a_number,
+
+   /// Received less bytes than expected.
+   unexpected_read_size,
+
+   /// The maximum depth of a nested response was exceeded.
+   exceeeds_max_nested_depth,
+
+   /// Got non boolean value.
+   unexpected_bool_value,
+
+   /// Expected field value is empty.
+   empty_field,
+
+   /// Expects a simple RESP3 type but got an aggregate.
+   expects_simple_type,
+
+   /// Expects aggregate type.
+   expects_aggregate_type,
+
+   /// Expects a map but got other aggregate.
+   expects_map_type,
+
+   /// Expects a set aggregate but got something else.
+   expects_set_type,
+
+   /// Nested response not supported.
+   nested_aggregate_unsupported,
+
+   /// Got RESP3 simple error.
+   simple_error,
+
+   /// Got RESP3 blob_error.
+   blob_error,
+
+   /// Aggregate container has incompatible size.
+   incompatible_size,
+
+   /// Not a double
+   not_a_double,
+
+   /// Got RESP3 null type.
+   null
+};
+
+/** \internal
+ *  \brief Creates a error_code object from an error.
+ *  \param e Error code.
+ *  \ingroup any
+ */
+boost::system::error_code make_error_code(error e);
+
+} // aedis
+
+namespace std {
+
+template<>
+struct is_error_code_enum<::aedis::error> : std::true_type {};
+
+} // std
+
+#endif // AEDIS_ERROR_HPP

aedis/generic/client.hpp

@@ -1,374 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <vector>
-
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/steady_timer.hpp>
-
-#include <aedis/resp3/type.hpp>
-#include <aedis/generic/detail/client_ops.hpp>
-#include <aedis/redis/command.hpp>
-
-// TODO: What to do if users send a discard command not contained in a
-// transaction. The client object will try to pop the queue until a
-// multi is found.
-
-namespace aedis {
-namespace generic {
-
-/** \brief A high level Redis client.
- *  \ingroup any
- *
- *  This class represents a connection to the Redis server. Some of
- *  its most important features are
- *
- *  1. Automatic management of commands. The implementation will send
- *     commands and read responses automatically for the user.
- *  2. Memory reuse. Dynamic memory allocations will decrease with time.
- *
- *  For more details, please see the documentation of each individual
- *  function.
- */
-template <class AsyncReadWriteStream, class Command>
-class client {
-public:
-   using stream_type = AsyncReadWriteStream;
-   using executor_type = typename stream_type::executor_type;
-   using default_completion_token_type = boost::asio::default_completion_token_t<executor_type>;
-
-   /** \brief Constructor.
-    *
-    *  \param ex The executor.
-    */
-   client(boost::asio::any_io_executor ex)
-   : socket_{ex}
-   , timer_{ex}
-   {
-      timer_.expires_at(std::chrono::steady_clock::time_point::max());
-      send(Command::hello, 3);
-   }
-
-   /// Returns the executor.
-   auto get_executor() {return socket_.get_executor();}
-
-   /** @brief Adds a command to the output command queue.
-    *
-    *  Adds a command to the output command queue and signals the write
-    *  operation there are new messages awaiting to be sent to Redis.
-    *
-    *  @sa serializer.hpp
-    *
-    *  @param cmd The command to send.
-    *  @param args Arguments to commands.
-    */
-   template <class... Ts>
-   void send(Command cmd, Ts const&... args)
-   {
-      auto const can_write = prepare_next();
-
-      serializer<std::string> sr(requests_);
-      auto const before = requests_.size();
-      sr.push(cmd, args...);
-      auto const after = requests_.size();
-      assert(after - before != 0);
-      req_info_.front().size += after - before;;
-
-      if (!has_push_response(cmd)) {
-         commands_.push_back(cmd);
-         ++req_info_.front().cmds;
-      }
-
-      if (can_write)
-         timer_.cancel_one();
-   }
-
-   /** @brief Adds a command to the output command queue.
-    *
-    *  Adds a command to the output command queue and signals the write
-    *  operation there are new messages awaiting to be sent to Redis.
-    *
-    *  @sa serializer.hpp
-    *
-    *  @param cmd The command.
-    *  @param key The key the commands refers to
-    *  @param begin Begin of the range.
-    *  @param end End of the range.
-    */
-   template <class Key, class ForwardIterator>
-   void send_range2(Command cmd, Key const& key, ForwardIterator begin, ForwardIterator end)
-   {
-      if (begin == end)
-         return;
-
-      auto const can_write = prepare_next();
-
-      serializer<std::string> sr(requests_);
-      auto const before = requests_.size();
-      sr.push_range2(cmd, key, begin, end);
-      auto const after = requests_.size();
-      assert(after - before != 0);
-      req_info_.front().size += after - before;;
-
-      if (!has_push_response(cmd)) {
-         commands_.push_back(cmd);
-         ++req_info_.front().cmds;
-      }
-
-      if (can_write)
-         timer_.cancel_one();
-   }
-
-   /** @brief Adds a command to the output command queue.
-    *
-    *  Adds a command to the output command queue and signals the write
-    *  operation there are new messages awaiting to be sent to Redis.
-    *
-    *  @sa serializer.hpp
-    *
-    *  @param cmd The command.
-    *  @param begin Begin of the range.
-    *  @param end End of the range.
-    */
-   template <class ForwardIterator>
-   void send_range2(Command cmd, ForwardIterator begin, ForwardIterator end)
-   {
-      if (begin == end)
-         return;
-
-      auto const can_write = prepare_next();
-
-      serializer<std::string> sr(requests_);
-      auto const before = requests_.size();
-      sr.push_range2(cmd, begin, end);
-      auto const after = requests_.size();
-      assert(after - before != 0);
-      req_info_.front().size += after - before;;
-
-      if (!has_push_response(cmd)) {
-         commands_.push_back(cmd);
-         ++req_info_.front().cmds;
-      }
-
-      if (can_write)
-         timer_.cancel_one();
-   }
-
-   /** @brief Adds a command to the output command queue.
-    *
-    *  Adds a command to the output command queue and signals the write
-    *  operation there are new messages awaiting to be sent to Redis.
-    *
-    *  @sa serializer.hpp
-    *
-    *  @param cmd The command.
-    *  @param key The key the commands refers to.
-    *  @param range Range of elements to send.
-    */
-   template <class Key, class Range>
-   void send_range(Command cmd, Key const& key, Range const& range)
-   {
-      using std::begin;
-      using std::end;
-      send_range2(cmd, key, begin(range), end(range));
-   }
-
-   /** @brief Adds a command to the output command queue.
-    *
-    *  Adds a command to the output command queue and signals the write
-    *  operation there are new messages awaiting to be sent to Redis.
-    *
-    *  @sa serializer.hpp
-    *
-    *  @param cmd The command.
-    *  @param range End of the range.
-    */
-   template <class Range>
-   void send_range(Command cmd, Range const& range)
-   {
-      using std::begin;
-      using std::end;
-      send_range2(cmd, begin(range), end(range));
-   }
-
-   /** @brief Starts communication with the Redis server asynchronously.
-    *
-    *  This class performs the following steps
-    *
-    *  @li Connect to the endpoint passed in the function parameter.
-    *  @li Start the async read operation that keeps reading responses to commands and server pushes.
-    *  @li Start the async write operation that keeps sending commands to Redis.
-    *
-    *  \param recv The receiver (see below)
-    *  \param ep The address of the Redis server.
-    *  \param token The completion token (ASIO jargon)
-    *
-    *  The receiver is a class that privides the following member functions
-    *
-    *  @code
-    *  class receiver {
-    *  public:
-    *     // Called when a new chunck of user data becomes available.
-    *     void on_resp3(command cmd, node<boost::string_view> const& nd, boost::system::error_code& ec);
-    *
-    *     // Called when a response becomes available.
-    *     void on_read(command cmd);
-    *
-    *     // Called when a request has been writen to the socket.
-    *     void on_write(std::size_t n);
-    *
-    *     // Called when a server push is received.
-    *     void on_push();
-    *  };
-    *  @endcode
-    *
-    */
-   template <
-     class Receiver,
-     class CompletionToken = default_completion_token_type
-   >
-   auto
-   async_run(
-      Receiver& recv,
-      boost::asio::ip::tcp::endpoint ep = {boost::asio::ip::make_address("127.0.0.1"), 6379},
-      CompletionToken token = CompletionToken{})
-   {
-      endpoint_ = ep;
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(run_op<client, Receiver>{this, &recv}, token, socket_, timer_);
-   }
-
-private:
-   template <class T, class U, class V> friend struct read_op;
-   template <class T, class U> friend struct writer_op;
-   template <class T, class U> friend struct read_write_op;
-   template <class T, class U> friend struct run_op;
-
-   struct request_info {
-      // Request size in bytes.
-      std::size_t size = 0;
-
-      // The number of commands it contains excluding commands that
-      // have push types as responses, see has_push_response.
-      std::size_t cmds = 0;
-   };
-
-   // Buffer used in the read operations.
-   std::string read_buffer_;
-
-   // Requests payload.
-   std::string requests_;
-
-   // The commands contained in the requests.
-   std::vector<Command> commands_;
-
-   // Info about the requests.
-   std::vector<request_info> req_info_;
-
-   // The stream.
-   stream_type socket_;
-
-   // Timer used to inform the write coroutine that it can write the
-   // next message in the output queue.
-   boost::asio::steady_timer timer_;
-
-   // Redis endpoint.
-   boost::asio::ip::tcp::endpoint endpoint_;
-
-   bool stop_writer_ = false;
-
-   /* Prepares the back of the queue to receive further commands. 
-    *
-    * If true is returned the request in the front of the queue can be
-    * sent to the server. See async_write_some.
-    */
-   bool prepare_next()
-   {
-      if (req_info_.empty()) {
-         req_info_.push_back({});
-         return true;
-      }
-
-      if (req_info_.front().size == 0) {
-         // It has already been written and we are waiting for the
-         // responses.
-         req_info_.push_back({});
-         return false;
-      }
-
-      return false;
-   }
-
-   // Returns true when the next request can be writen.
-   bool on_cmd(Command)
-   {
-      // TODO: If the response to a discard is received we have to
-      // remove all commands up until multi.
-
-      assert(!req_info_.empty());
-      assert(!commands_.empty());
-
-      commands_.erase(std::begin(commands_));
-
-      if (--req_info_.front().cmds != 0)
-         return false;
-
-      req_info_.erase(std::begin(req_info_));
-
-      return !req_info_.empty();
-   }
-
-   // Reads messages asynchronously.
-   template <
-      class Receiver,
-      class CompletionToken = default_completion_token_type>
-   auto
-   async_reader(
-      Receiver* recv,
-      CompletionToken&& token = default_completion_token_type{})
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(read_op<client, Receiver, Command>{this, recv}, token, socket_);
-   }
-
-   template <
-      class Receiver,
-      class CompletionToken = default_completion_token_type>
-   auto
-   async_writer(
-      Receiver* recv,
-      CompletionToken&& token = default_completion_token_type{})
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(writer_op<client, Receiver>{this, recv}, token, socket_, timer_);
-   }
-
-   template <
-      class Receiver,
-      class CompletionToken = default_completion_token_type>
-   auto
-   async_read_write(
-      Receiver* recv,
-      CompletionToken&& token = default_completion_token_type{})
-   {
-      return boost::asio::async_compose
-         < CompletionToken
-         , void(boost::system::error_code)
-         >(read_write_op<client, Receiver>{this, recv}, token, socket_, timer_);
-   }
-};
-
-} // generic
-} // aedis

aedis/generic/detail/client_ops.hpp

@@ -1,205 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <array>
-
-#include <boost/asio/experimental/parallel_group.hpp>
-#include <boost/system.hpp>
-#include <boost/asio/write.hpp>
-#include <boost/core/ignore_unused.hpp>
-
-#include <aedis/resp3/type.hpp>
-#include <aedis/resp3/detail/parser.hpp>
-#include <aedis/resp3/read.hpp>
-
-namespace aedis {
-namespace generic {
-
-#include <boost/asio/yield.hpp>
-
-template <class Client, class Receiver>
-struct run_op {
-   Client* cli;
-   Receiver* recv_;
-   boost::asio::coroutine coro;
-
-   template <class Self>
-   void operator()(Self& self, boost::system::error_code ec = {})
-   {
-      reenter (coro) {
-         yield cli->socket_.async_connect(cli->endpoint_, std::move(self));
-         if (ec) {
-            self.complete(ec);
-            return;
-         }
-
-         yield cli->async_read_write(recv_, std::move(self));
-         self.complete(ec);
-      }
-   }
-};
-
-template <class Client, class Receiver>
-struct read_write_op {
-   Client* cli;
-   Receiver* recv;
-   boost::asio::coroutine coro;
-
-   template <class Self>
-   void operator()( Self& self
-                  , std::array<std::size_t, 2> order = {}
-                  , boost::system::error_code ec1 = {}
-                  , boost::system::error_code ec2 = {}
-                  )
-   {
-      reenter (coro) {
-
-         yield
-         boost::asio::experimental::make_parallel_group(
-            [this](auto token) { return cli->async_writer(recv, token);},
-            [this](auto token) { return cli->async_reader(recv, token);}
-         ).async_wait(
-            boost::asio::experimental::wait_for_one_error(),
-            std::move(self));
-
-         switch (order[0]) {
-           case 0: self.complete(ec1); break;
-           case 1: self.complete(ec2); break;
-           default: assert(false);
-         }
-      }
-   }
-};
-
-// Consider limiting the size of the pipelines by spliting that last
-// one in two if needed.
-template <class Client, class Receiver>
-struct writer_op {
-   Client* cli;
-   Receiver* recv;
-   std::size_t size;
-   boost::asio::coroutine coro;
-
-   template <class Self>
-   void operator()( Self& self
-                  , boost::system::error_code ec = {}
-                  , std::size_t n = 0)
-   {
-      reenter (coro) for (;;) {
-
-         boost::ignore_unused(n);
-
-         assert(!cli->req_info_.empty());
-         assert(cli->req_info_.front().size != 0);
-         assert(!cli->requests_.empty());
-
-         yield
-         boost::asio::async_write(
-            cli->socket_,
-            boost::asio::buffer(cli->requests_.data(), cli->req_info_.front().size),
-            std::move(self));
-
-         if (ec) {
-            cli->socket_.close();
-            self.complete(ec);
-            return;
-         }
-
-         size = cli->req_info_.front().size;
-
-         cli->requests_.erase(0, cli->req_info_.front().size);
-         cli->req_info_.front().size = 0;
-         
-         if (cli->req_info_.front().cmds == 0) 
-            cli->req_info_.erase(std::begin(cli->req_info_));
-
-         recv->on_write(size);
-
-         yield cli->timer_.async_wait(std::move(self));
-
-         if (cli->stop_writer_) {
-            self.complete(ec);
-            return;
-         }
-      }
-   }
-};
-
-template <class Client, class Receiver, class Command>
-struct read_op {
-   Client* cli;
-   Receiver* recv;
-   boost::asio::coroutine coro;
-
-   // Consider moving this variables to the client to spare some
-   // memory in the competion handler.
-   resp3::type t = resp3::type::invalid;
-   Command cmd = Command::invalid;
-
-   template <class Self>
-   void operator()( Self& self
-                  , boost::system::error_code ec = {}
-                  , std::size_t n = 0)
-   {
-      reenter (coro) for (;;) {
-
-         boost::ignore_unused(n);
-
-         if (cli->read_buffer_.empty()) {
-            yield
-            boost::asio::async_read_until(
-               cli->socket_,
-               boost::asio::dynamic_buffer(cli->read_buffer_),
-               "\r\n",
-               std::move(self));
-
-            if (ec) {
-               cli->stop_writer_ = true;
-               self.complete(ec);
-               return;
-            }
-         }
-
-         assert(!cli->read_buffer_.empty());
-         t = resp3::detail::to_type(cli->read_buffer_.front());
-         cmd = Command::invalid;
-         if (t != resp3::type::push) {
-            assert(!cli->commands_.empty());
-            cmd = cli->commands_.front();
-         }
-
-         yield
-         resp3::async_read(
-            cli->socket_,
-            boost::asio::dynamic_buffer(cli->read_buffer_),
-            [p = recv, c = cmd](resp3::node<boost::string_view> const& nd, boost::system::error_code& ec) mutable {p->on_resp3(c, nd, ec);},
-            std::move(self));
-
-         if (ec) {
-            cli->stop_writer_ = true;
-            self.complete(ec);
-            return;
-         }
-
-         if (t == resp3::type::push) {
-            recv->on_push();
-         } else {
-            if (cli->on_cmd(cmd))
-               cli->timer_.cancel_one();
-
-            recv->on_read(cmd);
-         }
-      }
-   }
-};
-
-#include <boost/asio/unyield.hpp>
-
-} // generic
-} // aedis

aedis/generic/serializer.hpp

@@ -1,200 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <boost/hana.hpp>
-#include <aedis/resp3/compose.hpp>
-
-namespace aedis {
-namespace generic {
-
-/** @brief Creates a Redis request from user data.
- *  \ingroup any
- *  
- *  A request is composed of one or more redis commands and is
- *  referred to in the redis documentation as a pipeline, see
- *  https://redis.io/topics/pipelining.
- *
- *  For example
- *
- *  @code
- *  std::string request;
- *  auto sr = make_serializer(request);
- *  sr.push(command::hello, 3);
- *  sr.push(command::flushall);
- *  sr.push(command::ping);
- *  sr.push(command::incr, "key");
- *  sr.push(command::quit);
- *  co_await async_write(socket, buffer(request));
- *  @endcode
- *
- *  \tparam Storage The storage type e.g \c std::string.
- *  \tparam Command The command to serialize.
- *
- *  \remarks  Non-string types will be converted to string by using \c
- *  to_string, which must be made available over ADL.
- */
-
-// Consider detecting tuples in the type in the parameter pack to
-// calculate the header size correctly.
-//
-// NOTE: For some commands like hset it would be a good idea to assert
-// the value type is a pair.
-template <class Storage>
-class serializer {
-private:
-   Storage* request_;
-
-public:
-   /** \brief Constructor
-    *  
-    *  \param storage Object where the serialized request will be
-    *  stored.
-    */
-   serializer(Storage& storage) : request_(&storage) {}
-
-   /** @brief Appends a new command to the end of the request.
-    *
-    *  For example
-    *
-    *  \code
-    *  std::string request;
-    *  auto sr = make_serializer<command>(request);
-    *  sr.push(command::set, "key", "some string", "EX", "2");
-    *  \endcode
-    *
-    *  will add the \c set command with payload "some string" and an
-    *  expiration of 2 seconds.
-    *
-    *  \param cmd The redis command.
-    *  \param args The arguments of the Redis command.
-    *
-    */
-   template <class Command, class... Ts>
-   void push(Command cmd, Ts const&... args)
-   {
-      using boost::hana::for_each;
-      using boost::hana::make_tuple;
-
-      auto constexpr pack_size = sizeof...(Ts);
-      resp3::add_header(*request_, 1 + pack_size);
-
-      resp3::add_bulk(*request_, to_string(cmd));
-      resp3::add_bulk(*request_, make_tuple(args...));
-   }
-
-   /** @brief Appends a new command to the end of the request.
-    *  
-    *  This overload is useful for commands that require a key. For example
-    *
-    *  \code{.cpp}
-    *  std::map<std::string, std::string> map
-    *     { {"key1", "value1"}
-    *     , {"key2", "value2"}
-    *     , {"key3", "value3"}
-    *     };
-    *
-    *  request req;
-    *  req.push_range2(command::hset, "key", std::cbegin(map), std::cend(map));
-    *  \endcode
-    *  
-    *  \param cmd The Redis command
-    *  \param key The key the Redis command refers to.
-    *  \param begin Iterator to the begin of the range.
-    *  \param end Iterator to the end of the range.
-    */
-   template <class Command, class Key, class ForwardIterator>
-   void push_range2(Command cmd, Key const& key, ForwardIterator begin, ForwardIterator end)
-   {
-      using value_type = typename std::iterator_traits<ForwardIterator>::value_type;
-
-      if (begin == end)
-         return;
-
-      auto constexpr size = resp3::bulk_counter<value_type>::size;
-      auto const distance = std::distance(begin, end);
-      resp3::add_header(*request_, 2 + size * distance);
-      resp3::add_bulk(*request_, to_string(cmd));
-      resp3::add_bulk(*request_, key);
-
-      for (; begin != end; ++begin)
-	 resp3::add_bulk(*request_, *begin);
-   }
-
-   /** @brief Appends a new command to the end of the request.
-    *
-    *  This overload is useful for commands that don't have a key. For
-    *  example
-    *
-    *  \code
-    *  std::set<std::string> channels
-    *     { "channel1" , "channel2" , "channel3" }
-    *
-    *  request req;
-    *  req.push(command::subscribe, std::cbegin(channels), std::cedn(channels));
-    *  \endcode
-    *
-    *  \param cmd The Redis command
-    *  \param begin Iterator to the begin of the range.
-    *  \param end Iterator to the end of the range.
-    */
-   template <class Command, class ForwardIterator>
-   void push_range2(Command cmd, ForwardIterator begin, ForwardIterator end)
-   {
-      using value_type = typename std::iterator_traits<ForwardIterator>::value_type;
-
-      if (begin == end)
-         return;
-
-      auto constexpr size = resp3::bulk_counter<value_type>::size;
-      auto const distance = std::distance(begin, end);
-      resp3::add_header(*request_, 1 + size * distance);
-      resp3::add_bulk(*request_, to_string(cmd));
-
-      for (; begin != end; ++begin)
-	 resp3::add_bulk(*request_, *begin);
-   }
-
-   /** @brief Appends a new command to the end of the request.
-    *  
-    *  Similar to the range version.
-    */
-   template <class Command, class Key, class Range>
-   void push_range(Command cmd, Key const& key, Range const& range)
-   {
-      using std::begin;
-      using std::end;
-      push_range2(cmd, key, begin(range), end(range));
-   }
-
-   /** @brief Appends a new command to the end of the request.
-    *
-    *  Similar to the range version.
-    */
-   template <class Command, class Range>
-   void push_range(Command cmd, Range const& range)
-   {
-      using std::begin;
-      using std::end;
-      push_range2(cmd, begin(range), end(range));
-   }
-};
-
-/** \brief Creates a serializer.
- *  \ingroup any
- *  \param storage The string.
- */
-template <class CharT, class Traits, class Allocator>
-serializer<std::basic_string<CharT, Traits, Allocator>>
-make_serializer(std::basic_string<CharT, Traits, Allocator>& storage)
-{
-   return serializer<std::basic_string<CharT, Traits, Allocator>>(storage);
-}
-
-} // generic
-} // aedis

aedis/impl/command.ipp

@@ -0,0 +1,19 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <aedis/command.hpp>
+
+namespace aedis {
+
+bool has_push_response(boost::string_view cmd)
+{
+   if (cmd == "SUBSCRIBE") return true;
+   if (cmd == "PSUBSCRIBE") return true;
+   if (cmd == "UNSUBSCRIBE") return true;
+   return false;
+}
+
+} // aedis

aedis/impl/error.ipp

@@ -0,0 +1,61 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <aedis/error.hpp>
+
+namespace aedis {
+namespace detail {
+
+struct error_category_impl : boost::system::error_category {
+
+   char const* name() const noexcept override
+   {
+      return "aedis";
+   }
+
+   std::string message(int ev) const override
+   {
+      switch(static_cast<error>(ev)) {
+	 case error::resolve_timeout: return "Resolve operation timeout.";
+	 case error::connect_timeout: return "Connect operation timeout.";
+	 case error::idle_timeout: return "Idle timeout.";
+	 case error::invalid_data_type: return "Invalid resp3 type.";
+	 case error::not_a_number: return "Can't convert string to number.";
+	 case error::unexpected_read_size: return "Unexpected read size.";
+	 case error::exceeeds_max_nested_depth: return "Exceeds the maximum number of nested responses.";
+	 case error::unexpected_bool_value: return "Unexpected bool value.";
+	 case error::empty_field: return "Expected field value is empty.";
+	 case error::expects_simple_type: return "Expects a simple RESP3 type.";
+	 case error::expects_aggregate_type: return "Expects aggregate type.";
+	 case error::expects_map_type: return "Expects map type.";
+	 case error::expects_set_type: return "Expects set type.";
+	 case error::nested_aggregate_unsupported: return "Nested aggregate unsupported.";
+	 case error::simple_error: return "Got RESP3 simple-error.";
+	 case error::blob_error: return "Got RESP3 blob-error.";
+	 case error::incompatible_size: return "Aggregate container has incompatible size.";
+	 case error::not_a_double: return "Not a double.";
+	 case error::null: return "Got RESP3 null.";
+	 default:
+            BOOST_ASSERT(false);
+            return "Aedis error.";
+      }
+   }
+};
+
+boost::system::error_category const& category()
+{
+  static error_category_impl instance;
+  return instance;
+}
+
+} // detail
+
+boost::system::error_code make_error_code(error e)
+{
+    return boost::system::error_code{static_cast<int>(e), detail::category()};
+}
+
+} // aedis

aedis/redis/command.hpp

@@ -1,458 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <ostream>
-#include <string>
-
-namespace aedis {
-namespace redis {
-
-/** \brief Redis commands.
- *  \ingroup any
- *
- *  For a full list of commands see https://redis.io/commands.
- *
- *  \remark The list of commands below are read from Redis with the
- *  help of the command \c command.
- */
-enum class command {
-   /// https://redis.io/commands/acl
-   acl,
-   /// https://redis.io/commands/append
-   append,
-   /// https://redis.io/commands/asking
-   asking,
-   /// https://redis.io/commands/auth
-   auth,
-   /// https://redis.io/commands/bgrewriteaof
-   bgrewriteaof,
-   /// https://redis.io/commands/bgsave
-   bgsave,
-   /// https://redis.io/commands/bitcount
-   bitcount,
-   /// https://redis.io/commands/bitfield
-   bitfield,
-   /// https://redis.io/commands/bitfield_ro
-   bitfield_ro,
-   /// https://redis.io/commands/bitop
-   bitop,
-   /// https://redis.io/commands/bitpos
-   bitpos,
-   /// https://redis.io/commands/blpop
-   blpop,
-   /// https://redis.io/commands/brpop
-   brpop,
-   /// https://redis.io/commands/brpoplpush
-   brpoplpush,
-   /// https://redis.io/commands/bzpopmax
-   bzpopmax,
-   /// https://redis.io/commands/bzpopmin
-   bzpopmin,
-   /// https://redis.io/commands/client
-   client,
-   /// https://redis.io/commands/cluster
-   cluster,
-   /// https://redis.io/commands/command
-   command,
-   /// https://redis.io/commands/config
-   config,
-   /// https://redis.io/commands/dbsize
-   dbsize,
-   /// https://redis.io/commands/debug
-   debug,
-   /// https://redis.io/commands/decr
-   decr,
-   /// https://redis.io/commands/decrby
-   decrby,
-   /// https://redis.io/commands/del
-   del,
-   /// https://redis.io/commands/discard (not supported yet)
-   discard,
-   /// https://redis.io/commands/dump
-   dump,
-   /// https://redis.io/commands/echo
-   echo,
-   /// https://redis.io/commands/eval
-   eval,
-   /// https://redis.io/commands/evalsha
-   evalsha,
-   /// https://redis.io/commands/exec
-   exec,
-   /// https://redis.io/commands/exists
-   exists,
-   /// https://redis.io/commands/expire
-   expire,
-   /// https://redis.io/commands/expireat
-   expireat,
-   /// https://redis.io/commands/flushall
-   flushall,
-   /// https://redis.io/commands/flushdb
-   flushdb,
-   /// https://redis.io/commands/geoadd
-   geoadd,
-   /// https://redis.io/commands/geodist
-   geodist,
-   /// https://redis.io/commands/geohash
-   geohash,
-   /// https://redis.io/commands/geopos
-   geopos,
-   /// https://redis.io/commands/georadius
-   georadius,
-   /// https://redis.io/commands/georadius_ro
-   georadius_ro,
-   /// https://redis.io/commands/georadiusbymember
-   georadiusbymember,
-   /// https://redis.io/commands/georadiusbymember_ro
-   georadiusbymember_ro,
-   /// https://redis.io/commands/get
-   get,
-   /// https://redis.io/commands/getbit
-   getbit,
-   /// https://redis.io/commands/getrange
-   getrange,
-   /// https://redis.io/commands/getset
-   getset,
-   /// https://redis.io/commands/hdel
-   hdel,
-   /// https://redis.io/commands/hello
-   hello,
-   /// https://redis.io/commands/hexists
-   hexists,
-   /// https://redis.io/commands/hget
-   hget,
-   /// https://redis.io/commands/hgetall
-   hgetall,
-   /// https://redis.io/commands/hincrby
-   hincrby,
-   /// https://redis.io/commands/hincrbyfloat
-   hincrbyfloat,
-   /// https://redis.io/commands/hkeys
-   hkeys,
-   /// https://redis.io/commands/hlen
-   hlen,
-   /// https://redis.io/commands/hmget
-   hmget,
-   /// https://redis.io/commands/hmset
-   hmset,
-   /// https://redis.io/commands/hscan
-   hscan,
-   /// https://redis.io/commands/hset
-   hset,
-   /// https://redis.io/commands/hsetnx
-   hsetnx,
-   /// https://redis.io/commands/hstrlen
-   hstrlen,
-   /// https://redis.io/commands/hvals
-   hvals,
-   /// https://redis.io/commands/incr
-   incr,
-   /// https://redis.io/commands/incrby
-   incrby,
-   /// https://redis.io/commands/incrbyfloat
-   incrbyfloat,
-   /// https://redis.io/commands/info
-   info,
-   /// https://redis.io/commands/keys
-   keys,
-   /// https://redis.io/commands/lastsave
-   lastsave,
-   /// https://redis.io/commands/latency
-   latency,
-   /// https://redis.io/commands/lindex
-   lindex,
-   /// https://redis.io/commands/linsert
-   linsert,
-   /// https://redis.io/commands/llen
-   llen,
-   /// https://redis.io/commands/lolwut
-   lolwut,
-   /// https://redis.io/commands/lpop
-   lpop,
-   /// https://redis.io/commands/lpos
-   lpos,
-   /// https://redis.io/commands/lpush
-   lpush,
-   /// https://redis.io/commands/lpushx
-   lpushx,
-   /// https://redis.io/commands/lrange
-   lrange,
-   /// https://redis.io/commands/lrem
-   lrem,
-   /// https://redis.io/commands/lset
-   lset,
-   /// https://redis.io/commands/ltrim
-   ltrim,
-   /// https://redis.io/commands/memory
-   memory,
-   /// https://redis.io/commands/mget
-   mget,
-   /// https://redis.io/commands/migrate
-   migrate,
-   /// https://redis.io/commands/module
-   module,
-   /// https://redis.io/commands/monitor
-   monitor,
-   /// https://redis.io/commands/move
-   move,
-   /// https://redis.io/commands/mset
-   mset,
-   /// https://redis.io/commands/msetnx
-   msetnx,
-   /// https://redis.io/commands/multi
-   multi,
-   /// https://redis.io/commands/object
-   object,
-   /// https://redis.io/commands/persist
-   persist,
-   /// https://redis.io/commands/pexpire
-   pexpire,
-   /// https://redis.io/commands/pexpireat
-   pexpireat,
-   /// https://redis.io/commands/pfadd
-   pfadd,
-   /// https://redis.io/commands/pfcount
-   pfcount,
-   /// https://redis.io/commands/pfdebug
-   pfdebug,
-   /// https://redis.io/commands/pfmerge
-   pfmerge,
-   /// https://redis.io/commands/pfselftest
-   pfselftest,
-   /// https://redis.io/commands/ping
-   ping,
-   /// https://redis.io/commands/post
-   post,
-   /// https://redis.io/commands/psetex
-   psetex,
-   /// https://redis.io/commands/psubscribe
-   psubscribe,
-   /// https://redis.io/commands/psync
-   psync,
-   /// https://redis.io/commands/pttl
-   pttl,
-   /// https://redis.io/commands/publish
-   publish,
-   /// https://redis.io/commands/pubsub
-   pubsub,
-   /// https://redis.io/commands/punsubscribe
-   punsubscribe,
-   /// https://redis.io/commands/randomkey
-   randomkey,
-   /// https://redis.io/commands/readonly
-   readonly,
-   /// https://redis.io/commands/readwrite
-   readwrite,
-   /// https://redis.io/commands/rename
-   rename,
-   /// https://redis.io/commands/renamenx
-   renamenx,
-   /// https://redis.io/commands/replconf
-   replconf,
-   /// https://redis.io/commands/replicaof
-   replicaof,
-   /// https://redis.io/commands/restore
-   restore,
-   /// https://redis.io/commands/role
-   role,
-   /// https://redis.io/commands/rpop
-   rpop,
-   /// https://redis.io/commands/rpoplpush
-   rpoplpush,
-   /// https://redis.io/commands/rpush
-   rpush,
-   /// https://redis.io/commands/rpushx
-   rpushx,
-   /// https://redis.io/commands/sadd
-   sadd,
-   /// https://redis.io/commands/save
-   save,
-   /// https://redis.io/commands/scan
-   scan,
-   /// https://redis.io/commands/scard
-   scard,
-   /// https://redis.io/commands/script
-   script,
-   /// https://redis.io/commands/sdiff
-   sdiff,
-   /// https://redis.io/commands/sdiffstore
-   sdiffstore,
-   /// https://redis.io/commands/select
-   select,
-   /// https://redis.io/commands/set
-   set,
-   /// https://redis.io/commands/setbit
-   setbit,
-   /// https://redis.io/commands/setex
-   setex,
-   /// https://redis.io/commands/setnx
-   setnx,
-   /// https://redis.io/commands/setrange
-   setrange,
-   /// https://redis.io/commands/shutdown
-   shutdown,
-   /// https://redis.io/commands/sinter
-   sinter,
-   /// https://redis.io/commands/sinterstore
-   sinterstore,
-   /// https://redis.io/commands/sismember
-   sismember,
-   /// https://redis.io/commands/slaveof
-   slaveof,
-   /// https://redis.io/commands/slowlog
-   slowlog,
-   /// https://redis.io/commands/smembers
-   smembers,
-   /// https://redis.io/commands/smove
-   smove,
-   /// https://redis.io/commands/sort
-   sort,
-   /// https://redis.io/commands/spop
-   spop,
-   /// https://redis.io/commands/srandmember
-   srandmember,
-   /// https://redis.io/commands/srem
-   srem,
-   /// https://redis.io/commands/sscan
-   sscan,
-   /// https://redis.io/commands/stralgo
-   stralgo,
-   /// https://redis.io/commands/strlen
-   strlen,
-   /// https://redis.io/commands/subscribe
-   subscribe,
-   /// https://redis.io/commands/substr
-   substr,
-   /// https://redis.io/commands/sunion
-   sunion,
-   /// https://redis.io/commands/sunionstore
-   sunionstore,
-   /// https://redis.io/commands/swapdb
-   swapdb,
-   /// https://redis.io/commands/sync
-   sync,
-   /// https://redis.io/commands/time
-   time,
-   /// https://redis.io/commands/touch
-   touch,
-   /// https://redis.io/commands/ttl
-   ttl,
-   /// https://redis.io/commands/type
-   type,
-   /// https://redis.io/commands/unlink
-   unlink,
-   /// https://redis.io/commands/quit
-   quit,
-   /// https://redis.io/commands/unsubscribe
-   unsubscribe,
-   /// https://redis.io/commands/unwatch
-   unwatch,
-   /// https://redis.io/commands/wait
-   wait,
-   /// https://redis.io/commands/watch
-   watch,
-   /// https://redis.io/commands/xack
-   xack,
-   /// https://redis.io/commands/xadd
-   xadd,
-   /// https://redis.io/commands/xclaim
-   xclaim,
-   /// https://redis.io/commands/xdel
-   xdel,
-   /// https://redis.io/commands/xgroup
-   xgroup,
-   /// https://redis.io/commands/xinfo
-   xinfo,
-   /// https://redis.io/commands/xlen
-   xlen,
-   /// https://redis.io/commands/xpending
-   xpending,
-   /// https://redis.io/commands/xrange
-   xrange,
-   /// https://redis.io/commands/xread
-   xread,
-   /// https://redis.io/commands/xreadgroup
-   xreadgroup,
-   /// https://redis.io/commands/xrevrange
-   xrevrange,
-   /// https://redis.io/commands/xsetid
-   xsetid,
-   /// https://redis.io/commands/xtrim
-   xtrim,
-   /// https://redis.io/commands/zadd
-   zadd,
-   /// https://redis.io/commands/zcard
-   zcard,
-   /// https://redis.io/commands/zcount
-   zcount,
-   /// https://redis.io/commands/zincrby
-   zincrby,
-   /// https://redis.io/commands/zinterstore
-   zinterstore,
-   /// https://redis.io/commands/zlexcount
-   zlexcount,
-   /// https://redis.io/commands/zpopmax
-   zpopmax,
-   /// https://redis.io/commands/zpopmin
-   zpopmin,
-   /// https://redis.io/commands/zrange
-   zrange,
-   /// https://redis.io/commands/zrangebylex
-   zrangebylex,
-   /// https://redis.io/commands/zrangebyscore
-   zrangebyscore,
-   /// https://redis.io/commands/zrank
-   zrank,
-   /// https://redis.io/commands/zrem
-   zrem,
-   /// https://redis.io/commands/zremrangebylex
-   zremrangebylex,
-   /// https://redis.io/commands/zremrangebyrank
-   zremrangebyrank,
-   /// https://redis.io/commands/zremrangebyscore
-   zremrangebyscore,
-   /// https://redis.io/commands/zrevrange
-   zrevrange,
-   /// https://redis.io/commands/zrevrangebylex
-   zrevrangebylex,
-   /// https://redis.io/commands/zrevrangebyscore
-   zrevrangebyscore,
-   /// https://redis.io/commands/zrevrank
-   zrevrank,
-   /// https://redis.io/commands/zscan
-   zscan,
-   /// https://redis.io/commands/zscore
-   zscore,
-   /// https://redis.io/commands/zunionstore
-   zunionstore,
-   /// Invalid command.
-   invalid
-};
-
-/** \brief Converts a command to a string
- *  \ingroup any
- *
- *  \param c The command to convert.
- */
-char const* to_string(command c);
-
-/** \brief Write the text for a command name to an output stream.
- *  \ingroup operators
- *
- *  \param os Output stream.
- *  \param c Redis command
- */
-std::ostream& operator<<(std::ostream& os, command c);
-
-/** \brief Returns true for commands with push response.
- *  \ingroup any
- */
-bool has_push_response(command cmd);
-
-} // redis
-} // aedis

aedis/redis/impl/command.ipp

@@ -1,247 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <cassert>
-#include <aedis/redis/command.hpp>
-
-namespace aedis {
-namespace redis {
-
-char const* to_string(command c)
-{
-   static char const* table[] = {
-      "ACL",
-      "APPEND",
-      "ASKING",
-      "AUTH",
-      "BGREWRITEAOF",
-      "BGSAVE",
-      "BITCOUNT",
-      "BITFIELD",
-      "BITFIELD_RO",
-      "BITOP",
-      "BITPOS",
-      "BLPOP",
-      "BRPOP",
-      "BRPOPLPUSH",
-      "BZPOPMAX",
-      "BZPOPMIN",
-      "CLIENT",
-      "CLUSTER",
-      "COMMAND",
-      "CONFIG",
-      "DBSIZE",
-      "DEBUG",
-      "DECR",
-      "DECRBY",
-      "DEL",
-      "DISCARD",
-      "DUMP",
-      "ECHO",
-      "EVAL",
-      "EVALSHA",
-      "EXEC",
-      "EXISTS",
-      "EXPIRE",
-      "EXPIREAT",
-      "FLUSHALL",
-      "FLUSHDB",
-      "GEOADD",
-      "GEODIST",
-      "GEOHASH",
-      "GEOPOS",
-      "GEORADIUS",
-      "GEORADIUS_RO",
-      "GEORADIUSBYMEMBER",
-      "GEORADIUSBYMEMBER_RO",
-      "GET",
-      "GETBIT",
-      "GETRANGE",
-      "GETSET",
-      "HDEL",
-      "HELLO",
-      "HEXISTS",
-      "HGET",
-      "HGETALL",
-      "HINCRBY",
-      "HINCRBYFLOAT",
-      "HKEYS",
-      "HLEN",
-      "HMGET",
-      "HMSET",
-      "HSCAN",
-      "HSET",
-      "HSETNX",
-      "HSTRLEN",
-      "HVALS",
-      "INCR",
-      "INCRBY",
-      "INCRBYFLOAT",
-      "INFO",
-      "KEYS",
-      "LASTSAVE",
-      "LATENCY",
-      "LINDEX",
-      "LINSERT",
-      "LLEN",
-      "LOLWUT",
-      "LPOP",
-      "LPOS",
-      "LPUSH",
-      "LPUSHX",
-      "LRANGE",
-      "LREM",
-      "LSET",
-      "LTRIM",
-      "MEMORY",
-      "MGET",
-      "MIGRATE",
-      "MODULE",
-      "MONITOR",
-      "MOVE",
-      "MSET",
-      "MSETNX",
-      "MULTI",
-      "OBJECT",
-      "PERSIST",
-      "PEXPIRE",
-      "PEXPIREAT",
-      "PFADD",
-      "PFCOUNT",
-      "PFDEBUG",
-      "PFMERGE",
-      "PFSELFTEST",
-      "PING",
-      "POST",
-      "PSETEX",
-      "PSUBSCRIBE",
-      "PSYNC",
-      "PTTL",
-      "PUBLISH",
-      "PUBSUB",
-      "PUNSUBSCRIBE",
-      "RANDOMKEY",
-      "READONLY",
-      "READWRITE",
-      "RENAME",
-      "RENAMENX",
-      "REPLCONF",
-      "REPLICAOF",
-      "RESTORE",
-      "ROLE",
-      "RPOP",
-      "RPOPLPUSH",
-      "RPUSH",
-      "RPUSHX",
-      "SADD",
-      "SAVE",
-      "SCAN",
-      "SCARD",
-      "SCRIPT",
-      "SDIFF",
-      "SDIFFSTORE",
-      "SELECT",
-      "SET",
-      "SETBIT",
-      "SETEX",
-      "SETNX",
-      "SETRANGE",
-      "SHUTDOWN",
-      "SINTER",
-      "SINTERSTORE",
-      "SISMEMBER",
-      "SLAVEOF",
-      "SLOWLOG",
-      "SMEMBERS",
-      "SMOVE",
-      "SORT",
-      "SPOP",
-      "SRANDMEMBER",
-      "SREM",
-      "SSCAN",
-      "STRALGO",
-      "STRLEN",
-      "SUBSCRIBE",
-      "SUBSTR",
-      "SUNION",
-      "SUNIONSTORE",
-      "SWAPDB",
-      "SYNC",
-      "TIME",
-      "TOUCH",
-      "TTL",
-      "TYPE",
-      "UNLINK",
-      "QUIT",
-      "UNSUBSCRIBE",
-      "UNWATCH",
-      "WAIT",
-      "WATCH",
-      "XACK",
-      "XADD",
-      "XCLAIM",
-      "XDEL",
-      "XGROUP",
-      "XINFO",
-      "XLEN",
-      "XPENDING",
-      "XRANGE",
-      "XREAD",
-      "XREADGROUP",
-      "XREVRANGE",
-      "XSETID",
-      "XTRIM",
-      "ZADD",
-      "ZCARD",
-      "ZCOUNT",
-      "ZINCRBY",
-      "ZINTERSTORE",
-      "ZLEXCOUNT",
-      "ZPOPMAX",
-      "ZPOPMIN",
-      "ZRANGE",
-      "ZRANGEBYLEX",
-      "ZRANGEBYSCORE",
-      "ZRANK",
-      "ZREM",
-      "ZREMRANGEBYLEX",
-      "ZREMRANGEBYRANK",
-      "ZREMRANGEBYSCORE",
-      "ZREVRANGE",
-      "ZREVRANGEBYLEX",
-      "ZREVRANGEBYSCORE",
-      "ZREVRANK",
-      "ZSCAN",
-      "ZSCORE",
-      "ZUNIONSTORE",
-      "INVALID",
-   };
-
-   return table[static_cast<int>(c)];
-}
-
-std::ostream& operator<<(std::ostream& os, command c)
-{
-   os << to_string(c);
-   return os;
-}
-
-bool has_push_response(command cmd)
-{
-   switch (cmd) {
-      case command::subscribe:
-      case command::unsubscribe:
-      case command::psubscribe:
-      return true;
-
-      default:
-      return false;
-   }
-}
-
-} // redis
-} // aedis

aedis/resp3/compose.hpp

@@ -1,11 +1,11 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_RESP3_COMPOSE_HPP
+#define AEDIS_RESP3_COMPOSE_HPP
 
 #include <string>
 #include <tuple>
@@ -13,22 +13,39 @@
 #include <boost/hana.hpp>
 #include <boost/utility/string_view.hpp>
 
+#include <aedis/resp3/type.hpp>
+
 namespace aedis {
 namespace resp3 {
 
-/** @brief Adds data to the request.
+constexpr char separator[] = "\r\n";
+
+/** @brief Adds a bulk to the request.
  *  @ingroup any
+ *
+ *  This function is useful in serialization of your own data
+ *  structures in a request. For example
+ *
+ *  @code
+ *  void to_bulk(std::string& to, mystruct const& obj)
+ *  {
+ *     auto const str = // Convert obj to a string.
+ *     resp3::to_bulk(to, str);
+ *  }
+ *  @endcode
+ *
+ *  See more in \ref requests-serialization.
  */
 template <class Request>
 void to_bulk(Request& to, boost::string_view data)
 {
    auto const str = std::to_string(data.size());
 
-   to += "$";
+   to += to_code(type::blob_string);
    to.append(std::cbegin(str), std::cend(str));
-   to += "\r\n";
+   to += separator;
    to.append(std::cbegin(data), std::cend(data));
-   to += "\r\n";
+   to += separator;
 }
 
 template <class Request, class T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
@@ -80,23 +97,25 @@ struct add_bulk_impl<boost::hana::tuple<Ts...>> {
 
 } // detail
 
-/** @brief Adds a resp3 header to the store to.
- *  @ingroup any
+/** \internal
+ *  \brief Adds a resp3 header to the request.
+ *  \ingroup any
+ *
+ *  See mystruct.hpp for an example.
  */
 template <class Request>
-void add_header(Request& to, std::size_t size)
+void add_header(Request& to, type t, std::size_t size)
 {
    auto const str = std::to_string(size);
 
-   to += "*";
+   to += to_code(t);
    to.append(std::cbegin(str), std::cend(str));
-   to += "\r\n";
+   to += separator;
 }
 
-/** @brief Adds a rep3 bulk to the request.
- *  @ingroup any
+/* Adds a rep3 bulk to the request.
  *
- *  This function adds \c data as a bulk string to the request \c to.
+ * This function adds \c data as a bulk string to the request \c to.
  */
 template <class Request, class T>
 void add_bulk(Request& to, T const& data)
@@ -117,5 +136,26 @@ struct bulk_counter<std::pair<T, U>> {
   static constexpr auto size = 2U;
 };
 
+template <class Request>
+void add_blob(Request& to, boost::string_view blob)
+{
+   to.append(std::cbegin(blob), std::cend(blob));
+   to += separator;
+}
+
+/** \internal
+ *  \brief Adds a separator to the request.
+ *  \ingroup any
+ *
+ *  See mystruct.hpp for an example.
+ */
+template <class Request>
+void add_separator(Request& to)
+{
+   to += separator;
+}
+
 } // resp3
 } // aedis
+
+#endif // AEDIS_RESP3_COMPOSE_HPP

aedis/resp3/detail/impl/parser.ipp

@@ -1,10 +1,12 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres at gmail dot com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/home/x3.hpp>
+
 #include <aedis/resp3/detail/parser.hpp>
 #include <aedis/resp3/type.hpp>
 
@@ -12,7 +14,8 @@ namespace aedis {
 namespace resp3 {
 namespace detail {
 
-std::size_t parse_uint(char const* data, std::size_t size, boost::system::error_code& ec)
+std::size_t
+parse_uint(char const* data, std::size_t size, boost::system::error_code& ec)
 {
    static constexpr boost::spirit::x3::uint_parser<std::size_t, 10> p{};
    std::size_t ret;
@@ -22,29 +25,6 @@ std::size_t parse_uint(char const* data, std::size_t size, boost::system::error_
    return ret;
 }
 
-type to_type(char c)
-{
-   switch (c) {
-      case '!': return type::blob_error;
-      case '=': return type::verbatim_string;
-      case '$': return type::blob_string;
-      case ';': return type::streamed_string_part;
-      case '-': return type::simple_error;
-      case ':': return type::number;
-      case ',': return type::doublean;
-      case '#': return type::boolean;
-      case '(': return type::big_number;
-      case '+': return type::simple_string;
-      case '_': return type::null;
-      case '>': return type::push;
-      case '~': return type::set;
-      case '*': return type::array;
-      case '|': return type::attribute;
-      case '%': return type::map;
-      default: return type::invalid;
-   }
-}
-
 } // detail
 } // resp3
 } // aedis

aedis/resp3/detail/parser.hpp

@@ -1,21 +1,19 @@
-/* Copyright (c) 2019 - 2021 Marcelo Zimbres Silva (mzimbres at gmail dot com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_RESP3_PARSER_HPP
+#define AEDIS_RESP3_PARSER_HPP
 
-#include <string_view>
-#include <system_error>
 #include <limits>
+#include <system_error>
 
-#include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/home/x3.hpp>
+#include <boost/assert.hpp>
 #include <boost/utility/string_view.hpp>
 
-#include <aedis/resp3/error.hpp>
+#include <aedis/error.hpp>
 #include <aedis/resp3/node.hpp>
 
 namespace aedis {
@@ -24,9 +22,6 @@ namespace detail {
 
 std::size_t parse_uint(char const* data, std::size_t size, boost::system::error_code& ec);
 
-// Converts a wire-format RESP3 type (char) to a resp3 type.
-type to_type(char c);
-
 template <class ResponseAdapter>
 class parser {
 private:
@@ -68,7 +63,7 @@ public:
          switch (bulk_) {
             case type::streamed_string_part:
             {
-               assert(bulk_length_ != 0);
+               BOOST_ASSERT(bulk_length_ != 0);
                adapter_({bulk_, 1, depth_, {data, bulk_length_}}, ec);
                if (ec)
                   return 0;
@@ -198,7 +193,7 @@ public:
             } break;
             default:
             {
-	       ec = error::invalid_type;
+	       ec = error::invalid_data_type;
 	       return 0;
             }
          }
@@ -227,3 +222,5 @@ public:
 } // detail
 } // resp3
 } // aedis
+
+#endif // AEDIS_RESP3_PARSER_HPP

aedis/resp3/detail/read_ops.hpp

@@ -1,14 +1,13 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres at gmail dot com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
-
-#include <string_view>
+#ifndef AEDIS_RESP3_READ_OPS_HPP
+#define AEDIS_RESP3_READ_OPS_HPP
 
+#include <boost/assert.hpp>
 #include <boost/asio/read.hpp>
 #include <boost/asio/read_until.hpp>
 #include <boost/asio/coroutine.hpp>
@@ -88,7 +87,7 @@ public:
             }
 
             n = parser_.bulk_length() + 2;
-            assert(buf_.size() >= n);
+            BOOST_ASSERT(buf_.size() >= n);
          }
 
          n = parser_.consume((char const*)buf_.data(0, n).data(), n, ec);
@@ -107,44 +106,10 @@ public:
    }
 };
 
-template <class AsyncReadStream, class DynamicBuffer>
-class type_op {
-private:
-   AsyncReadStream& stream_;
-   DynamicBuffer buf_;
-   boost::asio::coroutine coro_;
-
-public:
-   type_op(AsyncReadStream& stream, DynamicBuffer buf)
-   : stream_ {stream}
-   , buf_ {buf}
-   { }
-
-   template <class Self>
-   void operator()( Self& self
-                  , boost::system::error_code ec = {}
-                  , std::size_t n = 0)
-   {
-      reenter (coro_) {
-
-         boost::ignore_unused(n);
-         if (buf_.size() == 0) {
-            yield boost::asio::async_read_until(stream_, buf_, "\r\n", std::move(self));
-            if (ec) {
-               self.complete(ec, type::invalid);
-               return;
-            }
-         }
-
-         auto const* data = (char const*)buf_.data(0, n).data();
-         auto const type = to_type(*data);
-         self.complete(ec, type);
-      }
-   }
-};
-
 #include <boost/asio/unyield.hpp>
 
 } // detail
 } // resp3
 } // aedis
+
+#endif // AEDIS_RESP3_READ_OPS_HPP

aedis/resp3/error.hpp

@@ -1,57 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <boost/system/error_code.hpp>
-
-namespace aedis {
-namespace resp3 {
-
-/** \brief RESP3 parsing errors.
- *  \ingroup any
- */
-enum class error
-{
-   /// Invalid RESP3 type.
-   invalid_type = 1,
-
-   /// Can't parse the string as an integer.
-   not_a_number,
-
-   /// Received less bytes than expected.
-   unexpected_read_size,
-
-   /// The maximum depth of a nested response was exceeded.
-   exceeeds_max_nested_depth,
-
-   /// Unexpected bool value
-   unexpected_bool_value,
-
-   /// Expected field value is empty.
-   empty_field
-};
-
-/** \brief Converts an error in an boost::system::error_code object.
- *  \ingroup any
- */
-boost::system::error_code make_error_code(error e);
-
-/** \brief todo
- *  \ingroup any
- */
-boost::system::error_condition make_error_condition(error e);
-
-} // resp3
-} // aedis
-
-namespace std {
-
-template<>
-struct is_error_code_enum<::aedis::resp3::error> : std::true_type {};
-
-} // std

aedis/resp3/exec.hpp

@@ -0,0 +1,176 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_RESP3_EXEC_HPP
+#define AEDIS_RESP3_EXEC_HPP
+
+#include <boost/assert.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/read.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/asio/coroutine.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+
+#include <aedis/error.hpp>
+#include <aedis/resp3/read.hpp>
+#include <aedis/resp3/request.hpp>
+
+namespace aedis {
+namespace resp3 {
+namespace detail {
+
+#include <boost/asio/yield.hpp>
+
+template <
+   class AsyncStream,
+   class Adapter,
+   class DynamicBuffer
+   >
+struct exec_op {
+   AsyncStream* socket;
+   request const* req;
+   Adapter adapter;
+   DynamicBuffer dbuf;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , boost::system::error_code ec = {}
+                  , std::size_t n = 0)
+   {
+      reenter (coro)
+      {
+         yield
+         boost::asio::async_write(
+            *socket,
+            boost::asio::buffer(req->payload()),
+            std::move(self));
+
+         if (ec) {
+            self.complete(ec, 0);
+            return;
+         }
+
+         yield resp3::async_read(*socket, dbuf, adapter, std::move(self));
+         self.complete(ec, n);
+      }
+   }
+};
+
+#include <boost/asio/unyield.hpp>
+
+} // detail
+
+template <
+   class AsyncStream,
+   class Adapter,
+   class DynamicBuffer,
+   class CompletionToken = boost::asio::default_completion_token_t<typename AsyncStream::executor_type>
+   >
+auto async_exec(
+   AsyncStream& socket,
+   request const& req,
+   Adapter adapter,
+   DynamicBuffer dbuf,
+   CompletionToken token = CompletionToken{})
+{
+   return boost::asio::async_compose
+      < CompletionToken
+      , void(boost::system::error_code, std::size_t)
+      >(detail::exec_op<AsyncStream, Adapter, DynamicBuffer>
+         {&socket, &req, adapter, dbuf}, token, socket);
+}
+
+namespace detail {
+
+#include <boost/asio/yield.hpp>
+
+template <
+   class AsyncStream,
+   class Adapter,
+   class DynamicBuffer
+   >
+struct exec_with_timeout_op {
+   AsyncStream* socket;
+   boost::asio::steady_timer* timer;
+   request const* req;
+   Adapter adapter;
+   DynamicBuffer dbuf;
+   boost::asio::coroutine coro;
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 2> order = {}
+                  , boost::system::error_code ec1 = {}
+                  , std::size_t n = 0
+                  , boost::system::error_code ec2 = {})
+   {
+      reenter (coro)
+      {
+         yield
+         boost::asio::experimental::make_parallel_group(
+            [this](auto token) { return resp3::async_exec(*socket, *req, adapter, dbuf, token);},
+            [this](auto token) { return timer->async_wait(token);}
+         ).async_wait(
+            boost::asio::experimental::wait_for_one(),
+            std::move(self));
+
+         switch (order[0]) {
+            case 0:
+            {
+               if (ec1) {
+                  self.complete(ec1, 0);
+                  return;
+               }
+            } break;
+
+            case 1:
+            {
+               if (!ec2) {
+                  self.complete(aedis::error::idle_timeout, 0);
+                  return;
+               }
+            } break;
+
+            default: BOOST_ASSERT(false);
+         }
+
+         self.complete({}, n);
+      }
+   }
+};
+
+#include <boost/asio/unyield.hpp>
+
+} // detail
+
+template <
+   class AsyncStream,
+   class Adapter,
+   class DynamicBuffer,
+   class CompletionToken = boost::asio::default_completion_token_t<typename AsyncStream::executor_type>
+   >
+auto async_exec(
+   AsyncStream& socket,
+   boost::asio::steady_timer& timer,
+   request const& req,
+   Adapter adapter,
+   DynamicBuffer dbuf,
+   CompletionToken token = CompletionToken{})
+{
+   return boost::asio::async_compose
+      < CompletionToken
+      , void(boost::system::error_code, std::size_t)
+      >(detail::exec_with_timeout_op<AsyncStream, Adapter, DynamicBuffer>
+         {&socket, &timer, &req, adapter, dbuf}, token, socket, timer);
+}
+
+} // resp3
+} // aedis
+
+#endif // AEDIS_RESP3_EXEC_HPP

aedis/resp3/impl/error.ipp

@@ -1,54 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <aedis/resp3/error.hpp>
-
-namespace aedis {
-namespace resp3 {
-namespace detail {
-
-struct error_category_impl : boost::system::error_category {
-
-   char const* name() const noexcept override
-   {
-      return "aedis.resp3";
-   }
-
-   std::string message(int ev) const override
-   {
-      switch(static_cast<error>(ev)) {
-	 case error::invalid_type: return "Invalid resp3 type.";
-	 case error::not_a_number: return "Can't convert string to number.";
-	 case error::unexpected_read_size: return "Unexpected read size.";
-	 case error::exceeeds_max_nested_depth: return "Exceeds the maximum number of nested responses.";
-	 case error::unexpected_bool_value: return "Unexpected bool value.";
-	 case error::empty_field: return "Expected field value is empty.";
-	 default: assert(false);
-      }
-   }
-};
-
-boost::system::error_category const& category()
-{
-  static error_category_impl instance;
-  return instance;
-}
-
-} // detail
-
-boost::system::error_code make_error_code(error e)
-{
-    return boost::system::error_code{static_cast<int>(e), detail::category()};
-}
-
-boost::system::error_condition make_error_condition(error e)
-{
-  return boost::system::error_condition(static_cast<int>(e), detail::category());
-}
-
-} // resp3
-} // aedis

aedis/resp3/impl/type.ipp

@@ -1,14 +1,12 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
+#include <boost/assert.hpp>
 #include <aedis/resp3/type.hpp>
 
-#include <cassert>
-
 namespace aedis {
 namespace resp3 {
 
@@ -64,5 +62,54 @@ std::size_t element_multiplicity(type t)
    }
 }
 
+char to_code(type t)
+{
+   switch (t) {
+      case type::blob_error:           return '!';
+      case type::verbatim_string:      return '=';
+      case type::blob_string:          return '$';
+      case type::streamed_string_part: return ';';
+      case type::simple_error:         return '-';
+      case type::number:               return ':';
+      case type::doublean:             return ',';
+      case type::boolean:              return '#';
+      case type::big_number:           return '(';
+      case type::simple_string:        return '+';
+      case type::null:                 return '_';
+      case type::push:                 return '>';
+      case type::set:                  return '~';
+      case type::array:                return '*';
+      case type::attribute:            return '|';
+      case type::map:                  return '%';
+
+      default:
+      BOOST_ASSERT(false);
+      return ' ';
+   }
+}
+
+type to_type(char c)
+{
+   switch (c) {
+      case '!': return type::blob_error;
+      case '=': return type::verbatim_string;
+      case '$': return type::blob_string;
+      case ';': return type::streamed_string_part;
+      case '-': return type::simple_error;
+      case ':': return type::number;
+      case ',': return type::doublean;
+      case '#': return type::boolean;
+      case '(': return type::big_number;
+      case '+': return type::simple_string;
+      case '_': return type::null;
+      case '>': return type::push;
+      case '~': return type::set;
+      case '*': return type::array;
+      case '|': return type::attribute;
+      case '%': return type::map;
+      default: return type::invalid;
+   }
+}
+
 } // resp3
 } // aedis

aedis/resp3/node.hpp

@@ -1,11 +1,11 @@
-/* Copyright (c) 2019 - 2022 Marcelo Zimbres Silva (mzimbres at gmail dot com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_RESP3_NODE_HPP
+#define AEDIS_RESP3_NODE_HPP
 
 #include <aedis/resp3/type.hpp>
 
@@ -21,15 +21,8 @@ namespace resp3 {
  *  Redis responses are the pre-order view of the response tree (see
  *  https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR).
  *
- *  The node class represent one element in the response tree. The string type
- *  is a template give more flexibility, for example
- *
- *  @li @c boost::string_view
- *  @li @c std::string
- *  @li @c boost::static_string
- *
- *  \remark Any Redis response can be received in an array of nodes, for
- *  example \c std::vector<node<std::string>>.
+ *  \remark Any Redis response can be received in an array of nodes,
+ *  for example \c std::vector<node<std::string>>.
  */
 template <class String>
 struct node {
@@ -42,7 +35,7 @@ struct node {
    /// The depth of this node in the response tree.
    std::size_t depth;
 
-   /// The actual data. For aggregate types this is always empty.
+   /// The actual data. For aggregate types this is usually empty.
    String value;
 };
 
@@ -79,7 +72,7 @@ bool operator==(node<String> const& a, node<String> const& b)
        && a.value == b.value;
 };
 
-/** \brief Writes the node to the stream.
+/** \brief Writes the node string to the stream.
  *  \ingroup any
  *
  *  NOTE: Binary data is not converted to text.
@@ -93,3 +86,5 @@ std::ostream& operator<<(std::ostream& os, node<String> const& o)
 
 } // adapter
 } // aedis
+
+#endif // AEDIS_RESP3_NODE_HPP

aedis/resp3/read.hpp

@@ -1,11 +1,11 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_RESP3_READ_HPP
+#define AEDIS_RESP3_READ_HPP
 
 #include <aedis/resp3/type.hpp>
 #include <aedis/resp3/detail/parser.hpp>
@@ -14,23 +14,40 @@
 #include <boost/asio/read.hpp>
 #include <boost/asio/compose.hpp>
 #include <boost/asio/async_result.hpp>
-#include <boost/asio/yield.hpp>
 
 namespace aedis {
 namespace resp3 {
 
-/** \brief Read the response to a command sychronously.
- *  \ingroup functions
+/** \internal
+ *  \brief Reads a complete response to a command sychronously.
+ *  \ingroup any
  *
- *  This function has to be called once for each command in the
- *  request until the whole request has been read.
+ *  This function reads a complete response to a command or a
+ *  server push synchronously. For example
  *
- *  \param stream The stream from which to read.
- *  \param buf Auxiliary read buffer, usually a `std::string`.
- *  \param adapter The response adapter, see adapt.
- *  \param ec Error if any.
- *  \returns The number of bytes that have been consumed from the
- *  auxiliary buffer.
+ *  @code
+ *  int resp;
+ *  std::string buffer;
+ *  resp3::read(socket, dynamic_buffer(buffer), adapt(resp));
+ *  @endcode
+ *
+ *  For a complete example see examples/intro_sync.cpp. This function
+ *  is implemented in terms of one or more calls to @c
+ *  asio::read_until and @c asio::read functions, and is known as a @a
+ *  composed @a operation. Furthermore, the implementation may read
+ *  additional bytes from the stream that lie past the end of the
+ *  message being read. These additional bytes are stored in the
+ *  dynamic buffer, which must be preserved for subsequent reads.
+ *
+ *  \param stream The stream from which to read e.g. a tcp socket.
+ *  \param buf Dynamic buffer (version 2).
+ *  \param adapter The response adapter, see more on \ref low-level-responses.
+ *  \param ec If an error occurs, it will be assigned to this paramter.
+ *  \returns The number of bytes that have been consumed from the dynamic buffer.
+ *
+ *  \remark This function calls buf.consume() in each chunk of data
+ *  after it has been passed to the adapter. Users must not consume
+ *  the bytes after it returns.
  */
 template <
   class SyncReadStream,
@@ -86,17 +103,11 @@ read(
    return consumed;
 }
 
-/** \brief Reads the reponse to a command.
- *  \ingroup functions
+/** \internal
+ *  \brief Reads a complete response to a command sychronously.
+ *  \ingroup any
  *  
- *  This function has to be called once for each command in the
- *  request until the whole request has been read.
- *
- *  \param stream The stream from which to read.
- *  \param buf Auxiliary read buffer, usually a `std::string`.
- *  \param adapter The response adapter, see adapt.
- *  \returns The number of bytes that have been consumed from the
- *  auxiliary buffer.
+ *  Same as the error_code overload but throws on error.
  */
 template<
    class SyncReadStream,
@@ -117,25 +128,44 @@ read(
    return n;
 }
 
-/** @brief Reads the response to a Redis command asynchronously.
- *  \ingroup functions
+/** \internal
+ *  \brief Reads a complete response to a Redis command asynchronously.
+ *  \ingroup any
  *
- *  This function has to be called once for each command in the
- *  request until the whole request has been read.
- *
- *  The completion handler must have the following signature.
+ *  This function reads a complete response to a command or a
+ *  server push asynchronously. For example
  *
  *  @code
- *  void(boost::system::error_code, std::size_t)
+ *  std::string buffer;
+ *  std::set<std::string> resp;
+ *  co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(resp));
  *  @endcode
  *
- *  The second argumet to the completion handler is the number of
- *  bytes that have been consumed in the read operation.
+ *  For a complete example see examples/transaction.cpp. This function
+ *  is implemented in terms of one or more calls to @c
+ *  asio::async_read_until and @c asio::async_read functions, and is
+ *  known as a @a composed @a operation.  Furthermore, the
+ *  implementation may read additional bytes from the stream that lie
+ *  past the end of the message being read. These additional bytes are
+ *  stored in the dynamic buffer, which must be preserved for
+ *  subsequent reads.
  *
- *  \param stream The stream from which to read.
- *  \param buffer Auxiliary read buffer, usually a `std::string`.
- *  \param adapter The response adapter, see adapt.
+ *  \param stream The stream from which to read e.g. a tcp socket.
+ *  \param buffer Dynamic buffer (version 2).
+ *  \param adapter The response adapter, see more on \ref low-level-responses.
  *  \param token The completion token.
+ *
+ *  The completion handler will receive as a parameter the total
+ *  number of bytes transferred from the stream and must have the
+ *  following signature
+ *
+ *  @code
+ *  void(boost::system::error_code, std::size_t);
+ *  @endcode
+ *
+ *  \remark This function calls buf.consume() in each chunk of data
+ *  after it has been passed to the adapter. Users must not consume
+ *  the bytes after it returns.
  */
 template <
    class AsyncReadStream,
@@ -158,39 +188,7 @@ auto async_read(
         stream);
 }
 
-/** \brief Reads the RESP3 type of the next incomming.
- *  \ingroup functions
- *
- *  This function won't consume any data from the buffer. The
- *  completion handler must have the following signature.
- *
- *  @code
-    void(boost::system::error_code, type)
- *  @endcode
- *  
- *  \param stream The stream from which to read.
- *  \param buffer Auxiliary read buffer, usually a `std::string`.
- *  \param token The completion token.
- */
-template <
-   class AsyncReadStream,
-   class DynamicBuffer,
-   class CompletionToken =
-      boost::asio::default_completion_token_t<typename AsyncReadStream::executor_type>
-   >
-auto async_read_type(
-   AsyncReadStream& stream,
-   DynamicBuffer buffer,
-   CompletionToken&& token =
-      boost::asio::default_completion_token_t<typename AsyncReadStream::executor_type>{})
-{
-   return boost::asio::async_compose
-      < CompletionToken
-      , void(boost::system::error_code, type)
-      >(detail::type_op<AsyncReadStream, DynamicBuffer> {stream, buffer}, token, stream);
-}
-
 } // resp3
 } // aedis
 
-#include <boost/asio/unyield.hpp>
+#endif // AEDIS_RESP3_READ_HPP

aedis/resp3/request.hpp

@@ -0,0 +1,221 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_RESP3_REQUEST_HPP
+#define AEDIS_RESP3_REQUEST_HPP
+
+#include <boost/hana.hpp>
+#include <aedis/resp3/compose.hpp>
+
+// NOTE: Consider detecting tuples in the type in the parameter pack
+// to calculate the header size correctly.
+//
+// NOTE: For some commands like hset it would be a good idea to assert
+// the value type is a pair.
+
+namespace aedis {
+namespace resp3 {
+
+/** @brief Creates Redis requests from user data.
+ *  \ingroup any
+ *  
+ *  A request is composed of one or more Redis commands and is
+ *  referred to in the redis documentation as a pipeline, see
+ *  https://redis.io/topics/pipelining.
+ *
+ *  Example
+ *
+ *  @code
+ *  request r;
+ *  r.push("HELLO", 3);
+ *  r.push("FLUSHALL");
+ *  r.push("PING");
+ *  r.push("PING", "key");
+ *  r.push("QUIT");
+ *  co_await async_write(socket, buffer(r));
+ *  @endcode
+ *
+ *  \remarks  Non-string types will be converted to string by using \c
+ *  to_bulk, which must be made available over ADL.
+ */
+class request {
+public:
+   //// Returns the number of commands contained in this request.
+   std::size_t commands() const noexcept { return commands_;};
+
+   /// Returns the request payload.
+   auto const& payload() const noexcept { return payload_;}
+
+   /// Clears the request preserving allocated memory.
+   void clear()
+   {
+      payload_.clear();
+      commands_ = 0;
+   }
+
+   /** @brief Appends a new command to the end of the request.
+    *
+    *  For example
+    *
+    *  \code
+    *  request req;
+    *  req.push("SET", "key", "some string", "EX", "2");
+    *  \endcode
+    *
+    *  will add the \c set command with value "some string" and an
+    *  expiration of 2 seconds.
+    *
+    *  \param cmd The command e.g redis or sentinel command.
+    *  \param args Command arguments.
+    */
+   template <class... Ts>
+   void push(boost::string_view cmd, Ts const&... args)
+   {
+      using boost::hana::for_each;
+      using boost::hana::make_tuple;
+      using resp3::type;
+
+      auto const before = payload_.size();
+      auto constexpr pack_size = sizeof...(Ts);
+      resp3::add_header(payload_, type::array, 1 + pack_size);
+      resp3::add_bulk(payload_, cmd);
+      resp3::add_bulk(payload_, make_tuple(args...));
+
+      auto const after = payload_.size();
+      if (!has_push_response(cmd))
+         ++commands_;
+   }
+
+   /** @brief Appends a new command to the end of the request.
+    *  
+    *  This overload is useful for commands that have a key and have a
+    *  dynamic range of arguments. For example
+    *
+    *  @code
+    *  std::map<std::string, std::string> map
+    *     { {"key1", "value1"}
+    *     , {"key2", "value2"}
+    *     , {"key3", "value3"}
+    *     };
+    *
+    *  request req;
+    *  req.push_range2("HSET", "key", std::cbegin(map), std::cend(map));
+    *  @endcode
+    *  
+    *  \param cmd The command e.g. Redis or Sentinel command.
+    *  \param key The command key.
+    *  \param begin Iterator to the begin of the range.
+    *  \param end Iterator to the end of the range.
+    */
+   template <class Key, class ForwardIterator>
+   void push_range2(boost::string_view cmd, Key const& key, ForwardIterator begin, ForwardIterator end)
+   {
+      using value_type = typename std::iterator_traits<ForwardIterator>::value_type;
+      using resp3::type;
+
+      if (begin == end)
+         return;
+
+      auto const before = payload_.size();
+
+      auto constexpr size = resp3::bulk_counter<value_type>::size;
+      auto const distance = std::distance(begin, end);
+      resp3::add_header(payload_, type::array, 2 + size * distance);
+      resp3::add_bulk(payload_, cmd);
+      resp3::add_bulk(payload_, key);
+
+      for (; begin != end; ++begin)
+	 resp3::add_bulk(payload_, *begin);
+
+      auto const after = payload_.size();
+      if (!has_push_response(cmd))
+         ++commands_;
+   }
+
+   /** @brief Appends a new command to the end of the request.
+    *
+    *  This overload is useful for commands that have a dynamic number
+    *  of arguments and don't have a key. For example
+    *
+    *  \code
+    *  std::set<std::string> channels
+    *     { "channel1" , "channel2" , "channel3" }
+    *
+    *  request req;
+    *  req.push("SUBSCRIBE", std::cbegin(channels), std::cedn(channels));
+    *  \endcode
+    *
+    *  \param cmd The Redis command
+    *  \param begin Iterator to the begin of the range.
+    *  \param end Iterator to the end of the range.
+    */
+   template <class ForwardIterator>
+   void push_range2(boost::string_view cmd, ForwardIterator begin, ForwardIterator end)
+   {
+      using value_type = typename std::iterator_traits<ForwardIterator>::value_type;
+      using resp3::type;
+
+      if (begin == end)
+         return;
+
+      auto const before = payload_.size();
+      auto constexpr size = resp3::bulk_counter<value_type>::size;
+      auto const distance = std::distance(begin, end);
+      resp3::add_header(payload_, type::array, 1 + size * distance);
+      resp3::add_bulk(payload_, cmd);
+
+      for (; begin != end; ++begin)
+	 resp3::add_bulk(payload_, *begin);
+
+      auto const after = payload_.size();
+      if (!has_push_response(cmd))
+         ++commands_;
+   }
+
+   /** @brief Appends a new command to the end of the request.
+    *  
+    *  Equivalent to the overload taking a range (i.e. send_range2).
+    *
+    *  \param cmd Redis command.
+    *  \param key Redis key.
+    *  \param range Range to send e.g. and \c std::map.
+    */
+   template <class Key, class Range>
+   void push_range(boost::string_view cmd, Key const& key, Range const& range)
+   {
+      using std::begin;
+      using std::end;
+      push_range2(cmd, key, begin(range), end(range));
+   }
+
+   /** @brief Appends a new command to the end of the request.
+    *
+    *  Equivalent to the overload taking a range (i.e. send_range2).
+    *
+    *  \param cmd Redis command.
+    *  \param range Range to send e.g. and \c std::map.
+    */
+   template <class Range>
+   void push_range(boost::string_view cmd, Range const& range)
+   {
+      using std::begin;
+      using std::end;
+      push_range2(cmd, begin(range), end(range));
+   }
+
+   void set_internal() noexcept { is_internal_ = true;}
+   bool is_internal() const noexcept { return is_internal_;}
+
+private:
+   std::string payload_;
+   std::size_t commands_ = 0;
+   bool is_internal_ = true;
+};
+
+} // resp3
+} // aedis
+
+#endif // AEDIS_RESP3_SERIALIZER_HPP

aedis/resp3/type.hpp

@@ -1,11 +1,11 @@
-/* Copyright (c) 2019 - 2021 Marcelo Zimbres Silva (mzimbres at gmail dot com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-#pragma once
+#ifndef AEDIS_RESP3_TYPE_HPP
+#define AEDIS_RESP3_TYPE_HPP
 
 #include <ostream>
 #include <vector>
@@ -14,10 +14,10 @@
 namespace aedis {
 namespace resp3 {
 
-/** \brief RESP3 types
+/** \brief RESP3 data types.
     \ingroup any
   
-    The RESP3 full specification can be found at https://github.com/antirez/RESP3/blob/74adea588783e463c7e84793b325b088fe6edd1c/spec.md
+    The RESP3 specification can be found at https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md.
  */
 enum class type
 { /// Aggregate
@@ -56,33 +56,34 @@ enum class type
   invalid
 };
 
-/** \brief Returns the string representation of the type.
+/** \brief Converts the data type to a string.
  *  \ingroup any
  *  \param t RESP3 type.
  */
 char const* to_string(type t);
 
 /** \brief Writes the type to the output stream.
- *  \ingroup operators
+ *  \ingroup any
  *  \param os Output stream.
  *  \param t RESP3 type.
  */
 std::ostream& operator<<(std::ostream& os, type t);
 
-/** \brief Returns true if the data type is an aggregate.
- *  \ingroup any
- *  \param t RESP3 type.
+/* Checks whether the data type is an aggregate.
  */
 bool is_aggregate(type t);
 
-/** @brief Returns the element multilicity.
- *  \ingroup any
- *  \param t RESP3 type.
- *
- *  For type map and attribute this value is 2, all other types have
- *  1.
- */
+// For map and attribute data types this function returns 2.  All
+// other types have value 1.
 std::size_t element_multiplicity(type t);
 
+// Returns the wire code of a given type.
+char to_code(type t);
+
+// Converts a wire-format RESP3 type (char) to a resp3 type.
+type to_type(char c);
+
 } // resp3
 } // aedis
+
+#endif // AEDIS_RESP3_TYPE_HPP

aedis/resp3/write.hpp

@@ -0,0 +1,53 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef AEDIS_RESP3_WRITE_HPP
+#define AEDIS_RESP3_WRITE_HPP
+
+#include <boost/asio/write.hpp>
+
+namespace aedis {
+namespace resp3 {
+
+template<
+   class SyncWriteStream,
+   class Request
+   >
+std::size_t write(SyncWriteStream& stream, Request const& req)
+{
+   return boost::asio::write(stream, boost::asio::buffer(req.payload()));
+}
+
+template<
+    class SyncWriteStream,
+    class Request
+    >
+std::size_t write(
+    SyncWriteStream& stream,
+    Request const& req,
+    boost::system::error_code& ec)
+{
+   return boost::asio::write(stream, boost::asio::buffer(req.payload()), ec);
+}
+
+template<
+   class AsyncWriteStream,
+   class Request,
+   class CompletionToken = boost::asio::default_completion_token_t<typename AsyncWriteStream::executor_type>
+   >
+auto async_write(
+   AsyncWriteStream& stream,
+   Request const& req,
+   CompletionToken&& token =
+      boost::asio::default_completion_token_t<typename AsyncWriteStream::executor_type>{})
+{
+   return boost::asio::async_write(stream, boost::asio::buffer(req.payload()), token);
+}
+
+} // resp3
+} // aedis
+
+#endif // AEDIS_RESP3_WRITE_HPP

aedis/sentinel/command.hpp

@@ -1,85 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <ostream>
-
-namespace aedis {
-namespace sentinel {
-
-/** \brief Sentinel commands.
- *  \ingroup any
- *
- *  For a full list of commands see https://redis.io/topics/sentinel
- *
- *  \remark The list of commands below are read from Redis with the
- *  help of the command \c command.
- */
-enum class command {
-   /// https://redis.io/commands/acl
-   acl,
-   /// https://redis.io/commands/auth
-   auth,
-   /// https://redis.io/commands/client
-   client,
-   /// https://redis.io/commands/command
-   command,
-   /// https://redis.io/commands/hello
-   hello,
-   /// https://redis.io/commands/info
-   info,
-   /// https://redis.io/commands/ping
-   ping,
-   /// https://redis.io/commands/psubscribe
-   psubscribe,
-   /// https://redis.io/commands/publish
-   publish,
-   /// https://redis.io/commands/punsubscribe
-   punsubscribe,
-   /// https://redis.io/commands/role
-   role,
-   /// https://redis.io/topics/sentinel
-   sentinel,
-   /// https://redis.io/commands/shutdown
-   shutdown,
-   /// https://redis.io/commands/subscribe
-   subscribe,
-   /// https://redis.io/commands/unsubscribe
-   unsubscribe,
-   /// Unknown/invalid command.
-   invalid,
-   // For internal usege only, users should ignore this.
-   multi,
-   // For internal usege only, users should ignore this.
-   discard,
-   // For internal usege only, users should ignore this.
-   exec,
-};
-
-/** \brief Converts a sentinel command to a string
- *  \ingroup any
- *
- *  \param c The command to convert.
- */
-char const* to_string(command c);
-
-/** \brief Write the text for a sentinel command name to an output stream.
- *  \ingroup operators
- *
- *  \param os Output stream.
- *  \param c Sentinel command
- */
-std::ostream& operator<<(std::ostream& os, command c);
-
-/** \brief Returns true for sentinel commands with push response.
- *  \ingroup any
- */
-bool has_push_response(command cmd);
-
-} // sentinel
-} // aedis

aedis/sentinel/impl/command.ipp

@@ -1,56 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <aedis/sentinel/command.hpp>
-
-namespace aedis {
-namespace sentinel {
-
-char const* to_string(command c)
-{
-   static char const* table[] = {
-      "ACL",
-      "AUTH",
-      "CLIENT",
-      "COMMAND",
-      "HELLO",
-      "INFO",
-      "PING",
-      "PSUBSCRIBE",
-      "PUBLISH",
-      "PUNSUBSCRIBE",
-      "ROLE",
-      "SENTINEL",
-      "SHUTDOWN",
-      "SUBSCRIBE",
-      "UNSUBSCRIBE",
-   };
-
-   return table[static_cast<int>(c)];
-}
-
-std::ostream& operator<<(std::ostream& os, command c)
-{
-   os << to_string(c);
-   return os;
-}
-
-bool has_push_response(command cmd)
-{
-   switch (cmd) {
-      case command::subscribe:
-      case command::unsubscribe:
-      case command::psubscribe:
-      return true;
-
-      default:
-      return false;
-   }
-}
-
-} // sentinel
-} // aedis

aedis/src.hpp

@@ -1,15 +1,10 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
-// Include this file in no more than one source file in your application.
-
-#include <aedis/redis/impl/command.ipp>
-#include <aedis/sentinel/impl/command.ipp>
+#include <aedis/impl/error.ipp>
+#include <aedis/impl/command.ipp>
 #include <aedis/resp3/impl/type.ipp>
 #include <aedis/resp3/detail/impl/parser.ipp>
-#include <aedis/resp3/impl/error.ipp>
-#include <aedis/adapter/impl/error.ipp>

benchmarks/cpp/asio/echo_server_client.cpp

@@ -0,0 +1,64 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <iostream>
+#include <boost/asio.hpp>
+
+namespace net = boost::asio;
+
+using net::ip::tcp;
+using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
+using timer_type = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
+
+net::awaitable<void>
+example(boost::asio::ip::tcp::endpoint ep, std::string msg, int n)
+{
+   try {
+      auto ex = co_await net::this_coro::executor;
+
+      tcp_socket socket{ex};
+      co_await socket.async_connect(ep);
+
+      std::string buffer;
+      auto dbuffer = net::dynamic_buffer(buffer);
+      for (int i = 0; i < n; ++i) {
+         co_await net::async_write(socket, net::buffer(msg));
+         auto n = co_await net::async_read_until(socket, dbuffer, "\n");
+         //std::printf("> %s", buffer.data());
+         dbuffer.consume(n);
+      }
+
+      //std::printf("Ok: %s", msg.data());
+   } catch (std::exception const& e) {
+      std::cerr << "Error: " << e.what() << std::endl;
+   }
+}
+
+int main(int argc, char* argv[])
+{
+   try {
+      int sessions = 1;
+      int msgs = 1;
+
+      if (argc == 3) {
+         sessions = std::stoi(argv[1]);
+         msgs = std::stoi(argv[2]);
+      }
+
+      net::io_context ioc;
+
+      tcp::resolver resv{ioc};
+      auto const res = resv.resolve("127.0.0.1", "55555");
+      auto ep = *std::begin(res);
+
+      for (int i = 0; i < sessions; ++i)
+         net::co_spawn(ioc, example(ep, "Some message\n", msgs), net::detached);
+
+      ioc.run();
+   } catch (std::exception const& e) {
+      std::cerr << e.what() << std::endl;
+   }
+}

benchmarks/cpp/asio/echo_server_direct.cpp

@@ -0,0 +1,55 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/detached.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/signal_set.hpp>
+#include <boost/asio/write.hpp>
+#include <cstdio>
+
+namespace net = boost::asio;
+namespace this_coro = net::this_coro;
+using net::ip::tcp;
+using net::awaitable;
+using net::co_spawn;
+using net::detached;
+using net::use_awaitable;
+
+awaitable<void> echo(tcp::socket socket)
+{
+  try {
+     char data[1024];
+     for (;;) {
+        std::size_t n = co_await socket.async_read_some(net::buffer(data), use_awaitable);
+        co_await async_write(socket, net::buffer(data, n), use_awaitable);
+     }
+  } catch (std::exception const& e) {
+     //std::printf("echo Exception: %s\n", e.what());
+  }
+}
+
+awaitable<void> listener()
+{
+  auto executor = co_await this_coro::executor;
+  tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
+  for (;;) {
+     tcp::socket socket = co_await acceptor.async_accept(use_awaitable);
+     co_spawn(executor, echo(std::move(socket)), detached);
+  }
+}
+
+int main()
+{
+  try {
+     net::io_context io_context(1);
+     co_spawn(io_context, listener(), detached);
+     io_context.run();
+  } catch (std::exception const& e) {
+     std::printf("Exception: %s\n", e.what());
+  }
+}

benchmarks/cpp/libuv/README.md

@@ -0,0 +1,7 @@
+This example was taken from
+
+   https://github.com/libuv/libuv/tree/v1.x/docs/code/tcp-echo-server
+
+To build it run, for example
+
+   $ gcc echo_server_direct.c -luv -O2 -o echo_server_direct

benchmarks/cpp/libuv/echo_server_direct.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uv.h>
+
+#define DEFAULT_PORT 55555
+#define DEFAULT_BACKLOG 128
+
+uv_loop_t *loop;
+struct sockaddr_in addr;
+
+typedef struct {
+    uv_write_t req;
+    uv_buf_t buf;
+} write_req_t;
+
+void free_write_req(uv_write_t *req) {
+    write_req_t *wr = (write_req_t*) req;
+    free(wr->buf.base);
+    free(wr);
+}
+
+void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
+    buf->base = (char*) malloc(suggested_size);
+    buf->len = suggested_size;
+}
+
+void on_close(uv_handle_t* handle) {
+    free(handle);
+}
+
+void echo_write(uv_write_t *req, int status) {
+    if (status) {
+        fprintf(stderr, "Write error %s\n", uv_strerror(status));
+    }
+    free_write_req(req);
+}
+
+void echo_read(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
+    if (nread > 0) {
+        write_req_t *req = (write_req_t*) malloc(sizeof(write_req_t));
+        req->buf = uv_buf_init(buf->base, nread);
+        uv_write((uv_write_t*) req, client, &req->buf, 1, echo_write);
+        return;
+    }
+    if (nread < 0) {
+        if (nread != UV_EOF)
+            fprintf(stderr, "Read error %s\n", uv_err_name(nread));
+        uv_close((uv_handle_t*) client, on_close);
+    }
+
+    free(buf->base);
+}
+
+void on_new_connection(uv_stream_t *server, int status) {
+    if (status < 0) {
+        fprintf(stderr, "New connection error %s\n", uv_strerror(status));
+        // error!
+        return;
+    }
+
+    uv_tcp_t *client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
+    uv_tcp_init(loop, client);
+    if (uv_accept(server, (uv_stream_t*) client) == 0) {
+        uv_read_start((uv_stream_t*) client, alloc_buffer, echo_read);
+    }
+    else {
+        uv_close((uv_handle_t*) client, on_close);
+    }
+}
+
+int main() {
+    loop = uv_default_loop();
+
+    uv_tcp_t server;
+    uv_tcp_init(loop, &server);
+
+    uv_ip4_addr("0.0.0.0", DEFAULT_PORT, &addr);
+
+    uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);
+    int r = uv_listen((uv_stream_t*) &server, DEFAULT_BACKLOG, on_new_connection);
+    if (r) {
+        fprintf(stderr, "Listen error %s\n", uv_strerror(r));
+        return 1;
+    }
+    return uv_run(loop, UV_RUN_DEFAULT);
+}

benchmarks/go/echo_server_direct.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"net"
+	"os"
+)
+
+func echo(conn net.Conn) {
+	r := bufio.NewReader(conn)
+	for {
+		line, err := r.ReadBytes(byte('\n'))
+		switch err {
+		case nil:
+			break
+		case io.EOF:
+		default:
+			fmt.Println("ERROR", err)
+		}
+		conn.Write(line)
+	}
+}
+
+func main() {
+	l, err := net.Listen("tcp", "0.0.0.0:55555")
+	if err != nil {
+		fmt.Println("ERROR", err)
+		os.Exit(1)
+	}
+
+	for {
+		conn, err := l.Accept()
+		if err != nil {
+			fmt.Println("ERROR", err)
+			continue
+		}
+		go echo(conn)
+	}
+}

benchmarks/nodejs/echo_server_direct.js

@@ -0,0 +1,7 @@
+var net = require('net');
+
+net.createServer(function(socket){
+    socket.on('data', function(data){
+        socket.write(data.toString())
+    });
+}).listen(55555);

benchmarks/nodejs/echo_server_over_redis.js

@@ -0,0 +1,13 @@
+import { createClient } from 'redis';
+import * as net from 'net';
+
+const client = createClient();
+client.on('error', (err) => console.log('Redis Client Error', err));
+await client.connect();
+
+net.createServer(function(socket){
+   socket.on('data', async function(data) {
+      const value = await client.ping(data.toString());
+      socket.write(data)
+   });
+}).listen(55555);

benchmarks/nodejs/package-lock.json

@@ -0,0 +1,169 @@
+{
+  "name": "aedis",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "redis": "^4.1.0"
+      }
+    },
+    "node_modules/@redis/bloom": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@redis/bloom/-/bloom-1.0.2.tgz",
+      "integrity": "sha512-EBw7Ag1hPgFzdznK2PBblc1kdlj5B5Cw3XwI9/oG7tSn85/HKy3X9xHy/8tm/eNXJYHLXHJL/pkwBpFMVVefkw==",
+      "peerDependencies": {
+        "@redis/client": "^1.0.0"
+      }
+    },
+    "node_modules/@redis/client": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@redis/client/-/client-1.1.0.tgz",
+      "integrity": "sha512-xO9JDIgzsZYDl3EvFhl6LC52DP3q3GCMUer8zHgKV6qSYsq1zB+pZs9+T80VgcRogrlRYhi4ZlfX6A+bHiBAgA==",
+      "dependencies": {
+        "cluster-key-slot": "1.1.0",
+        "generic-pool": "3.8.2",
+        "yallist": "4.0.0"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@redis/graph": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@redis/graph/-/graph-1.0.1.tgz",
+      "integrity": "sha512-oDE4myMCJOCVKYMygEMWuriBgqlS5FqdWerikMoJxzmmTUErnTRRgmIDa2VcgytACZMFqpAOWDzops4DOlnkfQ==",
+      "peerDependencies": {
+        "@redis/client": "^1.0.0"
+      }
+    },
+    "node_modules/@redis/json": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@redis/json/-/json-1.0.3.tgz",
+      "integrity": "sha512-4X0Qv0BzD9Zlb0edkUoau5c1bInWSICqXAGrpwEltkncUwcxJIGEcVryZhLgb0p/3PkKaLIWkjhHRtLe9yiA7Q==",
+      "peerDependencies": {
+        "@redis/client": "^1.0.0"
+      }
+    },
+    "node_modules/@redis/search": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@redis/search/-/search-1.0.6.tgz",
+      "integrity": "sha512-pP+ZQRis5P21SD6fjyCeLcQdps+LuTzp2wdUbzxEmNhleighDDTD5ck8+cYof+WLec4csZX7ks+BuoMw0RaZrA==",
+      "peerDependencies": {
+        "@redis/client": "^1.0.0"
+      }
+    },
+    "node_modules/@redis/time-series": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@redis/time-series/-/time-series-1.0.3.tgz",
+      "integrity": "sha512-OFp0q4SGrTH0Mruf6oFsHGea58u8vS/iI5+NpYdicaM+7BgqBZH8FFvNZ8rYYLrUO/QRqMq72NpXmxLVNcdmjA==",
+      "peerDependencies": {
+        "@redis/client": "^1.0.0"
+      }
+    },
+    "node_modules/cluster-key-slot": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/cluster-key-slot/-/cluster-key-slot-1.1.0.tgz",
+      "integrity": "sha512-2Nii8p3RwAPiFwsnZvukotvow2rIHM+yQ6ZcBXGHdniadkYGZYiGmkHJIbZPIV9nfv7m/U1IPMVVcAhoWFeklw==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/generic-pool": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/generic-pool/-/generic-pool-3.8.2.tgz",
+      "integrity": "sha512-nGToKy6p3PAbYQ7p1UlWl6vSPwfwU6TMSWK7TTu+WUY4ZjyZQGniGGt2oNVvyNSpyZYSB43zMXVLcBm08MTMkg==",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/redis": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/redis/-/redis-4.1.0.tgz",
+      "integrity": "sha512-5hvJ8wbzpCCiuN1ges6tx2SAh2XXCY0ayresBmu40/SGusWHFW86TAlIPpbimMX2DFHOX7RN34G2XlPA1Z43zg==",
+      "dependencies": {
+        "@redis/bloom": "1.0.2",
+        "@redis/client": "1.1.0",
+        "@redis/graph": "1.0.1",
+        "@redis/json": "1.0.3",
+        "@redis/search": "1.0.6",
+        "@redis/time-series": "1.0.3"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+    }
+  },
+  "dependencies": {
+    "@redis/bloom": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@redis/bloom/-/bloom-1.0.2.tgz",
+      "integrity": "sha512-EBw7Ag1hPgFzdznK2PBblc1kdlj5B5Cw3XwI9/oG7tSn85/HKy3X9xHy/8tm/eNXJYHLXHJL/pkwBpFMVVefkw==",
+      "requires": {}
+    },
+    "@redis/client": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@redis/client/-/client-1.1.0.tgz",
+      "integrity": "sha512-xO9JDIgzsZYDl3EvFhl6LC52DP3q3GCMUer8zHgKV6qSYsq1zB+pZs9+T80VgcRogrlRYhi4ZlfX6A+bHiBAgA==",
+      "requires": {
+        "cluster-key-slot": "1.1.0",
+        "generic-pool": "3.8.2",
+        "yallist": "4.0.0"
+      }
+    },
+    "@redis/graph": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@redis/graph/-/graph-1.0.1.tgz",
+      "integrity": "sha512-oDE4myMCJOCVKYMygEMWuriBgqlS5FqdWerikMoJxzmmTUErnTRRgmIDa2VcgytACZMFqpAOWDzops4DOlnkfQ==",
+      "requires": {}
+    },
+    "@redis/json": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@redis/json/-/json-1.0.3.tgz",
+      "integrity": "sha512-4X0Qv0BzD9Zlb0edkUoau5c1bInWSICqXAGrpwEltkncUwcxJIGEcVryZhLgb0p/3PkKaLIWkjhHRtLe9yiA7Q==",
+      "requires": {}
+    },
+    "@redis/search": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@redis/search/-/search-1.0.6.tgz",
+      "integrity": "sha512-pP+ZQRis5P21SD6fjyCeLcQdps+LuTzp2wdUbzxEmNhleighDDTD5ck8+cYof+WLec4csZX7ks+BuoMw0RaZrA==",
+      "requires": {}
+    },
+    "@redis/time-series": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@redis/time-series/-/time-series-1.0.3.tgz",
+      "integrity": "sha512-OFp0q4SGrTH0Mruf6oFsHGea58u8vS/iI5+NpYdicaM+7BgqBZH8FFvNZ8rYYLrUO/QRqMq72NpXmxLVNcdmjA==",
+      "requires": {}
+    },
+    "cluster-key-slot": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/cluster-key-slot/-/cluster-key-slot-1.1.0.tgz",
+      "integrity": "sha512-2Nii8p3RwAPiFwsnZvukotvow2rIHM+yQ6ZcBXGHdniadkYGZYiGmkHJIbZPIV9nfv7m/U1IPMVVcAhoWFeklw=="
+    },
+    "generic-pool": {
+      "version": "3.8.2",
+      "resolved": "https://registry.npmjs.org/generic-pool/-/generic-pool-3.8.2.tgz",
+      "integrity": "sha512-nGToKy6p3PAbYQ7p1UlWl6vSPwfwU6TMSWK7TTu+WUY4ZjyZQGniGGt2oNVvyNSpyZYSB43zMXVLcBm08MTMkg=="
+    },
+    "redis": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/redis/-/redis-4.1.0.tgz",
+      "integrity": "sha512-5hvJ8wbzpCCiuN1ges6tx2SAh2XXCY0ayresBmu40/SGusWHFW86TAlIPpbimMX2DFHOX7RN34G2XlPA1Z43zg==",
+      "requires": {
+        "@redis/bloom": "1.0.2",
+        "@redis/client": "1.1.0",
+        "@redis/graph": "1.0.1",
+        "@redis/json": "1.0.3",
+        "@redis/search": "1.0.6",
+        "@redis/time-series": "1.0.3"
+      }
+    },
+    "yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+    }
+  }
+}

benchmarks/nodejs/package.json

@@ -0,0 +1,4 @@
+{
+   "type": "module",
+   "dependencies": { "redis": "^4.1.0" }
+}

benchmarks/rust/echo_server_direct/Cargo.lock

@@ -0,0 +1,336 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bytes"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38"
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "echo_server_direct"
+version = "0.1.0"
+dependencies = [
+ "tokio",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+dependencies = [
+ "bitflags",
+ "fuchsia-zircon-sys",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+
+[[package]]
+name = "futures-core"
+version = "0.3.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c09fd04b7e4073ac7156a9539b57a484a8ea920f79c7c675d05d289ab6110d3"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "iovec"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+
+[[package]]
+name = "log"
+version = "0.4.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "mio"
+version = "0.6.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"
+dependencies = [
+ "cfg-if 0.1.10",
+ "fuchsia-zircon",
+ "fuchsia-zircon-sys",
+ "iovec",
+ "kernel32-sys",
+ "libc",
+ "log",
+ "miow 0.2.2",
+ "net2",
+ "slab",
+ "winapi 0.2.8",
+]
+
+[[package]]
+name = "mio-named-pipes"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0840c1c50fd55e521b247f949c241c9997709f23bd7f023b9762cd561e935656"
+dependencies = [
+ "log",
+ "mio",
+ "miow 0.3.7",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "mio-uds"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afcb699eb26d4332647cc848492bbc15eafb26f08d0304550d5aa1f612e066f0"
+dependencies = [
+ "iovec",
+ "libc",
+ "mio",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
+dependencies = [
+ "kernel32-sys",
+ "net2",
+ "winapi 0.2.8",
+ "ws2_32-sys",
+]
+
+[[package]]
+name = "miow"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+dependencies = [
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "net2"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "391630d12b68002ae1e25e8f974306474966550ad82dac6886fb8910c19568ae"
+dependencies = [
+ "cfg-if 0.1.10",
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "257b64915a082f7811703966789728173279bdebb956b143dbcd23f6f970a777"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f53dc8cf16a769a6f677e09e7ff2cd4be1ea0f48754aac39520536962011de0d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb703cfe953bccee95685111adeedb76fabe4e97549a58d16f03ea7b9367bb32"
+
+[[package]]
+name = "syn"
+version = "1.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tokio"
+version = "0.2.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6703a273949a90131b290be1fe7b039d0fc884aa1935860dfcbe056f28cd8092"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "iovec",
+ "lazy_static",
+ "libc",
+ "memchr",
+ "mio",
+ "mio-named-pipes",
+ "mio-uds",
+ "num_cpus",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "slab",
+ "tokio-macros",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e44da00bfc73a25f814cd8d7e57a68a5c31b74b3152a0a1d1f590c97ed06265a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c"
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "ws2_32-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]

benchmarks/rust/echo_server_direct/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "echo_server_direct"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+tokio = { version = "0.2", features = ["full"] }

benchmarks/rust/echo_server_direct/src/main.rs

@@ -0,0 +1,34 @@
+use tokio::net::TcpListener;
+use tokio::prelude::*;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut listener = TcpListener::bind("127.0.0.1:55555").await?;
+
+    loop {
+        let (mut socket, _) = listener.accept().await?;
+
+        tokio::spawn(async move {
+            let mut buf = [0; 1024];
+
+            // In a loop, read data from the socket and write the data back.
+            loop {
+                let n = match socket.read(&mut buf).await {
+                    // socket closed
+                    Ok(n) if n == 0 => return,
+                    Ok(n) => n,
+                    Err(e) => {
+                        eprintln!("failed to read from socket; err = {:?}", e);
+                        return;
+                    }
+                };
+
+                // Write the data back
+                if let Err(e) = socket.write_all(&buf[0..n]).await {
+                    eprintln!("failed to write to socket; err = {:?}", e);
+                    return;
+                }
+            }
+        });
+    }
+}

benchmarks/rust/echo_server_over_redis/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "echo_server_over_redis"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+tokio = { version = "1.16.1", features = ["full"] }
+redis = { version = "0.21.5", features = ["tokio-comp"] }
+futures = "0.3"

benchmarks/rust/echo_server_over_redis/src/main.rs

@@ -0,0 +1,44 @@
+use tokio::net::TcpListener;
+use tokio::io::AsyncReadExt;
+use tokio::io::AsyncWriteExt;
+use tokio::sync::Mutex;
+use std::sync::{Arc};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let listener = TcpListener::bind("127.0.0.1:55555").await?;
+    let client = redis::Client::open("redis://127.0.0.1/").unwrap();
+    let con = Arc::new(Mutex::new(client.get_async_connection().await?));
+
+    loop {
+        let conn = Arc::clone(&con);
+        let (mut socket, _) = listener.accept().await?;
+
+        tokio::spawn(async move {
+            let mut buf = [0; 1024];
+
+            loop {
+                let n = match socket.read(&mut buf).await {
+                    Ok(n) if n == 0 => return,
+                    Ok(n) => n,
+                    Err(e) => {
+                        eprintln!("failed to read from socket; err = {:?}", e);
+                        return;
+                    }
+                };
+
+                let mut local_conn = conn.lock().await;
+
+                let result =
+                    redis::cmd("PING")
+                    .arg(&buf[0..n])
+                    .query_async::<redis::aio::Connection, String>(&mut local_conn).await.unwrap();
+
+                if let Err(e) = socket.write_all(result.as_bytes()).await {
+                    eprintln!("failed to write to socket; err = {:?}", e);
+                    return;
+                }
+            }
+        });
+    }
+}

configure.ac

@@ -1,5 +1,5 @@
 AC_PREREQ([2.69])
-AC_INIT([Aedis], [0.1.0], [mzimbres@gmail.com])
+AC_INIT([Aedis], [0.1.2], [mzimbres@gmail.com])
 AC_CONFIG_MACRO_DIR([m4])
 #AC_CONFIG_SRCDIR([src/aedis.cpp])
 AC_CONFIG_HEADERS([config.h])

doc/Doxyfile.in

@@ -44,7 +44,7 @@ PROJECT_NUMBER         = "@PACKAGE_VERSION@"
 # for a project that appears at the top of each page and should give viewer a
 # quick idea about the purpose of the project. Keep the description short.
 
-PROJECT_BRIEF          = "Low level Redis client library"
+PROJECT_BRIEF          = "High level Redis client library"
 
 # With the PROJECT_LOGO tag one can specify a logo or an icon that is included
 # in the documentation. The maximum height of the logo should not exceed 55

examples/chat_room.cpp

@@ -0,0 +1,159 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <queue>
+#include <vector>
+#include <string>
+#include <iostream>
+
+#include <boost/asio.hpp>
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+using aedis::adapt;
+using aedis::resp3::request;
+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 connection = aedis::connection<tcp_socket>;
+using response_type = std::vector<aedis::resp3::node<std::string>>;
+
+class user_session:
+   public std::enable_shared_from_this<user_session> {
+public:
+   user_session(tcp_socket socket)
+   : socket_(std::move(socket))
+   , timer_(socket_.get_executor())
+      { timer_.expires_at(std::chrono::steady_clock::time_point::max()); }
+
+   void start(std::shared_ptr<connection> db)
+   {
+      co_spawn(socket_.get_executor(),
+          [self = shared_from_this(), db]{ return self->reader(db); },
+          net::detached);
+
+      co_spawn(socket_.get_executor(),
+          [self = shared_from_this()]{ return self->writer(); },
+          net::detached);
+   }
+
+   void deliver(std::string const& msg)
+   {
+      write_msgs_.push_back(msg);
+      timer_.cancel_one();
+   }
+
+private:
+   net::awaitable<void> reader(std::shared_ptr<connection> db)
+   {
+      try {
+         std::string msg;
+         request req;
+         auto dbuffer = net::dynamic_buffer(msg, 1024);
+         for (;;) {
+            auto const n = co_await net::async_read_until(socket_, dbuffer, "\n");
+            req.push("PUBLISH", "channel", msg);
+            co_await db->async_exec(req);
+            req.clear();
+            msg.erase(0, n);
+         }
+      } catch (std::exception&) {
+         stop();
+      }
+   }
+
+   net::awaitable<void> writer()
+   {
+      try {
+         while (socket_.is_open()) {
+            if (write_msgs_.empty()) {
+               boost::system::error_code ec;
+               co_await timer_.async_wait(net::redirect_error(net::use_awaitable, ec));
+            } else {
+               co_await net::async_write(socket_, net::buffer(write_msgs_.front()));
+               write_msgs_.pop_front();
+            }
+         }
+      } catch (std::exception&) {
+        stop();
+      }
+   }
+
+   void stop()
+   {
+      socket_.close();
+      timer_.cancel();
+   }
+
+   tcp_socket socket_;
+   net::steady_timer timer_;
+   std::deque<std::string> write_msgs_;
+};
+
+using sessions_type = std::vector<std::shared_ptr<user_session>>;
+
+net::awaitable<void>
+reader(
+   std::shared_ptr<connection> db,
+   std::shared_ptr<sessions_type> sessions)
+{
+   request req;
+   req.push("SUBSCRIBE", "channel");
+   co_await db->async_exec(req);
+
+   for (response_type resp;;) {
+      co_await db->async_read_push(adapt(resp));
+
+      for (auto& session: *sessions)
+         session->deliver(resp.at(3).value);
+
+      resp.clear();
+   }
+}
+
+net::awaitable<void>
+listener(
+    std::shared_ptr<tcp_acceptor> acc,
+    std::shared_ptr<connection> db,
+    std::shared_ptr<sessions_type> sessions)
+{
+   request req;
+   req.push("HELLO", 3);
+   co_await db->async_exec(req);
+
+   for (;;) {
+      auto socket = co_await acc->async_accept();
+      auto session = std::make_shared<user_session>(std::move(socket));
+      sessions->push_back(session);
+      session->start(db);
+   }
+}
+
+auto handler =[](auto ec, auto...)
+   { std::cout << ec.message() << std::endl; };
+
+int main()
+{
+   try {
+      net::io_context ioc{1};
+
+      // Redis client and receiver.
+      auto db = std::make_shared<connection>(ioc);
+      db->async_run("127.0.0.1", "6379", handler);
+
+      auto sessions = std::make_shared<sessions_type>();
+      net::co_spawn(ioc, reader(db, sessions), net::detached);
+
+      // TCP acceptor.
+      auto endpoint = net::ip::tcp::endpoint{net::ip::tcp::v4(), 55555};
+      auto acc = std::make_shared<tcp_acceptor>(ioc, endpoint);
+      co_spawn(ioc, listener(acc, db, sessions), net::detached);
+
+      ioc.run();
+   } catch (std::exception const& e) {
+      std::cerr << e.what() << std::endl;
+   }
+}

examples/containers.cpp

@@ -0,0 +1,63 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <map>
+#include <vector>
+#include <iostream>
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+#include "print.hpp"
+
+namespace net = boost::asio;
+using boost::optional;
+using aedis::adapt;
+using aedis::resp3::request;
+using connection = aedis::connection<>;
+
+// $ redis-cli
+// > ACL SETUSER mzimbres on >Jabuticaba  ~* +@all
+// OK
+
+int main()
+{
+   std::vector<int> vec
+      {1, 2, 3, 4, 5, 6};
+
+   std::map<std::string, int> map
+      {{"key1", 10}, {"key2", 20}, {"key3", 30}};
+
+   request req;
+   req.push("AUTH", "mzimbres", "Jabuticaba");
+   req.push("HELLO", 3);
+   req.push_range("RPUSH", "rpush-key", vec);
+   req.push_range("HSET", "hset-key", map);
+   req.push("MULTI");
+   req.push("LRANGE", "rpush-key", 0, -1);
+   req.push("HGETALL", "hset-key");
+   req.push("EXEC");
+   req.push("QUIT");
+
+   std::tuple<
+      aedis::ignore, // auth
+      aedis::ignore, // hello
+      aedis::ignore, // rpush
+      aedis::ignore, // hset
+      aedis::ignore, // multi
+      aedis::ignore, // lrange
+      aedis::ignore, // hgetall
+      std::tuple<optional<std::vector<int>>, optional<std::map<std::string, int>>>, // exec
+      aedis::ignore  // quit
+   > resp;
+
+   net::io_context ioc;
+   connection db{ioc};
+   db.async_exec("127.0.0.1", "6379", req, aedis::adapt(resp),
+      [](auto ec, auto) { std::cout << ec.message() << std::endl; });
+   ioc.run();
+
+   print(std::get<0>(std::get<7>(resp)).value());
+   print(std::get<1>(std::get<7>(resp)).value());
+}

examples/echo_server.cpp

@@ -0,0 +1,65 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <string>
+#include <iostream>
+#include <boost/asio.hpp>
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+using aedis::adapt;
+using aedis::resp3::request;
+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 connection = aedis::connection<tcp_socket>;
+
+net::awaitable<void> echo_loop(tcp_socket socket, std::shared_ptr<connection> db)
+{
+   try {
+      request req;
+      std::tuple<std::string> resp;
+      std::string buffer;
+
+      for (;;) {
+         auto n = co_await net::async_read_until(socket, net::dynamic_buffer(buffer, 1024), "\n");
+         req.push("PING", buffer);
+         co_await db->async_exec(req, adapt(resp));
+         co_await net::async_write(socket, net::buffer(std::get<0>(resp)));
+         std::get<0>(resp).clear();
+         req.clear();
+         buffer.erase(0, n);
+      }
+   } catch (std::exception const& e) {
+      std::cout << e.what() << std::endl;
+   }
+}
+
+net::awaitable<void> listener()
+{
+   auto ex = co_await net::this_coro::executor;
+   auto db = std::make_shared<connection>(ex);
+   db->async_run("127.0.0.1", "6379", net::detached);
+
+   request req;
+   req.push("HELLO", 3);
+   co_await db->async_exec(req);
+
+   tcp_acceptor acc(ex, {net::ip::tcp::v4(), 55555});
+   for (;;)
+      net::co_spawn(ex, echo_loop(co_await acc.async_accept(), db), net::detached);
+}
+
+int main()
+{
+   try {
+      net::io_context ioc;
+      co_spawn(ioc, listener(), net::detached);
+      ioc.run();
+   } catch (std::exception const& e) {
+      std::cerr << e.what() << std::endl;
+   }
+}

examples/high_level/aggregates.cpp

@@ -1,110 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <map>
-#include <set>
-#include <vector>
-#include <iostream>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using aedis::resp3::node;
-using aedis::adapter::adapt;
-using aedis::redis::command;
-using client_type = aedis::generic::client<net::ip::tcp::socket, command>;
-using response_type = std::vector<node<std::string>>;
-using adapter_type = aedis::adapter::adapter_t<response_type>;
-
-// Prints aggregates that don't contain any nested aggregates.
-void print_aggregate(response_type const& v)
-{
-   auto const m = element_multiplicity(v.front().data_type);
-   for (auto i = 0lu; i < m * v.front().aggregate_size; ++i)
-      std::cout << v[i + 1].value << " ";
-   std::cout << "\n";
-}
-
-struct receiver {
-public:
-   receiver(client_type& db)
-   : adapter_{adapt(resp_)}
-   , db_{&db} {}
-
-   void on_resp3(command cmd, node<boost::string_view> const& nd, boost::system::error_code& ec)
-   {
-      adapter_(nd, ec);
-   }
-
-   void on_read(command cmd)
-   {
-      switch (cmd) {
-         case command::hello:
-         {
-            std::map<std::string, std::string> map
-               { {"key1", "value1"}
-               , {"key2", "value2"}
-               , {"key3", "value3"}
-               };
-
-            std::vector<int> vec
-               {1, 2, 3, 4, 5, 6};
-
-            std::set<std::string> set
-               {"one", "two", "three", "four"};
-
-            // Sends the stl containers.
-            db_->send_range(command::hset, "hset-key", map);
-            db_->send_range(command::rpush, "rpush-key", vec);
-            db_->send_range(command::sadd, "sadd-key", set);
-
-            // Retrieves the containers.
-            db_->send(command::hgetall, "hset-key");
-            db_->send(command::lrange, "rpush-key", 0, -1);
-            db_->send(command::smembers, "sadd-key");
-            db_->send(command::quit);
-         } break;
-
-         case command::lrange:
-         case command::smembers:
-         case command::hgetall:
-         print_aggregate(resp_);
-         break;
-
-         default:;
-      }
-
-      resp_.clear();
-   }
-
-   void on_write(std::size_t n)
-   { 
-      std::cout << "Number of bytes written: " << n << std::endl;
-   }
-
-   void on_push() { }
-
-private:
-   response_type resp_;
-   adapter_type adapter_;
-   client_type* db_;
-};
-
-int main()
-{
-   net::io_context ioc;
-   client_type db{ioc.get_executor()};
-   receiver recv{db};
-
-   db.async_run(
-      recv,
-      {net::ip::make_address("127.0.0.1"), 6379},
-      [](auto ec){ std::cout << ec.message() << std::endl;});
-
-   ioc.run();
-}

examples/high_level/chat_room.cpp

@@ -1,125 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <vector>
-#include <iostream>
-
-#include <boost/asio/signal_set.hpp>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-#include "user_session.hpp"
-
-namespace net = boost::asio;
-using aedis::resp3::node;
-using aedis::adapter::adapt;
-using aedis::redis::command;
-using aedis::generic::client;
-using aedis::user_session;
-using aedis::user_session_base;
-using client_type = client<net::ip::tcp::socket, command>;
-using response_type = std::vector<node<std::string>>;
-using adapter_type = aedis::adapter::adapter_t<response_type>;
-
-class receiver {
-public:
-   receiver(std::shared_ptr<client_type> db)
-   : adapter_{adapt(resp_)}
-   , db_{db}
-   {}
-
-   void on_resp3(command cmd, node<boost::string_view> const& nd, boost::system::error_code& ec)
-   {
-      adapter_(nd, ec);
-   }
-
-   void on_read(command cmd)
-   {
-      switch (cmd) {
-         case command::hello:
-         db_->send(command::subscribe, "channel");
-         break;
-
-         case command::incr:
-         std::cout << "Messages so far: " << resp_.front().value << std::endl;
-         break;
-
-         default:;
-      }
-
-      resp_.clear();
-   }
-
-   void on_write(std::size_t n)
-   { 
-      std::cout << "Number of bytes written: " << n << std::endl;
-   }
-
-   void on_push()
-   {
-      for (auto& session: sessions_)
-         session->deliver(resp_.at(3).value);
-
-      resp_.clear();
-   }
-
-   auto add(std::shared_ptr<user_session_base> session)
-      { sessions_.push_back(session); }
-
-private:
-   response_type resp_;
-   adapter_type adapter_;
-   std::shared_ptr<client_type> db_;
-   std::vector<std::shared_ptr<user_session_base>> sessions_;
-};
-
-net::awaitable<void>
-listener(
-    std::shared_ptr<net::ip::tcp::acceptor> acc,
-    std::shared_ptr<client_type> db,
-    std::shared_ptr<receiver> recv)
-{
-   auto on_user_msg = [db](std::string const& msg)
-   {
-      db->send(command::publish, "channel", msg);
-      db->send(command::incr, "message-counter");
-   };
-
-   for (;;) {
-      auto socket = co_await acc->async_accept(net::use_awaitable);
-      auto session = std::make_shared<user_session>(std::move(socket));
-      session->start(on_user_msg);
-      recv->add(session);
-   }
-}
-
-int main()
-{
-   try {
-      net::io_context ioc{1};
-
-      auto db = std::make_shared<client_type>(ioc.get_executor());
-      auto recv = std::make_shared<receiver>(db);
-
-      db->async_run(
-          *recv,
-          {net::ip::make_address("127.0.0.1"), 6379},
-          [](auto ec){ std::cout << ec.message() << std::endl;});
-
-      auto endpoint = net::ip::tcp::endpoint{net::ip::tcp::v4(), 55555};
-      auto acc = std::make_shared<net::ip::tcp::acceptor>(ioc.get_executor(), endpoint);
-      co_spawn(ioc, listener(acc, db, recv), net::detached);
-
-      net::signal_set signals(ioc.get_executor(), SIGINT, SIGTERM);
-      signals.async_wait([&] (auto, int) { ioc.stop(); });
-
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}

examples/high_level/echo_server.cpp

@@ -1,121 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <iostream>
-#include <queue>
-#include <vector>
-#include <string>
-
-#include <boost/asio/signal_set.hpp>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-#include "user_session.hpp"
-
-namespace net = boost::asio;
-using aedis::resp3::node;
-using aedis::adapter::adapt;
-using aedis::redis::command;
-using aedis::generic::client;
-using aedis::user_session;
-using aedis::user_session_base;
-using client_type = client<net::ip::tcp::socket, command>;
-using response_type = std::vector<node<std::string>>;
-using adapter_type = aedis::adapter::adapter_t<response_type>;
-
-class myreceiver {
-public:
-   myreceiver()
-   : adapter_{adapt(resp_)}
-   {}
-
-   void on_resp3(command cmd, node<boost::string_view> const& nd, boost::system::error_code& ec)
-   {
-      adapter_(nd, ec);
-   }
-
-   void on_write(std::size_t n)
-   { 
-      std::cout << "Number of bytes written: " << n << std::endl;
-   }
-
-   void on_push() { }
-
-   void on_read(command cmd)
-   {
-      switch (cmd) {
-         case command::ping:
-         sessions_.front()->deliver(resp_.front().value);
-         sessions_.pop();
-         break;
-
-         case command::incr:
-         std::cout << "Echos so far: " << resp_.front().value << std::endl;
-         break;
-
-         default: /* Ignore */;
-      }
-
-      resp_.clear();
-   }
-
-   void add_user_session(std::shared_ptr<user_session_base> session)
-      { sessions_.push(session); }
-
-private:
-   response_type resp_;
-   adapter_type adapter_;
-   std::queue<std::shared_ptr<user_session_base>> sessions_;
-};
-
-net::awaitable<void>
-listener(
-    std::shared_ptr<net::ip::tcp::acceptor> acc,
-    std::shared_ptr<client_type> db,
-    std::shared_ptr<myreceiver> recv)
-{
-   for (;;) {
-      auto socket = co_await acc->async_accept(net::use_awaitable);
-      auto session = std::make_shared<user_session>(std::move(socket));
-
-      auto on_user_msg = [db, recv, session](std::string const& msg)
-      {
-         db->send(command::ping, msg);
-         db->send(command::incr, "echo-counter");
-         recv->add_user_session(session);
-      };
-
-      session->start(on_user_msg);
-   }
-}
-
-int main()
-{
-   try {
-      net::io_context ioc;
-
-      auto db = std::make_shared<client_type>(ioc.get_executor());
-      auto recv = std::make_shared<myreceiver>();
-
-      db->async_run(
-          *recv,
-          {net::ip::make_address("127.0.0.1"), 6379},
-          [](auto ec){ std::cout << ec.message() << std::endl;});
-
-      auto endpoint = net::ip::tcp::endpoint{net::ip::tcp::v4(), 55555};
-      auto acc = std::make_shared<net::ip::tcp::acceptor>(ioc.get_executor(), endpoint);
-      co_spawn(ioc, listener(acc, db, recv), net::detached);
-
-      net::signal_set signals(ioc.get_executor(), SIGINT, SIGTERM);
-      signals.async_wait([&] (auto, int) { ioc.stop(); });
-
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}

examples/high_level/intro.cpp

@@ -1,76 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <string>
-#include <iostream>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-using aedis::resp3::node;
-using aedis::redis::command;
-using aedis::generic::client;
-using aedis::adapter::adapt;
-using client_type = client<net::ip::tcp::socket, command>;
-using response_type = node<std::string>;
-using adapter_type = aedis::adapter::adapter_t<response_type>;
-
-struct myreceiver {
-public:
-   myreceiver(client_type& db)
-   : adapter_{adapt(resp_)}
-   , db_{&db} {}
-
-   void on_resp3(command cmd, node<boost::string_view> const& nd, boost::system::error_code& ec)
-   {
-      adapter_(nd, ec);
-   }
-
-   void on_read(command cmd)
-   {
-      switch (cmd) {
-         case command::hello:
-         db_->send(command::ping, "O rato roeu a roupa do rei de Roma");
-         db_->send(command::incr, "intro-counter");
-         db_->send(command::set, "intro-key", "Três pratos de trigo para três tigres");
-         db_->send(command::get, "intro-key");
-         db_->send(command::quit);
-         break;
-
-         default:
-         std::cout << resp_.value << std::endl;
-      }
-   }
-
-   void on_write(std::size_t n)
-   { 
-      std::cout << "Number of bytes written: " << n << std::endl;
-   }
-
-   void on_push() { }
-
-private:
-   response_type resp_;
-   adapter_type adapter_;
-   client_type* db_;
-};
-
-int main()
-{
-   net::io_context ioc;
-   client_type db(ioc.get_executor());
-   myreceiver recv{db};
-
-   db.async_run(
-       recv,
-       {net::ip::make_address("127.0.0.1"), 6379},
-       [](auto ec){ std::cout << ec.message() << std::endl;});
-
-   ioc.run();
-}
-

examples/high_level/serialization.cpp

@@ -1,183 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <string>
-#include <iostream>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-// Arbitrary struct to de/serialize.
-struct mystruct {
-  int a;
-  int b;
-};
-
-namespace net = boost::asio;
-namespace adapter = aedis::adapter;
-using aedis::resp3::node;
-using aedis::adapter::adapters_tuple_t;
-using aedis::adapter::make_adapters_tuple;
-using aedis::adapter::get;
-using aedis::redis::command;
-using aedis::generic::client;
-using client_type = client<net::ip::tcp::socket, command>;
-using responses_tuple_type =
-   std::tuple<
-      boost::optional<mystruct>,
-      std::list<mystruct>,
-      std::set<mystruct>,
-      std::map<std::string, mystruct>
-   >;
-using adapters_tuple_type = adapters_tuple_t<responses_tuple_type>;
-
-std::ostream& operator<<(std::ostream& os, mystruct const& obj)
-{
-   os << "a: " << obj.a << ", b: " << obj.b;
-   return os;
-}
-
-bool operator<(mystruct const& a, mystruct const& b)
-{
-   return std::tie(a.a, a.b) < std::tie(b.a, b.b);
-}
-
-// Dumy serialization.
-void to_bulk(std::string& to, mystruct const& obj)
-{
-   aedis::resp3::to_bulk(to, "Dummy serializaiton string.");
-}
-
-// Dummy deserialization.
-void from_string(mystruct& obj, boost::string_view sv, boost::system::error_code& ec)
-{
-   obj.a = 1;
-   obj.b = 2;
-}
-
-class receiver  {
-public:
-   receiver(client_type& db)
-   : adapters_(make_adapters_tuple(resps_))
-   , db_{&db} {}
-
-   void
-   on_resp3(
-      command cmd,
-      node<boost::string_view> const& nd,
-      boost::system::error_code& ec)
-   {
-      switch (cmd) {
-         case command::get:      adapter::get<boost::optional<mystruct>>(adapters_)(nd, ec); break;
-         case command::lrange:   adapter::get<std::list<mystruct>>(adapters_)(nd, ec); break;
-         case command::smembers: adapter::get<std::set<mystruct>>(adapters_)(nd, ec); break;
-         case command::hgetall:  adapter::get<std::map<std::string, mystruct>>(adapters_)(nd, ec); break;
-         default:; // Ignore
-      }
-   }
-
-   void on_read(command cmd)
-   {
-      std::cout << cmd << "\n";
-
-      switch (cmd) {
-         case command::hello:
-         {
-            mystruct var{1, 2};
-
-            std::map<std::string, mystruct> map
-               { {"key1", {1, 2}}
-               , {"key2", {3, 4}}
-               , {"key3", {5, 6}}};
-
-            std::vector<mystruct> vec
-               {{1, 2}, {3, 4}, {5, 6}};
-
-            std::set<std::string> set
-               {{1, 2}, {3, 4}, {5, 6}};
-
-            // Sends
-            db_->send(command::set, "serialization-var-key", var, "EX", "2");
-            db_->send_range(command::hset, "serialization-hset-key", map);
-            db_->send_range(command::rpush, "serialization-rpush-key", vec);
-            db_->send_range(command::sadd, "serialization-sadd-key", set);
-
-            // Retrieves
-            db_->send(command::get, "serialization-var-key");
-            db_->send(command::hgetall, "serialization-hset-key");
-            db_->send(command::lrange, "serialization-rpush-key", 0, -1);
-            db_->send(command::smembers, "serialization-sadd-key");
-         } break;
-
-         case command::get:
-         {
-            if (std::get<boost::optional<mystruct>>(resps_).has_value()) {
-               std::cout << std::get<boost::optional<mystruct>>(resps_).value() << "\n\n";
-               std::get<boost::optional<mystruct>>(resps_).reset();
-            } else {
-               std::cout << "Expired." << "\n";
-            }
-         } break;
-
-         case command::lrange:
-         for (auto const& e: std::get<std::list<mystruct>>(resps_))
-            std::cout << e << "\n";
-         std::cout << "\n";
-         std::get<std::list<mystruct>>(resps_).clear();
-         break;
-
-         case command::smembers:
-         for (auto const& e: std::get<std::set<mystruct>>(resps_))
-            std::cout << e << "\n";
-         std::cout << "\n";
-         std::get<std::set<mystruct>>(resps_).clear();
-         break;
-
-         case command::hgetall:
-         for (auto const& e: std::get<std::map<std::string, mystruct>>(resps_))
-            std::cout << e.first << ", " << e.second << std::endl;
-         std::cout << "\n";
-         std::get<std::map<std::string, mystruct>>(resps_).clear();
-         break;
-
-         default:;
-      }
-   }
-
-   void on_write(std::size_t n)
-   { 
-      std::cout << "Number of bytes written: " << n << std::endl;
-   }
-
-   void on_push() { }
-
-private:
-   responses_tuple_type resps_;
-   adapters_tuple_type adapters_;
-   client_type* db_;
-};
-
-int main()
-{
-   net::io_context ioc;
-   client_type db(ioc.get_executor());
-   receiver recv{db};
-
-   db.async_run(
-      recv,
-      {net::ip::make_address("127.0.0.1"), 6379},
-      [](auto ec){ std::cout << ec.message() << std::endl;});
-
-   net::steady_timer tm{ioc, std::chrono::seconds{3}};
-
-   tm.async_wait([&db](auto ec){
-       db.send(command::get, "serialization-var-key");
-       db.send(command::quit);
-   });
-
-   ioc.run();
-}

examples/high_level/stl_containers.cpp

@@ -1,127 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <map>
-#include <vector>
-#include <iostream>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-namespace adapter = aedis::adapter;
-using aedis::resp3::node;
-using aedis::redis::command;
-using aedis::generic::client;
-using aedis::adapter::adapt;
-using aedis::adapter::adapters_tuple_t;
-using aedis::adapter::make_adapters_tuple;
-using client_type = client<net::ip::tcp::socket, command>;
-using responses_tuple_type =
-   std::tuple<
-      std::list<int>,
-      boost::optional<std::set<std::string>>,
-      std::vector<node<std::string>>
-   >;
-using adapters_tuple_type = adapters_tuple_t<responses_tuple_type>;
-
-template <class Container>
-void print_and_clear(Container& cont)
-{
-   std::cout << "\n";
-   for (auto const& e: cont) std::cout << e << " ";
-   std::cout << "\n";
-   cont.clear();
-}
-
-class myreceiver {
-public:
-   myreceiver(client_type& db)
-   : adapters_(make_adapters_tuple(resps_))
-   , db_{&db} {}
-
-   void
-   on_resp3(
-      command cmd,
-      node<boost::string_view> const& nd,
-      boost::system::error_code& ec)
-   {
-      switch (cmd) {
-         case command::lrange:   adapter::get<std::list<int>>(adapters_)(nd, ec); break;
-         case command::smembers: adapter::get<boost::optional<std::set<std::string>>>(adapters_)(nd, ec); break;
-         default:;
-      }
-   }
-
-   void on_read(command cmd)
-   {
-      switch (cmd) {
-         case command::hello:
-         {
-            std::map<std::string, std::string> map
-               { {"key1", "value1"}
-               , {"key2", "value2"}
-               , {"key3", "value3"}
-               };
-
-            std::vector<int> vec
-               {1, 2, 3, 4, 5, 6};
-
-            std::set<std::string> set
-               {"one", "two", "three", "four"};
-
-            // Sends the stl containers.
-            db_->send_range(command::hset, "hset-key", map);
-            db_->send_range(command::rpush, "rpush-key", vec);
-            db_->send_range(command::sadd, "sadd-key", set);
-
-            //_ Retrieves the containers.
-            db_->send(command::hgetall, "hset-key");
-            db_->send(command::lrange, "rpush-key", 0, -1);
-            db_->send(command::smembers, "sadd-key");
-            db_->send(command::quit);
-         } break;
-
-         case command::lrange:
-         print_and_clear(std::get<std::list<int>>(resps_));
-         break;
-
-         case command::smembers:
-         print_and_clear(std::get<boost::optional<std::set<std::string>>>(resps_).value());
-         break;
-
-         default:;
-      }
-   }
-
-   void on_write(std::size_t n)
-   { 
-      std::cout << "Number of bytes written: " << n << std::endl;
-   }
-
-   void on_push() { }
-
-private:
-   responses_tuple_type resps_;
-   adapters_tuple_type adapters_;
-   client_type* db_;
-};
-
-int main()
-{
-   net::io_context ioc;
-   client_type db{ioc.get_executor()};
-   myreceiver recv{db};
-
-   db.async_run(
-       recv,
-       {net::ip::make_address("127.0.0.1"), 6379},
-       [](auto ec){ std::cout << ec.message() << std::endl;});
-
-   ioc.run();
-}
-

examples/high_level/subscriber.cpp

@@ -1,95 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres at gmail dot com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <iostream>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-
-using aedis::resp3::node;
-using aedis::sentinel::command;
-using aedis::generic::client;
-using aedis::adapter::adapt;
-using client_type = client<net::ip::tcp::socket, command>;
-using response_type = std::vector<node<std::string>>;
-using adapter_type = aedis::adapter::adapter_t<response_type>;
-
-/* In this example we send a subscription to a channel and start
- * reading server side messages indefinitely.
- *
- * After starting the example you can test it by sending messages with
- * redis-cli like this
- *
- *    $ redis-cli -3
- *    127.0.0.1:6379> PUBLISH channel1 some-message
- *    (integer) 3
- *    127.0.0.1:6379>
- *
- * The messages will then appear on the terminal you are running the
- * example.
- */
-
-class myreceiver {
-public:
-   myreceiver(client_type& db)
-   : adapter_{adapt(resp_)}
-   , db_{&db} {}
-
-   void on_resp3(command cmd, node<boost::string_view> const& nd, boost::system::error_code& ec)
-   {
-      adapter_(nd, ec);
-   }
-
-   void on_read(command cmd)
-   {
-      switch (cmd) {
-         case command::hello:
-         db_->send(command::subscribe, "channel1", "channel2");
-         break;
-         default:;
-      }
-
-      resp_.clear();
-   }
-
-   void on_write(std::size_t n)
-   { 
-      std::cout << "Number of bytes written: " << n << std::endl;
-   }
-
-   void on_push()
-   {
-      std::cout
-         << "Event: " << resp_.at(1).value << "\n"
-         << "Channel: " << resp_.at(2).value << "\n"
-         << "Message: " << resp_.at(3).value << "\n"
-         << std::endl;
-
-      resp_.clear();
-   }
-
-private:
-   response_type resp_;
-   adapter_type adapter_;
-   client_type* db_;
-};
-
-int main()
-{
-   net::io_context ioc;
-   client_type db{ioc.get_executor()};
-   myreceiver recv{db};
-
-   db.async_run(
-      recv,
-      {net::ip::make_address("127.0.0.1"), 6379},
-      [](auto ec){ std::cout << ec.message() << std::endl;});
-
-   ioc.run();
-}

examples/high_level/user_session.hpp

@@ -1,97 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#pragma once
-
-#include <functional>
-
-#include <boost/asio/awaitable.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/redirect_error.hpp>
-
-// An example user session.
-
-namespace aedis
-{
-
-// Base class for user sessions.
-struct user_session_base {
-  virtual ~user_session_base() {}
-  virtual void deliver(std::string const& msg) = 0;
-};
-
-class user_session:
-   public user_session_base,
-   public std::enable_shared_from_this<user_session> {
-public:
-   user_session(boost::asio::ip::tcp::socket socket)
-   : socket_(std::move(socket))
-   , timer_(socket_.get_executor())
-      { timer_.expires_at(std::chrono::steady_clock::time_point::max()); }
-
-   void start(std::function<void(std::string const&)> on_msg)
-   {
-      co_spawn(socket_.get_executor(),
-          [self = shared_from_this(), on_msg]{ return self->reader(on_msg); },
-          boost::asio::detached);
-
-      co_spawn(socket_.get_executor(),
-          [self = shared_from_this()]{ return self->writer(); },
-          boost::asio::detached);
-   }
-
-   void deliver(std::string const& msg)
-   {
-      write_msgs_.push_back(msg);
-      timer_.cancel_one();
-   }
-
-private:
-   boost::asio::awaitable<void>
-   reader(std::function<void(std::string const&)> on_msg)
-   {
-      try {
-         for (std::string msg;;) {
-            auto const n = co_await boost::asio::async_read_until(socket_, boost::asio::dynamic_buffer(msg, 1024), "\n", boost::asio::use_awaitable);
-            on_msg(msg);
-            msg.erase(0, n);
-         }
-      } catch (std::exception&) {
-         stop();
-      }
-   }
-
-   boost::asio::awaitable<void> writer()
-   {
-      try {
-         while (socket_.is_open()) {
-            if (write_msgs_.empty()) {
-               boost::system::error_code ec;
-               co_await timer_.async_wait(boost::asio::redirect_error(boost::asio::use_awaitable, ec));
-            } else {
-               co_await boost::asio::async_write(socket_, boost::asio::buffer(write_msgs_.front()), boost::asio::use_awaitable);
-               write_msgs_.pop_front();
-            }
-         }
-      } catch (std::exception&) {
-        stop();
-      }
-   }
-
-   void stop()
-   {
-      socket_.close();
-      timer_.cancel();
-   }
-
-   boost::asio::ip::tcp::socket socket_;
-   boost::asio::steady_timer timer_;
-   std::deque<std::string> write_msgs_;
-};
-
-} // aedis

examples/intro.cpp

@@ -0,0 +1,37 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <tuple>
+#include <string>
+#include <boost/asio.hpp>
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+
+using aedis::adapt;
+using aedis::resp3::request;
+using connection = aedis::connection<>;
+
+int main()
+{
+   request req;
+   req.push("HELLO", 3);
+   req.push("PING");
+   req.push("QUIT");
+
+   std::tuple<aedis::ignore, std::string, aedis::ignore> resp;
+
+   net::io_context ioc;
+
+   connection db{ioc};
+   db.async_exec("127.0.0.1", "6379", req, adapt(resp),
+      [](auto ec, auto) { std::cout << ec.message() << std::endl; });
+
+   ioc.run();
+
+   std::cout << std::get<1>(resp) << std::endl;
+}

examples/low_level/adapter.cpp

@@ -1,65 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres.gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <iostream>
-
-#include <boost/asio/use_awaitable.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/co_spawn.hpp>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-namespace resp3 = aedis::resp3;
-
-using aedis::redis::command;
-using aedis::generic::make_serializer;
-using net::ip::tcp;
-using net::write;
-using net::buffer;
-using net::dynamic_buffer;
-using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
-
-net::awaitable<void> example()
-{
-   auto ex = co_await net::this_coro::executor;
-
-   tcp::resolver resv{ex};
-   auto const res = resv.resolve("127.0.0.1", "6379");
-   tcp_socket socket{ex};
-   co_await socket.async_connect(*std::begin(res));
-
-   std::string request, buffer;
-
-   auto sr = make_serializer(request);
-   sr.push(command::hello, 3);
-   sr.push(command::ping, "Some message.");
-   sr.push(command::quit);
-   co_await net::async_write(socket, net::buffer(request));
-
-   auto adapter = [](resp3::node<boost::string_view> const& nd, boost::system::error_code&)
-   {
-      std::cout << nd << std::endl;
-   };
-
-   co_await resp3::async_read(socket, dynamic_buffer(buffer)); // hello
-   co_await resp3::async_read(socket, dynamic_buffer(buffer), adapter);
-   co_await resp3::async_read(socket, dynamic_buffer(buffer)); // quit
-}
-
-int main()
-{
-   try {
-      net::io_context ioc;
-      net::co_spawn(ioc, example(), net::detached);
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}
-

examples/low_level/async_intro.cpp

@@ -1,78 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres.gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <iostream>
-
-#include <boost/asio/use_awaitable.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/co_spawn.hpp>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-namespace resp3 = aedis::resp3;
-
-using aedis::redis::command;
-using aedis::adapter::adapt;
-using aedis::generic::make_serializer;
-using net::ip::tcp;
-using net::write;
-using net::buffer;
-using net::dynamic_buffer;
-using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
-using response_type = std::tuple<std::string, boost::optional<std::string>>;
-
-net::awaitable<void> example()
-{
-   auto ex = co_await net::this_coro::executor;
-
-   tcp::resolver resv{ex};
-   auto const res = resv.resolve("127.0.0.1", "6379");
-   tcp_socket socket{ex};
-   co_await socket.async_connect(*std::begin(res));
-
-   std::string request;
-   auto sr = make_serializer(request);
-   sr.push(command::hello, 3);
-   sr.push(command::multi);
-   sr.push(command::ping, "Some message.");
-   sr.push(command::set, "low-level-key", "some content", "EX", "2");
-   sr.push(command::exec);
-   sr.push(command::quit);
-   co_await net::async_write(socket, buffer(request));
-
-   std::tuple<std::string, boost::optional<std::string>> response;
-
-   std::string buffer;
-   co_await resp3::async_read(socket, dynamic_buffer(buffer));
-   co_await resp3::async_read(socket, dynamic_buffer(buffer)); // multi
-   co_await resp3::async_read(socket, dynamic_buffer(buffer)); // ping
-   co_await resp3::async_read(socket, dynamic_buffer(buffer)); // set
-   co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(response));
-   co_await resp3::async_read(socket, dynamic_buffer(buffer));
-
-   std::cout
-      << "Ping: " << std::get<0>(response) << "\n"
-      << "Get (has_value): " << std::get<1>(response).has_value()
-      << std::endl;
-
-   if (std::get<1>(response).has_value())
-      std::cout << "Get (value): " << std::get<1>(response).value() << std::endl;
-}
-
-int main()
-{
-   try {
-      net::io_context ioc;
-      net::co_spawn(ioc, example(), net::detached);
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}
-

examples/low_level/subscriber.cpp

@@ -1,68 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres.gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <iostream>
-
-#include <boost/asio/use_awaitable.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/co_spawn.hpp>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-namespace resp3 = aedis::resp3;
-
-using aedis::resp3::node;
-using aedis::redis::command;
-using aedis::adapter::adapt;
-using aedis::generic::make_serializer;
-using net::ip::tcp;
-using net::write;
-using net::buffer;
-using net::dynamic_buffer;
-using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
-using response_type = std::tuple<std::string, boost::optional<std::string>>;
-
-net::awaitable<void> example()
-{
-   auto ex = co_await net::this_coro::executor;
-
-   tcp::resolver resv{ex};
-   auto const res = resv.resolve("127.0.0.1", "6379");
-   tcp_socket socket{ex};
-   co_await socket.async_connect(*std::begin(res));
-
-   std::string request;
-   auto sr = make_serializer(request);
-   sr.push(command::hello, 3);
-   sr.push(command::subscribe, "channel1", "channel2");
-   co_await net::async_write(socket, buffer(request));
-
-   // Ignores the response to hello.
-   std::string buffer;
-   co_await resp3::async_read(socket, dynamic_buffer(buffer));
-
-   for (std::vector<node<std::string>> resp;;) {
-      co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(resp));
-      for (auto const& e: resp)
-         std::cout << e << std::endl;
-      resp.clear();
-   }
-}
-
-int main()
-{
-   try {
-      net::io_context ioc;
-      net::co_spawn(ioc, example(), net::detached);
-      ioc.run();
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}
-

examples/low_level/sync_intro.cpp

@@ -1,68 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <iostream>
-#include <string>
-
-#include <boost/asio/connect.hpp>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-namespace resp3 = aedis::resp3;
-
-using aedis::redis::command;
-using aedis::generic::make_serializer;
-using aedis::adapter::adapt;
-using net::dynamic_buffer;
-using net::ip::tcp;
-
-using hello_type = std::tuple<
-   std::string, std::string,
-   std::string, std::string,
-   std::string, int,
-   std::string, int,
-   std::string, std::string,
-   std::string, std::string,
-   std::string, std::vector<std::string>>;
-
-int main()
-{
-   try {
-      net::io_context ioc;
-      tcp::resolver resv{ioc};
-      auto const res = resv.resolve("127.0.0.1", "6379");
-      tcp::socket socket{ioc};
-      net::connect(socket, res);
-
-      // Creates and sends a request to redis.
-      std::string request;
-      auto sr = make_serializer(request);
-      sr.push(command::hello, 3);
-      sr.push(command::ping);
-      sr.push(command::quit);
-      net::write(socket, net::buffer(request));
-
-      // Responses
-      std::string resp;
-      hello_type hello;
-
-      // Reads the responses to all commands in the request.
-      std::string buffer;
-      resp3::read(socket, dynamic_buffer(buffer), adapt(hello)); // hello
-      resp3::read(socket, dynamic_buffer(buffer), adapt(resp));
-      resp3::read(socket, dynamic_buffer(buffer)); // quit (ignored)
-
-      std::cout << std::get<0>(hello) << ": " << std::get<1>(hello) << std::endl;
-      std::cout << "Ping: " << resp << std::endl;
-
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-      exit(EXIT_FAILURE);
-   }
-}

examples/print.hpp

@@ -0,0 +1,56 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <map>
+#include <set>
+#include <vector>
+#include <string>
+#include <iostream>
+
+#include <aedis/resp3/type.hpp>
+#include <aedis/resp3/node.hpp>
+
+// Some functions to make the examples less repetitive.
+
+namespace net = boost::asio;
+using aedis::resp3::node;
+using aedis::adapter::adapt;
+using aedis::adapter::adapter_t;
+
+void print_aggr(std::vector<aedis::resp3::node<std::string>>& v)
+{
+   auto const m = aedis::resp3::element_multiplicity(v.front().data_type);
+   for (auto i = 0lu; i < m * v.front().aggregate_size; ++i)
+      std::cout << v[i + 1].value << " ";
+   std::cout << "\n";
+   v.clear();
+}
+
+template <class T>
+void print(std::vector<T> const& cont)
+{
+   for (auto const& e: cont) std::cout << e << " ";
+   std::cout << "\n";
+}
+
+template <class T>
+void print(std::set<T> const& cont)
+{
+   for (auto const& e: cont) std::cout << e << "\n";
+}
+
+template <class T, class U>
+void print(std::map<T, U> const& cont)
+{
+   for (auto const& e: cont)
+      std::cout << e.first << ": " << e.second << "\n";
+}
+
+void print(std::string const& e)
+{
+   std::cout << e << std::endl;
+}
+

examples/serialization.cpp

@@ -0,0 +1,108 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <set>
+#include <iterator>
+#include <string>
+#include <boost/json.hpp>
+#include <boost/json/src.hpp>
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+#include "print.hpp"
+
+namespace net = boost::asio;
+using aedis::resp3::request;
+using connection = aedis::connection<>;
+using namespace boost::json;
+
+struct user {
+   std::string name;
+   std::string age;
+   std::string country;
+};
+
+void tag_invoke(value_from_tag, value& jv, user const& u)
+{
+   jv =
+   { {"name", u.name}
+   , {"age", u.age}
+   , {"country", u.country}
+   };
+}
+
+template<class T>
+void extract(object const& obj, T& t, boost::string_view key)
+{
+    t = value_to<T>(obj.at(key));
+}
+
+user tag_invoke(value_to_tag<user>, value const& jv)
+{
+    user u;
+    object const& obj = jv.as_object();
+    extract(obj, u.name, "name");
+    extract(obj, u.age, "age");
+    extract(obj, u.country, "country");
+    return u;
+}
+
+// Serializes
+void to_bulk(std::string& to, user const& u)
+{
+   aedis::resp3::to_bulk(to, serialize(value_from(u)));
+}
+
+// Deserializes
+void from_bulk(user& u, boost::string_view sv, boost::system::error_code& ec)
+{
+   value jv = parse(sv);
+   u = value_to<user>(jv);
+}
+
+std::ostream& operator<<(std::ostream& os, user const& u)
+{
+   os << "Name: " << u.name << "\n"
+      << "Age: " << u.age << "\n"
+      << "Country: " << u.country;
+
+   return os;
+}
+
+bool operator<(user const& a, user const& b)
+{
+   return std::tie(a.name, a.age, a.country) < std::tie(b.name, b.age, b.country);
+}
+
+int main()
+{
+   net::io_context ioc;
+   connection db{ioc};
+
+   // Request that sends the containers.
+   std::set<user> users
+      { {"Joao", "56", "Brazil"}
+      , {"Serge", "60", "France"}
+      };
+
+   request req;
+   req.push("HELLO", 3);
+   req.push_range("SADD", "sadd-key", users);
+   req.push("SMEMBERS", "sadd-key");
+   req.push("QUIT");
+
+   std::tuple<aedis::ignore, int, std::set<user>, std::string> resp;
+
+   db.async_exec("127.0.0.1", "6379", req, aedis::adapt(resp),
+      [](auto ec, auto) { std::cout << ec.message() << std::endl; });
+
+   ioc.run();
+
+   // Print
+   print(std::get<2>(resp));
+}

examples/subscriber.cpp

@@ -0,0 +1,63 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <boost/asio.hpp>
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+using aedis::adapt;
+using aedis::resp3::request;
+using aedis::resp3::node;
+using tcp_socket = net::use_awaitable_t<>::as_default_on_t<net::ip::tcp::socket>;
+using connection = aedis::connection<tcp_socket>;
+
+/* In this example we send a subscription to a channel and start
+ * reading server side messages indefinitely.
+ *
+ * After starting the example you can test it by sending messages with
+ * redis-cli like this
+ *
+ *    $ redis-cli -3
+ *    127.0.0.1:6379> PUBLISH channel1 some-message
+ *    (integer) 3
+ *    127.0.0.1:6379>
+ *
+ * The messages will then appear on the terminal you are running the
+ * example.
+ */
+net::awaitable<void> reader(std::shared_ptr<connection> db)
+{
+   for (std::vector<node<std::string>> resp;;) {
+      auto n = co_await db->async_read_push(adapt(resp));
+      std::cout
+         << "Size: " << n << "\n"
+         << "Event: " << resp.at(1).value << "\n"
+         << "Channel: " << resp.at(2).value << "\n"
+         << "Message: " << resp.at(3).value << "\n"
+         << std::endl;
+
+      resp.clear();
+   }
+}
+
+auto handler = [](auto ec, auto...)
+   { std::cout << ec.message() << std::endl; };
+
+int main()
+{
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc);
+   request req;
+   req.push("HELLO", 3);
+   req.push("SUBSCRIBE", "channel");
+   db->async_exec("127.0.0.1", "6379", req, adapt(), handler);
+   net::co_spawn(ioc, reader(db), net::detached);
+   ioc.run();
+}

tests/check.hpp

@@ -1,8 +1,7 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
 #include <iostream>
@@ -12,24 +11,44 @@ template <class T>
 void expect_eq(T const& a, T const& b, std::string const& msg = "")
 {
    if (a == b) {
-     std::cout << "Success: " << msg << std::endl;
+      if (!msg.empty())
+         std::cout << "Success: " << msg << std::endl;
    } else {
      std::cout << "Error: " << msg << std::endl;
      exit(EXIT_FAILURE);
    }
 }
 
-void expect_error(boost::system::error_code a, boost::system::error_condition expected = {})
+template <class T>
+void expect_neq(T const& a, T const& b, std::string const& msg = "")
+{
+   if (a != b) {
+      if (!msg.empty())
+         std::cout << "Success: " << msg << std::endl;
+   } else {
+     std::cout << "Error: " << msg << std::endl;
+     exit(EXIT_FAILURE);
+   }
+}
+
+template <class T>
+void expect_error(boost::system::error_code a, T expected = {}, std::string const& msg = "")
 {
    if (a == expected) {
       if (a)
-         std::cout << "Success: " << a.message() << " (" << a.category().name() << ")" << std::endl;
+         std::cout << "Success: " << a.message() << " (" << a.category().name() << ") " << msg << std::endl;
    } else {
-      std::cout << "Error: " << a.message() << " (" << a.category().name() << ")" << std::endl;
+      std::cout << "Error: " << a.message() << " (" << a.category().name() << ") " << msg << std::endl;
       exit(EXIT_FAILURE);
    }
 }
 
+inline
+void expect_no_error(boost::system::error_code ec, std::string const& msg)
+{
+   expect_error(ec, boost::system::error_code{}, msg);
+}
+
 template <class T>
 void check_empty(T const& t)
 {

tests/high_level.cpp

@@ -0,0 +1,391 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <iostream>
+#include <map>
+
+//#define BOOST_ASIO_ENABLE_HANDLER_TRACKING
+#include <boost/asio.hpp>
+#include <boost/system/errc.hpp>
+#include <boost/asio/experimental/as_tuple.hpp>
+
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+
+#include "check.hpp"
+
+//std::cout << "aaaa " << ec.message() << " " << cmd << " " << n << std::endl;
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+
+using aedis::resp3::request;
+using connection = aedis::connection<>;
+using error_code = boost::system::error_code;
+using net::experimental::as_tuple;
+using tcp = net::ip::tcp;
+using boost::system::error_code;
+
+auto print_read = [](auto cmd, auto n)
+{
+   std::cout << cmd << ": " << n << std::endl;
+};
+
+//----------------------------------------------------------------
+
+void test_resolve()
+{
+   connection::config cfg;
+   cfg.resolve_timeout = std::chrono::seconds{100};
+
+   net::io_context ioc;
+   connection db{ioc, cfg};
+   db.async_run("Atibaia", "6379", [](auto ec) {
+      expect_error(ec, net::error::netdb_errors::host_not_found, "test_resolve");
+   });
+
+   ioc.run();
+}
+
+//----------------------------------------------------------------
+
+void test_connect()
+{
+   connection::config cfg;
+   cfg.connect_timeout = std::chrono::seconds{100};
+
+   net::io_context ioc;
+   connection db{ioc, cfg};
+   db.async_run("127.0.0.1", "1", [](auto ec) {
+      expect_error(ec, net::error::basic_errors::connection_refused, "test_connect");
+   });
+   ioc.run();
+}
+
+//----------------------------------------------------------------
+
+// Test if quit causes async_run to exit.
+void test_quit1()
+{
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc);
+
+   request req;
+   req.push("HELLO", 3);
+   req.push("QUIT");
+   db->async_exec(req, aedis::adapt(), [](auto ec, auto r){
+      expect_no_error(ec, "test_quit1");
+   });
+
+   db->async_run("127.0.0.1", "6379", [](auto ec){
+      expect_error(ec, net::error::misc_errors::eof, "test_quit1");
+   });
+
+   ioc.run();
+}
+
+void test_quit2()
+{
+   request req;
+   req.push("HELLO", 3);
+   req.push("QUIT");
+
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc);
+   db->async_exec("127.0.0.1", "6379", req, aedis::adapt(), [](auto ec, auto n){
+      expect_error(ec, net::error::misc_errors::eof, "test_quit2");
+   });
+
+   ioc.run();
+}
+
+//----------------------------------------------------------------
+
+net::awaitable<void>
+push_consumer1(std::shared_ptr<connection> db)
+{
+   {
+      auto [ec, n] = co_await db->async_read_push(aedis::adapt(), as_tuple(net::use_awaitable));
+      expect_no_error(ec, "push_consumer1");
+   }
+
+   {
+      auto [ec, n] = co_await db->async_read_push(aedis::adapt(), as_tuple(net::use_awaitable));
+      expect_error(ec, boost::asio::experimental::channel_errc::channel_cancelled, "push_consumer1");
+   }
+}
+
+// Tests whether a push is indeed delivered.
+void test_push1()
+{
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc);
+
+   request req;
+   req.push("HELLO", 3);
+   req.push("SUBSCRIBE", "channel");
+   req.push("QUIT");
+
+   db->async_exec("127.0.0.1", "6379", req, aedis::adapt(), [](auto ec, auto r){
+      expect_error(ec, net::error::misc_errors::eof, "test_push1");
+   });
+
+   net::co_spawn(ioc.get_executor(), push_consumer1(db), net::detached);
+   ioc.run();
+}
+
+//----------------------------------------------------------------
+
+net::awaitable<void> run5(std::shared_ptr<connection> db)
+{
+   {
+      request req;
+      req.push("QUIT");
+      db->async_exec(req, aedis::adapt(), [](auto ec, auto n){
+         expect_no_error(ec, "test_quit1");
+      });
+
+      auto [ec] = co_await db->async_run("127.0.0.1", "6379", as_tuple(net::use_awaitable));
+      expect_error(ec, net::error::misc_errors::eof, "run5a");
+   }
+
+   {
+      request req;
+      req.push("QUIT");
+      db->async_exec(req, aedis::adapt(), [](auto ec, auto n){
+         expect_no_error(ec, "test_quit1");
+      });
+
+      auto [ec] = co_await db->async_run("127.0.0.1", "6379", as_tuple(net::use_awaitable));
+      expect_error(ec, net::error::misc_errors::eof, "run5a");
+   }
+
+   co_return;
+}
+
+// Test whether the client works after a reconnect.
+void test_reconnect()
+{
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc.get_executor());
+
+   net::co_spawn(ioc, run5(db), net::detached);
+   ioc.run();
+   std::cout << "Success: test_reconnect()" << std::endl;
+}
+
+// Checks whether we get idle timeout when no push reader is set.
+void test_no_push_reader1()
+{
+   connection::config cfg;
+
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc, cfg);
+
+   request req;
+   req.push("HELLO", 3);
+   req.push("SUBSCRIBE", "channel");
+
+   db->async_exec("127.0.0.1", "6379", req, aedis::adapt(), [](auto ec, auto r){
+      expect_error(ec, aedis::error::idle_timeout, "test_no_push_reader1");
+   });
+
+   ioc.run();
+}
+
+void test_no_push_reader2()
+{
+   connection::config cfg;
+
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc, cfg);
+
+   request req; // Wrong command syntax.
+   req.push("HELLO", 3);
+   req.push("SUBSCRIBE");
+
+   db->async_exec("127.0.0.1", "6379", req, aedis::adapt(), [](auto ec, auto r){
+      expect_error(ec, aedis::error::idle_timeout, "test_no_push_reader2");
+   });
+
+   ioc.run();
+}
+
+void test_no_push_reader3()
+{
+   connection::config cfg;
+
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc, cfg);
+
+   request req; // Wrong command synthax.
+   req.push("HELLO", 3);
+   req.push("PING", "Message");
+   req.push("SUBSCRIBE");
+
+   db->async_exec("127.0.0.1", "6379", req, aedis::adapt(), [](auto ec, auto r){
+      expect_error(ec, aedis::error::idle_timeout, "test_no_push_reader3");
+   });
+
+   ioc.run();
+}
+
+void test_idle()
+{
+   connection::config cfg;
+   cfg.resolve_timeout = std::chrono::seconds{1};
+   cfg.connect_timeout = std::chrono::seconds{1};
+   cfg.ping_interval = std::chrono::seconds{1};
+
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc, cfg);
+
+   request req;
+   req.push("HELLO", 3);
+   req.push("CLIENT", "PAUSE", 5000);
+
+   db->async_exec(req, aedis::adapt(), [](auto ec, auto r){
+      expect_no_error(ec, "test_idle");
+   });
+
+   db->async_run("127.0.0.1", "6379", [](auto ec){
+      expect_error(ec, aedis::error::idle_timeout, "test_idle");
+   });
+
+   ioc.run();
+}
+
+auto handler =[](auto ec, auto...)
+   { std::cout << ec.message() << std::endl; };
+
+void test_push2()
+{
+   request req1;
+   req1.push("HELLO", 3);
+   req1.push("PING", "Message1");
+
+   request req2;
+   req2.push("SUBSCRIBE", "channel");
+
+   request req3;
+   req3.push("PING", "Message2");
+   req3.push("QUIT");
+
+   std::tuple<std::string, std::string> resp;
+
+   net::io_context ioc;
+   connection db{ioc};
+   db.async_exec(req1, aedis::adapt(resp), handler);
+   db.async_exec(req2, aedis::adapt(resp), handler);
+   db.async_exec(req3, aedis::adapt(resp), handler);
+   db.async_run("127.0.0.1", "6379", [&db](auto ec, auto...) {
+      std::cout << ec.message() << std::endl;
+      db.cancel_requests();
+   });
+   ioc.run();
+}
+
+net::awaitable<void>
+push_consumer3(std::shared_ptr<connection> db)
+{
+   for (;;)
+      co_await db->async_read_push(aedis::adapt(), net::use_awaitable);
+}
+
+void test_push3()
+{
+   request req1;
+   req1.push("HELLO", 3);
+   req1.push("PING", "Message1");
+
+   request req2;
+   req2.push("SUBSCRIBE", "channel");
+
+   request req3;
+   req3.push("QUIT");
+
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc);
+   db->async_exec(req1, aedis::adapt(), handler);
+   db->async_exec(req2, aedis::adapt(), handler);
+   db->async_exec(req2, aedis::adapt(), handler);
+   db->async_exec(req1, aedis::adapt(), handler);
+   db->async_exec(req2, aedis::adapt(), handler);
+   db->async_exec(req1, aedis::adapt(), handler);
+   db->async_exec(req2, aedis::adapt(), handler);
+   db->async_exec(req2, aedis::adapt(), handler);
+   db->async_exec(req1, aedis::adapt(), handler);
+   db->async_exec(req2, aedis::adapt(), handler);
+   db->async_exec(req3, aedis::adapt(), handler);
+   db->async_run("127.0.0.1", "6379",  [db](auto ec, auto...) {
+      db->cancel_requests();
+   });
+   net::co_spawn(ioc.get_executor(), push_consumer3(db), net::detached);
+   ioc.run();
+}
+
+void test_exec_while_processing()
+{
+   request req1;
+   req1.push("HELLO", 3);
+   req1.push("PING", "Message1");
+
+   request req2;
+   req2.push("SUBSCRIBE", "channel");
+
+   request req3;
+   req3.push("QUIT");
+
+   net::io_context ioc;
+   auto db = std::make_shared<connection>(ioc);
+
+   db->async_exec(req1, aedis::adapt(), [db, &req1](auto ec, auto) {
+      db->async_exec(req1, aedis::adapt(), handler);
+   });
+
+   db->async_exec(req1, aedis::adapt(), [db, &req2](auto ec, auto) {
+      db->async_exec(req2, aedis::adapt(), handler);
+   });
+
+   db->async_exec(req2, aedis::adapt(), [db, &req2](auto ec, auto) {
+      db->async_exec(req2, aedis::adapt(), handler);
+   });
+
+   db->async_exec(req1, aedis::adapt(), [db, &req1](auto ec, auto) {
+      db->async_exec(req1, aedis::adapt(), handler);
+   });
+
+   db->async_exec(req2, aedis::adapt(), [db, &req3](auto ec, auto) {
+      db->async_exec(req3, aedis::adapt(), handler);
+   });
+
+   db->async_run("127.0.0.1", "6379", [db](auto ec, auto...) {
+      db->cancel_requests();
+   });
+   net::co_spawn(ioc.get_executor(), push_consumer3(db), net::detached);
+   ioc.run();
+   std::cout << "Success: test_exec_while_processing()" << std::endl;
+}
+
+int main()
+{
+   test_resolve();
+   test_connect();
+   test_quit1();
+   test_quit2();
+   test_push1();
+   test_push2();
+   test_push3();
+   test_no_push_reader1();
+   test_no_push_reader2();
+   test_no_push_reader3();
+   test_reconnect();
+   test_exec_while_processing();
+
+   // Must come last as it send a client pause.
+   test_idle();
+}
+

tests/intro_sync.cpp

@@ -0,0 +1,53 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <string>
+#include <iostream>
+
+#include <boost/asio/connect.hpp>
+
+#include <aedis/aedis.hpp>
+#include <aedis/src.hpp>
+
+namespace net = boost::asio;
+namespace resp3 = aedis::resp3;
+
+using aedis::resp3::request;
+using aedis::adapter::adapt;
+using net::ip::tcp;
+
+int main()
+{
+   try {
+      net::io_context ioc;
+      tcp::resolver resv{ioc};
+      auto const res = resv.resolve("127.0.0.1", "6379");
+      tcp::socket socket{ioc};
+      net::connect(socket, res);
+
+      // Creates the request and writes to the socket.
+      request req;
+      req.push("HELLO", 3);
+      req.push("PING");
+      req.push("QUIT");
+      resp3::write(socket, req);
+
+      // Responses
+      std::string buffer, resp;
+
+      // Reads the responses to all commands in the request.
+      auto dbuffer = net::dynamic_buffer(buffer);
+      resp3::read(socket, dbuffer);
+      resp3::read(socket, dbuffer, adapt(resp));
+      resp3::read(socket, dbuffer);
+
+      std::cout << "Ping: " << resp << std::endl;
+
+   } catch (std::exception const& e) {
+      std::cerr << e.what() << std::endl;
+      exit(EXIT_FAILURE);
+   }
+}

tests/low_level.cpp

@@ -1,8 +1,7 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
  *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
  */
 
 #include <map>
@@ -37,7 +36,7 @@ struct expect {
    std::string in;
    Result expected;
    std::string name;
-   boost::system::error_condition ec;
+   boost::system::error_code ec;
 };
 
 template <class Result>
@@ -109,12 +108,12 @@ void test_number(net::io_context& ioc)
    auto const in03 = expect<int>{":11\r\n", int{11}, "number.int"};
    auto const in04 = expect<boost::optional<int>>{":11\r\n", ok, "number.optional.int"};
    auto const in05 = expect<std::tuple<int>>{"*1\r\n:11\r\n", std::tuple<int>{11}, "number.tuple.int"};
-   auto const in06 = expect<boost::optional<int>>{"%11\r\n", boost::optional<int>{}, "number.optional.int", aedis::adapter::make_error_condition(aedis::adapter::error::expects_simple_type)};
-   auto const in07 = expect<std::set<std::string>>{":11\r\n", std::set<std::string>{}, "number.optional.int", aedis::adapter::make_error_condition(aedis::adapter::error::expects_set_aggregate)};
-   auto const in08 = expect<std::unordered_set<std::string>>{":11\r\n", std::unordered_set<std::string>{}, "number.optional.int", aedis::adapter::make_error_condition(aedis::adapter::error::expects_set_aggregate)};
-   auto const in09 = expect<std::map<std::string, std::string>>{":11\r\n", std::map<std::string, std::string>{}, "number.optional.int", aedis::adapter::make_error_condition(aedis::adapter::error::expects_map_like_aggregate)};
-   auto const in10 = expect<std::unordered_map<std::string, std::string>>{":11\r\n", std::unordered_map<std::string, std::string>{}, "number.optional.int", aedis::adapter::make_error_condition(aedis::adapter::error::expects_map_like_aggregate)};
-   auto const in11 = expect<std::list<std::string>>{":11\r\n", std::list<std::string>{}, "number.optional.int", aedis::adapter::make_error_condition(aedis::adapter::error::expects_aggregate)};
+   auto const in06 = expect<boost::optional<int>>{"%11\r\n", boost::optional<int>{}, "number.optional.int", aedis::make_error_code(aedis::error::expects_simple_type)};
+   auto const in07 = expect<std::set<std::string>>{":11\r\n", std::set<std::string>{}, "number.optional.int", aedis::make_error_code(aedis::error::expects_set_type)};
+   auto const in08 = expect<std::unordered_set<std::string>>{":11\r\n", std::unordered_set<std::string>{}, "number.optional.int", aedis::make_error_code(aedis::error::expects_set_type)};
+   auto const in09 = expect<std::map<std::string, std::string>>{":11\r\n", std::map<std::string, std::string>{}, "number.optional.int", aedis::make_error_code(aedis::error::expects_map_type)};
+   auto const in10 = expect<std::unordered_map<std::string, std::string>>{":11\r\n", std::unordered_map<std::string, std::string>{}, "number.optional.int", aedis::make_error_code(aedis::error::expects_map_type)};
+   auto const in11 = expect<std::list<std::string>>{":11\r\n", std::list<std::string>{}, "number.optional.int", aedis::make_error_code(aedis::error::expects_aggregate_type)};
 
    auto ex = ioc.get_executor();
 
@@ -156,11 +155,11 @@ void test_bool(net::io_context& ioc)
    auto const in13 = expect<boost::optional<bool>>{"#t\r\n", ok, "optional.int"};
 
    // Error
-   auto const in01 = expect<boost::optional<bool>>{"#11\r\n", boost::optional<bool>{}, "bool.error", aedis::resp3::make_error_condition(aedis::resp3::error::unexpected_bool_value)};
-   auto const in03 = expect<std::set<int>>{"#t\r\n", std::set<int>{}, "bool.error", aedis::adapter::make_error_condition(aedis::adapter::error::expects_set_aggregate)};
-   auto const in04 = expect<std::unordered_set<int>>{"#t\r\n", std::unordered_set<int>{}, "bool.error", aedis::adapter::make_error_condition(aedis::adapter::error::expects_set_aggregate)};
-   auto const in05 = expect<std::map<int, int>>{"#t\r\n", std::map<int, int>{}, "bool.error", aedis::adapter::make_error_condition(aedis::adapter::error::expects_map_like_aggregate)};
-   auto const in06 = expect<std::unordered_map<int, int>>{"#t\r\n", std::unordered_map<int, int>{}, "bool.error", aedis::adapter::make_error_condition(aedis::adapter::error::expects_map_like_aggregate)};
+   auto const in01 = expect<boost::optional<bool>>{"#11\r\n", boost::optional<bool>{}, "bool.error", aedis::make_error_code(aedis::error::unexpected_bool_value)};
+   auto const in03 = expect<std::set<int>>{"#t\r\n", std::set<int>{}, "bool.error", aedis::make_error_code(aedis::error::expects_set_type)};
+   auto const in04 = expect<std::unordered_set<int>>{"#t\r\n", std::unordered_set<int>{}, "bool.error", aedis::make_error_code(aedis::error::expects_set_type)};
+   auto const in05 = expect<std::map<int, int>>{"#t\r\n", std::map<int, int>{}, "bool.error", aedis::make_error_code(aedis::error::expects_map_type)};
+   auto const in06 = expect<std::unordered_map<int, int>>{"#t\r\n", std::unordered_map<int, int>{}, "bool.error", aedis::make_error_code(aedis::error::expects_map_type)};
 
    auto ex = ioc.get_executor();
 
@@ -320,7 +319,7 @@ void test_map(net::io_context& ioc)
    auto const in07 = expect<op_map_type>{wire, expected_1d, "map.optional.map"};
    auto const in08 = expect<op_vec_type>{wire, expected_1e, "map.optional.vector"};
    auto const in09 = expect<std::tuple<op_map_type>>{"*1\r\n" + wire, std::tuple<op_map_type>{expected_1d}, "map.transaction.optional.map"};
-   auto const in10 = expect<int>{"%11\r\n", int{}, "map.invalid.int", aedis::adapter::make_error_condition(aedis::adapter::error::expects_simple_type)};
+   auto const in10 = expect<int>{"%11\r\n", int{}, "map.invalid.int", aedis::make_error_code(aedis::error::expects_simple_type)};
    auto const in11 = expect<tuple_type>{wire, e1f, "map.tuple"};
 
    auto ex = ioc.get_executor();
@@ -489,8 +488,8 @@ void test_set(net::io_context& ioc)
 
 void test_simple_error(net::io_context& ioc)
 {
-   auto const in01 = expect<node_type>{"-Error\r\n", node_type{resp3::type::simple_error, 1UL, 0UL, {"Error"}}, "simple_error.node"};
-   auto const in02 = expect<node_type>{"-\r\n", node_type{resp3::type::simple_error, 1UL, 0UL, {""}}, "simple_error.node.empty"};
+   auto const in01 = expect<node_type>{"-Error\r\n", node_type{resp3::type::simple_error, 1UL, 0UL, {"Error"}}, "simple_error.node", aedis::make_error_code(aedis::error::simple_error)};
+   auto const in02 = expect<node_type>{"-\r\n", node_type{resp3::type::simple_error, 1UL, 0UL, {""}}, "simple_error.node.empty", aedis::make_error_code(aedis::error::simple_error)};
 
    auto ex = ioc.get_executor();
 
@@ -534,25 +533,29 @@ void test_blob_string(net::io_context& ioc)
 
 void test_double(net::io_context& ioc)
 {
+   // TODO: Add test for double.
    auto const in01 = expect<node_type>{",1.23\r\n", node_type{resp3::type::doublean, 1UL, 0UL, {"1.23"}}, "double.node"};
    auto const in02 = expect<node_type>{",inf\r\n", node_type{resp3::type::doublean, 1UL, 0UL, {"inf"}}, "double.node (inf)"};
    auto const in03 = expect<node_type>{",-inf\r\n", node_type{resp3::type::doublean, 1UL, 0UL, {"-inf"}}, "double.node (-inf)"};
+   auto const in04 = expect<double>{",1.23\r\n", double{1.23}, "double.double"};
 
    auto ex = ioc.get_executor();
 
    test_sync(ex, in01);
    test_sync(ex, in02);
    test_sync(ex, in03);
+   test_sync(ex, in04);
 
    test_async(ex, in01);
    test_async(ex, in02);
    test_async(ex, in03);
+   test_async(ex, in04);
 }
 
 void test_blob_error(net::io_context& ioc)
 {
-   auto const in01 = expect<node_type>{"!21\r\nSYNTAX invalid syntax\r\n", node_type{resp3::type::blob_error, 1UL, 0UL, {"SYNTAX invalid syntax"}}, "blob_error"};
-   auto const in02 = expect<node_type>{"!0\r\n\r\n", node_type{resp3::type::blob_error, 1UL, 0UL, {}}, "blob_error.empty"};
+   auto const in01 = expect<node_type>{"!21\r\nSYNTAX invalid syntax\r\n", node_type{resp3::type::blob_error, 1UL, 0UL, {"SYNTAX invalid syntax"}}, "blob_error", aedis::make_error_code(aedis::error::blob_error)};
+   auto const in02 = expect<node_type>{"!0\r\n\r\n", node_type{resp3::type::blob_error, 1UL, 0UL, {}}, "blob_error.empty", aedis::make_error_code(aedis::error::blob_error)};
 
    auto ex = ioc.get_executor();
 
@@ -580,7 +583,7 @@ void test_verbatim_string(net::io_context& ioc)
 void test_big_number(net::io_context& ioc)
 {
    auto const in01 = expect<node_type>{"(3492890328409238509324850943850943825024385\r\n", node_type{resp3::type::big_number, 1UL, 0UL, {"3492890328409238509324850943850943825024385"}}, "big_number.node"};
-   auto const in02 = expect<int>{"(\r\n", int{}, "big_number.error (empty field)", aedis::resp3::make_error_condition(aedis::resp3::error::empty_field)};
+   auto const in02 = expect<int>{"(\r\n", int{}, "big_number.error (empty field)", aedis::make_error_code(aedis::error::empty_field)};
 
    auto ex = ioc.get_executor();
 
@@ -617,11 +620,11 @@ void test_simple_string(net::io_context& ioc)
 
 void test_resp3(net::io_context& ioc)
 {
-   auto const in01 = expect<int>{"s11\r\n", int{}, "number.error", aedis::resp3::make_error_condition(aedis::resp3::error::invalid_type)};
-   auto const in02 = expect<int>{":adf\r\n", int{11}, "number.int", aedis::resp3::make_error_condition(aedis::resp3::error::not_a_number)};
-   auto const in03 = expect<int>{":\r\n", int{}, "number.error (empty field)", aedis::resp3::make_error_condition(aedis::resp3::error::empty_field)};
-   auto const in04 = expect<boost::optional<bool>>{"#\r\n", boost::optional<bool>{}, "bool.error", aedis::resp3::make_error_condition(aedis::resp3::error::empty_field)};
-   auto const in05 = expect<std::string>{",\r\n", std::string{}, "double.error (empty field)", aedis::resp3::make_error_condition(aedis::resp3::error::empty_field)};
+   auto const in01 = expect<int>{"s11\r\n", int{}, "number.error", aedis::make_error_code(aedis::error::invalid_data_type)};
+   auto const in02 = expect<int>{":adf\r\n", int{11}, "number.int", aedis::make_error_code(aedis::error::not_a_number)};
+   auto const in03 = expect<int>{":\r\n", int{}, "number.error (empty field)", aedis::make_error_code(aedis::error::empty_field)};
+   auto const in04 = expect<boost::optional<bool>>{"#\r\n", boost::optional<bool>{}, "bool.error", aedis::make_error_code(aedis::error::empty_field)};
+   auto const in05 = expect<std::string>{",\r\n", std::string{}, "double.error (empty field)", aedis::make_error_code(aedis::error::empty_field)};
 
    auto ex = ioc.get_executor();
 

tests/online.cpp

@@ -1,403 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <iostream>
-#include <map>
-
-#include <boost/system/errc.hpp>
-#include <boost/asio/awaitable.hpp>
-#include <boost/asio/redirect_error.hpp>
-#include <boost/asio/use_awaitable.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/connect.hpp>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-#include "check.hpp"
-
-namespace net = boost::asio;
-namespace resp3 = aedis::resp3;
-
-using aedis::redis::command;
-using aedis::generic::make_serializer;
-using aedis::adapter::adapt;
-using node_type = aedis::resp3::node<std::string>;
-using tcp = net::ip::tcp;
-using tcp_socket = net::use_awaitable_t<>::as_default_on_t<tcp::socket>;
-
-std::vector<node_type> gresp;
-
-net::awaitable<void>
-test_general(net::ip::tcp::resolver::results_type const& res)
-{
-   auto ex = co_await net::this_coro::executor;
-
-   std::vector<int> list_ {1 ,2, 3, 4, 5, 6};
-   std::string set_ {"aaa"};
-
-   //----------------------------------
-   std::string request;
-   auto sr = make_serializer(request);
-   sr.push(command::hello, 3);
-   sr.push(command::flushall);
-   sr.push_range(command::rpush, "a", list_);
-   sr.push(command::llen, "a");
-   sr.push(command::lrange, "a", 0, -1);
-   sr.push(command::ltrim, "a", 2, -2);
-   sr.push(command::lpop, "a");
-   //sr.lpop("a", 2); // Not working?
-   sr.push(command::set, "b", set_);
-   sr.push(command::get, "b");
-   sr.push(command::append, "b", "b");
-   sr.push(command::del, "b");
-   sr.push(command::subscribe, "channel");
-   sr.push(command::incr, "3");
-
-   // transaction
-   for (auto i = 0; i < 3; ++i) {
-      sr.push(command::multi);
-      sr.push(command::ping);
-      sr.push(command::lrange, "a", 0, -1);
-      sr.push(command::ping);
-      // TODO: It looks like we can't publish to a channel we
-      // are already subscribed to from inside a transaction.
-      //req.publish("some-channel", "message1");
-      sr.push(command::exec);
-   }
-
-   std::map<std::string, std::string> m1 =
-   { {"field1", "value1"}
-   , {"field2", "value2"}};
-
-   sr.push_range(command::hset, "d", m1);
-   sr.push(command::hget, "d", "field2");
-   sr.push(command::hgetall, "d");
-   sr.push(command::hdel, "d", "field1", "field2"); // TODO: Test as range too.
-   sr.push(command::hincrby, "e", "some-field", 10);
-
-   sr.push(command::zadd, "f", 1, "Marcelo");
-   sr.push(command::zrange, "f", 0, 1);
-   sr.push(command::zrangebyscore, "f", 1, 1);
-   sr.push(command::zremrangebyscore, "f", "-inf", "+inf");
-
-   auto const v = std::vector<int>{1, 2, 3};
-   sr.push_range(command::sadd, "g", v);
-   sr.push(command::smembers, "g");
-   sr.push(command::quit);
-   //----------------------------------
-
-   net::ip::tcp::socket socket{ex};
-   co_await net::async_connect(socket, res, net::use_awaitable);
-   co_await net::async_write(socket, net::buffer(request), net::use_awaitable);
-
-   // Reads the responses.
-   std::string buffer;
-
-   // hello
-   co_await resp3::async_read(socket, net::dynamic_buffer(buffer), adapt(), net::use_awaitable);
-
-   // flushall
-   co_await resp3::async_read(socket, net::dynamic_buffer(buffer), adapt(), net::use_awaitable);
-
-   { // rpush:
-      std::vector<node_type> resp;
-      co_await resp3::async_read(socket, net::dynamic_buffer(buffer), adapt(resp), net::use_awaitable);
-      auto const n = std::to_string(std::size(list_));
-      std::vector<node_type> expected
-	 { {resp3::type::number, 1UL, 0UL, n} };
-
-     expect_eq(resp, expected, "rpush (value)");
-   }
-
-   { // llen
-      std::vector<node_type> resp;
-      co_await resp3::async_read(socket, net::dynamic_buffer(buffer), adapt(resp), net::use_awaitable);
-      std::vector<node_type> expected
-	 { {resp3::type::number, 1UL, 0UL, {"6"}} };
-      expect_eq(resp, expected, "llen");
-   }
-
-   { // lrange
-      std::vector<node_type> resp;
-      co_await resp3::async_read(socket, net::dynamic_buffer(buffer), adapt(resp), net::use_awaitable);
-
-      std::vector<node_type> expected
-         { {resp3::type::array,       6UL, 0UL, {}}
-         , {resp3::type::blob_string, 1UL, 1UL, {"1"}}
-         , {resp3::type::blob_string, 1UL, 1UL, {"2"}}
-         , {resp3::type::blob_string, 1UL, 1UL, {"3"}}
-         , {resp3::type::blob_string, 1UL, 1UL, {"4"}}
-         , {resp3::type::blob_string, 1UL, 1UL, {"5"}}
-         , {resp3::type::blob_string, 1UL, 1UL, {"6"}}
-         };
-
-      expect_eq(resp, expected, "lrange ");
-   }
-
-   {  // ltrim
-      std::vector<node_type> resp;
-      co_await resp3::async_read(socket, net::dynamic_buffer(buffer), adapt(resp), net::use_awaitable);
-
-      std::vector<node_type> expected
-         { {resp3::type::simple_string, 1UL, 0UL, {"OK"}} };
-
-      expect_eq(resp, expected, "ltrim");
-   }
-
-   {  // lpop
-      std::vector<node_type> resp;
-      co_await resp3::async_read(socket, net::dynamic_buffer(buffer), adapt(resp), net::use_awaitable);
-
-      std::vector<node_type> expected
-         { {resp3::type::blob_string, 1UL, 0UL, {"3"}} };
-
-      expect_eq(resp, expected, "lpop");
-   }
-
-   //{  // lpop
-   //   std::vector<node_type> resp;
-   //   co_await resp3::async_read(socket, net::dynamic_buffer(buffer), adapt(resp), net::use_awaitable);
-
-   //   std::vector<node_type> expected
-   //      { {resp3::type::array, 2UL, 0UL, {}}
-   //      , {resp3::type::array, 1UL, 1UL, {"4"}}
-   //      , {resp3::type::array, 1UL, 1UL, {"5"}}
-   //      };
-
-   //   expect_eq(resp, expected, "lpop");
-   //}
-
-   //{ // lrange
-   //   static int c = 0;
-
-   //   if (c == 0) {
-   //     std::vector<node_type> expected
-   //         { {resp3::type::array,       6UL, 0UL, {}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"1"}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"2"}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"3"}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"4"}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"5"}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"6"}}
-   //         };
-
-   //      expect_eq(resp, expected, "lrange ");
-   //   } else {
-   //     std::vector<node_type> expected
-   //         { {resp3::type::simple_string, 1UL, 0UL, {"QUEUED"}} };
-
-   //      expect_eq(resp, expected, "lrange (inside transaction)");
-   //   }
-   //   
-   //   ++c;
-   //}
-
-   //for (;;) {
-   //   switch (cmd) {
-   //      case command::multi:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::simple_string, 1UL, 0UL, {"OK"}} };
-
-   //         expect_eq(resp, expected, "multi");
-   //      } break;
-   //      case command::ping:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::simple_string, 1UL, 0UL, {"QUEUED"}} };
-
-   //         expect_eq(resp, expected, "ping");
-   //      } break;
-   //      case command::set:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::simple_string, 1UL, 0UL, {"OK"}} };
-
-   //         expect_eq(resp, expected, "set");
-   //      } break;
-   //      case command::quit:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::simple_string, 1UL, 0UL, {"OK"}} };
-
-   //         expect_eq(resp, expected, "quit");
-   //      } break;
-   //      case command::flushall:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::simple_string, 1UL, 0UL, {"OK"}} };
-
-   //         expect_eq(resp, expected, "flushall");
-   //      } break;
-   //      case command::append:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"4"}} };
-
-   //        expect_eq(resp, expected, "append");
-   //      } break;
-   //      case command::hset:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"2"}} };
-
-   //        expect_eq(resp, expected, "hset");
-   //      } break;
-   //      case command::del:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"1"}} };
-
-   //        expect_eq(resp, expected, "del");
-   //      } break;
-   //      case command::incr:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"1"}} };
-
-   //        expect_eq(resp, expected, "incr");
-   //      } break;
-   //      case command::publish:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"1"}} };
-
-   //        expect_eq(resp, expected, "publish");
-   //      } break;
-   //      case command::hincrby:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"10"}} };
-
-   //        expect_eq(resp, expected, "hincrby");
-   //      } break;
-   //      case command::zadd:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"1"}} };
-
-   //        expect_eq(resp, expected, "zadd");
-   //      } break;
-   //      case command::sadd:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"3"}} };
-
-   //        expect_eq(resp, expected, "sadd");
-   //      } break;
-   //      case command::hdel:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"2"}} };
-
-   //        expect_eq(resp, expected, "hdel");
-   //      } break;
-   //      case command::zremrangebyscore:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::number, 1UL, 0UL, {"1"}} };
-
-   //        expect_eq(resp, expected, "zremrangebyscore");
-   //      } break;
-   //      case command::get:
-   //      {
-   //        std::vector<node_type> expected
-   //            { {resp3::type::blob_string, 1UL, 0UL, test.set_} };
-
-   //         expect_eq(resp, expected, "get");
-   //      } break;
-   //      case command::hget:
-   //      {
-   //        std::vector<node_type> expected
-   //            { {resp3::type::blob_string, 1UL, 0UL, std::string{"value2"}} };
-
-   //         expect_eq(resp, expected, "hget");
-   //      } break;
-   //      case command::hvals:
-   //      {
-   //        std::vector<node_type> expected
-   //            { {resp3::type::array, 2UL, 0UL, {}}
-   //            , {resp3::type::array, 1UL, 1UL, {"value1"}}
-   //            , {resp3::type::array, 1UL, 1UL, {"value2"}}
-   //            };
-
-   //        expect_eq(resp, expected, "hvals");
-   //      } break;
-   //      case command::zrange:
-   //      {
-   //        std::vector<node_type> expected
-   //            { {resp3::type::array,       1UL, 0UL, {}}
-   //            , {resp3::type::blob_string, 1UL, 1UL, {"Marcelo"}}
-   //            };
-
-   //        expect_eq(resp, expected, "hvals");
-   //      } break;
-   //      case command::zrangebyscore:
-   //      {
-   //        std::vector<node_type> expected
-   //            { {resp3::type::array,       1UL, 0UL, {}}
-   //            , {resp3::type::blob_string, 1UL, 1UL, {"Marcelo"}}
-   //            };
-
-   //        expect_eq(resp, expected, "zrangebyscore");
-   //      } break;
-   //      case command::exec:
-   //      {
-   //        std::vector<node_type> expected
-   //            { {resp3::type::array,         3UL, 0UL, {}}
-   //            , {resp3::type::simple_string, 1UL, 1UL, {"PONG"}}
-   //            , {resp3::type::array,         2UL, 1UL, {}}
-   //            , {resp3::type::blob_string,   1UL, 2UL, {"4"}}
-   //            , {resp3::type::blob_string,   1UL, 2UL, {"5"}}
-   //            , {resp3::type::simple_string, 1UL, 1UL, {"PONG"}}
-   //            };
-
-   //         expect_eq(resp, expected, "transaction");
-
-   //      } break;
-   //      case command::hgetall:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::map,         2UL, 0UL, {}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"field1"}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"value1"}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"field2"}}
-   //         , {resp3::type::blob_string, 1UL, 1UL, {"value2"}}
-   //         };
-   //         expect_eq(resp, expected, "hgetall (value)");
-   //      } break;
-   //      case command::smembers:
-   //      {
-   //        std::vector<node_type> expected
-   //         { {resp3::type::set,          3UL, 0UL, {}}
-   //         , {resp3::type::blob_string,  1UL, 1UL, {"1"}}
-   //         , {resp3::type::blob_string,  1UL, 1UL, {"2"}}
-   //         , {resp3::type::blob_string,  1UL, 1UL, {"3"}}
-   //         };
-   //         expect_eq(resp, expected, "smembers (value)");
-   //      } break;
-   //      default: { std::cout << "Error: " << resp.front().data_type << " " << cmd << std::endl; }
-   //   }
-
-   //   resp.clear();
-   //}
-}
-
-//-------------------------------------------------------------------
-
-int main()
-{
-   net::io_context ioc {1};
-   tcp::resolver resv(ioc);
-   auto const res = resv.resolve("127.0.0.1", "6379");
-
-   co_spawn(ioc, test_general(res), net::detached);
-   ioc.run();
-}
-

tools/commands.cpp

@@ -1,108 +0,0 @@
-/* Copyright (c) 2019 Marcelo Zimbres Silva (mzimbres.gmail.com)
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-#include <iostream>
-#include <algorithm>
-#include <cctype>
-
-#include <boost/asio/connect.hpp>
-
-#include <aedis/aedis.hpp>
-#include <aedis/src.hpp>
-
-namespace net = boost::asio;
-namespace resp3 = aedis::resp3;
-
-using aedis::redis::command;
-using aedis::generic::make_serializer;
-using aedis::resp3::node;
-using aedis::adapter::adapt;
-using net::ip::tcp;
-using net::write;
-using net::buffer;
-using net::dynamic_buffer;
-
-std::string toupper(std::string s)
-{
-   std::transform(std::begin(s), std::end(s), std::begin(s),
-                  [](unsigned char c){ return std::toupper(c); });
-   return s;
-}
-
-std::vector<std::string>
-get_cmd_names(std::vector<node<std::string>> const& resp)
-{
-   if (resp.empty()) {
-      std::cerr << "Response is empty." << std::endl;
-      return {};
-   }
-
-   std::vector<std::string> ret;
-   for (auto i = 0ULL; i < resp.size(); ++i) {
-      if (resp.at(i).depth == 1)
-         ret.push_back(resp.at(i + 1).value);
-   }
-
-   std::sort(std::begin(ret), std::end(ret));
-   return ret;
-}
-
-void print_cmds_enum(std::vector<std::string> const& cmds)
-{
-   std::cout << "enum class command {\n";
-   for (auto const& cmd : cmds) {
-      std::cout
-         << "   /// https://redis.io/commands/" << cmd << "\n"
-         << "   " << cmd << ",\n";
-   }
-
-   std::cout << "   invalid\n};\n";
-}
-
-void print_cmds_strs(std::vector<std::string> const& cmds)
-{
-   std::cout << "   static char const* table[] = {\n";
-   for (auto const& cmd : cmds) {
-      std::cout << "      \"" << toupper(cmd) << "\",\n";
-   }
-
-   std::cout << "   };\n";
-}
-
-int main()
-{
-   try {
-     net::io_context ioc;
-     tcp::resolver resv{ioc};
-     auto const res = resv.resolve("127.0.0.1", "6379");
-     tcp::socket socket{ioc};
-     net::connect(socket, res);
-
-     std::string request;
-     auto sr = make_serializer(request);
-     sr.push(command::hello, 3);
-     sr.push(command::command);
-     sr.push(command::quit);
-     write(socket, buffer(request));
-
-     std::vector<node<std::string>> resp;
-
-     std::string buffer;
-     resp3::read(socket, dynamic_buffer(buffer));
-     resp3::read(socket, dynamic_buffer(buffer), adapt(resp));
-     resp3::read(socket, dynamic_buffer(buffer));
-
-     auto const cmds = get_cmd_names(resp);
-     print_cmds_enum(cmds);
-     std::cout << "\n";
-     print_cmds_strs(cmds);
-
-   } catch (std::exception const& e) {
-      std::cerr << e.what() << std::endl;
-   }
-}
-