From f9ba9bd5714ae699b658bf2d6575b8ef379bf473 Mon Sep 17 00:00:00 2001 From: Marcelo Zimbres Date: Sun, 26 Sep 2021 13:17:38 +0200 Subject: [PATCH] Moves some code to the resp3 namespace. --- examples/async_basic.cpp | 6 +- {include/aedis => examples}/utils.hpp | 0 include/aedis/aedis.hpp | 3 +- include/aedis/impl/response.ipp | 62 ------ include/aedis/resp3/array_adapter.hpp | 8 +- .../aedis/resp3/basic_flat_array_adapter.hpp | 4 +- include/aedis/resp3/big_number_adapter.hpp | 8 +- include/aedis/resp3/blob_error_adapter.hpp | 8 +- include/aedis/resp3/blob_string_adapter.hpp | 11 +- include/aedis/resp3/boolean_adapter.hpp | 8 +- .../aedis/{ => resp3}/detail/impl/parser.ipp | 5 +- include/aedis/{ => resp3}/detail/parser.hpp | 6 +- include/aedis/resp3/doublean_adapter.hpp | 8 +- include/aedis/resp3/flat_map_adapter.hpp | 8 +- include/aedis/resp3/flat_set_adapter.hpp | 8 +- include/aedis/resp3/ignore_adapter.hpp | 2 +- include/aedis/resp3/impl/response.ipp | 45 ++++ include/aedis/{ => resp3}/impl/type.ipp | 2 +- include/aedis/resp3/number_adapter.hpp | 10 +- include/aedis/{ => resp3}/read.hpp | 68 +++--- include/aedis/resp3/response.hpp | 121 ++++++++++ .../{ => resp3}/response_adapter_base.hpp | 3 +- include/aedis/resp3/simple_error_adapter.hpp | 8 +- include/aedis/resp3/simple_string_adapter.hpp | 9 +- include/aedis/{ => resp3}/type.hpp | 35 +-- .../aedis/resp3/verbatim_string_adapter.hpp | 8 +- include/aedis/response.hpp | 73 ------ include/aedis/{impl => }/src.hpp | 7 +- src/aedis.cpp | 2 +- tests/general.cpp | 210 +++++++++--------- 30 files changed, 394 insertions(+), 362 deletions(-) rename {include/aedis => examples}/utils.hpp (100%) delete mode 100644 include/aedis/impl/response.ipp rename include/aedis/{ => resp3}/detail/impl/parser.ipp (96%) rename include/aedis/{ => resp3}/detail/parser.hpp (95%) create mode 100644 include/aedis/resp3/impl/response.ipp rename include/aedis/{ => resp3}/impl/type.ipp (98%) rename include/aedis/{ => resp3}/read.hpp (85%) create mode 100644 include/aedis/resp3/response.hpp rename include/aedis/{ => resp3}/response_adapter_base.hpp (96%) rename include/aedis/{ => resp3}/type.hpp (58%) delete mode 100644 include/aedis/response.hpp rename include/aedis/{impl => }/src.hpp (75%) diff --git a/examples/async_basic.cpp b/examples/async_basic.cpp index 8f10fe23..84d09a0b 100644 --- a/examples/async_basic.cpp +++ b/examples/async_basic.cpp @@ -15,11 +15,11 @@ example(net::ip::tcp::socket& socket, std::queue& requests) requests.push({}); requests.back().hello("3"); - response resp; - consumer_state cs; + resp3::response resp; + resp3::consumer cs; for (;;) { - auto const type = co_await async_consume(socket, requests, resp, cs, net::use_awaitable); + auto const type = co_await cs.async_consume(socket, requests, resp, net::use_awaitable); if (type == resp3::type::flat_push) { std::cout << "Event: " << "(" << type << ")" << std::endl; diff --git a/include/aedis/utils.hpp b/examples/utils.hpp similarity index 100% rename from include/aedis/utils.hpp rename to examples/utils.hpp diff --git a/include/aedis/aedis.hpp b/include/aedis/aedis.hpp index 5f9f77e1..6ea167b4 100644 --- a/include/aedis/aedis.hpp +++ b/include/aedis/aedis.hpp @@ -9,6 +9,5 @@ #include #include -#include -#include #include +#include diff --git a/include/aedis/impl/response.ipp b/include/aedis/impl/response.ipp deleted file mode 100644 index 3e6bdd22..00000000 --- a/include/aedis/impl/response.ipp +++ /dev/null @@ -1,62 +0,0 @@ -/* Copyright (c) 2019 - 2021 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 -#include - -namespace aedis { - -response::response() -: array_{&array} -, flat_array_{&flat_array} -, flat_push_{&flat_push} -, flat_set_{&flat_set} -, flat_map_{&flat_map} -, flat_attribute_{&flat_attribute} -, simple_string_{&simple_string} -, simple_error_{&simple_error} -, number_{&number} -, doublean_{&doublean} -, boolean_{&boolean} -, big_number_{&big_number} -, blob_string_{&blob_string} -, blob_error_{&blob_error} -, verbatim_string_{&verbatim_string} -, streamed_string_part_{&streamed_string_part} -{ } - -response_adapter_base* response::select_adapter(resp3::type type, command cmd) -{ - if (type == resp3::type::flat_push) - return &flat_push_; - - if (cmd == command::exec) - return &array_; - - switch (type) { - case resp3::type::flat_set: return &flat_set_; - case resp3::type::flat_map: return &flat_map_; - case resp3::type::flat_attribute: return &flat_attribute_; - case resp3::type::flat_array: return &flat_array_; - case resp3::type::simple_error: return &simple_error_; - case resp3::type::simple_string: return &simple_string_; - case resp3::type::number: return &number_; - case resp3::type::doublean: return &doublean_; - case resp3::type::big_number: return &big_number_; - case resp3::type::boolean: return &boolean_; - case resp3::type::blob_error: return &blob_error_; - case resp3::type::blob_string: return &blob_string_; - case resp3::type::verbatim_string: return &verbatim_string_; - case resp3::type::streamed_string_part: return &streamed_string_part_; - case resp3::type::null: return &ignore_; - default: { - assert(false); - return nullptr; - } - } -} -} // aedis diff --git a/include/aedis/resp3/array_adapter.hpp b/include/aedis/resp3/array_adapter.hpp index daa7fe51..3ad03e3c 100644 --- a/include/aedis/resp3/array_adapter.hpp +++ b/include/aedis/resp3/array_adapter.hpp @@ -7,8 +7,8 @@ #pragma once -#include -#include +#include +#include namespace aedis { namespace resp3 { @@ -16,9 +16,9 @@ namespace aedis { namespace resp3 { // as in a transaction for example. class array_adapter: public response_adapter_base { public: - array* result; + array_type* result; - array_adapter(array* p) : result(p) {} + array_adapter(array_type* p) : result(p) {} private: int depth_ = 0; diff --git a/include/aedis/resp3/basic_flat_array_adapter.hpp b/include/aedis/resp3/basic_flat_array_adapter.hpp index 9adfd4a5..53f8e2b0 100644 --- a/include/aedis/resp3/basic_flat_array_adapter.hpp +++ b/include/aedis/resp3/basic_flat_array_adapter.hpp @@ -7,9 +7,9 @@ #pragma once -#include +#include #include -#include +#include namespace aedis { namespace resp3 { diff --git a/include/aedis/resp3/big_number_adapter.hpp b/include/aedis/resp3/big_number_adapter.hpp index 3e57b86a..8dae5e97 100644 --- a/include/aedis/resp3/big_number_adapter.hpp +++ b/include/aedis/resp3/big_number_adapter.hpp @@ -7,16 +7,16 @@ #pragma once -#include -#include +#include +#include #include namespace aedis { namespace resp3 { struct big_number_adapter : public response_adapter_base { - big_number* result = nullptr; + big_number_type* result = nullptr; - big_number_adapter(big_number* p) : result(p) {} + big_number_adapter(big_number_type* p) : result(p) {} void on_big_number(std::string_view s) override { from_string_view(s, *result); } diff --git a/include/aedis/resp3/blob_error_adapter.hpp b/include/aedis/resp3/blob_error_adapter.hpp index c9eab1eb..73a147f5 100644 --- a/include/aedis/resp3/blob_error_adapter.hpp +++ b/include/aedis/resp3/blob_error_adapter.hpp @@ -7,16 +7,16 @@ #pragma once -#include -#include +#include +#include #include namespace aedis { namespace resp3 { struct blob_error_adapter : public response_adapter_base { - blob_error* result = nullptr; + blob_error_type* result = nullptr; - blob_error_adapter(blob_error* p) : result(p) {} + blob_error_adapter(blob_error_type* p) : result(p) {} void on_blob_error(std::string_view s) override { from_string_view(s, *result); } diff --git a/include/aedis/resp3/blob_string_adapter.hpp b/include/aedis/resp3/blob_string_adapter.hpp index 3b8319cf..749ebb16 100644 --- a/include/aedis/resp3/blob_string_adapter.hpp +++ b/include/aedis/resp3/blob_string_adapter.hpp @@ -7,19 +7,18 @@ #pragma once -#include -#include -#include +#include +#include namespace aedis { namespace resp3 { struct blob_string_adapter : public response_adapter_base { - resp3::blob_string* result = nullptr; + blob_string_type* result = nullptr; - blob_string_adapter(resp3::blob_string* p) : result(p) {} + blob_string_adapter(blob_string_type* p) : result(p) {} void on_blob_string(std::string_view s) override - { resp3::from_string_view(s, *result); } + { from_string_view(s, *result); } }; } // resp3 diff --git a/include/aedis/resp3/boolean_adapter.hpp b/include/aedis/resp3/boolean_adapter.hpp index b64d3d4a..7b61cb51 100644 --- a/include/aedis/resp3/boolean_adapter.hpp +++ b/include/aedis/resp3/boolean_adapter.hpp @@ -7,15 +7,15 @@ #pragma once -#include -#include +#include +#include namespace aedis { namespace resp3 { struct boolean_adapter : public response_adapter_base { - boolean* result = nullptr; + boolean_type* result = nullptr; - boolean_adapter(boolean* p) : result(p) {} + boolean_adapter(boolean_type* p) : result(p) {} void on_bool(std::string_view s) override { diff --git a/include/aedis/detail/impl/parser.ipp b/include/aedis/resp3/detail/impl/parser.ipp similarity index 96% rename from include/aedis/detail/impl/parser.ipp rename to include/aedis/resp3/detail/impl/parser.ipp index 747f7d85..b8a46e27 100644 --- a/include/aedis/detail/impl/parser.ipp +++ b/include/aedis/resp3/detail/impl/parser.ipp @@ -5,9 +5,9 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ -#include +#include -namespace aedis { namespace detail { +namespace aedis { namespace resp3 { namespace detail { // Converts a decimal number in ascii format to an integer. long long length(char const* p) @@ -141,4 +141,5 @@ std::size_t parser::advance(char const* data, std::size_t n) } } // detail +} // resp3 } // aedis diff --git a/include/aedis/detail/parser.hpp b/include/aedis/resp3/detail/parser.hpp similarity index 95% rename from include/aedis/detail/parser.hpp rename to include/aedis/resp3/detail/parser.hpp index da521368..65851704 100644 --- a/include/aedis/detail/parser.hpp +++ b/include/aedis/resp3/detail/parser.hpp @@ -8,10 +8,9 @@ #pragma once #include +#include -#include - -namespace aedis { namespace detail { +namespace aedis { namespace resp3 { namespace detail { // resp3 parser. class parser { @@ -62,4 +61,5 @@ public: }; } // detail +} // resp3 } // aedis diff --git a/include/aedis/resp3/doublean_adapter.hpp b/include/aedis/resp3/doublean_adapter.hpp index 0c75f025..eb6a21aa 100644 --- a/include/aedis/resp3/doublean_adapter.hpp +++ b/include/aedis/resp3/doublean_adapter.hpp @@ -7,15 +7,15 @@ #pragma once -#include -#include +#include +#include namespace aedis { namespace resp3 { struct doublean_adapter : public response_adapter_base { - doublean* result = nullptr; + doublean_type* result = nullptr; - doublean_adapter(doublean* p) : result(p) {} + doublean_adapter(doublean_type* p) : result(p) {} void on_double(std::string_view s) override { *result = s; } diff --git a/include/aedis/resp3/flat_map_adapter.hpp b/include/aedis/resp3/flat_map_adapter.hpp index 457027c2..2d58d1b0 100644 --- a/include/aedis/resp3/flat_map_adapter.hpp +++ b/include/aedis/resp3/flat_map_adapter.hpp @@ -7,15 +7,15 @@ #pragma once -#include -#include +#include +#include namespace aedis { namespace resp3 { struct flat_map_adapter : response_adapter_base { - flat_map* result = nullptr; + flat_map_type* result = nullptr; - flat_map_adapter(flat_map* p) : result(p) {} + flat_map_adapter(flat_map_type* p) : result(p) {} void add(std::string_view s = {}) { diff --git a/include/aedis/resp3/flat_set_adapter.hpp b/include/aedis/resp3/flat_set_adapter.hpp index c00c2a00..b506c718 100644 --- a/include/aedis/resp3/flat_set_adapter.hpp +++ b/include/aedis/resp3/flat_set_adapter.hpp @@ -7,16 +7,16 @@ #pragma once -#include -#include +#include +#include #include namespace aedis { namespace resp3 { struct flat_set_adapter : response_adapter_base { - flat_set* result = nullptr; + flat_set_type* result = nullptr; - flat_set_adapter(flat_set* p) : result(p) {} + flat_set_adapter(flat_set_type* p) : result(p) {} void add(std::string_view s = {}) { diff --git a/include/aedis/resp3/ignore_adapter.hpp b/include/aedis/resp3/ignore_adapter.hpp index 17ea88e4..83113c23 100644 --- a/include/aedis/resp3/ignore_adapter.hpp +++ b/include/aedis/resp3/ignore_adapter.hpp @@ -7,7 +7,7 @@ #pragma once -#include +#include namespace aedis { namespace resp3 { diff --git a/include/aedis/resp3/impl/response.ipp b/include/aedis/resp3/impl/response.ipp new file mode 100644 index 00000000..26665164 --- /dev/null +++ b/include/aedis/resp3/impl/response.ipp @@ -0,0 +1,45 @@ +/* Copyright (c) 2019 - 2021 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 +#include + +namespace aedis { namespace resp3 { + +response_adapter_base* response::select_adapter(type type, command cmd) +{ + if (type == type::flat_push) + return &flat_push_adapter_; + + if (cmd == command::exec) + return &array_adapter_; + + switch (type) { + case type::flat_set: return &flat_set_adapter_; + case type::flat_map: return &flat_map_adapter_; + case type::flat_attribute: return &flat_attribute_adapter_; + case type::flat_array: return &flat_array_adapter_; + case type::simple_error: return &simple_error_adapter_; + case type::simple_string: return &simple_string_adapter_; + case type::number: return &number_adapter_; + case type::doublean: return &doublean_adapter_; + case type::big_number: return &big_number_adapter_; + case type::boolean: return &boolean_adapter_; + case type::blob_error: return &blob_error_adapter_; + case type::blob_string: return &blob_string_adapter_; + case type::verbatim_string: return &verbatim_string_adapter_; + case type::streamed_string_part: return &streamed_string_part_adapter_; + case type::null: return &ignore_adapter_; + default: { + assert(false); + return nullptr; + } + } +} + +} // resp3 +} // aedis diff --git a/include/aedis/impl/type.ipp b/include/aedis/resp3/impl/type.ipp similarity index 98% rename from include/aedis/impl/type.ipp rename to include/aedis/resp3/impl/type.ipp index bf7b9898..c4bf9b27 100644 --- a/include/aedis/impl/type.ipp +++ b/include/aedis/resp3/impl/type.ipp @@ -5,7 +5,7 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ -#include +#include #include diff --git a/include/aedis/resp3/number_adapter.hpp b/include/aedis/resp3/number_adapter.hpp index d4b0771a..eb48638c 100644 --- a/include/aedis/resp3/number_adapter.hpp +++ b/include/aedis/resp3/number_adapter.hpp @@ -7,18 +7,16 @@ #pragma once -#include -#include +#include +#include #include -#include - namespace aedis { namespace resp3 { struct number_adapter : public response_adapter_base { - resp3::number* result = nullptr; + number_type* result = nullptr; - number_adapter(resp3::number* p) : result(p) {} + number_adapter(number_type* p) : result(p) {} void on_number(std::string_view s) override { from_string_view(s, *result); } diff --git a/include/aedis/read.hpp b/include/aedis/resp3/read.hpp similarity index 85% rename from include/aedis/read.hpp rename to include/aedis/resp3/read.hpp index 3f9a0947..35379f73 100644 --- a/include/aedis/read.hpp +++ b/include/aedis/resp3/read.hpp @@ -10,16 +10,17 @@ #include #include -#include #include #include -#include -#include +#include +#include +#include +#include #include -namespace aedis { +namespace aedis { namespace resp3 { // The parser supports up to 5 levels of nested structures. The first // element in the sizes stack is a sentinel and must be different from @@ -185,7 +186,7 @@ public: , std::size_t n = 0) { if (ec) { - self.complete(ec, resp3::type::invalid); + self.complete(ec, type::invalid); return; } @@ -199,8 +200,8 @@ public: } assert(!std::empty(*buf_)); - auto const type = resp3::to_type(buf_->front()); - // TODO: when type = resp3::type::invalid should we report an error or + auto const type = to_type(buf_->front()); + // TODO: when type = type::invalid should we report an error or // complete normally and let the caller check whether it is invalid. self.complete(ec, type); return; @@ -221,29 +222,29 @@ auto async_read_type( { return net::async_compose < CompletionToken - , void(boost::system::error_code, resp3::type) + , void(boost::system::error_code, type) >(type_op {stream, &buffer}, token, stream); } -struct consume_op { +struct consumer_op { net::ip::tcp::socket& socket; std::string& buffer; std::queue& requests; response& resp; - resp3::type& m_type; + type& m_type; net::coroutine& coro; template void operator()( Self& self, boost::system::error_code const& ec = {}, - resp3::type type = resp3::type::invalid) + type t = type::invalid) { reenter (coro) for (;;) { yield async_write_some(socket, requests, std::move(self)); if (ec) { - self.complete(ec, resp3::type::invalid); + self.complete(ec, type::invalid); return; } @@ -251,16 +252,16 @@ struct consume_op { do { yield async_read_type(socket, buffer, std::move(self)); if (ec) { - self.complete(ec, resp3::type::invalid); + self.complete(ec, type::invalid); return; } - m_type = type; + m_type = t; yield { auto cmd = command::unknown; - if (m_type != resp3::type::flat_push) + if (m_type != type::flat_push) cmd = requests.front().commands.front(); auto* adapter = resp.select_adapter(m_type, cmd); @@ -268,13 +269,13 @@ struct consume_op { } if (ec) { - self.complete(ec, resp3::type::invalid); + self.complete(ec, type::invalid); return; } yield self.complete(ec, m_type); - if (m_type != resp3::type::flat_push) + if (m_type != type::flat_push) requests.front().commands.pop(); } while (!std::empty(requests.front().commands)); @@ -284,26 +285,27 @@ struct consume_op { } }; -struct consumer_state { +struct consumer { std::string buffer; response resp; net::coroutine coro = net::coroutine(); - resp3::type type = resp3::type::invalid; + type t = type::invalid; + + template + auto async_consume( + net::ip::tcp::socket& socket, + std::queue& requests, + response& resp, + CompletionToken&& token) + { + return net::async_compose< + CompletionToken, + void(boost::system::error_code, type)>( + consumer_op{socket, buffer, requests, resp, t, coro}, token, socket); + } }; -template -auto async_consume( - net::ip::tcp::socket& socket, - std::queue& requests, - response& resp, - consumer_state& cs, - CompletionToken&& token) -{ - return net::async_compose< - CompletionToken, - void(boost::system::error_code, resp3::type)>( - consume_op{socket, cs.buffer, requests, resp, cs.type, cs.coro}, token, socket); -} - +} // resp3 } // aedis + #include diff --git a/include/aedis/resp3/response.hpp b/include/aedis/resp3/response.hpp new file mode 100644 index 00000000..e32f6c54 --- /dev/null +++ b/include/aedis/resp3/response.hpp @@ -0,0 +1,121 @@ +/* Copyright (c) 2019 - 2021 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/. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace aedis { namespace resp3 { + +class response { +private: + array_type array_; + array_adapter array_adapter_{&array_}; + + flat_array_type flat_array_; + basic_flat_array_adapter flat_array_adapter_{&flat_array_}; + + flat_array_type flat_attribute_; + basic_flat_array_adapter flat_attribute_adapter_{&flat_attribute_}; + + flat_array_type flat_push_; + basic_flat_array_adapter flat_push_adapter_{&flat_push_}; + + big_number_type big_number_; + big_number_adapter big_number_adapter_{&big_number_}; + + blob_error_type blob_error_; + blob_error_adapter blob_error_adapter_{&blob_error_}; + + blob_string_type blob_string_; + blob_string_adapter blob_string_adapter_{&blob_string_}; + + boolean_type boolean_; + boolean_adapter boolean_adapter_{&boolean_}; + + doublean_type doublean_; + doublean_adapter doublean_adapter_{&doublean_}; + + flat_map_type flat_map_; + flat_map_adapter flat_map_adapter_{&flat_map_}; + + flat_set_type flat_set_; + flat_set_adapter flat_set_adapter_{&flat_set_}; + + number_type number_; + number_adapter number_adapter_{&number_}; + + simple_error_type simple_error_; + simple_error_adapter simple_error_adapter_{&simple_error_}; + + simple_string_type simple_string_; + simple_string_adapter simple_string_adapter_{&simple_string_}; + + streamed_string_part_type streamed_string_part_; + streamed_string_part_adapter streamed_string_part_adapter_{&streamed_string_part_}; + + verbatim_string_type verbatim_string_; + verbatim_string_adapter verbatim_string_adapter_{&verbatim_string_}; + + ignore_adapter ignore_adapter_; + +public: + response_adapter_base* select_adapter(resp3::type type, command cmd); + + auto const& array() const noexcept {return array_;} + auto& array() noexcept {return array_;} + + auto const& flat_push() const noexcept {return flat_push_;} + auto& flat_push() noexcept {return flat_push_;} + + auto const& flat_array() const noexcept {return flat_array_;} + auto& flat_array() noexcept {return flat_array_;} + + auto const& flat_map() const noexcept {return flat_map_;} + auto& flat_map() noexcept {return flat_map_;} + + auto const& flat_set() const noexcept {return flat_set_;} + auto& flat_set() noexcept {return flat_set_;} + + auto const& simple_string() const noexcept {return simple_string_;} + auto& simple_string() noexcept {return simple_string_;} + + auto const& number() const noexcept {return number_;} + auto& number() noexcept {return number_;} + + auto const& boolean() const noexcept {return boolean_;} + auto& boolean() noexcept {return boolean_;} + + auto const& blob_string() const noexcept {return blob_string_;} + auto& blob_string() noexcept {return blob_string_;} + + auto const& blob_error() const noexcept {return blob_error_;} + auto& blob_error() noexcept {return blob_error_;} + + auto const& streamed_string_part() const noexcept {return streamed_string_part_;} + auto& streamed_string_part() noexcept {return streamed_string_part_;} +}; + +} // resp3 +} // aedis diff --git a/include/aedis/response_adapter_base.hpp b/include/aedis/resp3/response_adapter_base.hpp similarity index 96% rename from include/aedis/response_adapter_base.hpp rename to include/aedis/resp3/response_adapter_base.hpp index 99500a40..be9393e2 100644 --- a/include/aedis/response_adapter_base.hpp +++ b/include/aedis/resp3/response_adapter_base.hpp @@ -9,7 +9,7 @@ #include -namespace aedis { +namespace aedis { namespace resp3 { struct response_adapter_base { virtual void pop() {} @@ -32,4 +32,5 @@ struct response_adapter_base { virtual ~response_adapter_base() {} }; +} // resp3 } // aedis diff --git a/include/aedis/resp3/simple_error_adapter.hpp b/include/aedis/resp3/simple_error_adapter.hpp index b536ef56..1bb5d894 100644 --- a/include/aedis/resp3/simple_error_adapter.hpp +++ b/include/aedis/resp3/simple_error_adapter.hpp @@ -7,15 +7,15 @@ #pragma once -#include -#include +#include +#include namespace aedis { namespace resp3 { struct simple_error_adapter : public response_adapter_base { - resp3::simple_error* result = nullptr; + simple_error_type* result = nullptr; - simple_error_adapter(resp3::simple_error* p) : result(p) {} + simple_error_adapter(simple_error_type* p) : result(p) {} void on_simple_error(std::string_view s) override { *result = s; } diff --git a/include/aedis/resp3/simple_string_adapter.hpp b/include/aedis/resp3/simple_string_adapter.hpp index b6990c62..4fcd70ec 100644 --- a/include/aedis/resp3/simple_string_adapter.hpp +++ b/include/aedis/resp3/simple_string_adapter.hpp @@ -7,16 +7,15 @@ #pragma once -#include -#include -#include +#include +#include namespace aedis { namespace resp3 { struct simple_string_adapter : public response_adapter_base { - simple_string* result = nullptr; + simple_string_type* result = nullptr; - simple_string_adapter(simple_string* p) : result(p) {} + simple_string_adapter(simple_string_type* p) : result(p) {} void on_simple_string(std::string_view s) override { *result = s; } diff --git a/include/aedis/type.hpp b/include/aedis/resp3/type.hpp similarity index 58% rename from include/aedis/type.hpp rename to include/aedis/resp3/type.hpp index 6096e423..b3e8b273 100644 --- a/include/aedis/type.hpp +++ b/include/aedis/resp3/type.hpp @@ -11,7 +11,8 @@ #include #include -#include "command.hpp" +// FIXME: We shouldn't need this header here. +#include namespace aedis { namespace resp3 { @@ -42,27 +43,27 @@ template using basic_flat_array = std::vector; /// RESP3 flat array types. -using flat_array = basic_flat_array; -using flat_array_int = basic_flat_array; +using flat_array_type = basic_flat_array; +using flat_array_int_type = basic_flat_array; -using flat_push = std::vector; +using flat_push_type = std::vector; /// RESP3 map type. -using flat_map = std::vector; +using flat_map_type = std::vector; /// RESP3 set type. -using flat_set = std::vector; +using flat_set_type = std::vector; -using number = long long int; -using boolean = bool; -using doublean = std::string; -using blob_string = std::string; -using blob_error = std::string; -using simple_string = std::string; -using simple_error = std::string; -using big_number = std::string; -using verbatim_string = std::string; -using streamed_string_part = std::string; +using number_type = long long int; +using boolean_type = bool; +using doublean_type = std::string; +using blob_string_type = std::string; +using blob_error_type = std::string; +using simple_string_type = std::string; +using simple_error_type = std::string; +using big_number_type = std::string; +using verbatim_string_type = std::string; +using streamed_string_part_type = std::string; struct node { int depth; @@ -72,7 +73,7 @@ struct node { std::vector value; }; -using array = std::vector; +using array_type = std::vector; } // resp3 } // aedis diff --git a/include/aedis/resp3/verbatim_string_adapter.hpp b/include/aedis/resp3/verbatim_string_adapter.hpp index d94bc91b..c794f24d 100644 --- a/include/aedis/resp3/verbatim_string_adapter.hpp +++ b/include/aedis/resp3/verbatim_string_adapter.hpp @@ -7,16 +7,16 @@ #pragma once -#include -#include +#include +#include #include namespace aedis { namespace resp3 { struct verbatim_string_adapter : public response_adapter_base { - verbatim_string* result = nullptr; + verbatim_string_type* result = nullptr; - verbatim_string_adapter(verbatim_string* p) : result(p) {} + verbatim_string_adapter(verbatim_string_type* p) : result(p) {} void on_verbatim_string(std::string_view s) override { from_string_view(s, *result); } diff --git a/include/aedis/response.hpp b/include/aedis/response.hpp deleted file mode 100644 index de1279c9..00000000 --- a/include/aedis/response.hpp +++ /dev/null @@ -1,73 +0,0 @@ -/* Copyright (c) 2019 - 2021 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/. - */ - -#pragma once - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace aedis { - -class response { -private: - resp3::array_adapter array_; - resp3::basic_flat_array_adapter flat_array_; - resp3::basic_flat_array_adapter flat_push_; - resp3::flat_set_adapter flat_set_; - resp3::flat_map_adapter flat_map_; - resp3::basic_flat_array_adapter flat_attribute_; - resp3::simple_string_adapter simple_string_; - resp3::simple_error_adapter simple_error_; - resp3::number_adapter number_; - resp3::doublean_adapter doublean_; - resp3::boolean_adapter boolean_; - resp3::big_number_adapter big_number_; - resp3::blob_string_adapter blob_string_; - resp3::blob_error_adapter blob_error_; - resp3::verbatim_string_adapter verbatim_string_; - resp3::streamed_string_part_adapter streamed_string_part_; - resp3::ignore_adapter ignore_; - -public: - resp3::array array; - resp3::flat_array flat_array; - resp3::flat_array flat_push; - resp3::flat_set flat_set; - resp3::flat_map flat_map; - resp3::flat_array flat_attribute; - resp3::simple_string simple_string; - resp3::simple_error simple_error; - resp3::number number; - resp3::doublean doublean; - resp3::boolean boolean; - resp3::big_number big_number; - resp3::blob_string blob_string; - resp3::blob_error blob_error; - resp3::verbatim_string verbatim_string; - resp3::streamed_string_part streamed_string_part; - - response(); - response_adapter_base* select_adapter(resp3::type type, command cmd); -}; - -} // aedis diff --git a/include/aedis/impl/src.hpp b/include/aedis/src.hpp similarity index 75% rename from include/aedis/impl/src.hpp rename to include/aedis/src.hpp index 1e533df8..278f4234 100644 --- a/include/aedis/impl/src.hpp +++ b/include/aedis/src.hpp @@ -5,9 +5,10 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ -#include #include #include #include -#include -#include + +#include +#include +#include diff --git a/src/aedis.cpp b/src/aedis.cpp index 2e9c84b5..cf250457 100644 --- a/src/aedis.cpp +++ b/src/aedis.cpp @@ -5,4 +5,4 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ -#include +#include diff --git a/tests/general.cpp b/tests/general.cpp index 7091484c..42a202a3 100644 --- a/tests/general.cpp +++ b/tests/general.cpp @@ -120,18 +120,18 @@ test_general(net::ip::tcp::resolver::results_type const& res) test_general_fill filler; - response resp; - consumer_state cs; + resp3::response resp; + resp3::consumer cs; int push_counter = 0; for (;;) { auto const type = - co_await async_consume(socket, requests, resp, cs, net::use_awaitable); + co_await cs.async_consume(socket, requests, resp, net::use_awaitable); if (type == resp3::type::flat_push) { switch (push_counter) { - case 0: check_equal(resp.flat_push, {"subscribe", "channel", "1"}, "push (value1)"); break; - case 1: check_equal(resp.flat_push, {"message", "channel", "message"}, "push (value2)"); break; + case 0: check_equal(resp.flat_push(), {"subscribe", "channel", "1"}, "push (value1)"); break; + case 1: check_equal(resp.flat_push(), {"message", "channel", "message"}, "push (value2)"); break; default: std::cout << "ERROR: unexpected push event." << std::endl; } ++push_counter; @@ -146,64 +146,64 @@ test_general(net::ip::tcp::resolver::results_type const& res) prepare_next(requests); filler(requests.back()); } break; - case command::multi: check_equal(resp.simple_string, {"OK"}, "multi"); break; - case command::ping: check_equal(resp.simple_string, {"QUEUED"}, "ping"); break; - case command::set: check_equal(resp.simple_string, {"OK"}, "set"); break; - case command::quit: check_equal(resp.simple_string, {"OK"}, "quit"); break; - case command::flushall: check_equal(resp.simple_string, {"OK"}, "flushall"); break; - case command::ltrim: check_equal(resp.simple_string, {"OK"}, "ltrim"); break; - case command::append: check_equal(resp.number, 4LL, "append"); break; - case command::hset: check_equal(resp.number, 2LL, "hset"); break; - case command::rpush: check_equal(resp.number, (resp3::number)std::size(filler.list_), "rpush (value)"); break; - case command::del: check_equal(resp.number, 1LL, "del"); break; - case command::llen: check_equal(resp.number, 6LL, "llen"); break; - case command::incr: check_equal(resp.number, 1LL, "incr"); break; - case command::publish: check_equal(resp.number, 1LL, "publish"); break; - case command::hincrby: check_equal(resp.number, 10LL, "hincrby"); break; - case command::zadd: check_equal(resp.number, 1LL, "zadd"); break; - case command::sadd: check_equal(resp.number, 3LL, "sadd"); break; - case command::hdel: check_equal(resp.number, 2LL, "hdel"); break; - case command::zremrangebyscore: check_equal(resp.number, 1LL, "zremrangebyscore"); break; - case command::get: check_equal(resp.blob_string, filler.set_, "get"); break; - case command::hget: check_equal(resp.blob_string, std::string{"value2"}, "hget"); break; - case command::lrange: check_equal(resp.flat_array, {"1", "2", "3", "4", "5", "6"}, "lrange"); break; - case command::hvals: check_equal(resp.flat_array, {"value1", "value2"}, "hvals"); break; - case command::zrange: check_equal(resp.flat_array, {"Marcelo"}, "hvals"); break; - case command::zrangebyscore: check_equal(resp.flat_array, {"Marcelo"}, "zrangebyscore"); break; + case command::multi: check_equal(resp.simple_string(), {"OK"}, "multi"); break; + case command::ping: check_equal(resp.simple_string(), {"QUEUED"}, "ping"); break; + case command::set: check_equal(resp.simple_string(), {"OK"}, "set"); break; + case command::quit: check_equal(resp.simple_string(), {"OK"}, "quit"); break; + case command::flushall: check_equal(resp.simple_string(), {"OK"}, "flushall"); break; + case command::ltrim: check_equal(resp.simple_string(), {"OK"}, "ltrim"); break; + case command::append: check_equal(resp.number(), 4LL, "append"); break; + case command::hset: check_equal(resp.number(), 2LL, "hset"); break; + case command::rpush: check_equal(resp.number(), (resp3::number_type)std::size(filler.list_), "rpush (value)"); break; + case command::del: check_equal(resp.number(), 1LL, "del"); break; + case command::llen: check_equal(resp.number(), 6LL, "llen"); break; + case command::incr: check_equal(resp.number(), 1LL, "incr"); break; + case command::publish: check_equal(resp.number(), 1LL, "publish"); break; + case command::hincrby: check_equal(resp.number(), 10LL, "hincrby"); break; + case command::zadd: check_equal(resp.number(), 1LL, "zadd"); break; + case command::sadd: check_equal(resp.number(), 3LL, "sadd"); break; + case command::hdel: check_equal(resp.number(), 2LL, "hdel"); break; + case command::zremrangebyscore: check_equal(resp.number(), 1LL, "zremrangebyscore"); break; + case command::get: check_equal(resp.blob_string(), filler.set_, "get"); break; + case command::hget: check_equal(resp.blob_string(), std::string{"value2"}, "hget"); break; + case command::lrange: check_equal(resp.flat_array(), {"1", "2", "3", "4", "5", "6"}, "lrange"); break; + case command::hvals: check_equal(resp.flat_array(), {"value1", "value2"}, "hvals"); break; + case command::zrange: check_equal(resp.flat_array(), {"Marcelo"}, "hvals"); break; + case command::zrangebyscore: check_equal(resp.flat_array(), {"Marcelo"}, "zrangebyscore"); break; case command::lpop: { switch (type) { - case resp3::type::blob_string: check_equal(resp.blob_string, {"3"}, "lpop"); break; - case resp3::type::flat_array: check_equal(resp.flat_array, {"4", "5"}, "lpop"); break; + case resp3::type::blob_string: check_equal(resp.blob_string(), {"3"}, "lpop"); break; + case resp3::type::flat_array: check_equal(resp.flat_array(), {"4", "5"}, "lpop"); break; default: {std::cout << "Error." << std::endl;} } } break; case command::exec: { check_equal_number(type, resp3::type::flat_array, "exec (type)"); - check_equal(std::size(resp.array), 2lu, "exec (size)"); + check_equal(std::size(resp.array()), 2lu, "exec (size)"); - check_equal(resp.array[0].cmd, command::unknown, "transaction ping (command)"); - check_equal(resp.array[0].depth, 1, "transaction (depth)"); - check_equal(resp.array[0].type, resp3::type::simple_string, "transaction (type)"); - check_equal(resp.array[0].expected_size, 1, "transaction (size)"); + check_equal(resp.array()[0].cmd, command::unknown, "transaction ping (command)"); + check_equal(resp.array()[0].depth, 1, "transaction (depth)"); + check_equal(resp.array()[0].type, resp3::type::simple_string, "transaction (type)"); + check_equal(resp.array()[0].expected_size, 1, "transaction (size)"); - check_equal(resp.array[1].cmd, command::unknown, "transaction ping (command)"); - check_equal(resp.array[1].depth, 1, "transaction (depth)"); - check_equal(resp.array[1].type, resp3::type::simple_string, "transaction (typ)e"); - check_equal(resp.array[1].expected_size, 1, "transaction (size)"); + check_equal(resp.array()[1].cmd, command::unknown, "transaction ping (command)"); + check_equal(resp.array()[1].depth, 1, "transaction (depth)"); + check_equal(resp.array()[1].type, resp3::type::simple_string, "transaction (typ)e"); + check_equal(resp.array()[1].expected_size, 1, "transaction (size)"); } break; - case command::hgetall: check_equal(resp.flat_map, {"field1", "value1", "field2", "value2"}, "hgetall (value)"); break; - case command::smembers: check_equal(resp.flat_set, {"1", "2", "3"}, "smembers (value)"); break; + case command::hgetall: check_equal(resp.flat_map(), {"field1", "value1", "field2", "value2"}, "hgetall (value)"); break; + case command::smembers: check_equal(resp.flat_set(), {"1", "2", "3"}, "smembers (value)"); break; default: { std::cout << "Error: " << type << " " << cmd << std::endl; } } - resp.blob_string.clear(); - resp.flat_push.clear(); - resp.flat_map.clear(); - resp.flat_set.clear(); - resp.array.clear(); + resp.blob_string().clear(); + resp.flat_push().clear(); + resp.flat_map().clear(); + resp.flat_set().clear(); + resp.array().clear(); } } @@ -236,49 +236,49 @@ test_list(net::ip::tcp::resolver::results_type const& results) } { // flushall - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, {"OK"}, "flushall"); } { // rpush - resp3::number buffer; + resp3::number_type buffer; resp3::number_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, (long long int)6, "rpush"); } { // lrange - resp3::flat_array_int buffer; + resp3::flat_array_int_type buffer; resp3::basic_flat_array_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, list, "lrange-1"); } { // lrange - resp3::flat_array_int buffer; + resp3::flat_array_int_type buffer; resp3::basic_flat_array_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, std::vector{3, 4, 5}, "lrange-2"); } { // ltrim - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, {"OK"}, "ltrim"); } { // lpop. Why a blob string instead of a number? - resp3::blob_string buffer; + resp3::blob_string_type buffer; resp3::blob_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, {"3"}, "lpop"); } { // quit - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, {"OK"}, "quit"); @@ -288,7 +288,7 @@ test_list(net::ip::tcp::resolver::results_type const& results) net::awaitable test_set(net::ip::tcp::resolver::results_type const& results) { - using namespace aedis::detail; + using namespace aedis; auto ex = co_await this_coro::executor; // Tests whether the parser can handle payloads that contain the separator. @@ -322,49 +322,49 @@ test_set(net::ip::tcp::resolver::results_type const& results) } { // set - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, {"OK"}, "set1"); } { // get - resp3::blob_string buffer; + resp3::blob_string_type buffer; resp3::blob_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, test_bulk1, "get1"); } { // set - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, {"OK"}, "set1"); } { // get - resp3::blob_string buffer; + resp3::blob_string_type buffer; resp3::blob_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, test_bulk2, "get2"); } { // set - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, {"OK"}, "set3"); } { // get - resp3::blob_string buffer; + resp3::blob_string_type buffer; resp3::blob_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, std::string {}, "get3"); } { // quit - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(socket, buf, res); check_equal(buffer, {"OK"}, "quit"); @@ -381,12 +381,12 @@ struct test_handler { net::awaitable test_simple_string() { - using namespace aedis::detail; + using namespace aedis; { // Small string std::string buf; std::string cmd {"+OK\r\n"}; test_tcp_socket ts {cmd}; - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"OK"}, "simple_string"); @@ -397,7 +397,7 @@ net::awaitable test_simple_string() std::string buf; std::string cmd {"+\r\n"}; test_tcp_socket ts {cmd}; - resp3::simple_string buffer; + resp3::simple_string_type buffer; resp3::simple_string_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {}, "simple_string (empty)"); @@ -421,12 +421,12 @@ net::awaitable test_simple_string() net::awaitable test_number() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { // int std::string cmd {":-3\r\n"}; test_tcp_socket ts {cmd}; - resp3::number buffer; + resp3::number_type buffer; resp3::number_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, (long long int)-3, "number (int)"); @@ -435,7 +435,7 @@ net::awaitable test_number() { // unsigned std::string cmd {":3\r\n"}; test_tcp_socket ts {cmd}; - resp3::number buffer; + resp3::number_type buffer; resp3::number_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, (long long int)3, "number (unsigned)"); @@ -444,7 +444,7 @@ net::awaitable test_number() { // std::size_t std::string cmd {":1111111\r\n"}; test_tcp_socket ts {cmd}; - resp3::number buffer; + resp3::number_type buffer; resp3::number_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, (long long int)1111111, "number (std::size_t)"); @@ -453,12 +453,12 @@ net::awaitable test_number() net::awaitable test_array() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { // String std::string cmd {"*3\r\n$3\r\none\r\n$3\r\ntwo\r\n$5\r\nthree\r\n"}; test_tcp_socket ts {cmd}; - resp3::flat_array buffer; + resp3::flat_array_type buffer; resp3::flat_array_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"one", "two", "three"}, "array (dynamic)"); @@ -467,7 +467,7 @@ net::awaitable test_array() { // int std::string cmd {"*3\r\n$1\r\n1\r\n$1\r\n2\r\n$1\r\n3\r\n"}; test_tcp_socket ts {cmd}; - resp3::flat_array_int buffer; + resp3::flat_array_int_type buffer; resp3::flat_array_int_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {1, 2, 3}, "array (int)"); @@ -476,7 +476,7 @@ net::awaitable test_array() { std::string cmd {"*0\r\n"}; test_tcp_socket ts {cmd}; - resp3::flat_array buffer; + resp3::flat_array_type buffer; resp3::flat_array_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {}, "array (empty)"); @@ -485,12 +485,12 @@ net::awaitable test_array() net::awaitable test_blob_string() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {"$2\r\nhh\r\n"}; test_tcp_socket ts {cmd}; - resp3::blob_string buffer; + resp3::blob_string_type buffer; resp3::blob_string_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"hh"}, "blob_string"); @@ -499,7 +499,7 @@ net::awaitable test_blob_string() { std::string cmd {"$26\r\nhhaa\aaaa\raaaaa\r\naaaaaaaaaa\r\n"}; test_tcp_socket ts {cmd}; - resp3::blob_string buffer; + resp3::blob_string_type buffer; resp3::blob_string_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"hhaa\aaaa\raaaaa\r\naaaaaaaaaa"}, "blob_string (with separator)"); @@ -508,7 +508,7 @@ net::awaitable test_blob_string() { std::string cmd {"$0\r\n\r\n"}; test_tcp_socket ts {cmd}; - resp3::blob_string buffer; + resp3::blob_string_type buffer; resp3::blob_string_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {}, "blob_string (size 0)"); @@ -517,12 +517,12 @@ net::awaitable test_blob_string() net::awaitable test_simple_error() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {"-Error\r\n"}; test_tcp_socket ts {cmd}; - resp3::simple_error buffer; + resp3::simple_error_type buffer; resp3::simple_error_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"Error"}, "simple_error (message)"); @@ -531,12 +531,12 @@ net::awaitable test_simple_error() net::awaitable test_floating_point() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {",1.23\r\n"}; test_tcp_socket ts {cmd}; - resp3::doublean buffer; + resp3::doublean_type buffer; resp3::doublean_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"1.23"}, "double"); @@ -545,7 +545,7 @@ net::awaitable test_floating_point() { std::string cmd {",inf\r\n"}; test_tcp_socket ts {cmd}; - resp3::doublean buffer; + resp3::doublean_type buffer; resp3::doublean_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"inf"}, "double (inf)"); @@ -554,7 +554,7 @@ net::awaitable test_floating_point() { std::string cmd {",-inf\r\n"}; test_tcp_socket ts {cmd}; - resp3::doublean buffer; + resp3::doublean_type buffer; resp3::doublean_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"-inf"}, "double (-inf)"); @@ -564,12 +564,12 @@ net::awaitable test_floating_point() net::awaitable test_boolean() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {"#f\r\n"}; test_tcp_socket ts {cmd}; - resp3::boolean buffer; + resp3::boolean_type buffer; resp3::boolean_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, false, "bool (false)"); @@ -578,7 +578,7 @@ net::awaitable test_boolean() { std::string cmd {"#t\r\n"}; test_tcp_socket ts {cmd}; - resp3::boolean buffer; + resp3::boolean_type buffer; resp3::boolean_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, true, "bool (true)"); @@ -587,12 +587,12 @@ net::awaitable test_boolean() net::awaitable test_blob_error() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {"!21\r\nSYNTAX invalid syntax\r\n"}; test_tcp_socket ts {cmd}; - resp3::blob_error buffer; + resp3::blob_error_type buffer; resp3::blob_error_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"SYNTAX invalid syntax"}, "blob_error (message)"); @@ -601,7 +601,7 @@ net::awaitable test_blob_error() { std::string cmd {"!0\r\n\r\n"}; test_tcp_socket ts {cmd}; - resp3::blob_error buffer; + resp3::blob_error_type buffer; resp3::blob_error_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {}, "blob_error (empty message)"); @@ -610,12 +610,12 @@ net::awaitable test_blob_error() net::awaitable test_verbatim_string() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {"=15\r\ntxt:Some string\r\n"}; test_tcp_socket ts {cmd}; - resp3::verbatim_string buffer; + resp3::verbatim_string_type buffer; resp3::verbatim_string_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"txt:Some string"}, "verbatim_string"); @@ -624,7 +624,7 @@ net::awaitable test_verbatim_string() { std::string cmd {"=0\r\n\r\n"}; test_tcp_socket ts {cmd}; - resp3::verbatim_string buffer; + resp3::verbatim_string_type buffer; resp3::verbatim_string_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {}, "verbatim_string (empty)"); @@ -633,12 +633,12 @@ net::awaitable test_verbatim_string() net::awaitable test_set2() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {"~5\r\n+orange\r\n+apple\r\n+one\r\n+two\r\n+three\r\n"}; test_tcp_socket ts {cmd}; - resp3::flat_set buffer; + resp3::flat_set_type buffer; resp3::flat_set_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"orange", "apple", "one", "two", "three"}, "set"); @@ -647,7 +647,7 @@ net::awaitable test_set2() { std::string cmd {"~5\r\n+orange\r\n+apple\r\n+one\r\n+two\r\n+three\r\n"}; test_tcp_socket ts {cmd}; - resp3::flat_set buffer; + resp3::flat_set_type buffer; resp3::flat_set_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"orange", "apple", "one", "two", "three"}, "set (flat)"); @@ -656,7 +656,7 @@ net::awaitable test_set2() { std::string cmd {"~0\r\n"}; test_tcp_socket ts {cmd}; - resp3::flat_set buffer; + resp3::flat_set_type buffer; resp3::flat_set_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {}, "set (empty)"); @@ -665,12 +665,12 @@ net::awaitable test_set2() net::awaitable test_map() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {"%7\r\n$6\r\nserver\r\n$5\r\nredis\r\n$7\r\nversion\r\n$5\r\n6.0.9\r\n$5\r\nproto\r\n:3\r\n$2\r\nid\r\n:203\r\n$4\r\nmode\r\n$10\r\nstandalone\r\n$4\r\nrole\r\n$6\r\nmaster\r\n$7\r\nmodules\r\n*0\r\n"}; test_tcp_socket ts {cmd}; - resp3::flat_map buffer; + resp3::flat_map_type buffer; resp3::flat_map_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {"server", "redis", "version", "6.0.9", "proto", "3", "id", "203", "mode", "standalone", "role", "master", "modules"}, "map (flat)"); @@ -679,7 +679,7 @@ net::awaitable test_map() { std::string cmd {"%0\r\n"}; test_tcp_socket ts {cmd}; - resp3::flat_map buffer; + resp3::flat_map_type buffer; resp3::flat_map_adapter res{&buffer}; co_await async_read_one(ts, buf, res); check_equal(buffer, {}, "map (flat - empty)"); @@ -688,24 +688,24 @@ net::awaitable test_map() net::awaitable test_streamed_string() { - using namespace aedis::detail; + using namespace aedis; std::string buf; { std::string cmd {"$?\r\n;4\r\nHell\r\n;5\r\no wor\r\n;1\r\nd\r\n;0\r\n"}; test_tcp_socket ts {cmd}; - resp3::streamed_string_part buffer; + resp3::streamed_string_part_type buffer; resp3::streamed_string_part_adapter res{&buffer}; - co_await async_read_one(ts, buf, res); + co_await resp3::async_read_one(ts, buf, res); check_equal(buffer, {"Hello word"}, "streamed string"); } { std::string cmd {"$?\r\n;0\r\n"}; test_tcp_socket ts {cmd}; - response resp; + resp3::response resp; auto* adapter = resp.select_adapter(resp3::type::streamed_string_part, command::unknown); - co_await async_read_one(ts, buf, *adapter); - check_equal(resp.streamed_string_part, {}, "streamed string (empty)"); + co_await resp3::async_read_one(ts, buf, *adapter); + check_equal(resp.streamed_string_part(), {}, "streamed string (empty)"); } }