Fixed #243.

std::vector<unsigned char> and std::array<unsigned char> are mapped to BIN.
std::vector<uint8_t> and std::array<uint8_t> are mapped to BIN if uint8_t is the same type of unsigned char, otherwise mapped to ARRAY.

Added array_ref. When client wraps BIN mapped types above with array_ref as msgpack::type::array_ref<std::vector<char> >, the type is mapped to ARRAY.

test/CMakeLists.txt

@@ -8,6 +8,7 @@ INCLUDE_DIRECTORIES (
 )
 
 LIST (APPEND check_PROGRAMS
+    array_ref.cpp
     buffer.cpp
     cases.cpp
     convert.cpp

test/Makefile.am

@@ -3,6 +3,7 @@ AM_C_CPPFLAGS = -I$(top_srcdir)/include -pthread
 AM_LDFLAGS = $(top_builddir)/src/libmsgpack.la -lgtest_main -lgtest -lpthread
 
 check_PROGRAMS = \
+		array_ref \
 		buffer \
 		cases \
 		convert \
@@ -45,6 +46,7 @@ check_PROGRAMS += \
 
 TESTS = $(check_PROGRAMS)
 
+array_ref_SOURCES = array_ref.cpp
 buffer_SOURCES = buffer.cpp
 cases_SOURCES = cases.cpp
 convert_SOURCES = convert.cpp

test/array_ref.cpp

@@ -0,0 +1,310 @@
+#include <msgpack.hpp>
+
+#include <string>
+#include <sstream>
+
+#include <gtest/gtest.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char)
+{
+    std::vector<char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+
+    msgpack::type::array_ref<std::vector<char> > ar1 = msgpack::type::make_array_ref(v);
+    std::stringstream ss;
+    msgpack::pack(ss, ar1);
+
+    msgpack::unpacked upd;
+    msgpack::unpack(upd, ss.str().data(), ss.str().size());
+    EXPECT_EQ(upd.get().type, msgpack::type::ARRAY);
+    std::vector<char> v2;
+    msgpack::type::array_ref<std::vector<char> > ar2(v2);
+    upd.get().convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const)
+{
+    std::vector<char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+
+    std::vector<char> const& cv = v;
+
+    msgpack::type::array_ref<std::vector<char> const> ar1 = msgpack::type::make_array_ref(cv);
+    std::stringstream ss;
+    msgpack::pack(ss, ar1);
+
+    msgpack::unpacked upd;
+    msgpack::unpack(upd, ss.str().data(), ss.str().size());
+    EXPECT_EQ(upd.get().type, msgpack::type::ARRAY);
+    std::vector<char> v2;
+    msgpack::type::array_ref<std::vector<char> > ar2(v2);
+    upd.get().convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char)
+{
+    std::vector<unsigned char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+
+    msgpack::type::array_ref<std::vector<unsigned char> > ar1 = msgpack::type::make_array_ref(v);
+    std::stringstream ss;
+    msgpack::pack(ss, ar1);
+
+    msgpack::unpacked upd;
+    msgpack::unpack(upd, ss.str().data(), ss.str().size());
+    EXPECT_EQ(upd.get().type, msgpack::type::ARRAY);
+    std::vector<unsigned char> v2;
+    msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
+    upd.get().convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const)
+{
+    std::vector<unsigned char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+
+    std::vector<unsigned char> const& cv = v;
+
+    msgpack::type::array_ref<std::vector<unsigned char> const> ar1 = msgpack::type::make_array_ref(cv);
+    std::stringstream ss;
+    msgpack::pack(ss, ar1);
+
+    msgpack::unpacked upd;
+    msgpack::unpack(upd, ss.str().data(), ss.str().size());
+    EXPECT_EQ(upd.get().type, msgpack::type::ARRAY);
+    std::vector<unsigned char> v2;
+    msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
+    upd.get().convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_char)
+{
+    std::vector<char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+
+    msgpack::type::array_ref<std::vector<char> > ar1 = msgpack::type::make_array_ref(v);
+    msgpack::zone z;
+    msgpack::object obj(ar1, z);
+
+    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    std::vector<char> v2;
+    msgpack::type::array_ref<std::vector<char> > ar2(v2);
+    obj.convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_char_const)
+{
+    std::vector<char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+
+    std::vector<char> const& cv = v;
+
+    msgpack::type::array_ref<std::vector<char> const> ar1 = msgpack::type::make_array_ref(cv);
+    msgpack::zone z;
+    msgpack::object obj(ar1, z);
+
+    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    std::vector<char> v2;
+    msgpack::type::array_ref<std::vector<char> > ar2(v2);
+    obj.convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_unsigned_char)
+{
+    std::vector<unsigned char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+
+    msgpack::type::array_ref<std::vector<unsigned char> > ar1 = msgpack::type::make_array_ref(v);
+    msgpack::zone z;
+    msgpack::object obj(ar1, z);
+
+    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    std::vector<unsigned char> v2;
+    msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
+    obj.convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, object_with_zone_vector_unsigned_char_const)
+{
+    std::vector<unsigned char> v;
+    v.push_back('a');
+    v.push_back('b');
+    v.push_back('c');
+
+    std::vector<unsigned char> const& cv = v;
+
+    msgpack::type::array_ref<std::vector<unsigned char> const> ar1 = msgpack::type::make_array_ref(cv);
+    msgpack::zone z;
+    msgpack::object obj(ar1, z);
+
+    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    std::vector<unsigned char> v2;
+    msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
+    obj.convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+#if !defined(MSGPACK_USE_CPP03)
+
+TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char)
+{
+    std::array<char, 3> v { { 'a', 'b', 'c' } };
+
+    msgpack::type::array_ref<std::array<char, 3> > ar1 = msgpack::type::make_array_ref(v);
+    std::stringstream ss;
+    msgpack::pack(ss, ar1);
+
+    msgpack::unpacked upd;
+    msgpack::unpack(upd, ss.str().data(), ss.str().size());
+    EXPECT_EQ(upd.get().type, msgpack::type::ARRAY);
+    std::array<char, 3> v2;
+    msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
+    upd.get().convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const)
+{
+    std::array<char, 3> v { { 'a', 'b', 'c' } };
+
+    std::array<char, 3> const& cv = v;
+
+    msgpack::type::array_ref<std::array<char, 3> const> ar1 = msgpack::type::make_array_ref(cv);
+    std::stringstream ss;
+    msgpack::pack(ss, ar1);
+
+    msgpack::unpacked upd;
+    msgpack::unpack(upd, ss.str().data(), ss.str().size());
+    EXPECT_EQ(upd.get().type, msgpack::type::ARRAY);
+    std::array<char, 3> v2;
+    msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
+    upd.get().convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char)
+{
+    std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
+
+    msgpack::type::array_ref<std::array<unsigned char, 3> > ar1 = msgpack::type::make_array_ref(v);
+    std::stringstream ss;
+    msgpack::pack(ss, ar1);
+
+    msgpack::unpacked upd;
+    msgpack::unpack(upd, ss.str().data(), ss.str().size());
+    EXPECT_EQ(upd.get().type, msgpack::type::ARRAY);
+    std::array<unsigned char, 3> v2;
+    msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
+    upd.get().convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const)
+{
+    std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
+
+    std::array<unsigned char, 3> const& cv = v;
+
+    msgpack::type::array_ref<std::array<unsigned char, 3> const> ar1 = msgpack::type::make_array_ref(cv);
+    std::stringstream ss;
+    msgpack::pack(ss, ar1);
+
+    msgpack::unpacked upd;
+    msgpack::unpack(upd, ss.str().data(), ss.str().size());
+    EXPECT_EQ(upd.get().type, msgpack::type::ARRAY);
+    std::array<unsigned char, 3> v2;
+    msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
+    upd.get().convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, object_with_zone_array_char)
+{
+    std::array<char, 3> v { { 'a', 'b', 'c' } };
+
+    msgpack::type::array_ref<std::array<char, 3> > ar1 = msgpack::type::make_array_ref(v);
+    msgpack::zone z;
+    msgpack::object obj(ar1, z);
+
+    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    std::array<char, 3> v2;
+    msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
+    obj.convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, object_with_zone_array_char_const)
+{
+    std::array<char, 3> v { { 'a', 'b', 'c' } };
+
+    std::array<char, 3> const& cv = v;
+
+    msgpack::type::array_ref<std::array<char, 3> const> ar1 = msgpack::type::make_array_ref(cv);
+    msgpack::zone z;
+    msgpack::object obj(ar1, z);
+
+    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    std::array<char, 3> v2;
+    msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
+    obj.convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, object_with_zone_array_unsigned_char)
+{
+    std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
+
+    msgpack::type::array_ref<std::array<unsigned char, 3> > ar1 = msgpack::type::make_array_ref(v);
+    msgpack::zone z;
+    msgpack::object obj(ar1, z);
+
+    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    std::array<unsigned char, 3> v2;
+    msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
+    obj.convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+TEST(MSGPACK_ARRAY_REF, object_with_zone_array_unsigned_char_const)
+{
+    std::array<unsigned char, 3> v { { 'a', 'b', 'c' } };
+
+    std::array<unsigned char, 3> const& cv = v;
+
+    msgpack::type::array_ref<std::array<unsigned char, 3> const> ar1 = msgpack::type::make_array_ref(cv);
+    msgpack::zone z;
+    msgpack::object obj(ar1, z);
+
+    EXPECT_EQ(obj.type, msgpack::type::ARRAY);
+    std::array<unsigned char, 3> v2;
+    msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
+    obj.convert(ar2);
+    EXPECT_EQ(ar1, ar2);
+}
+
+#endif // !defined(MSGPACK_USE_CPP03)

test/msgpack_container.cpp

@@ -72,6 +72,43 @@ TEST(MSGPACK_STL, simple_buffer_vector_char)
     }
 }
 
