Added unpack function using existing zone.

Removed redundant inline keyword form declarations.

include/msgpack/unpack.hpp

@@ -1108,19 +1108,19 @@ private:
 
 #if !defined(MSGPACK_USE_CPP03)
 
-inline unpacked unpack(
+unpacked unpack(
     const char* data, std::size_t len, std::size_t& off, bool& referenced,
     unpack_reference_func f = nullptr, void* user_data = nullptr,
     unpack_limit const& limit = unpack_limit());
-inline unpacked unpack(
+unpacked unpack(
     const char* data, std::size_t len, std::size_t& off,
     unpack_reference_func f = nullptr, void* user_data = nullptr,
     unpack_limit const& limit = unpack_limit());
-inline unpacked unpack(
+unpacked unpack(
     const char* data, std::size_t len, bool& referenced,
     unpack_reference_func f = nullptr, void* user_data = nullptr,
     unpack_limit const& limit = unpack_limit());
-inline unpacked unpack(
+unpacked unpack(
     const char* data, std::size_t len,
     unpack_reference_func f = nullptr, void* user_data = nullptr,
     unpack_limit const& limit = unpack_limit());
@@ -1128,29 +1128,51 @@ inline unpacked unpack(
 #endif // !defined(MSGPACK_USE_CPP03)
 
 
-inline void unpack(unpacked& result,
-                   const char* data, std::size_t len, std::size_t& off, bool& referenced,
-                   unpack_reference_func f = nullptr, void* user_data = nullptr,
-                   unpack_limit const& limit = unpack_limit());
-inline void unpack(unpacked& result,
-                   const char* data, std::size_t len, std::size_t& off,
-                   unpack_reference_func f = nullptr, void* user_data = nullptr,
-                   unpack_limit const& limit = unpack_limit());
-inline void unpack(unpacked& result,
-                   const char* data, std::size_t len, bool& referenced,
-                   unpack_reference_func f = nullptr, void* user_data = nullptr,
-                   unpack_limit const& limit = unpack_limit());
+void unpack(unpacked& result,
+            const char* data, std::size_t len, std::size_t& off, bool& referenced,
+            unpack_reference_func f = nullptr, void* user_data = nullptr,
+            unpack_limit const& limit = unpack_limit());
+void unpack(unpacked& result,
+            const char* data, std::size_t len, std::size_t& off,
+            unpack_reference_func f = nullptr, void* user_data = nullptr,
+            unpack_limit const& limit = unpack_limit());
+void unpack(unpacked& result,
+            const char* data, std::size_t len, bool& referenced,
+            unpack_reference_func f = nullptr, void* user_data = nullptr,
+            unpack_limit const& limit = unpack_limit());
+
+void unpack(unpacked& result,
+            const char* data, std::size_t len,
+            unpack_reference_func f = nullptr, void* user_data = nullptr,
+            unpack_limit const& limit = unpack_limit());
+
+object unpack(
+    zone& z,
+    const char* data, std::size_t len, std::size_t& off, bool& referenced,
+    unpack_reference_func f = nullptr, void* user_data = nullptr,
+    unpack_limit const& limit = unpack_limit());
+object unpack(
+    zone& z,
+    const char* data, std::size_t len, std::size_t& off,
+    unpack_reference_func f = nullptr, void* user_data = nullptr,
+    unpack_limit const& limit = unpack_limit());
+object unpack(
+    zone& z,
+    const char* data, std::size_t len, bool& referenced,
+    unpack_reference_func f = nullptr, void* user_data = nullptr,
+    unpack_limit const& limit = unpack_limit());
+object unpack(
+    zone& z,
+    const char* data, std::size_t len,
+    unpack_reference_func f = nullptr, void* user_data = nullptr,
+    unpack_limit const& limit = unpack_limit());
 
-inline void unpack(unpacked& result,
-                   const char* data, std::size_t len,
-                   unpack_reference_func f = nullptr, void* user_data = nullptr,
-                   unpack_limit const& limit = unpack_limit());
 
 // obsolete
-inline void unpack(unpacked* result,
-                   const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr,
-                   unpack_reference_func f = nullptr, void* user_data = nullptr,
-                   unpack_limit const& limit = unpack_limit());
+void unpack(unpacked* result,
+            const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr,
+            unpack_reference_func f = nullptr, void* user_data = nullptr,
+            unpack_limit const& limit = unpack_limit());
 
 
 // for internal use
@@ -1548,7 +1570,6 @@ inline unpacked unpack(
 
 #endif // !defined(MSGPACK_USE_CPP03)
 
-
 inline void unpack(unpacked& result,
                    const char* data, std::size_t len, std::size_t& off, bool& referenced,
                    unpack_reference_func f, void* user_data, unpack_limit const& limit)
@@ -1601,6 +1622,59 @@ inline void unpack(unpacked& result,
     unpack(result, data, len, off, referenced, f, user_data, limit);
 }
 
+
+inline object unpack(
+    zone& z,
+    const char* data, std::size_t len, std::size_t& off, bool& referenced,
+    unpack_reference_func f, void* user_data, unpack_limit const& limit)
+{
+    object obj;
+    referenced = false;
+    unpack_return ret = detail::unpack_imp(
+        data, len, off, z, obj, referenced, f, user_data, limit);
+
+    switch(ret) {
+    case UNPACK_SUCCESS:
+        return obj;
+    case UNPACK_EXTRA_BYTES:
+        return obj;
+    case UNPACK_CONTINUE:
+        throw insufficient_bytes("insufficient bytes");
+    case UNPACK_PARSE_ERROR:
+    default:
+        throw parse_error("parse error");
+    }
+    return obj;
+}
+
+inline object unpack(
+    zone& z,
+    const char* data, std::size_t len, std::size_t& off,
+    unpack_reference_func f, void* user_data, unpack_limit const& limit)
+{
+    bool referenced;
+    return unpack(z, data, len, off, referenced, f, user_data, limit);
+}
+
+inline object unpack(
+    zone& z,
+    const char* data, std::size_t len, bool& referenced,
+    unpack_reference_func f, void* user_data, unpack_limit const& limit)
+{
+    std::size_t off = 0;
+    return unpack(z, data, len, off, referenced, f, user_data, limit);
+}
+
+inline object unpack(
+    zone& z,
+    const char* data, std::size_t len,
+    unpack_reference_func f, void* user_data, unpack_limit const& limit)
+{
+    bool referenced;
+    std::size_t off = 0;
+    return unpack(z, data, len, off, referenced, f, user_data, limit);
+}
+
 // obsolete
 // pointer version
 inline void unpack(unpacked* result,

test/pack_unpack.cpp

@@ -218,6 +218,56 @@ TEST(unpack, int_default_null_pointer)
     EXPECT_EQ(1, msg.get().as<int>());
 }
 
+TEST(unpack, int_zone_no_offset_no_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    msgpack::zone z;
+    msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size());
+    EXPECT_EQ(1, obj.as<int>());
+}
+
+TEST(unpack, int_zone_offset_no_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    std::size_t off = 0;
+
+    msgpack::zone z;
+    msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off);
+    EXPECT_EQ(1, obj.as<int>());
+    EXPECT_EQ(off, sbuf.size());
+}
+
+TEST(unpack, int_zone_no_offset_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    bool referenced;
+
+    msgpack::zone z;
+    msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), referenced);
+    EXPECT_EQ(1, obj.as<int>());
+    EXPECT_EQ(false, referenced);
+}
+
+TEST(unpack, int_zone_offset_ref)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    std::size_t off = 0;
+    bool referenced;
+
+    msgpack::zone z;
+    msgpack::object obj = msgpack::unpack(z, sbuf.data(), sbuf.size(), off, referenced);
+    EXPECT_EQ(1, obj.as<int>());
+    EXPECT_EQ(false, referenced);
+    EXPECT_EQ(off, sbuf.size());
+}
+
+
 TEST(unpack, sequence)
 {
     msgpack::sbuffer sbuf;