rroonga 7.1.1-x86-mingw32 → 9.0.2-x86-mingw32

data/vendor/local/include/msgpack/v3/parse_decl.hpp

@@ -0,0 +1,49 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2018-2017 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_V3_PARSE_DECL_HPP
+#define MSGPACK_V3_PARSE_DECL_HPP
+
+#include "msgpack/v2/parse_decl.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v3) {
+/// @endcond
+
+namespace detail {
+
+template <typename VisitorHolder>
+class context;
+
+} // detail
+
+using v2::parser;
+using v2::parse;
+
+namespace detail {
+
+template <typename Visitor>
+struct parse_helper;
+
+template <typename Visitor>
+inline parse_return
+parse_imp(const char* data, size_t len, size_t& off, Visitor& v);
+
+} // detail
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v3)
+/// @endcond
+
+}  // namespace msgpack
+
+
+#endif // MSGPACK_V3_PARSE_DECL_HPP

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

@@ -0,0 +1,35 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2008-2018 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_V3_PARSE_RETURN_HPP
+#define MSGPACK_V3_PARSE_RETURN_HPP
+
+#include "msgpack/v2/parse_return.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v3) {
+/// @endcond
+
+using v2::parse_return;
+
+using v2::PARSE_SUCCESS;
+using v2::PARSE_EXTRA_BYTES;
+using v2::PARSE_CONTINUE;
+using v2::PARSE_PARSE_ERROR;
+using v2::PARSE_STOP_VISITOR;
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v3)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V3_PARSE_RETURN_HPP

data/vendor/local/include/msgpack/v3/sbuffer_decl.hpp

@@ -0,0 +1,33 @@
+//
+// MessagePack for C++ simple buffer implementation
+//
+// Copyright (C) 2018 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_V3_SBUFFER_DECL_HPP
+#define MSGPACK_V3_SBUFFER_DECL_HPP
+
+#include "msgpack/versioning.hpp"
+
+#ifndef MSGPACK_SBUFFER_INIT_SIZE
+#define MSGPACK_SBUFFER_INIT_SIZE 8192
+#endif
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v3) {
+/// @endcond
+
+using v2::sbuffer;
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v3)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V3_SBUFFER_DECL_HPP

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

