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

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

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution 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_TYPE_ARRAY_REF_DECL_HPP
+#define MSGPACK_TYPE_ARRAY_REF_DECL_HPP
+
+#include "msgpack/v1/adaptor/array_ref_decl.hpp"
+#include "msgpack/v2/adaptor/array_ref_decl.hpp"
+
+#endif // MSGPACK_TYPE_ARRAY_REF_DECL_HPP

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

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// 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,57 +10,6 @@
 #ifndef MSGPACK_TYPE_BOOL_HPP
 #define MSGPACK_TYPE_BOOL_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-template <>
-struct convert<bool> {
-    msgpack::object const& operator()(msgpack::object const& o, bool& v) const {
-        if(o.type != msgpack::type::BOOLEAN) { throw msgpack::type_error(); }
-        v = o.via.boolean;
-        return o;
-    }
-};
-
-template <>
-struct pack<bool> {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const bool& v) const {
-        if(v) { o.pack_true(); }
-        else { o.pack_false(); }
-        return o;
-    }
-};
-
-template <>
-struct object<bool> {
-    void operator()(msgpack::object& o, bool v) const {
-        o.type = msgpack::type::BOOLEAN;
-        o.via.boolean = v;
-    }
-};
-
-template <>
-struct object_with_zone<bool> {
-    void operator()(msgpack::object::with_zone& o, bool v) const {
-        static_cast<msgpack::object&>(o) << v;
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
+#include "msgpack/v1/adaptor/bool.hpp"
 
 #endif // MSGPACK_TYPE_BOOL_HPP

data/vendor/local/include/msgpack/adaptor/boost/fusion.hpp

@@ -10,151 +10,6 @@
 #ifndef MSGPACK_TYPE_BOOST_FUSION_HPP
 #define MSGPACK_TYPE_BOOST_FUSION_HPP
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include "msgpack/meta.hpp"
-
-#if !defined (MSGPACK_USE_CPP03)
-#include "msgpack/adaptor/cpp11/tuple.hpp"
-#endif // #if !defined (MSGPACK_USE_CPP03)
-
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/fusion/sequence/intrinsic/size.hpp>
-#include <boost/fusion/algorithm/iteration/for_each.hpp>
-#include <boost/fusion/sequence/intrinsic/at.hpp>
-#include <boost/fusion/include/mpl.hpp>
-#include <boost/mpl/size.hpp>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace adaptor {
-
-#if !defined (MSGPACK_USE_CPP03)
-
-template <typename T>
-struct as<
-    T,
-    typename msgpack::enable_if<
-        boost::fusion::traits::is_sequence<T>::value &&
-        boost::mpl::fold<
-            T,
-            boost::mpl::bool_<true>,
-            boost::mpl::if_ <
-                boost::mpl::and_<
-                    boost::mpl::_1,
-                    msgpack::has_as<boost::mpl::_2>
-                >,
-                boost::mpl::bool_<true>,
-                boost::mpl::bool_<false>
-            >
-        >::type::value
-    >::type
-> {
-    T operator()(msgpack::object const& o) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size != checked_get_container_size(boost::mpl::size<T>::value)) {
-            throw msgpack::type_error();
-        }
-        using tuple_t = decltype(to_tuple(std::declval<T>(), gen_seq<boost::mpl::size<T>::value>()));
-        return to_t(
-            o.as<tuple_t>(),
-            msgpack::gen_seq<boost::mpl::size<T>::value>());
-    }
-    template<std::size_t... Is, typename U>
-    static std::tuple<
-        typename std::remove_reference<
-            typename boost::fusion::result_of::at_c<T, Is>::type
-        >::type...>
-    to_tuple(U const& u, seq<Is...>) {
-        return std::make_tuple(boost::fusion::at_c<Is>(u)...);
-    }
-    template<std::size_t... Is, typename U>
-    static T to_t(U const& u, seq<Is...>) {
-        return T(std::get<Is>(u)...);
-    }
-};
-
-#endif // !defined (MSGPACK_USE_CPP03)
-
-template <typename T>
-struct convert<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
-    msgpack::object const& operator()(msgpack::object const& o, T& v) const {
-        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-        if (o.via.array.size != checked_get_container_size(boost::fusion::size(v))) {
-            throw msgpack::type_error();
-        }
-        uint32_t index = 0;
-        boost::fusion::for_each(v, convert_imp(o, index));
-        return o;
-    }
-private:
-    struct convert_imp {
-        convert_imp(msgpack::object const& obj, uint32_t& index):obj_(obj), index_(index) {}
-        template <typename U>
-        void operator()(U& v) const {
-            msgpack::adaptor::convert<U>()(obj_.via.array.ptr[index_++], v);
-        }
-    private:
-        msgpack::object const& obj_;
-        uint32_t& index_;
-    };
-};
-
-template <typename T>
-struct pack<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const T& v) const {
-        uint32_t size = checked_get_container_size(boost::fusion::size(v));
-        o.pack_array(size);
-        boost::fusion::for_each(v, pack_imp<Stream>(o));
-        return o;
-    }
-private:
-    template <typename Stream>
-    struct pack_imp {
-        pack_imp(msgpack::packer<Stream>& stream):stream_(stream) {}
-        template <typename U>
-        void operator()(U const& v) const {
-            stream_.pack(v);
-        }
-    private:
-        msgpack::packer<Stream>& stream_;
-    };
-};
-
-template <typename T>
-struct object_with_zone<T, typename msgpack::enable_if<boost::fusion::traits::is_sequence<T>::value>::type > {
-    void operator()(msgpack::object::with_zone& o, const T& v) const {
-        uint32_t size = checked_get_container_size(boost::fusion::size(v));
-        o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        o.via.array.size = size;
-        uint32_t count = 0;
-        boost::fusion::for_each(v, with_zone_imp(o, count));
-    }
-private:
-    struct with_zone_imp {
-        with_zone_imp(msgpack::object::with_zone const& obj, uint32_t& count):obj_(obj), count_(count) {}
-        template <typename U>
-        void operator()(U const& v) const {
-            obj_.via.array.ptr[count_++] = msgpack::object(v, obj_.zone);
-        }
-        msgpack::object::with_zone const& obj_;
-        uint32_t& count_;
-    };
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
+#include "msgpack/v1/adaptor/boost/fusion.hpp"
 
 #endif // MSGPACK_TYPE_BOOST_FUSION_HPP

data/vendor/local/include/msgpack/adaptor/boost/msgpack_variant.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2015 KONDO Takatoshi
+// Copyright (C) 2015-2016 KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,421 +10,9 @@
 #ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
 #define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP
 
-#if defined(MSGPACK_USE_BOOST)
+#include "msgpack/adaptor/boost/msgpack_variant_decl.hpp"
 
-#include "msgpack/versioning.hpp"
-#include "msgpack/adaptor/adaptor_base.hpp"
-#include "msgpack/adaptor/check_container_size.hpp"
-#include "msgpack/adaptor/boost/string_ref.hpp"
+#include "msgpack/v1/adaptor/boost/msgpack_variant.hpp"
+//#include "msgpack/v2/adaptor/boost/msgpack_variant.hpp"
 
-#include "msgpack/adaptor/nil.hpp"
-#include "msgpack/adaptor/bool.hpp"
-#include "msgpack/adaptor/int.hpp"
-#include "msgpack/adaptor/float.hpp"
-#include "msgpack/adaptor/string.hpp"
-#include "msgpack/adaptor/vector_char.hpp"
-#include "msgpack/adaptor/raw.hpp"
-#include "msgpack/adaptor/ext.hpp"
-#include "msgpack/adaptor/vector.hpp"
-#include "msgpack/adaptor/map.hpp"
-
-#include <boost/variant.hpp>
-#include <boost/operators.hpp>
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-namespace type {
-
-
-template <typename STR, typename BIN, typename EXT>
-struct basic_variant :
-    boost::variant<
-        nil,               // NIL
-        bool,              // BOOL
-        int64_t,           // NEGATIVE_INTEGER
-        uint64_t,          // POSITIVE_INTEGER
-        double,            // FLOAT
-        std::string,       // STR
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        boost::string_ref, // STR
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        std::vector<char>, // BIN
-        msgpack::type::raw_ref, // BIN
-        ext,               // EXT
-        ext_ref,           // EXT
-        boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY
-        boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP
-        boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP
-    >,
-    private boost::totally_ordered<basic_variant<STR, BIN, EXT> > {
-    typedef boost::variant<
-        nil,               // NIL
-        bool,              // BOOL
-        int64_t,           // NEGATIVE_INTEGER
-        uint64_t,          // POSITIVE_INTEGER
-        double,            // FLOAT
-        std::string,       // STR
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        boost::string_ref, // STR
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-        std::vector<char>, // BIN
-        msgpack::type::raw_ref, // BIN
-        ext,               // EXT
-        ext_ref,           // EXT
-        boost::recursive_wrapper<std::vector<basic_variant<STR, BIN, EXT> > >, // ARRAY
-        boost::recursive_wrapper<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >, // MAP
-        boost::recursive_wrapper<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >// MAP
-    > base;
-    basic_variant() {}
-    template <typename T>
-    basic_variant(T const& t):base(t) {}
-    basic_variant(char const* p):base(std::string(p)) {}
-    basic_variant(char v) {
-        int_init(v);
-    }
-    basic_variant(signed char v) {
-        int_init(v);
-    }
-    basic_variant(unsigned char v):base(uint64_t(v)) {}
-    basic_variant(signed int v) {
-        int_init(v);
-    }
-    basic_variant(unsigned int v):base(uint64_t(v)) {}
-    basic_variant(signed long v) {
-        int_init(v);
-    }
-    basic_variant(unsigned long v):base(uint64_t(v)) {}
-    basic_variant(signed long long v) {
-        int_init(v);
-    }
-    basic_variant(unsigned long long v):base(uint64_t(v)) {}
-
-    bool is_nil() const {
-        return boost::get<nil>(this);
-    }
-    bool is_bool() const {
-        return boost::get<bool>(this);
-    }
-    bool is_int64_t() const {
-        return boost::get<int64_t>(this);
-    }
-    bool is_uint64_t() const {
-        return boost::get<uint64_t>(this);
-    }
-    bool is_double() const {
-        return boost::get<double>(this);
-    }
-    bool is_string() const {
-        return boost::get<std::string>(this);
-    }
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    bool is_boost_string_ref() const {
-        return boost::get<boost::string_ref>(this);
-    }
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    bool is_vector_char() const {
-        return boost::get<std::vector<char> >(this);
-    }
-    bool is_vector_char() {
-        return boost::get<std::vector<char> >(this);
-    }
-    bool is_raw_ref() const {
-        return boost::get<raw_ref>(this);
-    }
-    bool is_ext() const {
-        return boost::get<ext>(this);
-    }
-    bool is_ext_ref() const {
-        return boost::get<ext_ref>(this);
-    }
-    bool is_vector() const {
-        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(this);
-    }
-    bool is_map() const {
-        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this);
-    }
-    bool is_multimap() const {
-        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(this);
-    }
-
-    bool as_bool() const {
-        return boost::get<bool>(*this);
-    }
-    int64_t as_int64_t() const {
-        return boost::get<int64_t>(*this);
-    }
-    int64_t& as_int64_t() {
-        return boost::get<int64_t>(*this);
-    }
-    uint64_t as_uint64_t() const {
-        return boost::get<uint64_t>(*this);
-    }
-    uint64_t& as_uint64_t() {
-        return boost::get<uint64_t>(*this);
-    }
-    double as_double() const {
-        return boost::get<double>(*this);
-    }
-    double& as_double() {
-        return boost::get<double>(*this);
-    }
-    std::string const& as_string() const {
-        return boost::get<std::string>(*this);
-    }
-    std::string& as_string() {
-        return boost::get<std::string>(*this);
-    }
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    boost::string_ref const& as_boost_string_ref() const {
-        return boost::get<boost::string_ref>(*this);
-    }
-    boost::string_ref& as_boost_string_ref() {
-        return boost::get<boost::string_ref>(*this);
-    }
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    std::vector<char> const& as_vector_char() const {
-        return boost::get<std::vector<char> >(*this);
-    }
-    std::vector<char>& as_vector_char() {
-        return boost::get<std::vector<char> >(*this);
-    }
-    raw_ref const& as_raw_ref() const {
-        return boost::get<raw_ref>(*this);
-    }
-    ext const& as_ext() const {
-        return boost::get<ext>(*this);
-    }
-    ext& as_ext() {
-        return boost::get<ext>(*this);
-    }
-    ext_ref const& as_ext_ref() const {
-        return boost::get<ext_ref>(*this);
-    }
-    std::vector<basic_variant<STR, BIN, EXT> > const& as_vector() const {
-        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::vector<basic_variant<STR, BIN, EXT> >& as_vector() {
-        return boost::get<std::vector<basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_map() const {
-        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_map() {
-        return boost::get<std::map<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > const& as_multimap() const {
-        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
-    }
-    std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> >& as_multimap() {
-        return boost::get<std::multimap<basic_variant<STR, BIN, EXT>, basic_variant<STR, BIN, EXT> > >(*this);
-    }
-private:
-    template <typename T>
-    void int_init(T v) {
-        if (v < 0) {
-            static_cast<base&>(*this) = int64_t(v);
-        }
-        else {
-            static_cast<base&>(*this) = uint64_t(v);
-        }
-    }
-};
-
-template <typename STR, typename BIN, typename EXT>
-inline bool operator<(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) {
-    return
-        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) <
-        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs);
-}
-
-template <typename STR, typename BIN, typename EXT>
-inline bool operator==(basic_variant<STR, BIN, EXT> const& lhs, basic_variant<STR, BIN, EXT> const& rhs) {
-    return
-        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(lhs) ==
-        static_cast<typename basic_variant<STR, BIN, EXT>::base const&>(rhs);
-}
-
-typedef basic_variant<std::string, std::vector<char>, ext> variant;
-typedef basic_variant<
-#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    boost::string_ref,
-#else  // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    std::string,
-#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
-    raw_ref, ext_ref> variant_ref;
-
-} // namespace type
-
-namespace adaptor {
-
-#if !defined (MSGPACK_USE_CPP03)
-
-template <typename STR, typename BIN, typename EXT>
-struct as<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    msgpack::type::basic_variant<STR, BIN, EXT> operator()(msgpack::object const& o) const {
-        switch(o.type) {
-        case type::NIL:
-            return o.as<msgpack::type::nil>();
-        case type::BOOLEAN:
-            return o.as<bool>();
-        case type::POSITIVE_INTEGER:
-            return o.as<uint64_t>();
-        case type::NEGATIVE_INTEGER:
-            return o.as<int64_t>();
-        case type::FLOAT:
-            return o.as<double>();
-        case type::STR:
-            return o.as<STR>();
-        case type::BIN:
-            return o.as<BIN>();
-        case type::EXT:
-            return o.as<EXT>();
-        case type::ARRAY:
-            return o.as<std::vector<msgpack::type::basic_variant<STR, BIN, EXT> > >();
-        case type::MAP:
-            return o.as<std::multimap<msgpack::type::basic_variant<STR, BIN, EXT>, msgpack::type::basic_variant<STR, BIN, EXT> > >();
-        default:
-            break;
-        }
-        return msgpack::type::basic_variant<STR, BIN, EXT>();
-    }
-};
-
-#endif // !defined (MSGPACK_USE_CPP03)
-
-
-template <typename STR, typename BIN, typename EXT>
-struct convert<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    msgpack::object const& operator()(
-        msgpack::object const& o,
-        msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        switch(o.type) {
-        case type::NIL:
-            v = o.as<msgpack::type::nil>();
-            break;
-        case type::BOOLEAN:
-            v = o.as<bool>();
-            break;
-        case type::POSITIVE_INTEGER:
-            v = o.as<uint64_t>();
-            break;
-        case type::NEGATIVE_INTEGER:
-            v = o.as<int64_t>();
-            break;
-        case type::FLOAT:
-            v = o.as<double>();
-            break;
-        case type::STR:
-            v = o.as<STR>();
-            break;
-        case type::BIN:
-            v = o.as<BIN>();
-            break;
-        case type::EXT:
-            v = o.as<EXT>();
-            break;
-        case type::ARRAY:
-            v = o.as<std::vector<msgpack::type::basic_variant<STR, BIN, EXT> > >();
-            break;
-        case type::MAP:
-            v = o.as<std::multimap<msgpack::type::basic_variant<STR, BIN, EXT>, msgpack::type::basic_variant<STR, BIN, EXT> > >();
-            break;
-        default:
-            break;
-        }
-        return o;
-    }
-};
-
-namespace detail {
-
-template <typename Stream>
-struct pack_imp : boost::static_visitor<void> {
-    template <typename T>
-    void operator()(T const& value) const {
-        pack<T>()(o_, value);
-    }
-    pack_imp(packer<Stream>& o):o_(o) {}
-    packer<Stream>& o_;
-};
-
-} // namespace detail
-
-template <typename STR, typename BIN, typename EXT>
-struct pack<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    template <typename Stream>
-    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        boost::apply_visitor(detail::pack_imp<Stream>(o), v);
-        return o;
-    }
-};
-
-namespace detail {
-
-struct object_imp : boost::static_visitor<void> {
-    void operator()(msgpack::type::nil const& v) const {
-        object<msgpack::type::nil>()(o_, v);
-    }
-    void operator()(bool const& v) const {
-        object<bool>()(o_, v);
-    }
-    void operator()(uint64_t const& v) const {
-        object<uint64_t>()(o_, v);
-    }
-    void operator()(int64_t const& v) const {
-        object<int64_t>()(o_, v);
-    }
-    void operator()(double const& v) const {
-        object<double>()(o_, v);
-    }
-    template <typename T>
-    void operator()(T const&) const {
-        throw msgpack::type_error();
-    }
-    object_imp(msgpack::object& o):o_(o) {}
-    msgpack::object& o_;
-};
-
-} // namespace detail
-
-template <typename STR, typename BIN, typename EXT>
-struct object<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    void operator()(msgpack::object& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        boost::apply_visitor(detail::object_imp(o), v);
-    }
-};
-
-namespace detail {
-
-struct object_with_zone_imp : boost::static_visitor<void> {
-    template <typename T>
-    void operator()(T const& v) const {
-        object_with_zone<T>()(o_, v);
-    }
-    object_with_zone_imp(msgpack::object::with_zone& o):o_(o) {}
-    msgpack::object::with_zone& o_;
-};
-
-} // namespace detail
-
-template <typename STR, typename BIN, typename EXT>
-struct object_with_zone<msgpack::type::basic_variant<STR, BIN, EXT> > {
-    void operator()(msgpack::object::with_zone& o, const msgpack::type::basic_variant<STR, BIN, EXT>& v) const {
-        boost::apply_visitor(detail::object_with_zone_imp(o), v);
-    }
-};
-
-} // namespace adaptor
-
-/// @cond
-} // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-} // namespace msgpack
-
-#endif // MSGPACK_USE_BOOST
 #endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP