relax requirements: use c++11 instead c++14

basiliscos · basiliscos · commit 9e3b7b5bff6f · 2019-08-10T12:36:32.000+03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,14 +1,13 @@
 cmake_minimum_required(VERSION 3.0)
 project (bredis)
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 include (CTest)
 enable_testing()
 
 
-
 add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY)
 add_definitions(-DBOOST_COROUTINES_NO_DEPRECATION_WARNING)
 #add_definitions(-DBREDIS_DEBUG)
diff --git a/examples/multi-threads-1.cpp b/examples/multi-threads-1.cpp
@@ -35,12 +35,15 @@
 namespace r = bredis;
 namespace asio = boost::asio;
 namespace po = boost::program_options;
+namespace sys = boost::system;
 
 using socket_t = asio::ip::tcp::socket;
 using next_layer_t = socket_t;
 //using next_layer_t = r::test::SocketWithLogging<asio::ip::tcp::socket>;
 using Buffer = boost::asio::streambuf;
 using Iterator = typename r::to_iterator<Buffer>::iterator_t;
+using Policy = r::parsing_policy::keep_result;
+using result_t = r::positive_parse_result_t<Iterator, Policy>;
 using Connection = r::Connection<next_layer_t>;
 
 struct redis_accessor_t {
@@ -64,8 +67,9 @@ struct producer_t {
         redis.conn.async_write(
             redis.tx_buff,
             cmd_ping,
-            asio::bind_executor(redis.strand, [self = this](const auto &error_code, size_t bytes_transferred){
-                if (!error_code){
+            asio::bind_executor(redis.strand, [this](const sys::error_code &ec, std::size_t bytes_transferred){
+                if (!ec){
+                    auto self = this;
                     self->redis.ping_count++;
                     self->redis.tx_buff.consume(bytes_transferred);
                     self->produce();
@@ -83,8 +87,9 @@ struct consumer_t {
     void consume(){
         redis.conn.async_read(
             redis.rx_buff,
-            asio::bind_executor(redis.strand, [self = this](const auto &error_code, auto &&r){
-                if(!error_code){
+            asio::bind_executor(redis.strand, [this](const sys::error_code &ec, result_t &&r){
+                if(!ec){
+                    auto self = this;
                     self->redis.pong_count++;
                     self->redis.rx_buff.consume(r.consumed);
                     self->consume();
@@ -103,8 +108,9 @@ struct watcher_t {
     void watch() {
         timer.expires_after(asio::chrono::seconds(1));
         timer.async_wait(
-            asio::bind_executor(redis.strand, [self = this](const auto &error_code){
-                if (!error_code) {
+            asio::bind_executor(redis.strand, [this](const sys::error_code &ec){
+                if (!ec) {
+                    auto self = this;
                     std::cout << "pings: " << self->redis.ping_count << ", pongs: " << self->redis.pong_count << "\n";
                     self->watch();
                 }
diff --git a/include/bredis/Command.hpp b/include/bredis/Command.hpp
@@ -6,9 +6,9 @@
 //
 #pragma once
 
+#include <boost/core/enable_if.hpp>
 #include <boost/utility/string_ref.hpp>
 #include <boost/variant.hpp>
-#include <type_traits>
 #include <vector>
 
 #include "Result.hpp"
@@ -31,14 +31,14 @@ struct single_command_t {
     args_container_t arguments;
 
     template <typename... Args,
-              typename = std::enable_if_t<detail::are_all_constructible<
+              typename = boost::enable_if_t<detail::are_all_constructible<
                   boost::string_ref, Args...>::value>>
     single_command_t(Args &&... args) : arguments{std::forward<Args>(args)...} {
         static_assert(sizeof...(Args) >= 1, "Empty command is not allowed");
     }
 
     template <typename InputIterator,
-              typename = std::enable_if_t<std::is_constructible<
+              typename = boost::enable_if_t<std::is_constructible<
                   boost::string_ref, typename std::iterator_traits<
                                          InputIterator>::value_type>::value>>
     single_command_t(InputIterator first, InputIterator last)
diff --git a/include/bredis/MarkerHelpers.hpp b/include/bredis/MarkerHelpers.hpp
@@ -8,6 +8,7 @@
 #pragma once
 
 #include <algorithm>
+#include <boost/algorithm/cxx14/equal.hpp>
 #include <boost/convert.hpp>
 #include <boost/convert/lexical_cast.hpp>
 #include <cctype>
@@ -81,21 +82,22 @@ class equality : public boost::static_visitor<bool> {
     }
 
     bool operator()(const markers::string_t<Iterator> &value) const {
-        auto helper = stringizer<Iterator>();
-        auto str = helper(value);
-        return std::equal(begin_, end_, value.from, value.to);
+        return boost::algorithm::equal(begin_, end_, value.from, value.to);
     }
 
     bool operator()(const markers::int_t<Iterator> &value) const {
-        return std::equal(begin_, end_, value.string.from, value.string.to);
+        return boost::algorithm::equal(begin_, end_, value.string.from,
+                                       value.string.to);
     }
 
     bool operator()(const markers::error_t<Iterator> &value) const {
-        return std::equal(begin_, end_, value.string.from, value.string.to);
+        return boost::algorithm::equal(begin_, end_, value.string.from,
+                                       value.string.to);
     }
 
     bool operator()(const markers::nil_t<Iterator> &value) const {
-        return std::equal(begin_, end_, value.string.from, value.string.to);
+        return boost::algorithm::equal(begin_, end_, value.string.from,
+                                       value.string.to);
     }
 };
 
@@ -172,8 +174,8 @@ class check_subscription : public boost::static_visitor<bool> {
             }
 
             const auto &channel_ = cmd_.arguments[idx];
-            return std::equal(channel_.cbegin(), channel_.cend(), channel->from,
-                              channel->to);
+            return boost::algorithm::equal(channel_.cbegin(), channel_.cend(),
+                                           channel->from, channel->to);
         }
         return false;
     }
diff --git a/include/bredis/impl/connection.ipp b/include/bredis/impl/connection.ipp
@@ -9,9 +9,9 @@
 
 #include "common.ipp"
 #include <algorithm>
+#include <boost/type_traits/decay.hpp>
 #include <cassert>
 #include <ostream>
-#include <type_traits>
 
 #include "async_op.ipp"
 
@@ -29,7 +29,7 @@ Connection<NextLayer>::async_write(DynamicBuffer &tx_buff,
 
     using boost::asio::async_write;
     using Signature = void(boost::system::error_code, std::size_t);
-    using Callback = std::decay_t<WriteCallback>;
+    using Callback = boost::decay_t<WriteCallback>;
     using AsyncResult = asio::async_result<Callback, Signature>;
     using CompletionHandler = typename AsyncResult::completion_handler_type;
     using serializer_t = command_serializer_visitor<DynamicBuffer>;
@@ -58,7 +58,7 @@ Connection<NextLayer>::async_read(DynamicBuffer &rx_buff,
     using Iterator = typename to_iterator<DynamicBuffer>::iterator_t;
     using ParseResult = BREDIS_PARSE_RESULT(DynamicBuffer, Policy);
     using Signature = void(boost::system::error_code, ParseResult);
-    using Callback = std::decay_t<ReadCallback>;
+    using Callback = boost::decay_t<ReadCallback>;
     using AsyncResult = asio::async_result<Callback, Signature>;
     using CompletionHandler = typename AsyncResult::completion_handler_type;
     using ReadOp =
diff --git a/t/10-ping.cpp b/t/10-ping.cpp
@@ -14,6 +14,7 @@ namespace r = bredis;
 namespace asio = boost::asio;
 namespace ep = empty_port;
 namespace ts = test_server;
+namespace sys = boost::system;
 
 TEST_CASE("ping", "[connection]") {
     using socket_t = asio::ip::tcp::socket;
@@ -48,10 +49,11 @@ TEST_CASE("ping", "[connection]") {
     Buffer tx_buff, rx_buff;
 
     c.async_write(
-        tx_buff, "ping", [&](const auto &error_code, auto bytes_transferred) {
+        tx_buff, "ping",
+        [&](const sys::error_code &error_code, std::size_t bytes_transferred) {
             REQUIRE(!error_code);
             tx_buff.consume(bytes_transferred);
-            c.async_read(rx_buff, [&](const auto&, auto &&r) {
+            c.async_read(rx_buff, [&](const sys::error_code &, result_t &&r) {
                 completion_promise.set_value(r);
                 rx_buff.consume(r.consumed);
             });
diff --git a/t/11-multi-ping.cpp b/t/11-multi-ping.cpp
@@ -1,7 +1,7 @@
 #include <boost/asio.hpp>
 #include <future>
-#include <vector>
 #include <string>
+#include <vector>
 
 #include "EmptyPort.hpp"
 #include "SocketWithLogging.hpp"
@@ -14,6 +14,7 @@ namespace r = bredis;
 namespace asio = boost::asio;
 namespace ep = empty_port;
 namespace ts = test_server;
+namespace sys = boost::system;
 
 TEST_CASE("ping", "[connection]") {
     using socket_t = asio::ip::tcp::socket;
@@ -59,23 +60,23 @@ TEST_CASE("ping", "[connection]") {
     std::future<result_t> completion_future = completion_promise.get_future();
 
     Buffer tx_buff, rx_buff;
-    read_callback_t read_callback =
-        [&](const boost::system::error_code &error_code, ParseResult &&r) {
-            if (error_code) {
-                BREDIS_LOG_DEBUG("error: " << error_code.message());
-                REQUIRE(!error_code);
-            }
+    read_callback_t read_callback = [&](const sys::error_code &error_code,
+                                        ParseResult &&r) {
+        if (error_code) {
+            BREDIS_LOG_DEBUG("error: " << error_code.message());
             REQUIRE(!error_code);
-            auto &replies =
-                boost::get<r::markers::array_holder_t<Iterator>>(r.result);
-            BREDIS_LOG_DEBUG("callback, size: " << replies.elements.size());
-            REQUIRE(replies.elements.size() == count);
-            completion_promise.set_value();
-            rx_buff.consume(r.consumed);
-        };
+        }
+        REQUIRE(!error_code);
+        auto &replies =
+            boost::get<r::markers::array_holder_t<Iterator>>(r.result);
+        BREDIS_LOG_DEBUG("callback, size: " << replies.elements.size());
+        REQUIRE(replies.elements.size() == count);
+        completion_promise.set_value();
+        rx_buff.consume(r.consumed);
+    };
 
-    write_callback_t write_callback = [&](
-        const boost::system::error_code &error_code, auto bytes_transferred) {
+    write_callback_t write_callback = [&](const sys::error_code &error_code,
+                                          std::size_t bytes_transferred) {
         (void)bytes_transferred;
         BREDIS_LOG_DEBUG("write_callback");
         if (error_code) {
diff --git a/t/12-basic-types.cpp b/t/12-basic-types.cpp
@@ -15,6 +15,7 @@ namespace r = bredis;
 namespace asio = boost::asio;
 namespace ep = empty_port;
 namespace ts = test_server;
+namespace sys = boost::system;
 
 TEST_CASE("ping", "[connection]") {
     using socket_t = asio::ip::tcp::socket;
@@ -64,7 +65,7 @@ TEST_CASE("ping", "[connection]") {
         r::single_command_t("time"),
     };
     std::vector<read_callback_t> callbacks{
-        [&](const boost::system::error_code&error_code, ParseResult &&r) {
+        [&](const boost::system::error_code &error_code, ParseResult &&r) {
             auto extract = boost::apply_visitor(Extractor(), r.result);
             REQUIRE(boost::get<r::extracts::int_t>(extract) == 0);
             REQUIRE(order == 0);
@@ -120,12 +121,13 @@ TEST_CASE("ping", "[connection]") {
             c.async_read(rx_buff, generic_callback);
         };
 
-    c.async_write(tx_buff, r::command_wrapper_t(cmds_container),
-                  [&](const auto &error_code, auto bytes_transferred) {
-                      REQUIRE(!error_code);
-                      tx_buff.consume(bytes_transferred);
-                      c.async_read(rx_buff, generic_callback);
-                  });
+    c.async_write(
+        tx_buff, r::command_wrapper_t(cmds_container),
+        [&](const sys::error_code &ec, std::size_t bytes_transferred) {
+            REQUIRE(!ec);
+            tx_buff.consume(bytes_transferred);
+            c.async_read(rx_buff, generic_callback);
+        });
 
     while (completion_future.wait_for(sleep_delay) !=
            std::future_status::ready) {
diff --git a/t/13-protol-error.cpp b/t/13-protol-error.cpp
@@ -13,6 +13,7 @@ namespace r = bredis;
 namespace asio = boost::asio;
 namespace sys = boost::system;
 namespace ep = empty_port;
+namespace sys = boost::system;
 
 TEST_CASE("protocol-error", "[connection]") {
     using socket_t = asio::ip::tcp::socket;
@@ -53,17 +54,18 @@ TEST_CASE("protocol-error", "[connection]") {
         async_read_until(
             peer_socket, remote_rx_buff, end_marker,
             [&](const sys::error_code &ec, std::size_t sz) {
-                (void)ec;(void)sz;
+                (void)ec;
+                (void)sz;
                 BREDIS_LOG_DEBUG("async_read: " << sz << ", " << ec.message());
 
                 async_write(peer_socket, output_buf,
                             [&](const sys::error_code &ec, std::size_t sz) {
-                                (void)ec;(void)sz;
+                                (void)ec;
+                                (void)sz;
                                 BREDIS_LOG_DEBUG("async_write: "
                                                  << sz << ", " << ec.message());
                             });
             });
-
     });
 
     socket_t socket(io_service, end_point.protocol());
@@ -75,14 +77,16 @@ TEST_CASE("protocol-error", "[connection]") {
 
     Buffer rx_buff, tx_buff;
     c.async_write(
-        tx_buff, "ping", [&](const auto &error_code, auto bytes_transferred) {
-            REQUIRE(!error_code);
+        tx_buff, "ping",
+        [&](const sys::error_code &ec, std::size_t bytes_transferred) {
+            REQUIRE(!ec);
             tx_buff.consume(bytes_transferred);
-            c.async_read(rx_buff, [&](const auto &error_code, ParseResult &&) {
-                REQUIRE(error_code);
-                REQUIRE(error_code.message() == "Wrong introduction");
-                completion_promise.set_value();
-            });
+            c.async_read(rx_buff,
+                         [&](const sys::error_code &ec, ParseResult &&) {
+                             REQUIRE(ec);
+                             REQUIRE(ec.message() == "Wrong introduction");
+                             completion_promise.set_value();
+                         });
         });
     while (completion_future.wait_for(sleep_delay) !=
            std::future_status::ready) {
diff --git a/t/14-uds.cpp b/t/14-uds.cpp
@@ -18,6 +18,7 @@ namespace r = bredis;
 namespace asio = boost::asio;
 namespace ts = test_server;
 namespace ep = empty_port;
+namespace sys = boost::system;
 
 struct tmpfile_holder_t {
     char *filename_;
@@ -75,9 +76,9 @@ TEST_CASE("ping", "[connection]") {
     std::future<result_t> completion_future = completion_promise.get_future();
     Buffer rx_buff, tx_buff;
 
-    read_callback_t read_callback = [&](const auto &error_code,
+    read_callback_t read_callback = [&](const sys::error_code &ec,
                                         ParseResult &&r) {
-        REQUIRE(!error_code);
+        REQUIRE(!ec);
         rx_buff.consume(r.consumed);
 
         auto str = boost::apply_visitor(
@@ -96,12 +97,13 @@ TEST_CASE("ping", "[connection]") {
         completion_promise.set_value();
     };
 
-    c.async_write(tx_buff, cmd,
-                  [&](const auto &error_code, auto bytes_transferred) {
-                      REQUIRE(!error_code);
-                      tx_buff.consume(bytes_transferred);
-                      c.async_read(rx_buff, read_callback, count);
-                  });
+    c.async_write(
+        tx_buff, cmd,
+        [&](const sys::error_code &ec, std::size_t bytes_transferred) {
+            REQUIRE(!ec);
+            tx_buff.consume(bytes_transferred);
+            c.async_read(rx_buff, read_callback, count);
+        });
 
     while (completion_future.wait_for(sleep_delay) !=
            std::future_status::ready) {
diff --git a/t/15-cancellation.cpp b/t/15-cancellation.cpp
diff --git a/t/16-close-connection.cpp b/t/16-close-connection.cpp
diff --git a/t/19-transaction.cpp b/t/19-transaction.cpp
diff --git a/t/22-ping_drop-policy.cpp b/t/22-ping_drop-policy.cpp
diff --git a/t/TestServer.hpp b/t/TestServer.hpp

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`#pragma once`
`9`	`9`
`10`	`10`	`#include <algorithm>`
	`11`	`+#include <boost/algorithm/cxx14/equal.hpp>`
`11`	`12`	`#include <boost/convert.hpp>`
`12`	`13`	`#include <boost/convert/lexical_cast.hpp>`
`13`	`14`	`#include <cctype>`
`@@ -81,21 +82,22 @@ class equality : public boost::static_visitor<bool> {`
`81`	`82`	`}`
`82`	`83`
`83`	`84`	`bool operator()(const markers::string_t<Iterator> &value) const {`
`84`		`- auto helper = stringizer<Iterator>();`
`85`		`- auto str = helper(value);`
`86`		`- return std::equal(begin_, end_, value.from, value.to);`
	`85`	`+ return boost::algorithm::equal(begin_, end_, value.from, value.to);`
`87`	`86`	`}`
`88`	`87`
`89`	`88`	`bool operator()(const markers::int_t<Iterator> &value) const {`
`90`		`- return std::equal(begin_, end_, value.string.from, value.string.to);`
	`89`	`+ return boost::algorithm::equal(begin_, end_, value.string.from,`
	`90`	`+ value.string.to);`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`bool operator()(const markers::error_t<Iterator> &value) const {`
`94`		`- return std::equal(begin_, end_, value.string.from, value.string.to);`
	`94`	`+ return boost::algorithm::equal(begin_, end_, value.string.from,`
	`95`	`+ value.string.to);`
`95`	`96`	`}`
`96`	`97`
`97`	`98`	`bool operator()(const markers::nil_t<Iterator> &value) const {`
`98`		`- return std::equal(begin_, end_, value.string.from, value.string.to);`
	`99`	`+ return boost::algorithm::equal(begin_, end_, value.string.from,`
	`100`	`+ value.string.to);`
`99`	`101`	`}`
`100`	`102`	`};`
`101`	`103`
`@@ -172,8 +174,8 @@ class check_subscription : public boost::static_visitor<bool> {`
`172`	`174`	`}`
`173`	`175`
`174`	`176`	`const auto &channel_ = cmd_.arguments[idx];`
`175`		`- return std::equal(channel_.cbegin(), channel_.cend(), channel->from,`
`176`		`- channel->to);`
	`177`	`+ return boost::algorithm::equal(channel_.cbegin(), channel_.cend(),`
	`178`	`+ channel->from, channel->to);`
`177`	`179`	`}`
`178`	`180`	`return false;`
`179`	`181`	`}`