@@ -0,0 +1,192 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2018 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_V3_UNPACK_HPP
+#define MSGPACK_V3_UNPACK_HPP
+
+#include "msgpack/unpack_decl.hpp"
+#include "msgpack/parse.hpp"
+#include "msgpack/create_object_visitor.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v3) {
+/// @endcond
+
+inline msgpack::object_handle unpack(
+    const char* data, std::size_t len, std::size_t& off, bool& referenced,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit
+)
+{
+    msgpack::object obj;
+    msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
+    referenced = false;
+    parse_return ret = detail::unpack_imp(
+        data, len, off, *z, obj, referenced, f, user_data, limit);
+
+    switch(ret) {
+    case msgpack::PARSE_SUCCESS:
+        return msgpack::object_handle(obj, msgpack::move(z));
+    case msgpack::PARSE_EXTRA_BYTES:
+        return msgpack::object_handle(obj, msgpack::move(z));
+    default:
+        break;
+    }
+    return msgpack::object_handle();
+}
+
+inline msgpack::object_handle unpack(
+    const char* data, std::size_t len, std::size_t& off,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    bool referenced;
+    return msgpack::v3::unpack(data, len, off, referenced, f, user_data, limit);
+}
+
+inline msgpack::object_handle unpack(
+    const char* data, std::size_t len, bool& referenced,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    std::size_t off = 0;
+    return msgpack::v3::unpack(data, len, off, referenced, f, user_data, limit);
+}
+
+inline msgpack::object_handle unpack(
+    const char* data, std::size_t len,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    bool referenced;
+    std::size_t off = 0;
+    return msgpack::v3::unpack(data, len, off, referenced, f, user_data, limit);
+}
+
+inline void unpack(
+    msgpack::object_handle& result,
+    const char* data, std::size_t len, std::size_t& off, bool& referenced,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    msgpack::object obj;
+    msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
+    referenced = false;
+    parse_return ret = detail::unpack_imp(
+        data, len, off, *z, obj, referenced, f, user_data, limit);
+
+    switch(ret) {
+    case msgpack::PARSE_SUCCESS:
+        result.set(obj);
+        result.zone() = msgpack::move(z);
+        return;
+    case msgpack::PARSE_EXTRA_BYTES:
+        result.set(obj);
+        result.zone() = msgpack::move(z);
+        return;
+    default:
+        return;
+    }
+}
+
+inline void unpack(
+    msgpack::object_handle& result,
+    const char* data, std::size_t len, std::size_t& off,
+    msgpack::v3::unpack_reference_func f, void* user_data,
+            msgpack::unpack_limit const& limit)
+{
+    bool referenced;
+    msgpack::v3::unpack(result, data, len, off, referenced, f, user_data, limit);
+}
+
+inline void unpack(
+    msgpack::object_handle& result,
+    const char* data, std::size_t len, bool& referenced,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    std::size_t off = 0;
+    msgpack::v3::unpack(result, data, len, off, referenced, f, user_data, limit);
+}
+
+inline void unpack(
+    msgpack::object_handle& result,
+    const char* data, std::size_t len,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    bool referenced;
+    std::size_t off = 0;
+    msgpack::v3::unpack(result, data, len, off, referenced, f, user_data, limit);
+}
+
+
+inline msgpack::object unpack(
+    msgpack::zone& z,
+    const char* data, std::size_t len, std::size_t& off, bool& referenced,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    msgpack::object obj;
+    referenced = false;
+    parse_return ret = detail::unpack_imp(
+        data, len, off, z, obj, referenced, f, user_data, limit);
+
+    switch(ret) {
+    case msgpack::PARSE_SUCCESS:
+        return obj;
+    case msgpack::PARSE_EXTRA_BYTES:
+        return obj;
+    default:
+        break;
+    }
+    return obj;
+}
+
+inline msgpack::object unpack(
+    msgpack::zone& z,
+    const char* data, std::size_t len, std::size_t& off,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    bool referenced;
+    return msgpack::v3::unpack(z, data, len, off, referenced, f, user_data, limit);
+}
+
+inline msgpack::object unpack(
+    msgpack::zone& z,
+    const char* data, std::size_t len, bool& referenced,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    std::size_t off = 0;
+    return msgpack::v3::unpack(z, data, len, off, referenced, f, user_data, limit);
+}
+
+inline msgpack::object unpack(
+    msgpack::zone& z,
+    const char* data, std::size_t len,
+    msgpack::unpack_reference_func f, void* user_data,
+    msgpack::unpack_limit const& limit)
+{
+    bool referenced;
+    std::size_t off = 0;
+    return msgpack::v3::unpack(z, data, len, off, referenced, f, user_data, limit);
+}
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v3)
+/// @endcond
+
+}  // namespace msgpack
+
+
+#endif // MSGPACK_V3_UNPACK_HPP

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

