rroonga 6.0.5-x64-mingw32 → 6.0.7-x64-mingw32

data/vendor/local/include/msgpack/adaptor/cpp11/unordered_set.hpp

@@ -1,172 +1,16 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2014-2015 KONDO Takatoshi
+// Copyright (C) 2016 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_TYPE_UNORDERED_SET_HPP
-#define MSGPACK_TYPE_UNORDERED_SET_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
+#ifndef MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP
+#define MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP
 
-#include <unordered_set>
+#include "msgpack/v1/adaptor/cpp11/unordered_set.hpp"
 
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct as<std::unordered_set<Key, Hash, Compare, Alloc>, typename std::enable_if<msgpack::has_as<Key>::value>::type> {
-    std::unordered_set<Key, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_set<Key, Hash, Compare, Alloc> v;
-        while (p > pbegin) {
-            --p;
-            v.insert(p->as<Key>());
-        }
-        return v;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct convert<std::unordered_set<Key, Hash, Compare, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_set<Key, Hash, Compare, Alloc> tmp;
-        while(p > pbegin) {
-            --p;
-            tmp.insert(p->as<Key>());
-        }
-        v = std::move(tmp);
-        return o;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct pack<std::unordered_set<Key, Hash, Compare, Alloc>> {
-    template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<std::unordered_set<Key, Hash, Compare, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_set<Key, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::unordered_set<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct as<std::unordered_multiset<Key, Hash, Compare, Alloc>, typename std::enable_if<msgpack::has_as<Key>::value>::type> {
-    std::unordered_multiset<Key, Hash, Compare, Alloc> operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_multiset<Key, Hash, Compare, Alloc> v;
-        while (p > pbegin) {
-            --p;
-            v.insert(p->as<Key>());
-        }
-        return v;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct convert<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
-    msgpack::object const& operator()(msgpack::object const& o, std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        msgpack::object* p = o.via.array.ptr + o.via.array.size;
-        msgpack::object* const pbegin = o.via.array.ptr;
-        std::unordered_multiset<Key, Hash, Compare, Alloc> tmp;
-        while(p > pbegin) {
-            --p;
-            tmp.insert(p->as<Key>());
-        }
-        v = std::move(tmp);
-        return o;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct pack<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
-    template <typename Stream>
-        msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename Key, typename Hash, typename Compare, typename Alloc>
-struct object_with_zone<std::unordered_multiset<Key, Hash, Compare, Alloc>> {
-    void operator()(msgpack::object::with_zone& o, const std::unordered_multiset<Key, Hash, Compare, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::unordered_multiset<Key, Hash, Compare, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_TYPE_UNORDERED_SET_HPP
+#endif // MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP

data/vendor/local/include/msgpack/adaptor/define.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
+// 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
@@ -10,22 +10,8 @@
 #ifndef MSGPACK_DEFINE_HPP
 #define MSGPACK_DEFINE_HPP
 
-#include "msgpack/cpp_config.hpp"
+#include "msgpack/adaptor/define_decl.hpp"
 
-#if defined(MSGPACK_USE_CPP03)
-#include "detail/cpp03_define_array.hpp"
-#include "detail/cpp03_define_map.hpp"
-#else  // MSGPACK_USE_CPP03
-#include "detail/cpp11_define_array.hpp"
-#include "detail/cpp11_define_map.hpp"
-#endif // MSGPACK_USE_CPP03
-
-#if defined(MSGPACK_USE_DEFINE_MAP)
-#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP
-#define MSGPACK_BASE MSGPACK_BASE_MAP
-#else  // defined(MSGPACK_USE_DEFINE_MAP)
-#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY
-#define MSGPACK_BASE MSGPACK_BASE_ARRAY
-#endif // defined(MSGPACK_USE_DEFINE_MAP)
+#include "msgpack/v1/adaptor/define.hpp"
 
 #endif // MSGPACK_DEFINE_HPP

data/vendor/local/include/msgpack/adaptor/define_decl.hpp

@@ -0,0 +1,142 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2016 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_DEFINE_DECL_HPP
+#define MSGPACK_DEFINE_DECL_HPP
+
+// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
+// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
+// However, supporting compiler detection is not complete. msgpack-c requires
+// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
+#if !defined(MSGPACK_PP_VARIADICS)
+#define MSGPACK_PP_VARIADICS
+#endif
+
+#include <msgpack/preprocessor.hpp>
+
+#include "msgpack/versioning.hpp"
+
+// for MSGPACK_ADD_ENUM
+#include "msgpack/adaptor/int.hpp"
+
+#define MSGPACK_DEFINE_ARRAY(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& pk) const \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& o) \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
+    }\
+    template <typename MSGPACK_OBJECT> \
+    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
+    }
+
+#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
+
+#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
+    MSGPACK_PP_IF( \
+        MSGPACK_PP_IS_BEGIN_PARENS(elem), \
+        elem, \
+        (MSGPACK_PP_STRINGIZE(elem))(elem) \
+    )
+
+#define MSGPACK_DEFINE_MAP_IMPL(...) \
+    MSGPACK_PP_SEQ_TO_TUPLE( \
+        MSGPACK_PP_SEQ_FOR_EACH( \
+            MSGPACK_DEFINE_MAP_EACH_PROC, \
+            0, \
+            MSGPACK_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
+        ) \
+    )
+
+#define MSGPACK_DEFINE_MAP(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& pk) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_pack(pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& o) \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_unpack(o); \
+    }\
+    template <typename MSGPACK_OBJECT> \
+    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_object(o, z); \
+    }
+
+#define MSGPACK_BASE_MAP(base) \
+    (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
+
+// MSGPACK_ADD_ENUM must be used in the global namespace.
+#define MSGPACK_ADD_ENUM(enum_name) \
+  namespace msgpack { \
+  /** @cond */ \
+  MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { \
+  /** @endcond */ \
+  namespace adaptor { \
+    template<> \
+    struct convert<enum_name> { \
+      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const { \
+        msgpack::underlying_type<enum_name>::type tmp; \
+        msgpack::operator>>(o, tmp);                   \
+        v = static_cast<enum_name>(tmp);   \
+        return o; \
+      } \
+    }; \
+    template<> \
+    struct object<enum_name> { \
+      void operator()(msgpack::object& o, const enum_name& v) const { \
+        msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(v); \
+        msgpack::operator<<(o, tmp);                                    \
+      } \
+    }; \
+    template<> \
+    struct object_with_zone<enum_name> { \
+      void operator()(msgpack::object::with_zone& o, const enum_name& v) const {  \
+        msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(v); \
+        msgpack::operator<<(o, tmp);                                    \
+      } \
+    }; \
+    template <> \
+    struct pack<enum_name> { \
+      template <typename Stream> \
+      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
+          return msgpack::operator<<(o, static_cast<msgpack::underlying_type<enum_name>::type>(v)); \
+      } \
+    }; \
+  } \
+  /** @cond */ \
+  } \
+  /** @endcond */ \
+  }
+
+#if defined(MSGPACK_USE_DEFINE_MAP)
+#define MSGPACK_DEFINE MSGPACK_DEFINE_MAP
+#define MSGPACK_BASE MSGPACK_BASE_MAP
+#else  // defined(MSGPACK_USE_DEFINE_MAP)
+#define MSGPACK_DEFINE MSGPACK_DEFINE_ARRAY
+#define MSGPACK_BASE MSGPACK_BASE_ARRAY
+#endif // defined(MSGPACK_USE_DEFINE_MAP)
+
+
+#include "msgpack/v1/adaptor/define_decl.hpp"
+#include "msgpack/v2/adaptor/define_decl.hpp"
+
+#endif // MSGPACK_DEFINE_DECL_HPP

data/vendor/local/include/msgpack/adaptor/deque.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2015 FURUHASHI Sadayuki
+// Copyright (C) 2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,99 +10,6 @@
 #ifndef MSGPACK_TYPE_DEQUE_HPP
 #define MSGPACK_TYPE_DEQUE_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
+#include "msgpack/v1/adaptor/deque.hpp"
 
-#include <deque>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Alloc>
-struct as<std::deque<T, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
-    std::deque<T, Alloc> operator()(const msgpack::object& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        std::deque<T, Alloc> v;
-        if (o.via.array.size > 0) {
-            msgpack::object* p = o.via.array.ptr;
-            msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-            do {
-                v.push_back(p->as<T>());
-                ++p;
-            } while (p < pend);
-        }
-        return v;
-    }
-};
-
-#endif // !defined(MSGPACK_USE_CPP03)
-
-template <typename T, typename Alloc>
-struct convert<std::deque<T, Alloc> > {
-    msgpack::object const& operator()(msgpack::object const& o, std::deque<T, Alloc>& v) const {
-        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        v.resize(o.via.array.size);
-        msgpack::object* p = o.via.array.ptr;
-        msgpack::object* const pend = o.via.array.ptr + o.via.array.size;
-        typename std::deque<T, Alloc>::iterator it = v.begin();
-        for(; p < pend; ++p, ++it) {
-            p->convert(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Alloc>
-struct pack<std::deque<T, Alloc> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::deque<T, Alloc>& v) const {
-        uint32_t size = checked_get_container_size(v.size());
-        o.pack_array(size);
-        for(typename std::deque<T, Alloc>::const_iterator it(v.begin()), it_end(v.end());
-            it != it_end; ++it) {
-            o.pack(*it);
-        }
-        return o;
-    }
-};
-
-template <typename T, typename Alloc>
-struct object_with_zone<std::deque<T, Alloc> > {
-    void operator()(msgpack::object::with_zone& o, const std::deque<T, Alloc>& v) const {
-        o.type = msgpack::type::ARRAY;
-        if(v.empty()) {
-            o.via.array.ptr = nullptr;
-            o.via.array.size = 0;
-        } else {
-            uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-            msgpack::object* const pend = p + size;
-            o.via.array.ptr = p;
-            o.via.array.size = size;
-            typename std::deque<T, Alloc>::const_iterator it(v.begin());
-            do {
-                *p = msgpack::object(*it, o.zone);
-                ++p;
-                ++it;
-            } while(p < pend);
-        }
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/deque.hpp */
+#endif // MSGPACK_TYPE_DEQUE_HPP