Added converting support for different size tuples.

erb/v1/cpp03_msgpack_tuple.hpp.erb

@@ -148,10 +148,10 @@ struct convert<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
         msgpack::object const& o,
         type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size < <%=i+1%>) { throw msgpack::type_error(); }
         <%0.upto(i) {|j|%>
         // In order to avoid clang++'s invalid warning, msgpack::object:: has been added.
-        o.via.array.ptr[<%=j%>].msgpack::object::convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
+        if(o.via.array.size > <%=j%>)
+            o.via.array.ptr[<%=j%>].msgpack::object::convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
         return o;
     }
 };

include/msgpack/v1/adaptor/cpp11/tuple.hpp

@@ -113,7 +113,6 @@ struct as<std::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::
     std::tuple<Args...> operator()(
         msgpack::object const& o) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size > sizeof...(Args)) { throw msgpack::type_error(); }
         return StdTupleAs<Args...>::as(o);
     }
 };
@@ -124,7 +123,6 @@ struct convert<std::tuple<Args...>> {
         msgpack::object const& o,
         std::tuple<Args...>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size > sizeof...(Args)) { throw msgpack::type_error(); }
         StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
         return o;
     }

include/msgpack/v1/adaptor/detail/cpp11_msgpack_tuple.hpp

@@ -150,7 +150,6 @@ struct as<msgpack::type::tuple<Args...>, typename std::enable_if<msgpack::all_of
     msgpack::type::tuple<Args...> operator()(
         msgpack::object const& o) const {
         if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size > sizeof...(Args)) { throw msgpack::type_error(); }
         return MsgpackTupleAs<Args...>::as(o);
     }
 };
@@ -161,7 +160,6 @@ struct convert<msgpack::type::tuple<Args...>> {
         msgpack::object const& o,
         msgpack::type::tuple<Args...>& v) const {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if(o.via.array.size > sizeof...(Args)) { throw msgpack::type_error(); }
         MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
         return o;
     }

test/msgpack_container.cpp

@@ -1,3 +1,4 @@
+#include <iostream>
 #include <msgpack.hpp>
 
 #include <cmath>
@@ -469,6 +470,63 @@ TEST(MSGPACK_TUPLE, simple_tuple_empty)
     EXPECT_EQ(oh.get().via.array.size, 0u);
 }
 
+TEST(MSGPACK_TUPLE, simple_tuple_grater_than_as)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::type::tuple<bool, std::string, int, int> val2
+        = oh.get().as<msgpack::type::tuple<bool, std::string, int, int> >();
+    EXPECT_EQ(oh.get().via.array.size, 3u);
+    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+    EXPECT_EQ(val1.get<2>(), val2.get<2>());
+}
+
+TEST(MSGPACK_TUPLE, simple_tuple_grater_than_convert)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::type::tuple<bool, std::string, int, int> val2;
+    oh.get().convert(val2);
+    EXPECT_EQ(oh.get().via.array.size, 3u);
+    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+    EXPECT_EQ(val1.get<2>(), val2.get<2>());
+}
+
+TEST(MSGPACK_TUPLE, simple_tuple_less_than_as)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::type::tuple<bool, std::string> val2
+        = oh.get().as<msgpack::type::tuple<bool, std::string> >();
+    EXPECT_EQ(oh.get().via.array.size, 3u);
+    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+}
+
+TEST(MSGPACK_TUPLE, simple_tuple_less_than_convert)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::type::tuple<bool, std::string, int> val1(true, "kzk", 42);
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    msgpack::type::tuple<bool, std::string> val2;
+    oh.get().convert(val2);
+    EXPECT_EQ(oh.get().via.array.size, 3u);
+    EXPECT_EQ(val1.get<0>(), val2.get<0>());
+    EXPECT_EQ(val1.get<1>(), val2.get<1>());
+}
 
 // TR1
 

test/msgpack_cpp11.cpp

@@ -59,6 +59,58 @@ TEST(MSGPACK_CPP11, simple_tuple_empty)
     EXPECT_EQ(val1, val2);
 }
 
+TEST(MSGPACK_CPP11, simple_tuple_size_greater_than_as)
+{
+    msgpack::sbuffer sbuf;
+    std::tuple<bool, std::string, int> val1(true, "kzk", 42);
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::tuple<bool, std::string, double, int> val2 = oh.get().as<std::tuple<bool, std::string, double, int> >();
+    EXPECT_EQ(std::get<0>(val1), std::get<0>(val2));
+    EXPECT_EQ(std::get<1>(val1), std::get<1>(val2));
+    EXPECT_EQ(std::get<2>(val1), std::get<2>(val2));
+}
+
+TEST(MSGPACK_CPP11, simple_tuple_size_greater_than_convert)
+{
+    msgpack::sbuffer sbuf;
+    std::tuple<bool, std::string, int> val1(true, "kzk", 42);
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::tuple<bool, std::string, double, int> val2;
+    oh.get().convert(val2);
+    EXPECT_EQ(std::get<0>(val1), std::get<0>(val2));
+    EXPECT_EQ(std::get<1>(val1), std::get<1>(val2));
+    EXPECT_EQ(std::get<2>(val1), std::get<2>(val2));
+}
+
+TEST(MSGPACK_CPP11, simple_tuple_size_less_than_as)
+{
+    msgpack::sbuffer sbuf;
+    std::tuple<bool, std::string, int> val1(true, "kzk", 42);
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::tuple<bool, std::string> val2 = oh.get().as<std::tuple<bool, std::string> >();
+    EXPECT_EQ(std::get<0>(val1), std::get<0>(val2));
+    EXPECT_EQ(std::get<1>(val1), std::get<1>(val2));
+}
+
+TEST(MSGPACK_CPP11, simple_tuple_size_less_than_convert)
+{
+    msgpack::sbuffer sbuf;
+    std::tuple<bool, std::string, int> val1(true, "kzk", 42);
+    msgpack::pack(sbuf, val1);
+    msgpack::object_handle oh =
+        msgpack::unpack(sbuf.data(), sbuf.size());
+    std::tuple<bool, std::string> val2;
+    oh.get().convert(val2);
+    EXPECT_EQ(std::get<0>(val1), std::get<0>(val2));
+    EXPECT_EQ(std::get<1>(val1), std::get<1>(val2));
+}
+
 TEST(MSGPACK_CPP11, simple_array)
 {
     for (unsigned int k = 0; k < kLoop; k++) {

test/user_class.cpp

@@ -151,7 +151,14 @@ public:
         msgpack::type::tuple<bool, msgpack::object> tuple;
         o.convert(tuple);
 
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
         is_double = tuple.get<0>();
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__)
         if (is_double)
             tuple.get<1>().convert(value.f);
         else