Uses class specialization instead of function overload. [skip-ci]

Author: mzimbres

example/cpp20_json.cpp

@@ -21,6 +21,7 @@
 #include <boost/redis/resp3/serialization.hpp>
 
 namespace asio = boost::asio;
+namespace resp3 = boost::redis::resp3;
 using namespace boost::describe;
 using boost::redis::request;
 using boost::redis::response;
@@ -42,8 +43,14 @@ BOOST_DESCRIBE_STRUCT(user, (), (name, age, country))
 void boost_redis_to_bulk(std::string& to, user const& u)
    { boost::redis::resp3::boost_redis_to_bulk(to, boost::json::serialize(boost::json::value_from(u))); }
 
-void boost_redis_from_bulk(user& u, std::string_view sv, boost::system::error_code&)
-   { u = boost::json::value_to<user>(boost::json::parse(sv)); }
+void
+boost_redis_from_bulk(
+   user& u,
+   resp3::node_view const& node,
+   boost::system::error_code&)
+{
+   u = boost::json::value_to<user>(boost::json::parse(node.value));
+}
 
 auto co_main(config cfg) -> asio::awaitable<void>
 {

example/cpp20_protobuf.cpp

@@ -19,6 +19,7 @@
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
 
 namespace asio = boost::asio;
+namespace resp3 = boost::redis::resp3;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::operation;
@@ -45,9 +46,13 @@ void boost_redis_to_bulk(std::string& to, person const& u)
    boost::redis::resp3::boost_redis_to_bulk(to, tmp);
 }
 
-void boost_redis_from_bulk(person& u, std::string_view sv, boost::system::error_code& ec)
+void
+boost_redis_from_bulk(
+   person& u,
+   resp3::node_view const& node,
+   boost::system::error_code& ec)
 {
-   std::string const tmp {sv};
+   std::string const tmp {node.value};
    if (!u.ParseFromString(tmp))
       ec = boost::redis::error::invalid_data_type;
 }

include/boost/redis/adapter/detail/adapters.hpp

@@ -37,49 +37,91 @@
 namespace boost::redis::adapter::detail
 {
 
-// Serialization.
+template <class> struct is_integral : std::false_type {};
 
-template <class T>
-auto boost_redis_from_bulk(T& i, std::string_view sv, system::error_code& ec) -> typename std::enable_if<std::is_integral<T>::value, void>::type
-{
-   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), i);
-   if (res.ec != std::errc())
-      ec = redis::error::not_a_number;
-}
+template <> struct is_integral<long long int         > : std::true_type {};
+template <> struct is_integral<unsigned long long int> : std::true_type {};
+template <> struct is_integral<int                   > : std::true_type {};
 
-inline
-void boost_redis_from_bulk(bool& t, std::string_view sv, system::error_code&)
-{
-   t = *sv.data() == 't';
-}
+template<class T, bool = is_integral<T>::value>
+struct converter_impl;
 
-inline
-void boost_redis_from_bulk(double& d, std::string_view sv, system::error_code& ec)
-{
+template<class T>
+struct converter_impl<T, true> {
+   template <class String>
+   static void
+   apply(
+      T& i,
+      resp3::basic_node<String> const& node,
+      system::error_code& ec)
+   {
+      auto const res =
+         std::from_chars(node.value.data(), node.value.data() + node.value.size(), i);
+      if (res.ec != std::errc())
+         ec = redis::error::not_a_number;
+   }
+};
+
+template<>
+struct converter_impl<bool, false> {
+   template <class String>
+   static void
+   apply(
+      bool& t,
+      resp3::basic_node<String> const& node,
+      system::error_code& ec)
+   {
+      t = *node.value.data() == 't';
+   }
+};
+
+template<>
+struct converter_impl<double, false> {
+   template <class String>
+   static void
+   apply(
+      double& d,
+      resp3::basic_node<String> const& node,
+      system::error_code& ec)
+   {
 #ifdef _LIBCPP_VERSION
-   // The string in sv is not null terminated and we also don't know
-   // if there is enough space at the end for a null char. The easiest
-   // thing to do is to create a temporary.
-   std::string const tmp{sv.data(), sv.data() + std::size(sv)};
-   char* end{};
-   d = std::strtod(tmp.data(), &end);
-   if (d == HUGE_VAL || d == 0)
-      ec = redis::error::not_a_double;
+      // The string in node.value is not null terminated and we also
+      // don't know if there is enough space at the end for a null
+      // char. The easiest thing to do is to create a temporary.
+      std::string const tmp{node.value.data(), node.value.data() + node.value.size()};
+      char* end{};
+      d = std::strtod(tmp.data(), &end);
+      if (d == HUGE_VAL || d == 0)
+         ec = redis::error::not_a_double;
 #else
-   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), d);
-   if (res.ec != std::errc())
-      ec = redis::error::not_a_double;
+      auto const res = std::from_chars(node.value.data(), node.value.data() + node.value.size(), d);
+      if (res.ec != std::errc())
+         ec = redis::error::not_a_double;
 #endif // _LIBCPP_VERSION
-}
+   }
+};
 
 template <class CharT, class Traits, class Allocator>
