rroonga 5.0.1-x64-mingw32 → 5.0.2-x64-mingw32

data/vendor/local/include/msgpack/gcc_atomic.h

@@ -0,0 +1,33 @@
+/*
+ *    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.
+ */
+
+#ifndef MSGPACK_GCC_ATOMIC_H
+#define MSGPACK_GCC_ATOMIC_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+typedef int _msgpack_atomic_counter_t;
+
+int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr);
+int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr);
+
+
+#if defined(__cplusplus)
+}
+#endif
+
+
+#endif // MSGPACK_GCC_ATOMIC_H

data/vendor/local/include/msgpack/iterator.hpp

@@ -0,0 +1,42 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2015 MIZUKI Hirata
+//
+//    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.
+//
+
+#ifndef MSGPACK_ITERATOR_HPP
+#define MSGPACK_ITERATOR_HPP
+#if !defined(MSGPACK_USE_CPP03)
+
+#include <msgpack_fwd.hpp>
+
+namespace msgpack
+{
+    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+    {
+        inline object_kv* begin(object_map &map) { return map.ptr; }
+        inline const object_kv* begin(const object_map &map) { return map.ptr; }
+        inline object_kv* end(object_map &map) { return map.ptr + map.size; }
+        inline const object_kv* end(const object_map &map) { return map.ptr + map.size; }
+        
+        inline object* begin(object_array &array) { return array.ptr; }
+        inline const object* begin(const object_array &array) { return array.ptr; }
+        inline object* end(object_array &array) { return array.ptr + array.size; }
+        inline const object* end(const object_array &array) { return array.ptr + array.size; }
+    }
+}
+
+#endif // !defined(MSGPACK_USE_CPP03)
+#endif // MSGPACK_ITERATOR_HPP

data/vendor/local/include/msgpack/object.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_OBJECT_H__
-#define MSGPACK_OBJECT_H__
+#ifndef MSGPACK_OBJECT_H
+#define MSGPACK_OBJECT_H
 
 #include "zone.h"
 #include <stdio.h>
@@ -33,14 +33,19 @@ extern "C" {
  */
 
 typedef enum {
-	MSGPACK_OBJECT_NIL					= 0x00,
-	MSGPACK_OBJECT_BOOLEAN				= 0x01,
-	MSGPACK_OBJECT_POSITIVE_INTEGER		= 0x02,
-	MSGPACK_OBJECT_NEGATIVE_INTEGER		= 0x03,
-	MSGPACK_OBJECT_DOUBLE				= 0x04,
-	MSGPACK_OBJECT_RAW					= 0x05,
-	MSGPACK_OBJECT_ARRAY				= 0x06,
-	MSGPACK_OBJECT_MAP					= 0x07,
+    MSGPACK_OBJECT_NIL                  = 0x00,
+    MSGPACK_OBJECT_BOOLEAN              = 0x01,
+    MSGPACK_OBJECT_POSITIVE_INTEGER     = 0x02,
+    MSGPACK_OBJECT_NEGATIVE_INTEGER     = 0x03,
+    MSGPACK_OBJECT_FLOAT                = 0x04,
+#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+    MSGPACK_OBJECT_DOUBLE               = MSGPACK_OBJECT_FLOAT, /* obsolete */
+#endif /* MSGPACK_USE_LEGACY_NAME_AS_FLOAT */
+    MSGPACK_OBJECT_STR                  = 0x05,
+    MSGPACK_OBJECT_ARRAY                = 0x06,
+    MSGPACK_OBJECT_MAP                  = 0x07,
+    MSGPACK_OBJECT_BIN                  = 0x08,
+    MSGPACK_OBJECT_EXT                  = 0x09
 } msgpack_object_type;
 
 
@@ -48,43 +53,60 @@ struct msgpack_object;
 struct msgpack_object_kv;
 
 typedef struct {
-	uint32_t size;
-	struct msgpack_object* ptr;
+    uint32_t size;
+    struct msgpack_object* ptr;
 } msgpack_object_array;
 
 typedef struct {
-	uint32_t size;
-	struct msgpack_object_kv* ptr;
+    uint32_t size;
+    struct msgpack_object_kv* ptr;
 } msgpack_object_map;
 
 typedef struct {
-	uint32_t size;
-	const char* ptr;
-} msgpack_object_raw;
+    uint32_t size;
+    const char* ptr;
+} msgpack_object_str;
+
+typedef struct {
+    uint32_t size;
+    const char* ptr;
+} msgpack_object_bin;
+
+typedef struct {
+    int8_t type;
+    uint32_t size;
+    const char* ptr;
+} msgpack_object_ext;
 
 typedef union {
-	bool boolean;
-	uint64_t u64;
-	int64_t  i64;
-	double   dec;
-	msgpack_object_array array;
-	msgpack_object_map map;
-	msgpack_object_raw raw;
+    bool boolean;
+    uint64_t u64;
+    int64_t  i64;
+#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+    double   dec; /* obsolete*/
+#endif /* MSGPACK_USE_LEGACY_NAME_AS_FLOAT */
+    double   f64;
+    msgpack_object_array array;
+    msgpack_object_map map;
+    msgpack_object_str str;
+    msgpack_object_bin bin;
+    msgpack_object_ext ext;
 } msgpack_object_union;
 
 typedef struct msgpack_object {
-	msgpack_object_type type;
-	msgpack_object_union via;
+    msgpack_object_type type;
+    msgpack_object_union via;
 } msgpack_object;
 
 typedef struct msgpack_object_kv {
-	msgpack_object key;
-	msgpack_object val;
+    msgpack_object key;
+    msgpack_object val;
 } msgpack_object_kv;
 