@@ -0,0 +1,304 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2018 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_V3_UNPACK_DECL_HPP
+#define MSGPACK_V3_UNPACK_DECL_HPP
+
+#include "msgpack/v2/unpack_decl.hpp"
+
+namespace msgpack {
+
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v3) {
+/// @endcond
+
+using v2::unpack_reference_func;
+
+using v2::unpack_error;
+using v2::parse_error;
+using v2::insufficient_bytes;
+using v2::size_overflow;
+using v2::array_size_overflow;
+using v2::map_size_overflow;
+using v2::str_size_overflow;
+using v2::bin_size_overflow;
+using v2::ext_size_overflow;
+using v2::depth_size_overflow;
+using v2::unpack_limit;
+
+namespace detail {
+
+using v2::detail::unpack_user;
+
+using v2::detail::unpack_uint8;
+using v2::detail::unpack_uint16;
+using v2::detail::unpack_uint32;
+using v2::detail::unpack_uint64;
+
+using v2::detail::unpack_int8;
+using v2::detail::unpack_int16;
+using v2::detail::unpack_int32;
+using v2::detail::unpack_int64;
+
+using v2::detail::unpack_float;
+using v2::detail::unpack_double;
+
+using v2::detail::unpack_nil;
+
+using v2::detail::unpack_true;
+using v2::detail::unpack_false;
+
+using v2::detail::unpack_array;
+using v2::detail::unpack_array_item;
+using v2::detail::unpack_map;
+using v2::detail::unpack_map_item;
+using v2::detail::unpack_str;
+using v2::detail::unpack_bin;
+using v2::detail::unpack_ext;
+
+using  v2::detail::unpack_stack;
+
+using v2::detail::init_count;
+using v2::detail::decr_count;
+using v2::detail::incr_count;
+
+using v2::detail::get_count;
+
+using v2::detail::fix_tag;
+
+using v2::detail::value;
+
+using v2::detail::load;
+
+} // detail
+
+
+using v2::unpacked;
+using v2::unpacker;
+using v2::basic_unpacker;
+
+namespace detail {
+
+using v2::detail::unpack_imp;
+
+} // detail
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param off The offset position of the buffer. It is read and overwritten.
+ * @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 limit The size limit information of msgpack::object.
+ *
+ * @return object_handle that contains unpacked data.
+ *
+ */
+msgpack::object_handle unpack(
+    const char* data, std::size_t len, std::size_t& off, bool& referenced,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param off The offset position of the buffer. It is read and overwritten.
+ * @param f A judging function that msgpack::object refer to the buffer.
+ * @param user_data This parameter is passed to f.
+ * @param limit The size limit information of msgpack::object.
+ *
+ * @return object_handle that contains unpacked data.
+ *
+ */
+msgpack::object_handle unpack(
+    const char* data, std::size_t len, std::size_t& off,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @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 limit The size limit information of msgpack::object.
+ *
+ * @return object_handle that contains unpacked data.
+ *
+ */
+msgpack::object_handle unpack(
+    const char* data, std::size_t len, bool& referenced,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param f A judging function that msgpack::object refer to the buffer.
+ * @param user_data This parameter is passed to f.
+ * @param limit The size limit information of msgpack::object.
+ *
+ * @return object_handle that contains unpacked data.
+ *
+ */
+msgpack::object_handle unpack(
+    const char* data, std::size_t len,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param result The object_handle that contains unpacked data.
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param off The offset position of the buffer. It is read and overwritten.
+ * @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 limit The size limit information of msgpack::object.
+ *
+ *
+ */
+void unpack(
+    msgpack::object_handle& result,
+    const char* data, std::size_t len, std::size_t& off, bool& referenced,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param result The object_handle that contains unpacked data.
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param off The offset position of the buffer. It is read and overwritten.
+ * @param f A judging function that msgpack::object refer to the buffer.
+ * @param user_data This parameter is passed to f.
+ * @param limit The size limit information of msgpack::object.
+ *
+ *
+ */
+void unpack(
+    msgpack::object_handle& result,
+    const char* data, std::size_t len, std::size_t& off,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param result The object_handle that contains unpacked data.
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @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 limit The size limit information of msgpack::object.
+ *
+ *
+ */
+void unpack(
+    msgpack::object_handle& result,
+    const char* data, std::size_t len, bool& referenced,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param result The object_handle that contains unpacked data.
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param f A judging function that msgpack::object refer to the buffer.
+ * @param user_data This parameter is passed to f.
+ * @param limit The size limit information of msgpack::object.
+ *
+ *
+ */
+void unpack(
+    msgpack::object_handle& result,
+    const char* data, std::size_t len,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param z The msgpack::zone that is used as a memory of unpacked msgpack objects.
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param off The offset position of the buffer. It is read and overwritten.
+ * @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 limit The size limit information of msgpack::object.
+ *
+ * @return msgpack::object that contains unpacked data.
+ *
+ */
+msgpack::object unpack(
+    msgpack::zone& z,
+    const char* data, std::size_t len, std::size_t& off, bool& referenced,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param z The msgpack::zone that is used as a memory of unpacked msgpack objects.
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param off The offset position of the buffer. It is read and overwritten.
+ * @param f A judging function that msgpack::object refer to the buffer.
+ * @param user_data This parameter is passed to f.
+ * @param limit The size limit information of msgpack::object.
+ *
+ * @return msgpack::object that contains unpacked data.
+ *
+ */
+msgpack::object unpack(
+    msgpack::zone& z,
+    const char* data, std::size_t len, std::size_t& off,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param z The msgpack::zone that is used as a memory of unpacked msgpack objects.
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @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 limit The size limit information of msgpack::object.
+ *
+ * @return msgpack::object that contains unpacked data.
+ *
+ */
+msgpack::object unpack(
+    msgpack::zone& z,
+    const char* data, std::size_t len, bool& referenced,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+/// Unpack msgpack::object from a buffer.
+/**
+ * @param z The msgpack::zone that is used as a memory of unpacked msgpack objects.
+ * @param data The pointer to the buffer.
+ * @param len The length of the buffer.
+ * @param f A judging function that msgpack::object refer to the buffer.
+ * @param user_data This parameter is passed to f.
+ * @param limit The size limit information of msgpack::object.
+ *
+ * @return msgpack::object that contains unpacked data.
+ *
+ */
+msgpack::object unpack(
+    msgpack::zone& z,
+    const char* data, std::size_t len,
+    msgpack::unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR, msgpack::unpack_limit const& limit = unpack_limit());
+
+
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v3)
+/// @endcond
+
+}  // namespace msgpack
+
+#endif // MSGPACK_V3_UNPACK_DECL_HPP