Removes memory_resource.

Author: mzimbres

examples/cpp20_serialization.cpp

@@ -76,7 +76,7 @@ auto tag_invoke(value_to_tag<user>, value const& jv)
 }
 
 // Serialization
-void to_bulk(std::pmr::string& to, user const& u)
+void to_bulk(std::string& to, user const& u)
 {
    redis::resp3::to_bulk(to, serialize(value_from(u)));
 }

include/boost/redis/connection.hpp

@@ -21,20 +21,19 @@ namespace boost::redis {
  *  For more details, please see the documentation of each individual
  *  function.
  *
- *  @tparam AsyncReadWriteStream A stream that supports reading and
- *  writing.
+ *  @tparam Socket The socket type e.g. asio::ip::tcp::socket.
  */
-template <class AsyncReadWriteStream>
+template <class Socket>
 class basic_connection :
    private detail::connection_base<
-      typename AsyncReadWriteStream::executor_type,
-      basic_connection<AsyncReadWriteStream>> {
+      typename Socket::executor_type,
+      basic_connection<Socket>> {
 public:
    /// Executor type.
-   using executor_type = typename AsyncReadWriteStream::executor_type;
+   using executor_type = typename Socket::executor_type;
 
    /// Type of the next layer
-   using next_layer_type = AsyncReadWriteStream;
+   using next_layer_type = Socket;
 
    /// Rebinds the socket type to another executor.
    template <class Executor1>
@@ -44,23 +43,19 @@ class basic_connection :
       using other = basic_connection<typename next_layer_type::template rebind_executor<Executor1>::other>;
    };
 
-   using base_type = detail::connection_base<executor_type, basic_connection<AsyncReadWriteStream>>;
+   using base_type = detail::connection_base<executor_type, basic_connection<Socket>>;
 
    /// Contructs from an executor.
    explicit
-   basic_connection(
-      executor_type ex,
-      std::pmr::memory_resource* resource = std::pmr::get_default_resource())
-   : base_type{ex, resource}
+   basic_connection(executor_type ex)
+   : base_type{ex}
    , stream_{ex}
    {}
 
    /// Contructs from a context.
    explicit
-   basic_connection(
-      asio::io_context& ioc,
-      std::pmr::memory_resource* resource = std::pmr::get_default_resource())
-   : basic_connection(ioc.get_executor(), resource)
+   basic_connection(asio::io_context& ioc)
+   : basic_connection(ioc.get_executor())
    { }
 
    /// Returns the associated executor.
@@ -190,6 +185,17 @@ class basic_connection :
    void set_max_buffer_read_size(std::size_t max_read_size) noexcept
       { base_type::set_max_buffer_read_size(max_read_size); }
 
+   /** @brief Reserve memory on the read and write internal buffers.
+    *
+    *  This function will call `std::string::reserve` on the
+    *  underlying buffers.
+    *  
+    *  @param read The new capacity of the read buffer.
+    *  @param write The new capacity of the write buffer.
+    */
+   void reserve(std::size_t read, std::size_t write)
+      { base_type::reserve(read, write); }
+
 private:
    using this_type = basic_connection<next_layer_type>;
 
@@ -206,7 +212,7 @@ class basic_connection :
    auto is_open() const noexcept { return stream_.is_open(); }
    auto lowest_layer() noexcept -> auto& { return stream_.lowest_layer(); }
 
-   AsyncReadWriteStream stream_;
+   Socket stream_;
 };
 
 /** \brief A connection that uses a asio::ip::tcp::socket.

include/boost/redis/detail/connection_base.hpp

@@ -24,7 +24,6 @@
 #include <chrono>
 #include <memory>
 #include <type_traits>
-#include <memory_resource>
 
 namespace boost::redis::detail {
 
@@ -43,13 +42,10 @@ class connection_base {
    using executor_type = Executor;
    using this_type = connection_base<Executor, Derived>;
 
-   connection_base(executor_type ex, std::pmr::memory_resource* resource)
+   connection_base(executor_type ex)
    : writer_timer_{ex}
    , read_timer_{ex}
    , channel_{ex}
-   , read_buffer_{resource}
-   , write_buffer_{resource}
-   , reqs_{resource}
    {
       writer_timer_.expires_at(std::chrono::steady_clock::time_point::max());
       read_timer_.expires_at(std::chrono::steady_clock::time_point::max());
@@ -166,6 +162,13 @@ class connection_base {
    void set_max_buffer_read_size(std::size_t max_read_size) noexcept
       {max_read_size_ = max_read_size;}
 
+   // Reserves memory in the read and write buffer.
+   void reserve(std::size_t read, std::size_t write)
+   {
+      read_buffer_.reserve(read);
+      write_buffer_.reserve(write);
+   }
+
 private:
    using clock_type = std::chrono::steady_clock;
    using clock_traits_type = asio::wait_traits<clock_type>;
@@ -269,7 +272,7 @@ class connection_base {
       reqs_.erase(std::remove(std::begin(reqs_), std::end(reqs_), info));
    }
 
-   using reqs_type = std::pmr::deque<std::shared_ptr<req_info>>;
+   using reqs_type = std::deque<std::shared_ptr<req_info>>;
 
    template <class> friend struct detail::reader_op;
    template <class> friend struct detail::writer_op;
@@ -383,8 +386,8 @@ class connection_base {
    timer_type read_timer_;
    channel_type channel_;
 
-   std::pmr::string read_buffer_;
-   std::pmr::string write_buffer_;
+   std::string read_buffer_;
+   std::string write_buffer_;
    reqs_type reqs_;
    std::size_t max_read_size_ = (std::numeric_limits<std::size_t>::max)();
 };

include/boost/redis/resp3/request.hpp

@@ -11,7 +11,6 @@
 
 #include <string>
 #include <tuple>
-#include <memory_resource>
 
 // NOTE: Consider detecting tuples in the type in the parameter pack
 // to calculate the header size correctly.
@@ -164,7 +163,7 @@ void add_separator(Request& to)
  *
  *  \li Non-string types will be converted to string by using \c
  *  to_bulk, which must be made available over ADL.
- *  \li Uses a std::pmr::string for internal storage.
+ *  \li Uses a std::string for internal storage.
  */
 class request {
 public:
@@ -211,9 +210,8 @@ class request {
     *  \param resource Memory resource.
     */
     explicit
-    request(config cfg = config{true, true, false, true, true},
-            std::pmr::memory_resource* resource = std::pmr::get_default_resource())
-    : cfg_{cfg}, payload_(resource) {}
+    request(config cfg = config{true, true, false, true, true})
+    : cfg_{cfg} {}
 
     //// Returns the number of commands contained in this request.
    [[nodiscard]] auto size() const noexcept -> std::size_t
@@ -232,7 +230,7 @@ class request {
       commands_ = 0;
    }
 
-   /// Calls std::pmr::string::reserve on the internal storage.
+   /// Calls std::string::reserve on the internal storage.
    void reserve(std::size_t new_cap = 0)
       { payload_.reserve(new_cap); }
 
@@ -395,7 +393,7 @@ class request {
    }
 
    config cfg_;
-   std::pmr::string payload_;
+   std::string payload_;
    std::size_t commands_ = 0;
    bool has_hello_priority_ = false;
 };

include/boost/redis/ssl/connection.hpp

@@ -25,18 +25,17 @@ class basic_connection;
  *  commands can be sent at any time. For more details, please see the
  *  documentation of each individual function.
  *
- *  @tparam AsyncReadWriteStream A stream that supports reading and
- *  writing.
+ *  @tparam Socket The socket type e.g. asio::ip::tcp::socket.
  *
  */
-template <class AsyncReadWriteStream>
-class basic_connection<asio::ssl::stream<AsyncReadWriteStream>> :
+template <class Socket>
+class basic_connection<asio::ssl::stream<Socket>> :
    private redis::detail::connection_base<
-      typename asio::ssl::stream<AsyncReadWriteStream>::executor_type,
-      basic_connection<asio::ssl::stream<AsyncReadWriteStream>>> {
+      typename asio::ssl::stream<Socket>::executor_type,
+      basic_connection<asio::ssl::stream<Socket>>> {
 public:
    /// Type of the next layer
-   using next_layer_type = asio::ssl::stream<AsyncReadWriteStream>;
+   using next_layer_type = asio::ssl::stream<Socket>;
 
    /// Executor type.
    using executor_type = typename next_layer_type::executor_type;
@@ -46,28 +45,22 @@ class basic_connection<asio::ssl::stream<AsyncReadWriteStream>> :
    struct rebind_executor
    {
       /// The socket type when rebound to the specified executor.
-      using other = basic_connection<asio::ssl::stream<typename AsyncReadWriteStream::template rebind_executor<Executor1>::other>>;
+      using other = basic_connection<asio::ssl::stream<typename Socket::template rebind_executor<Executor1>::other>>;
    };
 
-   using base_type = redis::detail::connection_base<executor_type, basic_connection<asio::ssl::stream<AsyncReadWriteStream>>>;
+   using base_type = redis::detail::connection_base<executor_type, basic_connection<asio::ssl::stream<Socket>>>;
 
    /// Constructor
    explicit
-   basic_connection(
-      executor_type ex,
-      asio::ssl::context& ctx,
-      std::pmr::memory_resource* resource = std::pmr::get_default_resource())
-   : base_type{ex, resource}
+   basic_connection(executor_type ex, asio::ssl::context& ctx)
+   : base_type{ex}
    , stream_{ex, ctx}
    { }
 
    /// Constructor
    explicit
-   basic_connection(
-      asio::io_context& ioc,
-      asio::ssl::context& ctx,
-      std::pmr::memory_resource* resource = std::pmr::get_default_resource())
-   : basic_connection(ioc.get_executor(), ctx, resource)
+   basic_connection(asio::io_context& ioc, asio::ssl::context& ctx)
+   : basic_connection(ioc.get_executor(), ctx)
    { }
 
    /// Returns the associated executor.
@@ -137,6 +130,17 @@ class basic_connection<asio::ssl::stream<AsyncReadWriteStream>> :
    void set_max_buffer_read_size(std::size_t max_read_size) noexcept
       { base_type::set_max_buffer_read_size(max_read_size); }
 
+   /** @brief Reserve memory on the read and write internal buffers.
+    *
+    *  This function will call `std::string::reserve` on the
+    *  underlying buffers.
+    *  
+    *  @param read The new capacity of the read buffer.
+    *  @param write The new capacity of the write buffer.
+    */
+   void reserve(std::size_t read, std::size_t write)
+      { base_type::reserve(read, write); }
+
 private:
    using this_type = basic_connection<next_layer_type>;
 

tests/request.cpp

@@ -5,7 +5,6 @@
  */
 
 #include <iostream>
-#include <memory_resource>
 
 #define BOOST_TEST_MODULE low level
 #include <boost/test/included/unit_test.hpp>
@@ -19,26 +18,24 @@ using boost::redis::resp3::request;
 
 BOOST_AUTO_TEST_CASE(single_arg_allocator)
 {
-   char buf[4096];
-   std::pmr::monotonic_buffer_resource resource{buf, 4096};
-   request req1{{}, &resource};
+   request req1;
    req1.push("PING");
-   BOOST_CHECK_EQUAL(req1.payload(), std::pmr::string{"*1\r\n$4\r\nPING\r\n"});
+   BOOST_CHECK_EQUAL(req1.payload(), std::string{"*1\r\n$4\r\nPING\r\n"});
 }
 
 BOOST_AUTO_TEST_CASE(arg_int)
 {
    request req;
    req.push("PING", 42);
-   BOOST_CHECK_EQUAL(req.payload(), std::pmr::string{"*2\r\n$4\r\nPING\r\n$2\r\n42\r\n"});
+   BOOST_CHECK_EQUAL(req.payload(), std::string{"*2\r\n$4\r\nPING\r\n$2\r\n42\r\n"});
 }
 
 BOOST_AUTO_TEST_CASE(multiple_args)
 {
    char const* res = "*5\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n$2\r\nEX\r\n$1\r\n2\r\n";
    request req;
    req.push("SET", "key", "value", "EX", "2");
-   BOOST_CHECK_EQUAL(req.payload(), std::pmr::string{res});
+   BOOST_CHECK_EQUAL(req.payload(), std::string{res});
 }
 
 BOOST_AUTO_TEST_CASE(container_and_range)
@@ -49,9 +46,9 @@ BOOST_AUTO_TEST_CASE(container_and_range)
 
    request req1;
    req1.push_range("HSET", "key", in);
-   BOOST_CHECK_EQUAL(req1.payload(), std::pmr::string{res});
+   BOOST_CHECK_EQUAL(req1.payload(), std::string{res});
 
    request req2;
    req2.push_range("HSET", "key", std::cbegin(in), std::cend(in));
-   BOOST_CHECK_EQUAL(req2.payload(), std::pmr::string{res});
+   BOOST_CHECK_EQUAL(req2.payload(), std::string{res});
 }