-
+MSGPACK_DLLEXPORT
 void msgpack_object_print(FILE* out, msgpack_object o);
 
+MSGPACK_DLLEXPORT
 bool msgpack_object_equal(const msgpack_object x, const msgpack_object y);
 
 /** @} */
@@ -95,4 +117,3 @@ bool msgpack_object_equal(const msgpack_object x, const msgpack_object y);
 #endif
 
 #endif /* msgpack/object.h */
-

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

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2010 FURUHASHI Sadayuki
+// Copyright (C) 2008-2014 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.
@@ -15,12 +15,48 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 //
-#ifndef MSGPACK_OBJECT_HPP__
-#define MSGPACK_OBJECT_HPP__
+#ifndef MSGPACK_OBJECT_HPP
+#define MSGPACK_OBJECT_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/object_fwd.hpp"
+#include "msgpack/pack.hpp"
+#include "msgpack/zone.hpp"
+#include "msgpack/adaptor/int_fwd.hpp"
+#include "msgpack/adaptor/bool_fwd.hpp"
+#include "msgpack/adaptor/char_ptr_fwd.hpp"
+#include "msgpack/adaptor/deque_fwd.hpp"
+#include "msgpack/adaptor/fixint_fwd.hpp"
+#include "msgpack/adaptor/float_fwd.hpp"
+#include "msgpack/adaptor/int_fwd.hpp"
+#include "msgpack/adaptor/list_fwd.hpp"
+#include "msgpack/adaptor/map_fwd.hpp"
+#include "msgpack/adaptor/msgpack_tuple_fwd.hpp"
+#include "msgpack/adaptor/nil_fwd.hpp"
+#include "msgpack/adaptor/pair_fwd.hpp"
+#include "msgpack/adaptor/raw_fwd.hpp"
+#include "msgpack/adaptor/set_fwd.hpp"
+#include "msgpack/adaptor/string_fwd.hpp"
+#include "msgpack/adaptor/vector_fwd.hpp"
+#include "msgpack/adaptor/vector_bool_fwd.hpp"
+#include "msgpack/adaptor/vector_char_fwd.hpp"
+
+#if defined(MSGPACK_USE_CPP03)
+
+#include "msgpack/adaptor/tr1/unordered_map_fwd.hpp"
+#include "msgpack/adaptor/tr1/unordered_set_fwd.hpp"
+
+#else  // defined(MSGPACK_USE_CPP03)
+
+#include "adaptor/cpp11/array_fwd.hpp"
+#include "adaptor/cpp11/array_char_fwd.hpp"
+#include "adaptor/cpp11/forward_list_fwd.hpp"
+#include "adaptor/cpp11/tuple_fwd.hpp"
+#include "adaptor/cpp11/unordered_map_fwd.hpp"
+#include "adaptor/cpp11/unordered_set_fwd.hpp"
+
+#endif // defined(MSGPACK_USE_CPP03)
 
-#include "object.h"
-#include "pack.hpp"
-#include "zone.hpp"
 #include <string.h>
 #include <stdexcept>
 #include <typeinfo>
