rroonga 7.1.1-x64-mingw32 → 9.0.2-x64-mingw32

data/vendor/local/include/msgpack/v1/object_decl.hpp

@@ -83,16 +83,26 @@ bool operator!=(const T& y, const msgpack::object& x);
 
 void operator<< (msgpack::object& o, const msgpack_object& v);
 
+class object_parser;
+
+template <typename Stream>
+struct object_pack_visitor;
+
+struct object_stringize_visitor;
+
 // obsolete
 template <typename T>
+MSGPACK_DEPRECATED("please use member function version of object::convert(T&)")
 void convert(T& v, msgpack::object const& o);
 
 // obsolete
 template <typename Stream, typename T>
+MSGPACK_DEPRECATED("please use member function version of packer::pack(const T&)")
 void pack(msgpack::packer<Stream>& o, const T& v);
 
 // obsolete
 template <typename Stream, typename T>
+MSGPACK_DEPRECATED("please use member function version of packer::pack(const T&)")
 void pack_copy(msgpack::packer<Stream>& o, T v);
 
 template <typename Stream>
@@ -101,7 +111,7 @@ msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::
 template <typename Stream>
 msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object::with_zone& v);
 
-std::ostream& operator<< (std::ostream& s, const msgpack::object& o);
+std::ostream& operator<< (std::ostream& s, const msgpack::object& v);
 
 /// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)

data/vendor/local/include/msgpack/v1/object_fwd.hpp

@@ -59,7 +59,7 @@ private:
             decltype(adaptor::as<U>()(std::declval<msgpack::object>())),
             T
         >::type;
-    template <typename>
+    template <typename...>
     static std::false_type check(...);
 public:
     using type = decltype(check<T>(MSGPACK_NULLPTR));
