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

data/vendor/local/include/msgpack/v1/detail/cpp03_zone_decl.hpp

@@ -24,6 +24,14 @@
 #define MSGPACK_ZONE_ALIGN sizeof(void*)
 #endif
 
+#if defined(_MSC_VER)
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
+#else
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
+#endif
+// For a compiler that doesn't support __alignof__:
+// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
+
 
 namespace msgpack {
 

data/vendor/local/include/msgpack/v1/detail/cpp11_zone.hpp

@@ -184,7 +184,6 @@ public:
 
     void swap(zone& o);
 
-
     static void* operator new(std::size_t size)
     {
         void* p = ::malloc(size);
@@ -220,44 +219,51 @@ private:
     template <typename T>
     static void object_delete(void* obj);
 
-    void* allocate_expand(size_t size);
+    static char* get_aligned(char* ptr, size_t align);
+
+    char* allocate_expand(size_t size);
 };
 
 inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_list(m_chunk_size)
 {
 }
 
-inline void* zone::allocate_align(size_t size, size_t align)
+inline char* zone::get_aligned(char* ptr, size_t align)
 {
-    char* aligned =
+    return
         reinterpret_cast<char*>(
             reinterpret_cast<size_t>(
-                (m_chunk_list.m_ptr + (align - 1))) / align * align);
+            (ptr + (align - 1))) / align * align);
+}
+
+inline void* zone::allocate_align(size_t size, size_t align)
+{
+    char* aligned = get_aligned(m_chunk_list.m_ptr, align);
     size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
-    if(m_chunk_list.m_free >= adjusted_size) {
-        m_chunk_list.m_free -= adjusted_size;
-        m_chunk_list.m_ptr  += adjusted_size;
-        return aligned;
+    if (m_chunk_list.m_free < adjusted_size) {
+        size_t enough_size = size + align - 1;
+        char* ptr = allocate_expand(enough_size);
+        aligned = get_aligned(ptr, align);
+        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
     }
-    return reinterpret_cast<char*>(
-        reinterpret_cast<size_t>(
-            allocate_expand(size + (align - 1))) / align * align);
+    m_chunk_list.m_free -= adjusted_size;
+    m_chunk_list.m_ptr  += adjusted_size;
+    return aligned;
 }
 
 inline void* zone::allocate_no_align(size_t size)
 {
+    char* ptr = m_chunk_list.m_ptr;
     if(m_chunk_list.m_free < size) {
-        return allocate_expand(size);
+        ptr = allocate_expand(size);
     }
-
-    char* ptr = m_chunk_list.m_ptr;
     m_chunk_list.m_free -= size;
     m_chunk_list.m_ptr  += size;
 
     return ptr;
 }
 
-inline void* zone::allocate_expand(size_t size)
+inline char* zone::allocate_expand(size_t size)
 {
     chunk_list* const cl = &m_chunk_list;
 
@@ -279,8 +285,8 @@ inline void* zone::allocate_expand(size_t size)
 
     c->m_next  = cl->m_head;
     cl->m_head = c;
-    cl->m_free = sz - size;
-    cl->m_ptr  = ptr + size;
+    cl->m_free = sz;
+    cl->m_ptr  = ptr;
 
     return ptr;
 }
@@ -329,7 +335,7 @@ inline void zone::undo_allocate(size_t size)
 template <typename T, typename... Args>
 T* zone::allocate(Args... args)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {

data/vendor/local/include/msgpack/v1/detail/cpp11_zone_decl.hpp

@@ -26,6 +26,14 @@
 #define MSGPACK_ZONE_ALIGN sizeof(void*)
 #endif
 
+#if defined(_MSC_VER)
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
+#else
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
+#endif
+// For a compiler that doesn't support __alignof__:
+// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
+
 namespace msgpack {
 
 /// @cond

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

@@ -21,11 +21,17 @@ namespace msgpack {
 MSGPACK_API_VERSION_NAMESPACE(v1) {
 /// @endcond
 
+
+
 namespace detail {
 
 template<bool...values> struct all_of_imp
     : std::is_same<bool_pack<values..., true>, bool_pack<true, values...>>{};
 
+template<bool...values> struct any_of_imp {
+    static const bool value = !std::is_same<bool_pack<values..., false>, bool_pack<false, values...>>::value;
+};
+
 } // namespace detail
 
 template<std::size_t... Is> struct seq {};

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

@@ -28,11 +28,16 @@ template<bool...> struct bool_pack;
 
 template<bool...values> struct all_of_imp;
 
+template<bool...values> struct any_of_imp;
+
 } // namespace detail
 
 template<template <class> class T, class... U>
 using all_of = detail::all_of_imp<T<U>::value...>;
 
+template<template <class> class T, class... U>
+using any_of = detail::any_of_imp<(T<U>::value)...>;
+
 template<std::size_t... Is> struct seq;
 
 template<std::size_t N, std::size_t... Is>

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

@@ -11,6 +11,7 @@
 #define MSGPACK_V1_OBJECT_HPP
 
 #include "msgpack/object_decl.hpp"
+#include "msgpack/adaptor/check_container_size.hpp"
 
 #include <cstring>
 #include <stdexcept>
@@ -60,7 +61,6 @@ public:
     ) :
         m_obj(obj), m_zone(msgpack::move(z)) { }
 
-    // obsolete
     void set(msgpack::object const& obj)
         { m_obj = obj; }
 
@@ -71,6 +71,18 @@ public:
     const msgpack::object& get() const
         { return m_obj; }
 
+    /**
+     * @return object (to mimic smart pointers).
+     */
+    const msgpack::object& operator*() const
+        { return get(); }
+
+    /**
+     * @return the address of the object (to mimic smart pointers).
+     */
+    const msgpack::object* operator->() const
+        { return &get(); }
+
     /// Get unique_ptr reference of zone.
     /**
      * @return unique_ptr reference of zone
@@ -136,36 +148,461 @@ inline std::size_t add_ext_type_size<4>(std::size_t size) {
 }
 
 } // namespace detail
+class object_parser {
+private:
+    enum next_ret {
+        cont,
+        finish,
+        abort
+    };
+    struct elem {
+        elem(msgpack::object const* p, std::size_t r)
+            : rest(r), is_map(false), is_key(false) {
+            as.obj_ptr = p;
+        }
+
+        elem(msgpack::object_kv const* p, std::size_t r)
+            : rest(r), is_map(true), is_key(true) {
+            as.kv_ptr = p;
+        }
+
+        msgpack::object const& get() const {
+            if (is_map) {
+                if (is_key) {
+                    return as.kv_ptr->key;
+                }
+                else {
+                    return as.kv_ptr->val;
+                }
+            }
+            else {
+                return *as.obj_ptr;
+            }
+        }
+
+        template <typename Visitor>
+        next_ret next(Visitor& v) {
+            if (rest == 0) {
+                if (is_map) {
+                    if (!v.end_map()) return abort;
+                }
+                else {
+                    if (!v.end_array()) return abort;
+                }
+                return finish;
+            }
+            else {
+                if (is_map) {
+                    if (is_key) {
+                        if (!v.end_map_key()) return abort;
+                        if (!v.start_map_value()) return abort;
+                        is_key = false;
+                    }
+                    else {
+                        if (!v.end_map_value()) return abort;
+                        --rest;
+                        if (rest == 0) {
+                            if (!v.end_map()) return abort;
+                            return finish;
+                        }
+                        if (!v.start_map_key()) return abort;
+                        ++as.kv_ptr;
+                        is_key = true;
+                    }
+                }
+                else {
+                    if (!v.end_array_item()) return abort;
+                    --rest;
+                    if (rest == 0) {
+                        if (!v.end_array()) return abort;
+                        return finish;
+                    }
+                    if (!v.start_array_item()) return abort;
+                    ++as.obj_ptr;
+                }
+                return cont;
+            }
+        }
+
+        union {
+            msgpack::object const* obj_ptr;
+            msgpack::object_kv const* kv_ptr;
+        } as;
+        std::size_t rest;
+        bool is_map;
+        bool is_key;
+    };
+public:
+    explicit object_parser(msgpack::object const& obj):m_current(&obj) {}
+    template <typename Visitor>
+    void parse(Visitor& v) {
+        while (true) {
+            bool start_collection = false;
+            switch(m_current->type) {
+            case msgpack::type::NIL:
+                if (!v.visit_nil()) return;
+                break;
+            case msgpack::type::BOOLEAN:
+                if (!v.visit_boolean(m_current->via.boolean)) return;
+                break;
+            case msgpack::type::POSITIVE_INTEGER:
+                if (!v.visit_positive_integer(m_current->via.u64)) return;
+                break;
+            case msgpack::type::NEGATIVE_INTEGER:
+                if (!v.visit_negative_integer(m_current->via.i64)) return;
+                break;
+            case msgpack::type::FLOAT32:
+                if (!v.visit_float32(static_cast<float>(m_current->via.f64))) return;
+                break;
+            case msgpack::type::FLOAT64:
+                if (!v.visit_float64(m_current->via.f64)) return;
+                break;
+            case msgpack::type::STR:
+                if (!v.visit_str(m_current->via.str.ptr, m_current->via.str.size)) return;
+                break;
+            case msgpack::type::BIN:
+                if (!v.visit_bin(m_current->via.bin.ptr, m_current->via.bin.size)) return;
+                break;
+            case msgpack::type::EXT:
+                msgpack::detail::check_container_size<sizeof(std::size_t)>(m_current->via.ext.size);
+                if (!v.visit_ext(m_current->via.ext.ptr, m_current->via.ext.size + 1)) return;
+                break;
+            case msgpack::type::ARRAY:
+                if (!v.start_array(m_current->via.array.size)) return;
+                m_ctx.push_back(elem(m_current->via.array.ptr, m_current->via.array.size));
+                start_collection = m_current->via.array.size != 0;
+                if (start_collection) {
+                    if (!v.start_array_item()) return;
+                }
+                break;
+            case msgpack::type::MAP:
+                if (!v.start_map(m_current->via.map.size)) return;
+                m_ctx.push_back(elem(m_current->via.map.ptr, m_current->via.map.size));
+                start_collection = m_current->via.map.size != 0;
+                if (start_collection) {
+                    if (!v.start_map_key()) return;
+                }
+                break;
+            default:
+                throw msgpack::type_error();
+                break;
+            }
+            if (m_ctx.empty()) return;
+            if (!start_collection) {
+                while (true) {
+                    next_ret r = m_ctx.back().next(v);
+                    if (r == finish) {
+                        m_ctx.pop_back();
+                        if (m_ctx.empty()) return;
+                    }
+                    else if (r == cont) {
+                        break;
+                    }
+                    else {
+                        // abort
+                        return;
+                    }
+                }
+            }
+            m_current = &m_ctx.back().get();
+        }
+    }
+private:
+    msgpack::object const* m_current;
+    std::vector<elem> m_ctx;
+};
+
+template <typename Stream>
+struct object_pack_visitor {
+    explicit object_pack_visitor(msgpack::packer<Stream>& pk)
+        :m_packer(pk) {}
+    bool visit_nil() {
+        m_packer.pack_nil();
+        return true;
+    }
+    bool visit_boolean(bool v) {
+        if (v) m_packer.pack_true();
+        else m_packer.pack_false();
+        return true;
+    }
+    bool visit_positive_integer(uint64_t v) {
+        m_packer.pack_uint64(v);
+        return true;
+    }
+    bool visit_negative_integer(int64_t v) {
+        m_packer.pack_int64(v);
+        return true;
+    }
+    bool visit_float32(float v) {
+        m_packer.pack_float(v);
+        return true;
+    }
+    bool visit_float64(double v) {
+        m_packer.pack_double(v);
+        return true;
+    }
+    bool visit_str(const char* v, uint32_t size) {
+        m_packer.pack_str(size);
+        m_packer.pack_str_body(v, size);
+        return true;
+    }
+    bool visit_bin(const char* v, uint32_t size) {
+        m_packer.pack_bin(size);
+        m_packer.pack_bin_body(v, size);
+        return true;
+    }
+    bool visit_ext(const char* v, uint32_t size) {
+        m_packer.pack_ext(size, *v);
+        m_packer.pack_ext_body(v, size);
+        return true;
+    }
+    bool start_array(uint32_t num_elements) {
+        m_packer.pack_array(num_elements);
+        return true;
+    }
+    bool start_array_item() {
+        return true;
+    }
+    bool end_array_item() {
+        return true;
+    }
+    bool end_array() {
+        return true;
+    }
+    bool start_map(uint32_t num_kv_pairs) {
+        m_packer.pack_array(num_kv_pairs);
+        return true;
+    }
+    bool start_map_key() {
+        return true;
+    }
+    bool end_map_key() {
+        return true;
+    }
+    bool start_map_value() {
+        return true;
+    }
+    bool end_map_value() {
+        return true;
+    }
+    bool end_map() {
+        return true;
+    }
+private:
+    msgpack::packer<Stream>& m_packer;
+};
+
+
+struct object_stringize_visitor {
+    explicit object_stringize_visitor(std::ostream& os)
+        :m_os(os) {}
+    bool visit_nil() {
+        m_os << "null";
+        return true;
+    }
+    bool visit_boolean(bool v) {
+        if (v) m_os << "true";
+        else m_os << "false";
+        return true;
+    }
+    bool visit_positive_integer(uint64_t v) {
+        m_os << v;
+        return true;
+    }
+    bool visit_negative_integer(int64_t v) {
+        m_os << v;
+        return true;
+    }
+    bool visit_float32(float v) {
+        m_os << v;
+        return true;
+    }
+    bool visit_float64(double v) {
+        m_os << v;
+        return true;
+    }
+    bool visit_str(const char* v, uint32_t size) {
+        m_os << '"';
+        for (uint32_t i = 0; i < size; ++i) {
+            char c = v[i];
+            switch (c) {
+            case '\\':
+                m_os << "\\\\";
+                break;
+            case '"':
+                m_os << "\\\"";
+                break;
+            case '/':
+                m_os << "\\/";
+                break;
+            case '\b':
+                m_os << "\\b";
+                break;
+            case '\f':
+                m_os << "\\f";
+                break;
+            case '\n':
+                m_os << "\\n";
+                break;
+            case '\r':
+                m_os << "\\r";
+                break;
+            case '\t':
+                m_os << "\\t";
+                break;
+            default: {
+                unsigned int code = static_cast<unsigned int>(c);
+                if (code < 0x20 || code == 0x7f) {
+                    std::ios::fmtflags flags(m_os.flags());
+                    m_os << "\\u" << std::hex << std::setw(4) << std::setfill('0') << (code & 0xff);
+                    m_os.flags(flags);
+                }
+                else {
+                    m_os << c;
+                }
+            } break;
+            }
+        }
+        m_os << '"';
+        return true;
+    }
+    bool visit_bin(const char* v, uint32_t size) {
+        (m_os << '"').write(v, size) << '"';
+        return true;
+    }
+    bool visit_ext(const char* /*v*/, uint32_t /*size*/) {
+        m_os << "EXT";
+        return true;
+    }
+    bool start_array(uint32_t num_elements) {
+        m_current_size.push_back(num_elements);
+        m_os << "[";
+        return true;
+    }
+    bool start_array_item() {
+        return true;
+    }
+    bool end_array_item() {
+        --m_current_size.back();
+        if (m_current_size.back() != 0) {
+            m_os << ",";
+        }
+        return true;
+    }
+    bool end_array() {
+        m_current_size.pop_back();
+        m_os << "]";
+        return true;
+    }
+    bool start_map(uint32_t num_kv_pairs) {
+        m_current_size.push_back(num_kv_pairs);
+        m_os << "{";
+        return true;
+    }
+    bool start_map_key() {
+        return true;
+    }
+    bool end_map_key() {
+        m_os << ":";
+        return true;
+    }
+    bool start_map_value() {
+        return true;
+    }
+    bool end_map_value() {
+        --m_current_size.back();
+        if (m_current_size.back() != 0) {
+            m_os << ",";
+        }
+        return true;
+    }
+    bool end_map() {
+        m_current_size.pop_back();
+        m_os << "}";
+        return true;
+    }
+private:
+    std::ostream& m_os;
+    std::vector<uint32_t> m_current_size;
+};
+
+struct aligned_zone_size_visitor {
+    explicit aligned_zone_size_visitor(std::size_t s)
+        :m_size(s) {}
+    bool visit_nil() {
+        return true;
+    }
+    bool visit_boolean(bool) {
+        return true;
+    }
+    bool visit_positive_integer(uint64_t) {
+        return true;
+    }
+    bool visit_negative_integer(int64_t) {
+        return true;
+    }
+    bool visit_float32(float) {
+        return true;
+    }
+    bool visit_float64(double) {
+        return true;
+    }
+    bool visit_str(const char*, uint32_t size) {
+        m_size += msgpack::aligned_size(size, MSGPACK_ZONE_ALIGNOF(char));
+        return true;
+    }
+    bool visit_bin(const char*, uint32_t size) {
+        m_size += msgpack::aligned_size(size, MSGPACK_ZONE_ALIGNOF(char));
+        return true;
+    }
+    bool visit_ext(const char*, uint32_t size) {
+        m_size += msgpack::aligned_size(size, MSGPACK_ZONE_ALIGNOF(char));
+        return true;
+    }
+    bool start_array(uint32_t num_elements) {
+        m_size += msgpack::aligned_size(
+            sizeof(msgpack::object) * num_elements,
+            MSGPACK_ZONE_ALIGNOF(msgpack::object));
+        return true;
+    }
+    bool start_array_item() {
+        return true;
+    }
+    bool end_array_item() {
+        return true;
+    }
+    bool end_array() {
+        return true;
+    }
+    bool start_map(uint32_t num_kv_pairs) {
+        m_size += msgpack::aligned_size(
+            sizeof(msgpack::object_kv) * num_kv_pairs,
+            MSGPACK_ZONE_ALIGNOF(msgpack::object_kv));
+        return true;
+    }
+    bool start_map_key() {
+        return true;
+    }
+    bool end_map_key() {
+        return true;
+    }
+    bool start_map_value() {
+        return true;
+    }
+    bool end_map_value() {
+        return true;
+    }
+    bool end_map() {
+        return true;
+    }
+private:
+    std::size_t m_size;
+};
 
 inline std::size_t aligned_zone_size(msgpack::object const& obj) {
     std::size_t s = 0;
-    switch (obj.type) {
-    case msgpack::type::ARRAY:
-        s += sizeof(msgpack::object) * obj.via.array.size;
-        for (uint32_t i = 0; i < obj.via.array.size; ++i) {
-            s += msgpack::aligned_zone_size(obj.via.array.ptr[i]);
-        }
-        break;
-    case msgpack::type::MAP:
-        s += sizeof(msgpack::object_kv) * obj.via.map.size;
-        for (uint32_t i = 0; i < obj.via.map.size; ++i) {
-            s += msgpack::aligned_zone_size(obj.via.map.ptr[i].key);
-            s += msgpack::aligned_zone_size(obj.via.map.ptr[i].val);
-        }
-        break;
-    case msgpack::type::EXT:
-        s += msgpack::aligned_size(
-            detail::add_ext_type_size<sizeof(std::size_t)>(obj.via.ext.size));
-        break;
-    case msgpack::type::STR:
-        s += msgpack::aligned_size(obj.via.str.size);
-        break;
-    case msgpack::type::BIN:
-        s += msgpack::aligned_size(obj.via.bin.size);
-        break;
-    default:
-        break;
-    }
+    aligned_zone_size_visitor vis(s);
+    msgpack::object_parser(obj).parse(vis);
     return s;
 }
 
@@ -236,142 +673,158 @@ template <>
 struct pack<msgpack::object> {
     template <typename Stream>
     msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, msgpack::object const& v) const {
-        switch(v.type) {
-        case msgpack::type::NIL:
-            o.pack_nil();
-            return o;
-
-        case msgpack::type::BOOLEAN:
-            if(v.via.boolean) {
-                o.pack_true();
-            } else {
-                o.pack_false();
-            }
-            return o;
-
-        case msgpack::type::POSITIVE_INTEGER:
-            o.pack_uint64(v.via.u64);
-            return o;
-
-        case msgpack::type::NEGATIVE_INTEGER:
-            o.pack_int64(v.via.i64);
-            return o;
-
-        case msgpack::type::FLOAT:
-            o.pack_double(v.via.f64);
-            return o;
-
-        case msgpack::type::STR:
-            o.pack_str(v.via.str.size);
-            o.pack_str_body(v.via.str.ptr, v.via.str.size);
-            return o;
-
-        case msgpack::type::BIN:
-            o.pack_bin(v.via.bin.size);
-            o.pack_bin_body(v.via.bin.ptr, v.via.bin.size);
-            return o;
-
-        case msgpack::type::EXT:
-            o.pack_ext(v.via.ext.size, v.via.ext.type());
-            o.pack_ext_body(v.via.ext.data(), v.via.ext.size);
-            return o;
-
-        case msgpack::type::ARRAY:
-            o.pack_array(v.via.array.size);
-            for(msgpack::object* p(v.via.array.ptr),
-                    * const pend(v.via.array.ptr + v.via.array.size);
-                p < pend; ++p) {
-                msgpack::operator<<(o, *p);
-            }
-            return o;
-
-        case msgpack::type::MAP:
-            o.pack_map(v.via.map.size);
-            for(msgpack::object_kv* p(v.via.map.ptr),
-                    * const pend(v.via.map.ptr + v.via.map.size);
-                p < pend; ++p) {
-                msgpack::operator<<(o, p->key);
-                msgpack::operator<<(o, p->val);
-            }
-            return o;
-
-        default:
-            throw msgpack::type_error();
-        }
+        object_pack_visitor<Stream> vis(o);
+        msgpack::object_parser(v).parse(vis);
+        return o;
     }
 };
 
 template <>
 struct object_with_zone<msgpack::object> {
     void operator()(msgpack::object::with_zone& o, msgpack::object const& v) const {
-        o.type = v.type;
-
-        switch(v.type) {
-        case msgpack::type::NIL:
-        case msgpack::type::BOOLEAN:
-        case msgpack::type::POSITIVE_INTEGER:
-        case msgpack::type::NEGATIVE_INTEGER:
-        case msgpack::type::FLOAT:
-            std::memcpy(&o.via, &v.via, sizeof(v.via));
-            return;
-
-        case msgpack::type::STR: {
-            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.str.size));
-            o.via.str.ptr = ptr;
-            o.via.str.size = v.via.str.size;
-            std::memcpy(ptr, v.via.str.ptr, v.via.str.size);
-            return;
-        }
-
-        case msgpack::type::BIN: {
-            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.bin.size));
-            o.via.bin.ptr = ptr;
-            o.via.bin.size = v.via.bin.size;
-            std::memcpy(ptr, v.via.bin.ptr, v.via.bin.size);
-            return;
-        }
-
-        case msgpack::type::EXT: {
-            char* ptr = static_cast<char*>(o.zone.allocate_align(v.via.ext.size + 1));
-            o.via.ext.ptr = ptr;
-            o.via.ext.size = v.via.ext.size;
-            std::memcpy(ptr, v.via.ext.ptr, v.via.ext.size + 1);
-            return;
-        }
-
-        case msgpack::type::ARRAY:
-            o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object) * v.via.array.size));
-            o.via.array.size = v.via.array.size;
-            for (msgpack::object
-                     * po(o.via.array.ptr),
-                     * pv(v.via.array.ptr),
-                     * const pvend(v.via.array.ptr + v.via.array.size);
-                 pv < pvend;
-                 ++po, ++pv) {
-                new (po) msgpack::object(*pv, o.zone);
-            }
-            return;
-
-        case msgpack::type::MAP:
-            o.via.map.ptr = (msgpack::object_kv*)o.zone.allocate_align(sizeof(msgpack::object_kv) * v.via.map.size);
-            o.via.map.size = v.via.map.size;
-            for(msgpack::object_kv
-                    * po(o.via.map.ptr),
-                    * pv(v.via.map.ptr),
-                    * const pvend(v.via.map.ptr + v.via.map.size);
-                pv < pvend;
-                ++po, ++pv) {
-                msgpack::object_kv* kv = new (po) msgpack::object_kv;
-                new (&kv->key) msgpack::object(pv->key, o.zone);
-                new (&kv->val) msgpack::object(pv->val, o.zone);
-            }
-            return;
-
-        default:
-            throw msgpack::type_error();
+        object_with_zone_visitor vis(o);
+        msgpack::object_parser(v).parse(vis);
+    }
+private:
+    struct object_with_zone_visitor {
+        explicit object_with_zone_visitor(msgpack::object::with_zone& owz)
+            :m_zone(owz.zone), m_ptr(&owz) {
+            m_objs.push_back(&owz);
+        }
+        bool visit_nil() {
+            m_ptr->type = msgpack::type::NIL;
+            return true;
+        }
+        bool visit_boolean(bool v) {
+            m_ptr->type = msgpack::type::BOOLEAN;
+            m_ptr->via.boolean = v;
+            return true;
+        }
+        bool visit_positive_integer(uint64_t v) {
+            m_ptr->type = msgpack::type::POSITIVE_INTEGER;
+            m_ptr->via.u64 = v;
+            return true;
+        }
+        bool visit_negative_integer(int64_t v) {
+            m_ptr->type = msgpack::type::NEGATIVE_INTEGER;
+            m_ptr->via.i64 = v;
+            return true;
+        }
+        bool visit_float32(float v) {
+            m_ptr->type = msgpack::type::FLOAT32;
+            m_ptr->via.f64 = v;
+            return true;
+        }
+        bool visit_float64(double v) {
+            m_ptr->type = msgpack::type::FLOAT64;
+            m_ptr->via.f64 = v;
+            return true;
+        }
+        bool visit_str(const char* v, uint32_t size) {
+            m_ptr->type = msgpack::type::STR;
+            m_ptr->via.str.size = size;
+            char* ptr = static_cast<char*>(m_zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
+            m_ptr->via.str.ptr = ptr;
+            std::memcpy(ptr, v, size);
+            return true;
         }
+        bool visit_bin(const char* v, uint32_t size) {
+            m_ptr->type = msgpack::type::BIN;
+            m_ptr->via.bin.size = size;
+            char* ptr = static_cast<char*>(m_zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
+            m_ptr->via.bin.ptr = ptr;
+            std::memcpy(ptr, v, size);
+            return true;
+        }
+        bool visit_ext(const char* v, uint32_t size) {
+            m_ptr->type = msgpack::type::EXT;
 
-    }
+            // v contains type but length(size) doesn't count the type byte.
+            // See https://github.com/msgpack/msgpack/blob/master/spec.md#ext-format-family
+            m_ptr->via.ext.size = size - 1;
+
+            char* ptr = static_cast<char*>(m_zone.allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
+            m_ptr->via.ext.ptr = ptr;
+            std::memcpy(ptr, v, size);
+            return true;
+        }
+        bool start_array(uint32_t num_elements) {
+            m_ptr->type = msgpack::type::ARRAY;
+            m_ptr->via.array.ptr = static_cast<msgpack::object*>(
+                m_zone.allocate_align(
+                    sizeof(msgpack::object) * num_elements, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
+            m_ptr->via.array.size = num_elements;
+            m_objs.push_back(elem(m_ptr->via.array.ptr));
+            return true;
+        }
+        bool start_array_item() {
+            m_ptr = m_objs.back().get_item();
+            return true;
+        }
+        bool end_array_item() {
+            ++m_objs.back().as.obj;
+            return true;
+        }
+        bool end_array() {
+            m_objs.pop_back();
+            return true;
+        }
+        bool start_map(uint32_t num_kv_pairs) {
+            m_ptr->type = msgpack::type::MAP;
+            m_ptr->via.map.ptr = (msgpack::object_kv*)m_zone.allocate_align(
+                sizeof(msgpack::object_kv) * num_kv_pairs, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv));
+            m_ptr->via.map.size = num_kv_pairs;
+            m_objs.push_back(elem(m_ptr->via.map.ptr));
+            return true;
+        }
+        bool start_map_key() {
+            m_ptr = m_objs.back().get_key();
+            return true;
+        }
+        bool end_map_key() {
+            return true;
+        }
+        bool start_map_value() {
+            m_ptr = m_objs.back().get_val();
+            return true;
+        }
+        bool end_map_value() {
+            ++m_objs.back().as.kv;
+            return true;
+        }
+        bool end_map() {
+            m_objs.pop_back();
+            return true;
+        }
+    private:
+        struct elem {
+            elem(msgpack::object* obj)
+                :is_obj(true) {
+                as.obj = obj;
+            }
+            elem(msgpack::object_kv* kv)
+                :is_obj(false) {
+                as.kv = kv;
+            }
+            msgpack::object* get_item() {
+                return as.obj;
+            }
+            msgpack::object* get_key() {
+                return &as.kv->key;
+            }
+            msgpack::object* get_val() {
+                return &as.kv->val;
+            }
+            union {
+                msgpack::object* obj;
+                msgpack::object_kv* kv;
+            } as;
+            bool is_obj;
+        };
+        std::vector<elem> m_objs;
+        msgpack::zone& m_zone;
+        msgpack::object* m_ptr;
+    };
 };
 
 // Adaptor functor specialization to object::with_zone
@@ -395,7 +848,6 @@ class define : public Type {
 public:
     typedef Type msgpack_type;
     typedef define<Type> define_type;
-
     define() {}
     define(const msgpack_type& v) : msgpack_type(v) {}
 
@@ -421,79 +873,164 @@ inline msgpack::packer<Stream>& packer<Stream>::pack(const T& v)
     return *this;
 }
 
-inline bool operator==(const msgpack::object& x, const msgpack::object& y)
-{
-    if(x.type != y.type) { return false; }
-
-    switch(x.type) {
-    case msgpack::type::NIL:
+struct object_equal_visitor {
+    object_equal_visitor(msgpack::object const& obj, bool& result)
+        :m_ptr(&obj), m_result(result) {}
+    bool visit_nil() {
+        if (m_ptr->type != msgpack::type::NIL) {
+            m_result = false;
+            return false;
+        }
         return true;
-
-    case msgpack::type::BOOLEAN:
-        return x.via.boolean == y.via.boolean;
-
-    case msgpack::type::POSITIVE_INTEGER:
-        return x.via.u64 == y.via.u64;
-
-    case msgpack::type::NEGATIVE_INTEGER:
-        return x.via.i64 == y.via.i64;
-
-    case msgpack::type::FLOAT:
-        return x.via.f64 == y.via.f64;
-
-    case msgpack::type::STR:
-        return x.via.str.size == y.via.str.size &&
-            std::memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0;
-
-    case msgpack::type::BIN:
-        return x.via.bin.size == y.via.bin.size &&
-            std::memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0;
-
-    case msgpack::type::EXT:
-        return x.via.ext.size == y.via.ext.size &&
-            std::memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0;
-
-    case msgpack::type::ARRAY:
-        if(x.via.array.size != y.via.array.size) {
+    }
+    bool visit_boolean(bool v) {
+        if (m_ptr->type != msgpack::type::BOOLEAN || m_ptr->via.boolean != v) {
+            m_result = false;
             return false;
-        } else if(x.via.array.size == 0) {
-            return true;
-        } else {
-            msgpack::object* px = x.via.array.ptr;
-            msgpack::object* const pxend = x.via.array.ptr + x.via.array.size;
-            msgpack::object* py = y.via.array.ptr;
-            do {
-                if(!(*px == *py)) {
-                    return false;
-                }
-                ++px;
-                ++py;
-            } while(px < pxend);
-            return true;
         }
-
-    case msgpack::type::MAP:
-        if(x.via.map.size != y.via.map.size) {
+        return true;
+    }
+    bool visit_positive_integer(uint64_t v) {
+        if (m_ptr->type != msgpack::type::POSITIVE_INTEGER || m_ptr->via.u64 != v) {
+            m_result = false;
             return false;
-        } else if(x.via.map.size == 0) {
-            return true;
-        } else {
-            msgpack::object_kv* px = x.via.map.ptr;
-            msgpack::object_kv* const pxend = x.via.map.ptr + x.via.map.size;
-            msgpack::object_kv* py = y.via.map.ptr;
-            do {
-                if(!(px->key == py->key) || !(px->val == py->val)) {
-                    return false;
-                }
-                ++px;
-                ++py;
-            } while(px < pxend);
-            return true;
         }
-
-    default:
-        return false;
+        return true;
+    }
+    bool visit_negative_integer(int64_t v) {
+        if (m_ptr->type != msgpack::type::NEGATIVE_INTEGER || m_ptr->via.i64 != v) {
+            m_result = false;
+            return false;
+        }
+        return true;
+    }
+    bool visit_float32(float v) {
+        if (m_ptr->type != msgpack::type::FLOAT32 || m_ptr->via.f64 != v) {
+            m_result = false;
+            return false;
+        }
+        return true;
+    }
+    bool visit_float64(double v) {
+        if (m_ptr->type != msgpack::type::FLOAT64 || m_ptr->via.f64 != v) {
+            m_result = false;
+            return false;
+        }
+        return true;
+    }
+    bool visit_str(const char* v, uint32_t size) {
+        if (m_ptr->type != msgpack::type::STR ||
+            m_ptr->via.str.size != size ||
+            std::memcmp(m_ptr->via.str.ptr, v, size) != 0) {
+            m_result = false;
+            return false;
+        }
+        return true;
     }
+    bool visit_bin(const char* v, uint32_t size) {
+        if (m_ptr->type != msgpack::type::BIN ||
+            m_ptr->via.bin.size != size ||
+            std::memcmp(m_ptr->via.bin.ptr, v, size) != 0) {
+            m_result = false;
+            return false;
+        }
+        return true;
+    }
+    bool visit_ext(const char* v, uint32_t size) {
+        if (m_ptr->type != msgpack::type::EXT ||
+            m_ptr->via.ext.size != size ||
+            std::memcmp(m_ptr->via.ext.ptr, v, size) != 0) {
+            m_result = false;
+            return false;
+        }
+        return true;
+    }
+    bool start_array(uint32_t num_elements) {
+        if (m_ptr->type != msgpack::type::ARRAY ||
+            m_ptr->via.array.size != num_elements) {
+            m_result = false;
+            return false;
+        }
+        m_objs.push_back(elem(m_ptr->via.array.ptr));
+        return true;
+    }
+    bool start_array_item() {
+        m_ptr = m_objs.back().get_item();
+        return true;
+    }
+    bool end_array_item() {
+        ++m_objs.back().as.obj;
+        return true;
+    }
+    bool end_array() {
+        m_objs.pop_back();
+        return true;
+    }
+    bool start_map(uint32_t num_kv_pairs) {
+        if (m_ptr->type != msgpack::type::MAP ||
+            m_ptr->via.array.size != num_kv_pairs) {
+            m_result = false;
+            return false;
+        }
+        m_objs.push_back(elem(m_ptr->via.map.ptr));
+        return true;
+    }
+    bool start_map_key() {
+        m_ptr = m_objs.back().get_key();
+        return true;
+    }
+    bool end_map_key() {
+        return true;
+    }
+    bool start_map_value() {
+        m_ptr = m_objs.back().get_val();
+        return true;
+    }
+    bool end_map_value() {
+        ++m_objs.back().as.kv;
+        return true;
+    }
+    bool end_map() {
+        m_objs.pop_back();
+        return true;
+    }
+private:
+    struct elem {
+        elem(msgpack::object const* obj)
+            :is_obj(true) {
+            as.obj = obj;
+        }
+        elem(msgpack::object_kv const* kv)
+            :is_obj(false) {
+            as.kv = kv;
+        }
+        msgpack::object const* get_item() {
+            return as.obj;
+        }
+        msgpack::object const* get_key() {
+            return &as.kv->key;
+        }
+        msgpack::object const* get_val() {
+            return &as.kv->val;
+        }
+        union {
+            msgpack::object const* obj;
+            msgpack::object_kv const* kv;
+        } as;
+        bool is_obj;
+    };
+    std::vector<elem> m_objs;
+    msgpack::object const* m_ptr;
+    bool& m_result;
+};
+
+inline bool operator==(const msgpack::object& x, const msgpack::object& y)
+{
+    if(x.type != y.type) { return false; }
+    bool b = true;
+    object_equal_visitor vis(y, b);
+    msgpack::object_parser(x).parse(vis);
+    return b;
 }
 
 template <typename T>
@@ -640,7 +1177,7 @@ inline object::object(const msgpack_object& o)
 inline void operator<< (msgpack::object& o, const msgpack_object& v)
 {
     // FIXME beter way?
-    std::memcpy(&o, &v, sizeof(v));
+    std::memcpy(static_cast<void*>(&o), &v, sizeof(v));
 }
 
 inline object::operator msgpack_object() const
@@ -673,72 +1210,12 @@ inline void pack_copy(msgpack::packer<Stream>& o, T v)
     pack(o, v);
 }
 
-
 template <typename Stream>
 inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object& v)
 {
-    switch(v.type) {
-    case msgpack::type::NIL:
-        o.pack_nil();
-        return o;
-
-    case msgpack::type::BOOLEAN:
-        if(v.via.boolean) {
-            o.pack_true();
-        } else {
-            o.pack_false();
-        }
-        return o;
-
-    case msgpack::type::POSITIVE_INTEGER:
-        o.pack_uint64(v.via.u64);
-        return o;
-
-    case msgpack::type::NEGATIVE_INTEGER:
-        o.pack_int64(v.via.i64);
-        return o;
-
-    case msgpack::type::FLOAT:
-        o.pack_double(v.via.f64);
-        return o;
-
-    case msgpack::type::STR:
-        o.pack_str(v.via.str.size);
-        o.pack_str_body(v.via.str.ptr, v.via.str.size);
-        return o;
-
-    case msgpack::type::BIN:
-        o.pack_bin(v.via.bin.size);
-        o.pack_bin_body(v.via.bin.ptr, v.via.bin.size);
-        return o;
-
-    case msgpack::type::EXT:
-        o.pack_ext(v.via.ext.size, v.via.ext.type());
-        o.pack_ext_body(v.via.ext.data(), v.via.ext.size);
-        return o;
-
-    case msgpack::type::ARRAY:
-        o.pack_array(v.via.array.size);
-        for(msgpack::object* p(v.via.array.ptr),
-                * const pend(v.via.array.ptr + v.via.array.size);
-                p < pend; ++p) {
-            msgpack::operator<<(o, *p);
-        }
-        return o;
-
-    case msgpack::type::MAP:
-        o.pack_map(v.via.map.size);
-        for(msgpack::object_kv* p(v.via.map.ptr),
-                * const pend(v.via.map.ptr + v.via.map.size);
-                p < pend; ++p) {
-            msgpack::operator<<(o, p->key);
-            msgpack::operator<<(o, p->val);
-        }
-        return o;
-
-    default:
-        throw msgpack::type_error();
-    }
+    object_pack_visitor<Stream> vis(o);
+    msgpack::object_parser(v).parse(vis);
+    return o;
 }
 
 template <typename Stream>
@@ -747,112 +1224,10 @@ inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const ms
     return o << static_cast<msgpack::object>(v);
 }
 
-inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o)
+inline std::ostream& operator<< (std::ostream& s, const msgpack::object& v)
 {
-    switch(o.type) {
-    case msgpack::type::NIL:
-        s << "null";
-        break;
-
-    case msgpack::type::BOOLEAN:
-        s << (o.via.boolean ? "true" : "false");
-        break;
-
-    case msgpack::type::POSITIVE_INTEGER:
-        s << o.via.u64;
-        break;
-
-    case msgpack::type::NEGATIVE_INTEGER:
-        s << o.via.i64;
-        break;
-
-    case msgpack::type::FLOAT:
-        s << o.via.f64;
-        break;
-
-    case msgpack::type::STR:
-        s << '"';
-        for (uint32_t i = 0; i < o.via.str.size; ++i) {
-            char c = o.via.str.ptr[i];
-            switch (c) {
-            case '\\':
-                s << "\\\\";
-                break;
-            case '"':
-                s << "\\\"";
-                break;
-            case '/':
-                s << "\\/";
-                break;
-            case '\b':
-                s << "\\b";
-                break;
-            case '\f':
-                s << "\\f";
-                break;
-            case '\n':
-                s << "\\n";
-                break;
-            case '\r':
-                s << "\\r";
-                break;
-            case '\t':
-                s << "\\t";
-                break;
-            default: {
-                unsigned int code = static_cast<unsigned int>(c);
-                if (code < 0x20 || code == 0x7f) {
-                    s << "\\u" << std::hex << std::setw(4) << std::setfill('0') << (code & 0xff);
-                }
-                else {
-                    s << c;
-                }
-            } break;
-            }
-        }
-        s << '"';
-        break;
-
-    case msgpack::type::BIN:
-        (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"';
-        break;
-
-    case msgpack::type::EXT:
-        s << "EXT";
-        break;
-
-    case msgpack::type::ARRAY:
-        s << "[";
-        if(o.via.array.size != 0) {
-            msgpack::object* p(o.via.array.ptr);
-            s << *p;
-            ++p;
-            for(msgpack::object* const pend(o.via.array.ptr + o.via.array.size);
-                    p < pend; ++p) {
-                s << ", " << *p;
-            }
-        }
-        s << "]";
-        break;
-
-    case msgpack::type::MAP:
-        s << "{";
-        if(o.via.map.size != 0) {
-            msgpack::object_kv* p(o.via.map.ptr);
-            s << p->key << ':' << p->val;
-            ++p;
-            for(msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size);
-                    p < pend; ++p) {
-                s << ", " << p->key << ':' << p->val;
-            }
-        }
-        s << "}";
-        break;
-
-    default:
-        // FIXME
-        s << "#<UNKNOWN " << static_cast<uint16_t>(o.type) << ">";
-    }
+    object_stringize_visitor vis(s);
+    msgpack::object_parser(v).parse(vis);
     return s;
 }