rroonga 5.1.1-x64-mingw32 → 6.0.0-x64-mingw32

data/vendor/local/include/msgpack/adaptor/detail/{cpp11_define.hpp → cpp11_define_array.hpp}

@@ -3,103 +3,110 @@
 //
 // Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
 //
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
+//    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)
 //
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#ifndef MSGPACK_CPP11_DEFINE_HPP
-#define MSGPACK_CPP11_DEFINE_HPP
+#ifndef MSGPACK_CPP11_DEFINE_ARRAY_HPP
+#define MSGPACK_CPP11_DEFINE_ARRAY_HPP
 
 #include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
 
 // for MSGPACK_ADD_ENUM
-#include "msgpack/adaptor/int_fwd.hpp"
+#include "msgpack/adaptor/int.hpp"
 
 #include <type_traits>
 #include <tuple>
 
-#define MSGPACK_DEFINE(...) \
+#define MSGPACK_DEFINE_ARRAY(...) \
     template <typename Packer> \
     void msgpack_pack(Packer& pk) const \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
     } \
     void msgpack_unpack(msgpack::object const& o) \
     { \
-        msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(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(__VA_ARGS__).msgpack_object(o, z); \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
     }
 
+#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
+
 // MSGPACK_ADD_ENUM must be used in the global namespace.
-#define MSGPACK_ADD_ENUM(enum) \
+#define MSGPACK_ADD_ENUM(enum_name) \
   namespace msgpack { \
+  /** @cond */ \
   MSGPACK_API_VERSION_NAMESPACE(v1) { \
-    inline msgpack::object const& operator>> (msgpack::object const& o, enum& v) \
-    { \
-      std::underlying_type<enum>::type tmp; \
-      o >> tmp; \
-      v = static_cast<enum>(tmp);   \
-      return o; \
-    } \
-    inline void operator<< (msgpack::object& o, const enum& v) \
-    { \
-      auto tmp = static_cast<std::underlying_type<enum>::type>(v); \
-      o << tmp; \
-    } \
-    inline void operator<< (msgpack::object::with_zone& o, const enum& v) \
-    { \
-      auto tmp = static_cast<std::underlying_type<enum>::type>(v); \
-      o << tmp; \
-    } \
-    namespace detail { \
+  /** @endcond */ \
+  namespace adaptor { \
+    template<> \
+    struct convert<enum_name> { \
+      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const { \
+        std::underlying_type<enum_name>::type tmp; \
+        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 { \
+        auto tmp = static_cast<std::underlying_type<enum_name>::type>(v); \
+        o << tmp; \
+      } \
+    }; \
+    template<> \
+    struct object_with_zone<enum_name> { \
+      void operator()(msgpack::object::with_zone& o, const enum_name& v) const {  \
+        auto tmp = static_cast<std::underlying_type<enum_name>::type>(v); \
+        o << tmp; \
+      } \
+    }; \
+    template <> \
+    struct pack<enum_name> { \
       template <typename Stream> \
-      struct packer_serializer<Stream, enum> { \
-        static msgpack::packer<Stream>& pack(msgpack::packer<Stream>& o, const enum& v) { \
-          return o << static_cast<std::underlying_type<enum>::type>(v); \
-        } \
-      }; \
-    } \
+      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
+        return o << static_cast<std::underlying_type<enum_name>::type>(v); \
+      } \
+    }; \
+  } \
+  /** @cond */ \
   } \
+  /** @endcond */ \
   }
 
 namespace msgpack {
+/// @cond
 MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
 namespace type {
 
 template <typename Tuple, std::size_t N>
-struct define_imp {
+struct define_array_imp {
     template <typename Packer>
     static void pack(Packer& pk, Tuple const& t) {
-        define_imp<Tuple, N-1>::pack(pk, t);
+        define_array_imp<Tuple, N-1>::pack(pk, t);
         pk.pack(std::get<N-1>(t));
     }
     static void unpack(msgpack::object const& o, Tuple& t) {
-        define_imp<Tuple, N-1>::unpack(o, t);
+        define_array_imp<Tuple, N-1>::unpack(o, t);
         const size_t size = o.via.array.size;
         if(size <= N-1) { return; }
         o.via.array.ptr[N-1].convert(std::get<N-1>(t));
     }
     static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
-        define_imp<Tuple, N-1>::object(o, z, t);
+        define_array_imp<Tuple, N-1>::object(o, z, t);
         o->via.array.ptr[N-1] = msgpack::object(std::get<N-1>(t), z);
     }
 };
 
 template <typename Tuple>
-struct define_imp<Tuple, 1> {
+struct define_array_imp<Tuple, 1> {
     template <typename Packer>
     static void pack(Packer& pk, Tuple const& t) {
         pk.pack(std::get<0>(t));
@@ -115,23 +122,23 @@ struct define_imp<Tuple, 1> {
 };
 
 template <typename... Args>
-struct define {
-    typedef define<Args...> value_type;
+struct define_array {
+    typedef define_array<Args...> value_type;
     typedef std::tuple<Args...> tuple_type;
-    define(Args&... args) :
+    define_array(Args&... args) :
         a(args...) {}
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
     {
         pk.pack_array(sizeof...(Args));
 
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
     }
     void msgpack_unpack(msgpack::object const& o)
     {
         if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
 
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
     }
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
@@ -139,15 +146,15 @@ struct define {
         o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
         o->via.array.size = sizeof...(Args);
 
-        define_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
+        define_array_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
     }
 
     std::tuple<Args&...> a;
 };
 
 template <>
-struct define<> {
-    typedef define<> value_type;
+struct define_array<> {
+    typedef define_array<> value_type;
     typedef std::tuple<> tuple_type;
     template <typename Packer>
     void msgpack_pack(Packer& pk) const
@@ -166,19 +173,21 @@ struct define<> {
     }
 };
 
-inline define<> make_define()
+inline define_array<> make_define_array()
 {
-    return define<>();
+    return define_array<>();
 }
 
 template <typename... Args>
-define<Args...> make_define(Args&... args)
+inline define_array<Args...> make_define_array(Args&... args)
 {
-    return define<Args...>(args...);
+    return define_array<Args...>(args...);
 }
 
 }  // namespace type
+/// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
 }  // namespace msgpack
 
-#endif // MSGPACK_CPP11_DEFINE_HPP
+#endif // MSGPACK_CPP11_DEFINE_ARRAY_HPP

data/vendor/local/include/msgpack/adaptor/detail/cpp11_define_map.hpp

@@ -0,0 +1,163 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2013 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_CPP11_DEFINE_MAP_HPP
+#define MSGPACK_CPP11_DEFINE_MAP_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"
+#include "msgpack/adaptor/adaptor_base.hpp"
+
+// for MSGPACK_ADD_ENUM
+#include "msgpack/adaptor/int.hpp"
+
+#include <type_traits>
+#include <tuple>
+
+#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)))
+
+namespace msgpack {
+/// @cond
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+namespace type {
+
+template <typename Tuple, std::size_t N>
+struct define_map_imp {
+    template <typename Packer>
+    static void pack(Packer& pk, Tuple const& t) {
+        define_map_imp<Tuple, N-1>::pack(pk, t);
+        pk.pack(std::get<N-1>(t));
+    }
+    static void unpack(
+        msgpack::object const& o, Tuple const& t,
+        std::map<std::string, msgpack::object const*> const& kvmap) {
+        define_map_imp<Tuple, N-2>::unpack(o, t, kvmap);
+        auto it = kvmap.find(std::get<N-2>(t));
+        if (it != kvmap.end()) {
+            it->second->convert(std::get<N-1>(t));
+        }
+    }
+    static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) {
+        define_map_imp<Tuple, N-2>::object(o, z, t);
+        o->via.map.ptr[(N-1)/2].key = msgpack::object(std::get<N-2>(t), z);
+        o->via.map.ptr[(N-1)/2].val = msgpack::object(std::get<N-1>(t), z);
+    }
+};
+
+template <typename Tuple>
+struct define_map_imp<Tuple, 0> {
+    template <typename Packer>
+    static void pack(Packer&, Tuple const&) {}
+    static void unpack(
+        msgpack::object const&, Tuple const&,
+        std::map<std::string, msgpack::object const*> const&) {}
+    static void object(msgpack::object*, msgpack::zone&, Tuple const&) {}
+};
+
+template <typename... Args>
+struct define_map {
+    define_map(Args&... args) :
+        a(args...) {}
+    template <typename Packer>
+    void msgpack_pack(Packer& pk) const
+    {
+        static_assert(sizeof...(Args) % 2 == 0, "");
+        pk.pack_map(sizeof...(Args) / 2);
+
+        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
+    }
+    void msgpack_unpack(msgpack::object const& o) const
+    {
+        if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
+        std::map<std::string, msgpack::object const*> kvmap;
+        for (uint32_t i = 0; i < o.via.map.size; ++i) {
+            kvmap.emplace(
+                std::string(
+                    o.via.map.ptr[i].key.via.str.ptr,
+                    o.via.map.ptr[i].key.via.str.size),
+                &o.via.map.ptr[i].val);
+        }
+        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::unpack(o, a, kvmap);
+    }
+    void msgpack_object(msgpack::object* o, msgpack::zone& z) const
+    {
+        static_assert(sizeof...(Args) % 2 == 0, "");
+        o->type = msgpack::type::MAP;
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*sizeof...(Args)/2));
+        o->via.map.size = sizeof...(Args) / 2;
+
+        define_map_imp<std::tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
+    }
+
+    std::tuple<Args&...> a;
+};
+
+
+template <typename... Args>
+define_map<Args...> make_define_map(Args&... args)
+{
+    return define_map<Args...>(args...);
+}
+
+}  // namespace type
+/// @cond
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
+}  // namespace msgpack
+
+#endif // MSGPACK_CPP11_DEFINE_MAP_HPP

data/vendor/local/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp

@@ -1,31 +1,26 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
+// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi
 //
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
+//    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_CPP11_MSGPACK_TUPLE_HPP
 #define MSGPACK_CPP11_MSGPACK_TUPLE_HPP
 
 #include "msgpack/versioning.hpp"
 #include "msgpack/object_fwd.hpp"
+#include "msgpack/meta.hpp"
 
 #include <tuple>
 
 namespace msgpack {
 
+/// @cond
 MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
 
 namespace type {
     // tuple
@@ -34,9 +29,6 @@ namespace type {
     using std::tuple_element;
     using std::uses_allocator;
     using std::ignore;
-    using std::make_tuple;
-    using std::tie;
-    using std::forward_as_tuple;
     using std::swap;
 
     template< class... Types >
@@ -71,24 +63,38 @@ namespace type {
 
         template< std::size_t I>
         typename tuple_element<I, base >::type&
-        get() { return std::get<I>(*this); }
+        get() & { return std::get<I>(*this); }
 
         template< std::size_t I>
         typename tuple_element<I, base >::type const&
-        get() const { return std::get<I>(*this); }
+        get() const& { return std::get<I>(*this); }
 
         template< std::size_t I>
         typename tuple_element<I, base >::type&&
         get() && { return std::get<I>(*this); }
     };
 
-    template< class... Tuples >
-    auto tuple_cat(Tuples&&... args) ->
+    template <class... Args>
+    inline tuple<Args...> make_tuple(Args&&... args) {
+        return tuple<Args...>(args...);
+    }
+
+    template<class... Args>
+    inline tuple<Args&&...> forward_as_tuple (Args&&... args) noexcept {
+        return tuple<Args&&...>(std::forward<Args>(args)...);
+    }
+
+    template <class... Tuples>
+    inline auto tuple_cat(Tuples&&... args) ->
         decltype(
             std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...)
         ) {
         return std::tuple_cat(std::forward<typename std::remove_reference<Tuples>::type::base>(args)...);
     }
+    template <class... Args>
+    inline tuple<Args&...> tie(Args&... args) {
+        return tuple<Args&...>(args...);
+    }
 } // namespace type
 
 // --- Pack from tuple to packer stream ---
@@ -119,17 +125,50 @@ struct MsgpackTuplePacker<Stream, Tuple, 0> {
     }
 };
 
-template <typename Stream, typename... Args>
-const msgpack::packer<Stream>& operator<< (
-    msgpack::packer<Stream>& o,
-    const type::tuple<Args...>& v) {
-    o.pack_array(sizeof...(Args));
-    MsgpackTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
-    return o;
-}
+namespace adaptor {
+
+template <typename... Args>
+struct pack<msgpack::type::tuple<Args...>> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(
+        msgpack::packer<Stream>& o,
+        const msgpack::type::tuple<Args...>& v) const {
+        o.pack_array(sizeof...(Args));
+        MsgpackTuplePacker<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
+        return o;
+    }
+};
+
+} // namespace adaptor
 
 // --- Convert from tuple to object ---
 
+template <typename... Args>
+struct MsgpackTupleAs;
+
+template <typename T, typename... Args>
+struct MsgpackTupleAsImpl {
+    static msgpack::type::tuple<T, Args...> as(msgpack::object const& o) {
+        return msgpack::type::tuple_cat(
+            msgpack::type::make_tuple(o.via.array.ptr[o.via.array.size - sizeof...(Args) - 1].as<T>()),
+            MsgpackTupleAs<Args...>::as(o));
+    }
+};
+
+template <typename... Args>
+struct MsgpackTupleAs {
+    static msgpack::type::tuple<Args...> as(msgpack::object const& o) {
+        return MsgpackTupleAsImpl<Args...>::as(o);
+    }
+};
+
+template <>
+struct MsgpackTupleAs<> {
+    static msgpack::type::tuple<> as (msgpack::object const&) {
+        return msgpack::type::tuple<>();
+    }
+};
+
 template <typename Tuple, std::size_t N>
 struct MsgpackTupleConverter {
     static void convert(
@@ -157,15 +196,31 @@ struct MsgpackTupleConverter<Tuple, 0> {
     }
 };
 
+namespace adaptor {
+
 template <typename... Args>
-msgpack::object const& operator>> (
-    msgpack::object const& o,
-    type::tuple<Args...>& v) {
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
-    MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
-    return o;
-}
+struct as<msgpack::type::tuple<Args...>, typename std::enable_if<msgpack::all_of<msgpack::has_as, Args...>::value>::type>  {
+    msgpack::type::tuple<Args...> operator()(
+        msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if (o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
+        return MsgpackTupleAs<Args...>::as(o);
+    }
+};
+
+template <typename... Args>
+struct convert<msgpack::type::tuple<Args...>> {
+    msgpack::object const& operator()(
+        msgpack::object const& o,
+        msgpack::type::tuple<Args...>& v) const {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); }
+        MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
+        return o;
+    }
+};
+
+} // namespace adaptor
 
 // --- Convert from tuple to object with zone ---
 template <typename Tuple, std::size_t N>
@@ -195,17 +250,25 @@ struct MsgpackTupleToObjectWithZone<Tuple, 0> {
     }
 };
 
+namespace adaptor {
+
 template <typename... Args>
-inline void operator<< (
+    struct object_with_zone<msgpack::type::tuple<Args...>> {
+    void operator()(
         msgpack::object::with_zone& o,
-        type::tuple<Args...> const& v) {
-    o.type = msgpack::type::ARRAY;
-    o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
-    o.via.array.size = sizeof...(Args);
-    MsgpackTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
-}
+        msgpack::type::tuple<Args...> const& v) const {
+        o.type = msgpack::type::ARRAY;
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*sizeof...(Args)));
+        o.via.array.size = sizeof...(Args);
+        MsgpackTupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
+    }
+};
+
+}  // namespace adaptor
 
+/// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
+///@endcond
 
 }  // namespace msgpack