+TEST(MSGPACK_STL, simple_buffer_vector_unsigned_char)
+{
+    typedef vector<unsigned char, test::allocator<unsigned char> > type;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        type val1;
+        for (unsigned int i = 0; i < kElements; i++)
+            val1.push_back(rand());
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, val1);
+        msgpack::unpacked ret;
+        msgpack::unpack(ret, sbuf.data(), sbuf.size());
+        EXPECT_EQ(ret.get().type, msgpack::type::BIN);
+        type const& val2 = ret.get().as<type>();
+        EXPECT_EQ(val1.size(), val2.size());
+        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    }
+}
+
+TEST(MSGPACK_STL, simple_buffer_vector_uint8_t)
+{
+    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
+    typedef vector<uint8_t, test::allocator<uint8_t> > type;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        type val1;
+        for (unsigned int i = 0; i < kElements; i++)
+            val1.push_back(rand());
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, val1);
+        msgpack::unpacked ret;
+        msgpack::unpack(ret, sbuf.data(), sbuf.size());
+        EXPECT_EQ(ret.get().type, msgpack::type::BIN);
+        type const& val2 = ret.get().as<type>();
+        EXPECT_EQ(val1.size(), val2.size());
+        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    }
+}
+
 TEST(MSGPACK_STL, simple_buffer_vector_bool)
 {
     typedef vector<bool, test::allocator<bool> > type;

test/msgpack_cpp11.cpp

@@ -93,6 +93,24 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char)
     }
 }
 