+struct converter_impl<std::basic_string<CharT, Traits, Allocator>, false> {
+   template <class String>
+   static void
+   apply(
+      std::basic_string<CharT, Traits, Allocator>& s,
+      resp3::basic_node<String> const& node,
+      system::error_code&)
+   {
+      s.append(node.value.data(), node.value.size());
+   }
+};
+
+template <class T, class String>
 void
 boost_redis_from_bulk(
-   std::basic_string<CharT, Traits, Allocator>& s,
-   std::string_view sv,
-   system::error_code&)
+  T& t,
+  resp3::basic_node<String> const& node,
+  system::error_code& ec)
 {
-  s.append(sv.data(), sv.size());
+   converter_impl<T>::apply(t, node, ec);
 }
 
 //================================================
@@ -138,14 +180,14 @@ class simple_impl {
    void on_value_available(Result&) {}
 
    template <class String>
-   void operator()(Result& result, resp3::basic_node<String> const& n, system::error_code& ec)
+   void operator()(Result& result, resp3::basic_node<String> const& node, system::error_code& ec)
    {
-      if (is_aggregate(n.data_type)) {
+      if (is_aggregate(node.data_type)) {
          ec = redis::error::expects_resp3_simple_type;
          return;
       }
 
-      boost_redis_from_bulk(result, n.value, ec);
+      boost_redis_from_bulk(result, node, ec);
    }
 };
 
@@ -175,7 +217,7 @@ class set_impl {
       }
 
       typename Result::key_type obj;
-      boost_redis_from_bulk(obj, nd.value, ec);
+      boost_redis_from_bulk(obj, nd, ec);
       hint_ = result.insert(hint_, std::move(obj));
    }
 };
@@ -208,11 +250,11 @@ class map_impl {
 
       if (on_key_) {
          typename Result::key_type obj;
-         boost_redis_from_bulk(obj, nd.value, ec);
+         boost_redis_from_bulk(obj, nd, ec);
          current_ = result.insert(current_, {std::move(obj), {}});
       } else {
          typename Result::mapped_type obj;
-         boost_redis_from_bulk(obj, nd.value, ec);
+         boost_redis_from_bulk(obj, nd, ec);
          current_->second = std::move(obj);
       }
 
@@ -233,7 +275,7 @@ class vector_impl {
          result.reserve(result.size() + m * nd.aggregate_size);
       } else {
          result.push_back({});
-         boost_redis_from_bulk(result.back(), nd.value, ec);
+         boost_redis_from_bulk(result.back(), nd, ec);
       }
    }
 };
@@ -266,7 +308,7 @@ class array_impl {
          }
 
          BOOST_ASSERT(nd.aggregate_size == 1);
-         boost_redis_from_bulk(result.at(i_), nd.value, ec);
+         boost_redis_from_bulk(result.at(i_), nd, ec);
       }
 
       ++i_;
@@ -289,7 +331,7 @@ struct list_impl {
         }
 
         result.push_back({});
-        boost_redis_from_bulk(result.back(), nd.value, ec);
+        boost_redis_from_bulk(result.back(), nd, ec);
       }
    }
 };

include/boost/redis/resp3/node.hpp

@@ -59,6 +59,8 @@ auto operator==(basic_node<String> const& a, basic_node<String> const& b)
  */
 using node = basic_node<std::string>;
 
+using node_view = basic_node<std::string_view>;
+
 } // boost::redis::resp3
 
 #endif // BOOST_REDIS_RESP3_NODE_HPP

test/test_low_level_sync_sans_io.cpp

@@ -199,4 +199,29 @@ BOOST_AUTO_TEST_CASE(issue_210_no_nested)
       exit(EXIT_FAILURE);
    }
 }
+// char const* wire = "*6\r\n+orange\r\n+apple\r\n_\r\n+two\r\n+three\r\n+orange\r\n";
+// $ ./test/boost_redis_test_low_level_sync_sans_io --run_test=issue_233_array_with_nil
+// Running 1 test case...
+// : Got RESP3 null. [boost.redis:15]
+//
+BOOST_AUTO_TEST_CASE(issue_233_array_with_nil)
+{
+   try {
+      result<std::vector<std::optional<std::string>>> resp;
+
+      char const* wire = "*6\r\n+orange\r\n+apple\r\n_\r\n+two\r\n+three\r\n+orange\r\n";
+      deserialize(wire, adapt2(resp));
+
+      for (auto const& e: resp.value()) {
+         if (e)
+            std::cout << e.value() << std::endl;
+         else
+            std::cout << "null" << std::endl;
+      }
+
+   } catch (std::exception const& e) {
+      std::cerr << e.what() << std::endl;
+      exit(EXIT_FAILURE);
+   }
+}