@@ -78,6 +78,7 @@ struct object {
         uint64_t u64;
         int64_t  i64;
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+        MSGPACK_DEPRECATED("please use f64 instead")
         double   dec; // obsolete
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
         double   f64;
@@ -157,6 +158,7 @@ struct object {
      * @return The pointer of `v`.
      */
     template <typename T>
+    MSGPACK_DEPRECATED("please use reference version instead")
     typename msgpack::enable_if<
         msgpack::is_pointer<T>::value,
         T
@@ -214,6 +216,7 @@ struct object {
      * @param z The pointer to the zone that is used by the object.
      */
     template <typename T>
+    MSGPACK_DEPRECATED("please use zone reference version instead of the pointer version")
     object(const T& v, msgpack::zone* z);
 
     template <typename T>

data/vendor/local/include/msgpack/v1/object_fwd_decl.hpp

@@ -30,9 +30,11 @@ namespace type {
         BOOLEAN             = MSGPACK_OBJECT_BOOLEAN,
         POSITIVE_INTEGER    = MSGPACK_OBJECT_POSITIVE_INTEGER,
         NEGATIVE_INTEGER    = MSGPACK_OBJECT_NEGATIVE_INTEGER,
+        FLOAT32             = MSGPACK_OBJECT_FLOAT32,
+        FLOAT64             = MSGPACK_OBJECT_FLOAT64,
         FLOAT               = MSGPACK_OBJECT_FLOAT,
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-        DOUBLE              = MSGPACK_OBJECT_DOUBLE, // obsolete
+        DOUBLE              = MSGPACK_DEPRECATED("please use FLOAT64 instead") MSGPACK_OBJECT_DOUBLE, // obsolete
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
         STR                 = MSGPACK_OBJECT_STR,
         BIN                 = MSGPACK_OBJECT_BIN,

data/vendor/local/include/msgpack/v1/parse_return.hpp

@@ -0,0 +1,36 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef MSGPACK_V1_PARSE_RETURN_HPP
+#define MSGPACK_V1_PARSE_RETURN_HPP
+
+#include "msgpack/versioning.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+
+// for internal use
+typedef enum {
+    PARSE_SUCCESS              =  2,
+    PARSE_EXTRA_BYTES          =  1,
+    PARSE_CONTINUE             =  0,
+    PARSE_PARSE_ERROR          = -1
+} parse_return;
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V1_PARSE_RETURN_HPP

data/vendor/local/include/msgpack/v1/unpack.hpp

@@ -14,12 +14,12 @@
 #include "msgpack/unpack_decl.hpp"
 #include "msgpack/object.hpp"
 #include "msgpack/zone.hpp"
+#include "msgpack/unpack_exception.hpp"
 #include "msgpack/unpack_define.h"
 #include "msgpack/cpp_config.hpp"
 #include "msgpack/sysdep.h"
 
 #include <memory>
-#include <stdexcept>
 
 #if !defined(MSGPACK_USE_CPP03)
 #include <atomic>
@@ -39,96 +39,6 @@ namespace msgpack {
 MSGPACK_API_VERSION_NAMESPACE(v1) {
 /// @endcond
 
-struct unpack_error : public std::runtime_error {
-    explicit unpack_error(const std::string& msg)
-        :std::runtime_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit unpack_error(const char* msg):
-        std::runtime_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-struct parse_error : public unpack_error {
-    explicit parse_error(const std::string& msg)
-        :unpack_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit parse_error(const char* msg)
-        :unpack_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-struct insufficient_bytes : public unpack_error {
-    explicit insufficient_bytes(const std::string& msg)
-        :unpack_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit insufficient_bytes(const char* msg)
-        :unpack_error(msg) {}
-#endif // !defined(MSGPACK_USE_CPP03)
-};
-
-struct size_overflow : public unpack_error {
-    explicit size_overflow(const std::string& msg)
-        :unpack_error(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    explicit size_overflow(const char* msg)
-        :unpack_error(msg) {}
-#endif
-};
-
-struct array_size_overflow : public size_overflow {
-    array_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    array_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct map_size_overflow : public size_overflow {
-    map_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    map_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct str_size_overflow : public size_overflow {
-    str_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    str_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct bin_size_overflow : public size_overflow {
-    bin_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    bin_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct ext_size_overflow : public size_overflow {
-    ext_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    ext_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
-struct depth_size_overflow : public size_overflow {
-    depth_size_overflow(const std::string& msg)
-        :size_overflow(msg) {}
-#if !defined(MSGPACK_USE_CPP03)
-    depth_size_overflow(const char* msg)
-        :size_overflow(msg) {}
-#endif
-};
-
 namespace detail {
 
 class unpack_user {
@@ -184,10 +94,10 @@ inline void unpack_int64(int64_t d, msgpack::object& o)
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_float(float d, msgpack::object& o)
-{ o.type = msgpack::type::FLOAT; o.via.f64 = d; }
+{ o.type = msgpack::type::FLOAT32; o.via.f64 = d; }
 
 inline void unpack_double(double d, msgpack::object& o)
-{ o.type = msgpack::type::FLOAT; o.via.f64 = d; }
+{ o.type = msgpack::type::FLOAT64; o.via.f64 = d; }
 
 inline void unpack_nil(msgpack::object& o)
 { o.type = msgpack::type::NIL; }
@@ -203,7 +113,11 @@ struct unpack_array {
         if (n > u.limit().array()) throw msgpack::array_size_overflow("array size overflow");
         o.type = msgpack::type::ARRAY;
         o.via.array.size = 0;
-        o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(n*sizeof(msgpack::object)));
+        size_t size = n*sizeof(msgpack::object);
+        if (size / sizeof(msgpack::object) != n) {
+            throw msgpack::array_size_overflow("array size overflow");
+        }
+        o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
     }
 };
 
@@ -221,7 +135,11 @@ struct unpack_map {
         if (n > u.limit().map()) throw msgpack::map_size_overflow("map size overflow");
         o.type = msgpack::type::MAP;
         o.via.map.size = 0;
-        o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(n*sizeof(msgpack::object_kv)));
+        size_t size = n*sizeof(msgpack::object_kv);
+        if (size / sizeof(msgpack::object_kv) != n) {
+            throw msgpack::map_size_overflow("map size overflow");
+        }
+        o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
     }
 };
 
@@ -246,7 +164,7 @@ inline void unpack_str(unpack_user& u, const char* p, uint32_t l, msgpack::objec
     }
     else {
         if (l > u.limit().str()) throw msgpack::str_size_overflow("str size overflow");
-        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
+        char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
         std::memcpy(tmp, p, l);
         o.via.str.ptr = tmp;
     }
@@ -262,7 +180,7 @@ inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, msgpack::objec
     }
     else {
         if (l > u.limit().bin()) throw msgpack::bin_size_overflow("bin size overflow");
-        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
+        char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
         std::memcpy(tmp, p, l);
         o.via.bin.ptr = tmp;
     }
@@ -278,7 +196,7 @@ inline void unpack_ext(unpack_user& u, const char* p, std::size_t l, msgpack::ob
     }
     else {
         if (l > u.limit().ext()) throw msgpack::ext_size_overflow("ext size overflow");
-        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
+        char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
         std::memcpy(tmp, p, l);
         o.via.ext.ptr = tmp;
     }
@@ -930,7 +848,6 @@ class unpacker {
 public:
     /// Constructor
     /**
-     * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false.
      * @param f A judging function that msgpack::object refer to the buffer.
      * @param user_data This parameter is passed to f.
      * @param initial_buffer_size The memory size to allocate when unpacker is constructed.
@@ -1003,6 +920,7 @@ public:
      * This function is obsolete. Use the reference inteface version of next() function instead of
      * the pointer interface version.
      */
+    MSGPACK_DEPRECATED("please use reference version instead")
     bool next(msgpack::object_handle* result);
 
     /// Unpack one msgpack::object.
@@ -1416,7 +1334,7 @@ inline void unpacker::remove_nonparsed_buffer()
 
 namespace detail {
 
-inline unpack_return
+inline parse_return
 unpack_imp(const char* data, std::size_t len, std::size_t& off,
            msgpack::zone& result_zone, msgpack::object& result, bool& referenced,
            unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR,
@@ -1426,7 +1344,7 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off,
 
     if(len <= noff) {
         // FIXME
-        return UNPACK_CONTINUE;
+        return PARSE_CONTINUE;
     }
 
     detail::context ctx(f, user_data, limit);
@@ -1438,23 +1356,23 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off,
 
     int e = ctx.execute(data, len, noff);
     if(e < 0) {
-        return UNPACK_PARSE_ERROR;
+        return PARSE_PARSE_ERROR;
     }
 
     referenced = ctx.user().referenced();
     off = noff;
 
     if(e == 0) {
-        return UNPACK_CONTINUE;
+        return PARSE_CONTINUE;
     }
 
     result = ctx.data();
 
     if(noff < len) {
-        return UNPACK_EXTRA_BYTES;
+        return PARSE_EXTRA_BYTES;
     }
 
-    return UNPACK_SUCCESS;
+    return PARSE_SUCCESS;
 }
 
 } // detail
@@ -1471,19 +1389,19 @@ inline msgpack::object_handle unpack(
     msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
     referenced = false;
     std::size_t noff = off;
-    unpack_return ret = detail::unpack_imp(
+    parse_return ret = detail::unpack_imp(
         data, len, noff, *z, obj, referenced, f, user_data, limit);
 
     switch(ret) {
-    case UNPACK_SUCCESS:
+    case PARSE_SUCCESS:
         off = noff;
         return msgpack::object_handle(obj, msgpack::move(z));
-    case UNPACK_EXTRA_BYTES:
+    case PARSE_EXTRA_BYTES:
         off = noff;
         return msgpack::object_handle(obj, msgpack::move(z));
-    case UNPACK_CONTINUE:
+    case PARSE_CONTINUE:
         throw msgpack::insufficient_bytes("insufficient bytes");
-    case UNPACK_PARSE_ERROR:
+    case PARSE_PARSE_ERROR:
     default:
         throw msgpack::parse_error("parse error");
     }
@@ -1528,23 +1446,23 @@ inline void unpack(
     msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
     referenced = false;
     std::size_t noff = off;
-    unpack_return ret = detail::unpack_imp(
+    parse_return ret = detail::unpack_imp(
         data, len, noff, *z, obj, referenced, f, user_data, limit);
 
     switch(ret) {
-    case UNPACK_SUCCESS:
+    case PARSE_SUCCESS:
         off = noff;
         result.set(obj);
         result.zone() = msgpack::move(z);
         return;
-    case UNPACK_EXTRA_BYTES:
+    case PARSE_EXTRA_BYTES:
         off = noff;
         result.set(obj);
         result.zone() = msgpack::move(z);
         return;
-    case UNPACK_CONTINUE:
+    case PARSE_CONTINUE:
         throw msgpack::insufficient_bytes("insufficient bytes");
-    case UNPACK_PARSE_ERROR:
+    case PARSE_PARSE_ERROR:
     default:
         throw msgpack::parse_error("parse error");
     }
@@ -1591,19 +1509,19 @@ inline msgpack::object unpack(
     msgpack::object obj;
     std::size_t noff = off;
     referenced = false;
-    unpack_return ret = detail::unpack_imp(
+    parse_return ret = detail::unpack_imp(
         data, len, noff, z, obj, referenced, f, user_data, limit);
 
     switch(ret) {
-    case UNPACK_SUCCESS:
+    case PARSE_SUCCESS:
         off = noff;
         return obj;
-    case UNPACK_EXTRA_BYTES:
+    case PARSE_EXTRA_BYTES:
         off = noff;
         return obj;
-    case UNPACK_CONTINUE:
+    case PARSE_CONTINUE:
         throw msgpack::insufficient_bytes("insufficient bytes");
-    case UNPACK_PARSE_ERROR:
+    case PARSE_PARSE_ERROR:
     default:
         throw msgpack::parse_error("parse error");
     }
@@ -1643,6 +1561,7 @@ inline msgpack::object unpack(
 
 // obsolete
 // pointer version
+MSGPACK_DEPRECATED("please use reference version instead")
 inline void unpack(
     msgpack::object_handle* result,
     const char* data, std::size_t len, std::size_t* off, bool* referenced,

data/vendor/local/include/msgpack/v1/unpack_decl.hpp

@@ -16,6 +16,7 @@
 #include "msgpack/zone.hpp"
 #include "msgpack/cpp_config.hpp"
 #include "msgpack/sysdep.h"
+#include "msgpack/parse_return.hpp"
 
 #include <memory>
 #include <stdexcept>
@@ -433,17 +434,9 @@ void unpack(
     unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, unpack_limit const& limit = unpack_limit());
 
 
-// for internal use
-typedef enum {
-    UNPACK_SUCCESS              =  2,
-    UNPACK_EXTRA_BYTES          =  1,
-    UNPACK_CONTINUE             =  0,
-    UNPACK_PARSE_ERROR          = -1
-} unpack_return;
-
 namespace detail {
 
-unpack_return
+parse_return
 unpack_imp(const char* data, std::size_t len, std::size_t& off,
            msgpack::zone& result_zone, msgpack::object& result, bool& referenced,
            unpack_reference_func f, void* user_data,