Problem: message_t ctor string inconsistency

Solution: Constuctor taking generic ranges including
string literals includes the null terminated char in
the message. Deprecate function and add overloads
for strings.

Author: gummif

tests/message.cpp

@@ -70,13 +70,40 @@ TEST_CASE("message constructor with char array", "[message]")
     CHECK(0 == memcmp(data, hi_msg.data(), 2));
 }
 
-#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11)
-TEST_CASE("message constructor with container", "[message]")
+#if defined(ZMQ_CPP11) && !defined(ZMQ_CPP11_PARTIAL)
+TEST_CASE("message constructor with container - deprecated", "[message]")
 {
-    const std::string hi(data);
-    zmq::message_t hi_msg(hi);
-    CHECK(2u == hi_msg.size());
-    CHECK(0 == memcmp(data, hi_msg.data(), 2));
+    zmq::message_t hi_msg("Hi"); // deprecated
+    REQUIRE(3u == hi_msg.size());
+    CHECK(0 == memcmp(data, hi_msg.data(), 3));
+}
+
+TEST_CASE("message constructor with container of trivial data", "[message]")
+{
+    int buf[3] = {1, 2, 3};
+    zmq::message_t msg(buf);
+    REQUIRE(sizeof(buf) == msg.size());
+    CHECK(0 == memcmp(buf, msg.data(), msg.size()));
+}
+
+TEST_CASE("message constructor with strings", "[message]")
+{
+    SECTION("string")
+    {
+        const std::string hi(data);
+        zmq::message_t hi_msg(hi);
+        CHECK(2u == hi_msg.size());
+        CHECK(0 == memcmp(data, hi_msg.data(), 2));
+    }
+#if CPPZMQ_HAS_STRING_VIEW
+    SECTION("string_view")
+    {
+        const std::string_view hi(data);
+        zmq::message_t hi_msg(hi);
+        CHECK(2u == hi_msg.size());
+        CHECK(0 == memcmp(data, hi_msg.data(), 2));
+    }
+#endif
 }
 #endif
 
@@ -162,6 +189,12 @@ TEST_CASE("message to string", "[message]")
     CHECK(a.to_string_view() == "");
     CHECK(b.to_string_view() == "Foo");
 #endif
+
+#if defined(ZMQ_CPP11) && !defined(ZMQ_CPP11_PARTIAL)
+    const zmq::message_t depr("Foo"); // deprecated
+    CHECK(depr.to_string() != "Foo");
+    CHECK(depr.to_string() == std::string("Foo", 4));
+#endif
 }
 
 #if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)

zmq.hpp

@@ -348,6 +348,19 @@ inline std::tuple<int, int, int> version()
     zmq_version(&std::get<0>(v), &std::get<1>(v), &std::get<2>(v));
     return v;
 }
+
+#if !defined(ZMQ_CPP11_PARTIAL)
+namespace detail{
+template<class T> struct is_char_type
+{
+    // true if character type for string literals in C++11
+    static constexpr bool value =
+      std::is_same<T, char>::value || std::is_same<T, wchar_t>::value ||
+      std::is_same<T, char16_t>::value || std::is_same<T, char32_t>::value;
+};
+}
+#endif
+
 #endif
 
 class message_t
@@ -399,16 +412,47 @@ class message_t
             throw error_t();
     }
 
+    // overload set of string-like types and generic containers
 #if defined(ZMQ_CPP11) && !defined(ZMQ_CPP11_PARTIAL)
+    // NOTE this constructor will include the null terminator
+    // when called with a string literal.
+    // An overload taking const char* can not be added because
+    // it would be preferred over this function and break compatiblity.
+    template<class Char, size_t N,
+            typename = typename std::enable_if<
+            detail::is_char_type<Char>::value
+            >::type
+            >
+    ZMQ_DEPRECATED(
+        "from 4.7.0, use constructors taking iterators, (pointer, size) or strings instead")
+    explicit message_t(const Char (&data)[N]) :
+        message_t(detail::ranges::begin(data), detail::ranges::end(data))
+    {
+    }
+
     template<class Range,
              typename = typename std::enable_if<
                detail::is_range<Range>::value
                && ZMQ_IS_TRIVIALLY_COPYABLE(detail::range_value_t<Range>)
+               && !detail::is_char_type<detail::range_value_t<Range>>::value
                && !std::is_same<Range, message_t>::value>::type>
     explicit message_t(const Range &rng) :
         message_t(detail::ranges::begin(rng), detail::ranges::end(rng))
     {
     }
+
+    explicit message_t(const std::string &str) :
+        message_t(str.data(), str.size())
+    {
+    }
+
+#if CPPZMQ_HAS_STRING_VIEW
+    explicit message_t(std::string_view str) :
+        message_t(str.data(), str.size())
+    {
+    }
+#endif
+
 #endif
 
 #ifdef ZMQ_HAS_RVALUE_REFS