@@ -29,393 +65,648 @@
 
 namespace msgpack {
 
-
-class type_error : public std::bad_cast { };
-
-
-namespace type {
-	enum object_type {
-		NIL					= MSGPACK_OBJECT_NIL,
-		BOOLEAN				= MSGPACK_OBJECT_BOOLEAN,
-		POSITIVE_INTEGER	= MSGPACK_OBJECT_POSITIVE_INTEGER,
-		NEGATIVE_INTEGER	= MSGPACK_OBJECT_NEGATIVE_INTEGER,
-		DOUBLE				= MSGPACK_OBJECT_DOUBLE,
-		RAW					= MSGPACK_OBJECT_RAW,
-		ARRAY				= MSGPACK_OBJECT_ARRAY,
-		MAP					= MSGPACK_OBJECT_MAP,
-	};
-}
-
-
-struct object;
-struct object_kv;
-
-struct object_array {
-	uint32_t size;
-	object* ptr;
-};
-
-struct object_map {
-	uint32_t size;
-	object_kv* ptr;
-};
-
-struct object_raw {
-	uint32_t size;
-	const char* ptr;
-};
-
-struct object {
-	union union_type {
-		bool boolean;
-		uint64_t u64;
-		int64_t  i64;
-		double   dec;
-		object_array array;
-		object_map map;
-		object_raw raw;
-		object_raw ref;  // obsolete
-	};
-
-	type::object_type type;
-	union_type via;
-
-	bool is_nil() const { return type == type::NIL; }
-
-	template <typename T>
-	T as() const;
-
-	template <typename T>
-	void convert(T* v) const;
-
-	object();
-
-	object(msgpack_object o);
-
-	template <typename T>
-	explicit object(const T& v);
-
-	template <typename T>
-	object(const T& v, zone* z);
-
-	template <typename T>
-	object& operator=(const T& v);
-
-	operator msgpack_object() const;
-
-	struct with_zone;
-
-private:
-	struct implicit_type;
-
-public:
-	implicit_type convert() const;
-};
-
-struct object_kv {
-	object key;
-	object val;
-};
+MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 struct object::with_zone : object {
-	with_zone(msgpack::zone* zone) : zone(zone) { }
-	msgpack::zone* zone;
+    with_zone(msgpack::zone& zone) : zone(zone) { }
+    msgpack::zone& zone;
 private:
-	with_zone();
+    with_zone();
 };
 
-
-bool operator==(const object x, const object y);
-bool operator!=(const object x, const object y);
-
-template <typename T>
-bool operator==(const object x, const T& y);
-
-template <typename T>
-bool operator==(const T& y, const object x);
-
-template <typename T>
-bool operator!=(const object x, const T& y);
-
-template <typename T>
-bool operator!=(const T& y, const object x);
-
-std::ostream& operator<< (std::ostream& s, const object o);
-
-
-// serialize operator
-template <typename Stream, typename T>
-packer<Stream>& operator<< (packer<Stream>& o, const T& v);
-
-// convert operator
-template <typename T>
-T& operator>> (object o, T& v);
-
-// deconvert operator
-template <typename T>
-void operator<< (object::with_zone& o, const T& v);
-
-
 struct object::implicit_type {
-	implicit_type(object o) : obj(o) { }
-	~implicit_type() { }
+    implicit_type(object const& o) : obj(o) { }
+    ~implicit_type() { }
 
-	template <typename T>
-	operator T() { return obj.as<T>(); }
+    template <typename T>
+    operator T() { return obj.as<T>(); }
 
 private:
-	object obj;
+    msgpack::object const& obj;
 };
 
+inline msgpack::object const& operator>> (msgpack::object const& o, msgpack::object& v)
+{
+    v = o;
+    return o;
+}
+
+template <typename T>
+inline msgpack::object const& operator>> (msgpack::object const& o, T& v)
+{
+    // If you get a error 'class your_class has no member named 'msgpack_unpack',
+    // check the following:
+    // 1. The class your_class should have MSGPACK_DEFINE macro or
+    //
+    // 2. The class your_class should have the following operator declaration and
+    //    definition:
+    //    inline object const& operator>> (object const& o, std::string& v)
+    //
+    //    See 3.
+    //
+    // 3. #include "msgpack.hpp" too early.
+    //    Replace msgpack.hpp with msgpack_fwd.hpp, then,
+    //    place operator declarations as follows:
+    //
+    //    namespace msgpack {
+    //    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+    //    object const& operator>> (object const& o, std::string& v);
+    //    }
+    //    }
+    //
+    //    then, #include "msgpack.hpp", finally place the operator definitions as follows:
+    //
+    //    namespace msgpack {
+    //    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+    //    object const& operator>> (object const& o, std::string& v) {
+    //        // converting operations here
+    //    }
+    //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+    //    } // namespace msgpack
+    //
+    v.msgpack_unpack(o.convert());
+    return o;
+}
 
 // obsolete
 template <typename Type>
 class define : public Type {
 public:
-	typedef Type msgpack_type;
-	typedef define<Type> define_type;
-
-	define() {}
-	define(const msgpack_type& v) : msgpack_type(v) {}
-
-	template <typename Packer>
-	void msgpack_pack(Packer& o) const
-	{
-		o << static_cast<const msgpack_type&>(*this);
-	}
-
-	void msgpack_unpack(object o)
-	{
-		o >> static_cast<msgpack_type&>(*this);
-	}
+    typedef Type msgpack_type;
+    typedef define<Type> define_type;
+
+    define() {}
+    define(const msgpack_type& v) : msgpack_type(v) {}
+
+    template <typename Packer>
+    void msgpack_pack(Packer& o) const
+    {
+        msgpack::operator<<(o, static_cast<const msgpack_type&>(*this));
+    }
+
+    void msgpack_unpack(object const& o)
+    {
+        msgpack::operator>>(o, static_cast<msgpack_type&>(*this));
+    }
 };
 
-
-template <typename Stream>
-template <typename T>
-inline packer<Stream>& packer<Stream>::pack(const T& v)
-{
-	*this << v;
-	return *this;
+namespace detail {
+template <typename Stream, typename T>
+struct packer_serializer {
+    static msgpack::packer<Stream>& pack(msgpack::packer<Stream>& o, const T& v) {
+        // If you get a error 'const class your_class has no member named 'msgpack_pack',
+        // check the following:
+        // 1. The class your_class should have MSGPACK_DEFINE macro or
+        //
+        // 2. The class your_class should have the following operator declaration and
+        //    definition:
+        //
+        //    namespace msgpack {
+        //    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+        //    template <typename Stream>
+        //    inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const your_class& v)
+        //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+        //    } // namespace msgpack
+        //
+        //    See 3.
+        //
+        // 3. #include "msgpack.hpp" too early.
+        //    Replace msgpack.hpp with msgpack_fwd.hpp, then,
+        //    place operator declarations as follows:
+        //
+        //    namespace msgpack {
+        //    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+        //    template <typename Stream>
+        //    msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const your_class& v);
+        //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+        //    } // namespace msgpack
+        //
+        //    then, #include "msgpack.hpp", finally place the operator definitions as follows:
+        //
+        //    template <typename Stream>
+        //    inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const your_class& v) {
+        //         // packing operation
+        //    }
+        //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+        //    } // namespace msgpack
+        //
+        v.msgpack_pack(o);
+        return o;
+    }
+};
 }
 
-inline object& operator>> (object o, object& v)
+inline void operator<< (msgpack::object::with_zone& o, const msgpack::object& v)
 {
-	v = o;
-	return v;
+    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<object*>(o.zone.allocate_align(sizeof(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 = (object_kv*)o.zone.allocate_align(sizeof(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) {
+            object_kv* kv = new (po) 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();
+    }
 }
 
-template <typename T>
-inline T& operator>> (object o, T& v)
+inline void operator<< (msgpack::object::with_zone& o, const msgpack::object::with_zone& v)
 {
-	v.msgpack_unpack(o.convert());
-	return v;
-}
-
-namespace detail {
-template <typename Stream, typename T>
-struct packer_serializer {
-	static packer<Stream>& pack(packer<Stream>& o, const T& v) {
-		v.msgpack_pack(o);
-		return o;
-	}
-};
+    return o << static_cast<msgpack::object const&>(v);
 }
 
-template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const T& v)
+// deconvert operator
+template <typename T>
+inline void operator<< (msgpack::object::with_zone& o, const T& v)
 {
-	return detail::packer_serializer<Stream, T>::pack(o, v);
+    // If you get a error 'const class your_class has no member named 'msgpack_object',
+    // check the following:
+    // 1. The class your_class should have MSGPACK_DEFINE macro or
+    //
+    // 2. The class your_class should have the following operator declaration and
+    //    definition:
+    //
+    //    namespace msgpack {
+    //    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+    //    void operator<< (object::with_zone& o, const your_class& v);
+    //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+    //    } // namespace msgpack
+    //
+    //    See 3.
+    //
+    // 3. #include "msgpack.hpp" too early.
+    //    Replace msgpack.hpp with msgpack_fwd.hpp, then,
+    //    place operator declarations as follows:
+    //
+    //    namespace msgpack {
+    //    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+    //    void operator<< (object::with_zone& o, const your_class& v);
+    //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+    //    } // namespace msgpack
+    //
+    //    then, #include "msgpack.hpp", finally place the operator definitions as follows:
+    //
+    //    void operator<< (object::with_zone& o, const your_class& v) {
+    //         // set object attributes using v.
+    //    }
+    //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+    //    } // namespace msgpack
+    //
+    v.msgpack_object(static_cast<object*>(&o), o.zone);
 }
 
+template <typename Stream>
 template <typename T>
-void operator<< (object::with_zone& o, const T& v)
+inline msgpack::packer<Stream>& packer<Stream>::pack(const T& v)
 {
-	v.msgpack_object(static_cast<object*>(&o), o.zone);
+    msgpack::operator<<(*this, v);
+    return *this;
 }
 
-
-inline bool operator==(const object x, const object y)
+inline bool operator==(const msgpack::object& x, const msgpack::object& y)
 {
-	return msgpack_object_equal(x, y);
+    if(x.type != y.type) { return false; }
+
+    switch(x.type) {
+    case msgpack::type::NIL:
+        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) {
+            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 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;
+    }
 }
 
 template <typename T>
-inline bool operator==(const object x, const T& y)
+inline bool operator==(const msgpack::object& x, const T& y)
 try {
-	return x == object(y);
+    return x == msgpack::object(y);
 } catch (msgpack::type_error&) {
-	return false;
+    return false;
 }
 
-inline bool operator!=(const object x, const object y)
+inline bool operator!=(const msgpack::object& x, const msgpack::object& y)
 { return !(x == y); }
 
 template <typename T>
-inline bool operator==(const T& y, const object x)
+inline bool operator==(const T& y, const msgpack::object x)
 { return x == y; }
 
 template <typename T>
-inline bool operator!=(const object x, const T& y)
+inline bool operator!=(const msgpack::object& x, const T& y)
 { return !(x == y); }
 
 template <typename T>
-inline bool operator!=(const T& y, const object x)
+inline bool operator!=(const T& y, const msgpack::object& x)
 { return x != y; }
 
 
-inline object::implicit_type object::convert() const
+inline msgpack::object::implicit_type object::convert() const
+{
+    return msgpack::object::implicit_type(*this);
+}
+
+template <typename T>
+inline void object::convert(T& v) const
 {
-	return implicit_type(*this);
+    msgpack::operator>>(*this, v);
 }
 
 template <typename T>
 inline void object::convert(T* v) const
 {
-	*this >> *v;
+    convert(*v);
 }
 
 template <typename T>
 inline T object::as() const
 {
-	T v;
-	convert(&v);
-	return v;
+    T v;
+    convert(v);
+    return v;
 }
 
 
 inline object::object()
 {
-	type = type::NIL;
+    type = msgpack::type::NIL;
 }
 
 template <typename T>
 inline object::object(const T& v)
 {
-	*this << v;
+    // If you get a error 'no matching function call to
+    // operator<<(msgpack::v?::object::object(const T&)
+    // [with T = your_class]'
+    //
+    // check the following:
+    // 1. The class your_class should have MSGPACK_DEFINE macro or
+    //
+    // 2. The class your_class should have the following operator declaration and
+    //    definition:
+    //
+    //    namespace msgpack {
+    //    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+    //    void operator<< (object& o, const your_class& v);
+    //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+    //    } // namespace msgpack
+    //
+    //    See 3.
+    //
+    // 3. #include "msgpack.hpp" too early.
+    //    Replace msgpack.hpp with msgpack_fwd.hpp, then,
+    //    place operator declarations as follows:
+    //
+    //    namespace msgpack {
+    //    MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) {
+    //    void operator<< (object& o, const your_class& v);
+    //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+    //    } // namespace msgpack
+    //
+    //    then, #include "msgpack.hpp", finally place the operator definitions as follows:
+    //
+    //    void operator<< (object& o, const your_class& v) {
+    //         // set object attributes using v.
+    //    }
+    //    } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
+    //    } // namespace msgpack
+    //
+    msgpack::operator<<(*this, v);
 }
 
 template <typename T>
 inline object& object::operator=(const T& v)
 {
-	*this = object(v);
-	return *this;
+    *this = object(v);
+    return *this;
 }
 
 template <typename T>
-object::object(const T& v, zone* z)
+object::object(const T& v, msgpack::zone& z)
 {
-	with_zone oz(z);
-	oz << v;
-	type = oz.type;
-	via = oz.via;
+    with_zone oz(z);
+    msgpack::operator<<(oz, v);
+    type = oz.type;
+    via = oz.via;
+}
+
+template <typename T>
+object::object(const T& v, msgpack::zone* z)
+{
+    with_zone oz(*z);
+    msgpack::operator<<(oz, v);
+    type = oz.type;
+    via = oz.via;
 }
 
 
-inline object::object(msgpack_object o)
+inline object::object(const msgpack_object& o)
 {
-	// FIXME beter way?
-	::memcpy(this, &o, sizeof(o));
+    // FIXME beter way?
+    std::memcpy(this, &o, sizeof(o));
 }
 
-inline void operator<< (object& o, msgpack_object v)
+inline void operator<< (msgpack::object& o, const msgpack_object& v)
 {
-	// FIXME beter way?
-	::memcpy(&o, &v, sizeof(v));
+    // FIXME beter way?
+    std::memcpy(&o, &v, sizeof(v));
 }
 
 inline object::operator msgpack_object() const
 {
-	// FIXME beter way?
-	msgpack_object obj;
-	::memcpy(&obj, this, sizeof(obj));
-	return obj;
+    // FIXME beter way?
+    msgpack_object obj;
+    std::memcpy(&obj, this, sizeof(obj));
+    return obj;
 }
 
 
 // obsolete
 template <typename T>
-inline void convert(T& v, object o)
+inline void convert(T& v, msgpack::object const& o)
 {
-	o.convert(&v);
+    o.convert(v);
 }
 
 // obsolete
 template <typename Stream, typename T>
-inline void pack(packer<Stream>& o, const T& v)
+inline void pack(msgpack::packer<Stream>& o, const T& v)
 {
-	o.pack(v);
+    o.pack(v);
 }
 
 // obsolete
 template <typename Stream, typename T>
-inline void pack_copy(packer<Stream>& o, T v)
+inline void pack_copy(msgpack::packer<Stream>& o, T v)
 {
-	pack(o, v);
+    pack(o, v);
 }
 
 
 template <typename Stream>
-packer<Stream>& operator<< (packer<Stream>& o, const object& v)
+inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object& v)
 {
-	switch(v.type) {
-	case type::NIL:
-		o.pack_nil();
-		return o;
-
-	case type::BOOLEAN:
-		if(v.via.boolean) {
-			o.pack_true();
-		} else {
-			o.pack_false();
-		}
-		return o;
-
-	case type::POSITIVE_INTEGER:
-		o.pack_uint64(v.via.u64);
-		return o;
-
-	case type::NEGATIVE_INTEGER:
-		o.pack_int64(v.via.i64);
-		return o;
-
-	case type::DOUBLE:
-		o.pack_double(v.via.dec);
-		return o;
-
-	case type::RAW:
-		o.pack_raw(v.via.raw.size);
-		o.pack_raw_body(v.via.raw.ptr, v.via.raw.size);
-		return o;
-
-	case type::ARRAY:
-		o.pack_array(v.via.array.size);
-		for(object* p(v.via.array.ptr),
-				* const pend(v.via.array.ptr + v.via.array.size);
-				p < pend; ++p) {
-			o << *p;
-		}
-		return o;
-
-	case type::MAP:
-		o.pack_map(v.via.map.size);
-		for(object_kv* p(v.via.map.ptr),
-				* const pend(v.via.map.ptr + v.via.map.size);
-				p < pend; ++p) {
-			o << p->key;
-			o << p->val;
-		}
-		return o;
-
-	default:
-		throw type_error();
-	}
+    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();
+    }
 }
 
+template <typename Stream>
+msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object::with_zone& v)
+{
+    return o << static_cast<msgpack::object>(v);
+}
+
+inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o)
+{
+    switch(o.type) {
+    case msgpack::type::NIL:
+        s << "nil";
+        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 << '"').write(o.via.str.ptr, o.via.str.size) << '"';
+        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) << ">";
+    }
+    return s;
+}
+
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
 
 }  // namespace msgpack
 
 #include "msgpack/type.hpp"
 
 #endif /* msgpack/object.hpp */
-