+TEST(MSGPACK_CPP11, simple_buffer_array_unsigned_char)
+{
+    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        array<unsigned char, kElements> val1;
+        for (unsigned int i = 0; i < kElements; i++)
+            val1[i] = rand();
+        msgpack::sbuffer sbuf;
+        msgpack::pack(sbuf, val1);
+        msgpack::unpacked ret;
+        msgpack::unpack(ret, sbuf.data(), sbuf.size());
+        EXPECT_EQ(ret.get().type, msgpack::type::BIN);
+        array<unsigned char, kElements> val2 = ret.get().as<array<unsigned char, kElements> >();
+        EXPECT_EQ(val1.size(), val2.size());
+        EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
+    }
+}
+
 // strong typedefs
 namespace test {
 

test/object_with_zone.cpp

@@ -240,6 +240,39 @@ TEST(object_without_zone, vector_char)
     }
 }
 
+// vector_unsgined_char
+TEST(object_with_zone, vector_unsigned_char)
+{
+    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        vector<unsigned char> v1;
+        v1.push_back(1);
+        for (unsigned int i = 1; i < kElements; i++)
+            v1.push_back(static_cast<unsigned char>(i));
+        msgpack::zone z;
+        msgpack::object obj(v1, z);
+        EXPECT_EQ(obj.as<vector<unsigned char> >(), v1);
+        v1.front() = 42;
+        EXPECT_EQ(obj.as<vector<unsigned char> >().front(), 1);
+    }
+}
+
+TEST(object_without_zone, vector_unsigned_char)
+{
+    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        vector<unsigned char> v1;
+        v1.push_back(1);
+        for (unsigned int i = 1; i < kElements; i++)
+            v1.push_back(static_cast<unsigned char>(i));
+        msgpack::object obj(v1);
+        EXPECT_EQ(obj.as<vector<unsigned char> >(), v1);
+        v1.front() = 42;
+        // obj refer to v1
+        EXPECT_EQ(obj.as<vector<unsigned char> >().front(), 42);
+    }
+}
+
 // list
 TEST(object_with_zone, list)
 {
@@ -830,6 +863,40 @@ TEST(object_without_zone, array_char)
     }
 }
 
+TEST(object_with_zone, array_unsigned_char)
+{
+    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
+    typedef array<unsigned char, kElements> test_t;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        test_t v1;
+        v1[0] = 1;
+        for (unsigned int i = 1; i < kElements; i++)
+            v1[i] = rand();
+        msgpack::zone z;
+        msgpack::object obj(v1, z);
+        EXPECT_EQ(obj.as<test_t>(), v1);
+        v1.front() = 42;
+        EXPECT_EQ(obj.as<test_t>().front(), 1);
+    }
+}
+
+TEST(object_without_zone, array_unsigned_char)
+{
+    if (!msgpack::is_same<uint8_t, unsigned char>::value) return;
+    typedef array<unsigned char, kElements> test_t;
+    for (unsigned int k = 0; k < kLoop; k++) {
+        test_t v1;
+        v1[0] = 1;
+        for (unsigned int i = 1; i < kElements; i++)
+            v1[i] = rand();
+        msgpack::object obj(v1);
+        EXPECT_EQ(obj.as<test_t>(), v1);
+        v1.front() = 42;
+        // obj refer to v1
+        EXPECT_EQ(obj.as<test_t>().front(), 42);
+    }
+}
+
 
 TEST(object_with_zone, forward_list)
 {