cpp: move source files into src/ directory

cpp/src/msgpack/object.h

@@ -0,0 +1,90 @@
+/*
+ * MessagePack for C dynamic typing routine
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ *    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_OBJECT_H__
+#define MSGPACK_OBJECT_H__
+
+#include "msgpack/zone.h"
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+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_type;
+
+
+struct msgpack_object;
+struct msgpack_object_kv;
+
+typedef struct {
+	uint32_t size;
+	struct msgpack_object* ptr;
+} msgpack_object_array;
+
+typedef struct {
+	uint32_t size;
+	struct msgpack_object_kv* ptr;
+} msgpack_object_map;
+
+typedef struct {
+	uint32_t size;
+	const char* ptr;
+} msgpack_object_raw;
+
+typedef union {
+	bool boolean;
+	uint64_t u64;
+	int64_t  i64;
+	double   dec;
+	msgpack_object_array array;
+	msgpack_object_map map;
+	msgpack_object_raw raw;
+} msgpack_object_union;
+
+typedef struct msgpack_object {
+	msgpack_object_type type;
+	msgpack_object_union via;
+} msgpack_object;
+
+typedef struct msgpack_object_kv {
+	msgpack_object key;
+	msgpack_object val;
+} msgpack_object_kv;
+
+
+void msgpack_object_print(FILE* out, msgpack_object o);
+
+bool msgpack_object_equal(const msgpack_object x, const msgpack_object y);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/object.h */
+

cpp/src/msgpack/object.hpp

@@ -0,0 +1,412 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_OBJECT_HPP__
+#define MSGPACK_OBJECT_HPP__
+
+#include "msgpack/object.h"
+#include "msgpack/pack.hpp"
+#include "msgpack/zone.hpp"
+#include <string.h>
+#include <stdexcept>
+#include <typeinfo>
+#include <limits>
+#include <ostream>
+
+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;
+};
+
+struct object::with_zone : object {
+	with_zone(msgpack::zone* zone) : zone(zone) { }
+	msgpack::zone* zone;
+private:
+	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() { }
+
+	template <typename T>
+	operator T() { return obj.as<T>(); }
+
+private:
+	object obj;
+};
+
+
+// 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);
+	}
+};
+
+
+template <typename Stream>
+template <typename T>
+inline packer<Stream>& packer<Stream>::pack(const T& v)
+{
+	*this << v;
+	return *this;
+}
+
+inline object& operator>> (object o, object& v)
+{
+	v = o;
+	return v;
+}
+
+template <typename T>
+inline T& operator>> (object o, T& v)
+{
+	v.msgpack_unpack(o.convert());
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const T& v)
+{
+	v.msgpack_pack(o);
+	return o;
+}
+
+template <typename T>
+void operator<< (object::with_zone& o, const T& v)
+{
+	v.msgpack_object(static_cast<object*>(&o), o.zone);
+}
+
+
+inline bool operator==(const object x, const object y)
+{
+	return msgpack_object_equal(x, y);
+}
+
+template <typename T>
+inline bool operator==(const object x, const T& y)
+try {
+	return x == object(y);
+} catch (msgpack::type_error&) {
+	return false;
+}
+
+inline bool operator!=(const object x, const object y)
+{ return !(x == y); }
+
+template <typename T>
+inline bool operator==(const T& y, const object x)
+{ return x == y; }
+
+template <typename T>
+inline bool operator!=(const object x, const T& y)
+{ return !(x == y); }
+
+template <typename T>
+inline bool operator!=(const T& y, const object x)
+{ return x != y; }
+
+
+inline object::implicit_type object::convert() const
+{
+	return implicit_type(*this);
+}
+
+template <typename T>
+inline void object::convert(T* v) const
+{
+	*this >> *v;
+}
+
+template <typename T>
+inline T object::as() const
+{
+	T v;
+	convert(&v);
+	return v;
+}
+
+
+inline object::object()
+{
+	type = type::NIL;
+}
+
+template <typename T>
+inline object::object(const T& v)
+{
+	*this << v;
+}
+
+template <typename T>
+inline object& object::operator=(const T& v)
+{
+	*this = object(v);
+	return *this;
+}
+
+template <typename T>
+object::object(const T& v, zone* z)
+{
+	with_zone oz(z);
+	oz << v;
+	type = oz.type;
+	via = oz.via;
+}
+
+
+inline object::object(msgpack_object o)
+{
+	// FIXME beter way?
+	::memcpy(this, &o, sizeof(o));
+}
+
+inline void operator<< (object& o, msgpack_object v)
+{
+	// FIXME beter way?
+	::memcpy(&o, &v, sizeof(v));
+}
+
+inline object::operator msgpack_object() const
+{
+	// FIXME beter way?
+	msgpack_object obj;
+	::memcpy(&obj, this, sizeof(obj));
+	return obj;
+}
+
+
+// obsolete
+template <typename T>
+inline void convert(T& v, object o)
+{
+	o.convert(&v);
+}
+
+// obsolete
+template <typename Stream, typename T>
+inline void pack(packer<Stream>& o, const T& v)
+{
+	o.pack(v);
+}
+
+// obsolete
+template <typename Stream, typename T>
+inline void pack_copy(packer<Stream>& o, T v)
+{
+	pack(o, v);
+}
+
+
+template <typename Stream>
+packer<Stream>& operator<< (packer<Stream>& o, const 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();
+	}
+}
+
+
+}  // namespace msgpack
+
+#include "msgpack/type.hpp"
+
+#endif /* msgpack/object.hpp */
+

cpp/src/msgpack/pack.h

@@ -0,0 +1,116 @@
+/*
+ * MessagePack for C packing routine
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ *    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_PACK_H__
+#define MSGPACK_PACK_H__
+
+#include "msgpack/pack_define.h"
+#include "msgpack/object.h"
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef int (*msgpack_packer_write)(void* data, const char* buf, unsigned int len);
+
+typedef struct msgpack_packer {
+	void* data;
+	msgpack_packer_write callback;
+} msgpack_packer;
+
+static void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback);
+
+static msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback);
+static void msgpack_packer_free(msgpack_packer* pk);
+
+static int msgpack_pack_short(msgpack_packer* pk, short d);
+static int msgpack_pack_int(msgpack_packer* pk, int d);
+static int msgpack_pack_long(msgpack_packer* pk, long d);
+static int msgpack_pack_long_long(msgpack_packer* pk, long long d);
+static int msgpack_pack_unsigned_short(msgpack_packer* pk, unsigned short d);
+static int msgpack_pack_unsigned_int(msgpack_packer* pk, unsigned int d);
+static int msgpack_pack_unsigned_long(msgpack_packer* pk, unsigned long d);
+static int msgpack_pack_unsigned_long_long(msgpack_packer* pk, unsigned long long d);
+
+static int msgpack_pack_uint8(msgpack_packer* pk, uint8_t d);
+static int msgpack_pack_uint16(msgpack_packer* pk, uint16_t d);
+static int msgpack_pack_uint32(msgpack_packer* pk, uint32_t d);
+static int msgpack_pack_uint64(msgpack_packer* pk, uint64_t d);
+static int msgpack_pack_int8(msgpack_packer* pk, int8_t d);
+static int msgpack_pack_int16(msgpack_packer* pk, int16_t d);
+static int msgpack_pack_int32(msgpack_packer* pk, int32_t d);
+static int msgpack_pack_int64(msgpack_packer* pk, int64_t d);
+
+static int msgpack_pack_float(msgpack_packer* pk, float d);
+static int msgpack_pack_double(msgpack_packer* pk, double d);
+
+static int msgpack_pack_nil(msgpack_packer* pk);
+static int msgpack_pack_true(msgpack_packer* pk);
+static int msgpack_pack_false(msgpack_packer* pk);
+
+static int msgpack_pack_array(msgpack_packer* pk, unsigned int n);
+
+static int msgpack_pack_map(msgpack_packer* pk, unsigned int n);
+
+static int msgpack_pack_raw(msgpack_packer* pk, size_t l);
+static int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l);
+
+int msgpack_pack_object(msgpack_packer* pk, msgpack_object d);
+
+
+
+#define msgpack_pack_inline_func(name) \
+	inline int msgpack_pack ## name
+
+#define msgpack_pack_inline_func_cint(name) \
+	inline int msgpack_pack ## name
+
+#define msgpack_pack_user msgpack_packer*
+
+#define msgpack_pack_append_buffer(user, buf, len) \
+	return (*(user)->callback)((user)->data, (const char*)buf, len)
+
+#include "msgpack/pack_template.h"
+
+inline void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback)
+{
+	pk->data = data;
+	pk->callback = callback;
+}
+
+inline msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback)
+{
+	msgpack_packer* pk = (msgpack_packer*)calloc(1, sizeof(msgpack_packer));
+	if(!pk) { return NULL; }
+	msgpack_packer_init(pk, data, callback);
+	return pk;
+}
+
+inline void msgpack_packer_free(msgpack_packer* pk)
+{
+	free(pk);
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/pack.h */
+

cpp/src/msgpack/pack.hpp

@@ -0,0 +1,262 @@
+//
+// MessagePack for C++ serializing routine
+//
+// Copyright (C) 2008-2010 FURUHASHI Sadayuki
+//
+//    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_PACK_HPP__
+#define MSGPACK_PACK_HPP__
+
+#include "msgpack/pack_define.h"
+#include <stdexcept>
+#include <limits.h>
+
+namespace msgpack {
+
+
+template <typename Stream>
+class packer {
+public:
+	packer(Stream* s);
+	packer(Stream& s);
+	~packer();
+
+public:
+	template <typename T>
+	packer<Stream>& pack(const T& v);
+
+	packer<Stream>& pack_uint8(uint8_t d);
+	packer<Stream>& pack_uint16(uint16_t d);
+	packer<Stream>& pack_uint32(uint32_t d);
+	packer<Stream>& pack_uint64(uint64_t d);
+	packer<Stream>& pack_int8(int8_t d);
+	packer<Stream>& pack_int16(int16_t d);
+	packer<Stream>& pack_int32(int32_t d);
+	packer<Stream>& pack_int64(int64_t d);
+
+	packer<Stream>& pack_short(short d);
+	packer<Stream>& pack_int(int d);
+	packer<Stream>& pack_long(long d);
+	packer<Stream>& pack_long_long(long long d);
+	packer<Stream>& pack_unsigned_short(unsigned short d);
+	packer<Stream>& pack_unsigned_int(unsigned int d);
+	packer<Stream>& pack_unsigned_long(unsigned long d);
+	packer<Stream>& pack_unsigned_long_long(unsigned long long d);
+
+	packer<Stream>& pack_float(float d);
+	packer<Stream>& pack_double(double d);
+
+	packer<Stream>& pack_nil();
+	packer<Stream>& pack_true();
+	packer<Stream>& pack_false();
+
+	packer<Stream>& pack_array(unsigned int n);
+
+	packer<Stream>& pack_map(unsigned int n);
+
+	packer<Stream>& pack_raw(size_t l);
+	packer<Stream>& pack_raw_body(const char* b, size_t l);
+
+private:
+	static void _pack_uint8(Stream& x, uint8_t d);
+	static void _pack_uint16(Stream& x, uint16_t d);
+	static void _pack_uint32(Stream& x, uint32_t d);
+	static void _pack_uint64(Stream& x, uint64_t d);
+	static void _pack_int8(Stream& x, int8_t d);
+	static void _pack_int16(Stream& x, int16_t d);
+	static void _pack_int32(Stream& x, int32_t d);
+	static void _pack_int64(Stream& x, int64_t d);
+
+	static void _pack_short(Stream& x, short d);
+	static void _pack_int(Stream& x, int d);
+	static void _pack_long(Stream& x, long d);
+	static void _pack_long_long(Stream& x, long long d);
+	static void _pack_unsigned_short(Stream& x, unsigned short d);
+	static void _pack_unsigned_int(Stream& x, unsigned int d);
+	static void _pack_unsigned_long(Stream& x, unsigned long d);
+	static void _pack_unsigned_long_long(Stream& x, unsigned long long d);
+
+	static void _pack_float(Stream& x, float d);
+	static void _pack_double(Stream& x, double d);
+
+	static void _pack_nil(Stream& x);
+	static void _pack_true(Stream& x);
+	static void _pack_false(Stream& x);
+
+	static void _pack_array(Stream& x, unsigned int n);
+
+	static void _pack_map(Stream& x, unsigned int n);
+
+	static void _pack_raw(Stream& x, size_t l);
+	static void _pack_raw_body(Stream& x, const void* b, size_t l);
+
+	static void append_buffer(Stream& x, const unsigned char* buf, unsigned int len)
+		{ x.write((const char*)buf, len); }
+
+private:
+	Stream& m_stream;
+
+private:
+	packer();
+};
+
+
+template <typename Stream, typename T>
+inline void pack(Stream* s, const T& v)
+{
+	packer<Stream>(s).pack(v);
+}
+
+template <typename Stream, typename T>
+inline void pack(Stream& s, const T& v)
+{
+	packer<Stream>(s).pack(v);
+}
+
+
+#define msgpack_pack_inline_func(name) \
+	template <typename Stream> \
+	inline void packer<Stream>::_pack ## name
+
+#define msgpack_pack_inline_func_cint(name) \
+	template <typename Stream> \
+	inline void packer<Stream>::_pack ## name
+
+#define msgpack_pack_user Stream&
+
+#define msgpack_pack_append_buffer append_buffer
+
+#include "msgpack/pack_template.h"
+
+
+template <typename Stream>
+packer<Stream>::packer(Stream* s) : m_stream(*s) { }
+
+template <typename Stream>
+packer<Stream>::packer(Stream& s) : m_stream(s) { }
+
+template <typename Stream>
+packer<Stream>::~packer() { }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_uint8(uint8_t d)
+{ _pack_uint8(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_uint16(uint16_t d)
+{ _pack_uint16(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_uint32(uint32_t d)
+{ _pack_uint32(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_uint64(uint64_t d)
+{ _pack_uint64(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int8(int8_t d)
+{ _pack_int8(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int16(int16_t d)
+{ _pack_int16(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int32(int32_t d)
+{ _pack_int32(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int64(int64_t d)
+{ _pack_int64(m_stream, d); return *this;}
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_short(short d)
+{ _pack_short(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_int(int d)
+{ _pack_int(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_long(long d)
+{ _pack_long(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_long_long(long long d)
+{ _pack_long_long(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_short(unsigned short d)
+{ _pack_unsigned_short(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_int(unsigned int d)
+{ _pack_unsigned_int(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_long(unsigned long d)
+{ _pack_unsigned_long(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_long_long(unsigned long long d)
+{ _pack_unsigned_long_long(m_stream, d); return *this; }
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_float(float d)
+{ _pack_float(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_double(double d)
+{ _pack_double(m_stream, d); return *this; }
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_nil()
+{ _pack_nil(m_stream); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_true()
+{ _pack_true(m_stream); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_false()
+{ _pack_false(m_stream); return *this; }
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_array(unsigned int n)
+{ _pack_array(m_stream, n); return *this; }
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_map(unsigned int n)
+{ _pack_map(m_stream, n); return *this; }
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_raw(size_t l)
+{ _pack_raw(m_stream, l); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_raw_body(const char* b, size_t l)
+{ _pack_raw_body(m_stream, b, l); return *this; }
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/pack.hpp */
+

cpp/src/msgpack/sbuffer.h

@@ -0,0 +1,90 @@
+/*
+ * MessagePack for C simple buffer implementation
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ *    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_SBUFFER_H__
+#define MSGPACK_SBUFFER_H__
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef MSGPACK_SBUFFER_INIT_SIZE
+#define MSGPACK_SBUFFER_INIT_SIZE 8192
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct msgpack_sbuffer {
+	size_t size;
+	char* data;
+	size_t alloc;
+} msgpack_sbuffer;
+
+static inline void msgpack_sbuffer_init(msgpack_sbuffer* sbuf)
+{
+	memset(sbuf, 0, sizeof(msgpack_sbuffer));
+}
+
+static inline void msgpack_sbuffer_destroy(msgpack_sbuffer* sbuf)
+{
+	free(sbuf->data);
+}
+
+static inline int msgpack_sbuffer_write(void* data, const char* buf, unsigned int len)
+{
+	msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data;
+
+	if(sbuf->alloc - sbuf->size < len) {
+		size_t nsize = (sbuf->alloc) ?
+				sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
+
+		while(nsize < sbuf->size + len) { nsize *= 2; }
+
+		void* tmp = realloc(sbuf->data, nsize);
+		if(!tmp) { return -1; }
+
+		sbuf->data = (char*)tmp;
+		sbuf->alloc = nsize;
+	}
+
+	memcpy(sbuf->data + sbuf->size, buf, len);
+	sbuf->size += len;
+	return 0;
+}
+
+static inline char* msgpack_sbuffer_release(msgpack_sbuffer* sbuf)
+{
+	char* tmp = sbuf->data;
+	sbuf->size = 0;
+	sbuf->data = NULL;
+	sbuf->alloc = 0;
+	return tmp;
+}
+
+static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf)
+{
+	sbuf->size = 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/sbuffer.h */
+

cpp/src/msgpack/sbuffer.hpp

@@ -0,0 +1,108 @@
+//
+// MessagePack for C++ simple buffer implementation
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_SBUFFER_HPP__
+#define MSGPACK_SBUFFER_HPP__
+
+#include "msgpack/sbuffer.h"
+#include <stdexcept>
+
+namespace msgpack {
+
+
+class sbuffer : public msgpack_sbuffer {
+public:
+	sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE)
+	{
+		base::data = (char*)::malloc(initsz);
+		if(!base::data) {
+			throw std::bad_alloc();
+		}
+
+		base::size = 0;
+		base::alloc = initsz;
+	}
+
+	~sbuffer()
+	{
+		::free(base::data);
+	}
+
+public:
+	void write(const char* buf, unsigned int len)
+	{
+		if(base::alloc - base::size < len) {
+			expand_buffer(len);
+		}
+		memcpy(base::data + base::size, buf, len);
+		base::size += len;
+	}
+
+	char* data()
+	{
+		return base::data;
+	}
+
+	const char* data() const
+	{
+		return base::data;
+	}
+
+	size_t size() const
+	{
+		return base::size;
+	}
+
+	char* release()
+	{
+		return msgpack_sbuffer_release(this);
+	}
+
+	void clear()
+	{
+		msgpack_sbuffer_clear(this);
+	}
+
+private:
+	void expand_buffer(size_t len)
+	{
+		size_t nsize = (base::alloc) ?
+				base::alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
+	
+		while(nsize < base::size + len) { nsize *= 2; }
+	
+		void* tmp = realloc(base::data, nsize);
+		if(!tmp) {
+			throw std::bad_alloc();
+		}
+	
+		base::data = (char*)tmp;
+		base::alloc = nsize;
+	}
+
+private:
+	typedef msgpack_sbuffer base;
+
+private:
+	sbuffer(const sbuffer&);
+};
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/sbuffer.hpp */
+

cpp/src/msgpack/type.hpp

@@ -0,0 +1,15 @@
+#include "msgpack/type/bool.hpp"
+#include "msgpack/type/float.hpp"
+#include "msgpack/type/int.hpp"
+#include "msgpack/type/list.hpp"
+#include "msgpack/type/deque.hpp"
+#include "msgpack/type/map.hpp"
+#include "msgpack/type/nil.hpp"
+#include "msgpack/type/pair.hpp"
+#include "msgpack/type/raw.hpp"
+#include "msgpack/type/set.hpp"
+#include "msgpack/type/string.hpp"
+#include "msgpack/type/vector.hpp"
+#include "msgpack/type/tuple.hpp"
+#include "msgpack/type/define.hpp"
+

cpp/src/msgpack/type/bool.hpp

@@ -0,0 +1,55 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_BOOL_HPP__
+#define MSGPACK_TYPE_BOOL_HPP__
+
+#include "msgpack/object.hpp"
+#include <vector>
+
+namespace msgpack {
+
+
+inline bool& operator>> (object o, bool& v)
+{
+	if(o.type != type::BOOLEAN) { throw type_error(); }
+	v = o.via.boolean;
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const bool& v)
+{
+	if(v) { o.pack_true(); }
+	else { o.pack_false(); }
+	return o;
+}
+
+inline void operator<< (object& o, bool v)
+{
+	o.type = type::BOOLEAN;
+	o.via.boolean = v;
+}
+
+inline void operator<< (object::with_zone& o, bool v)
+	{ static_cast<object&>(o) << v; }
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/bool.hpp */
+

cpp/src/msgpack/type/define.hpp.erb

@@ -0,0 +1,117 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_DEFINE_HPP__
+#define MSGPACK_TYPE_DEFINE_HPP__
+
+#define MSGPACK_DEFINE(...) \
+	template <typename Packer> \
+	void msgpack_pack(Packer& pk) const \
+	{ \
+		msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \
+	} \
+	void msgpack_unpack(msgpack::object o) \
+	{ \
+		msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
+	}\
+	template <typename MSGPACK_OBJECT> \
+	void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \
+	{ \
+		msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
+	}
+
+namespace msgpack {
+namespace type {
+
+
+<% GENERATION_LIMIT = 31 %>
+template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
+struct define;
+
+
+template <>
+struct define<> {
+	typedef define<> value_type;
+	typedef tuple<> tuple_type;
+	template <typename Packer>
+	void msgpack_pack(Packer& pk) const
+	{
+		pk.pack_array(1);
+	}
+	void msgpack_unpack(msgpack::object o)
+	{
+		if(o.type != type::ARRAY) { throw type_error(); }
+	}
+	void msgpack_object(msgpack::object* o, msgpack::zone* z) const
+	{
+		o->type = type::ARRAY;
+		o->via.array.ptr = NULL;
+		o->via.array.size = 0;
+	}
+};
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
+	typedef define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
+	typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> tuple_type;
+	define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
+		a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
+	template <typename Packer>
+	void msgpack_pack(Packer& pk) const
+	{
+		pk.pack_array(<%=i+1%>);
+		<%0.upto(i) {|j|%>
+		pk.pack(a<%=j%>);<%}%>
+	}
+	void msgpack_unpack(msgpack::object o)
+	{
+		if(o.type != type::ARRAY) { throw type_error(); }
+		const size_t size = o.via.array.size;
+		<%0.upto(i) {|j|%>
+		if(size <= <%=j%>) { return; } o.via.array.ptr[<%=j%>].convert(&a<%=j%>);<%}%>
+	}
+	void msgpack_object(msgpack::object* o, msgpack::zone* z) const
+	{
+		o->type = type::ARRAY;
+		o->via.array.ptr = (object*)z->malloc(sizeof(object)*<%=i+1%>);
+		o->via.array.size = <%=i+1%>;
+		<%0.upto(i) {|j|%>
+		o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%>
+	}
+	<%0.upto(i) {|j|%>
+	A<%=j%>& a<%=j%>;<%}%>
+};
+<%}%>
+
+inline define<> make_define()
+{
+	return define<>();
+}
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
+{
+	return define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
+}
+<%}%>
+
+}  // namespace type
+}  // namespace msgpack
+
+
+#endif /* msgpack/type/define.hpp */
+

cpp/src/msgpack/type/deque.hpp

@@ -0,0 +1,77 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_DEQUE_HPP__
+#define MSGPACK_TYPE_DEQUE_HPP__
+
+#include "msgpack/object.hpp"
+#include <deque>
+
+namespace msgpack {
+
+
+template <typename T>
+inline std::deque<T>& operator>> (object o, std::deque<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	v.resize(o.via.array.size);
+	object* p = o.via.array.ptr;
+	object* const pend = o.via.array.ptr + o.via.array.size;
+	typename std::deque<T>::iterator it = v.begin();
+	for(; p < pend; ++p, ++it) {
+		p->convert(&*it);
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::deque<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::deque<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::deque<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::deque<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/deque.hpp */
+

cpp/src/msgpack/type/float.hpp

@@ -0,0 +1,82 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_FLOAT_HPP__
+#define MSGPACK_TYPE_FLOAT_HPP__
+
+#include "msgpack/object.hpp"
+#include <vector>
+
+namespace msgpack {
+
+
+// FIXME check overflow, underflow
+
+
+inline float& operator>> (object o, float& v)
+{
+	if(o.type != type::DOUBLE) { throw type_error(); }
+	v = o.via.dec;
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const float& v)
+{
+	o.pack_float(v);
+	return o;
+}
+
+
+inline double& operator>> (object o, double& v)
+{
+	if(o.type != type::DOUBLE) { throw type_error(); }
+	v = o.via.dec;
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const double& v)
+{
+	o.pack_double(v);
+	return o;
+}
+
+
+inline void operator<< (object& o, float v)
+{
+	o.type = type::DOUBLE;
+	o.via.dec = v;
+}
+
+inline void operator<< (object& o, double v)
+{
+	o.type = type::DOUBLE;
+	o.via.dec = v;
+}
+
+inline void operator<< (object::with_zone& o, float v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, double v)
+	{ static_cast<object&>(o) << v; }
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/float.hpp */
+

cpp/src/msgpack/type/int.hpp

@@ -0,0 +1,211 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_INT_HPP__
+#define MSGPACK_TYPE_INT_HPP__
+
+#include "msgpack/object.hpp"
+#include <limits>
+
+namespace msgpack {
+
+
+namespace type {
+namespace detail {
+	template <typename T, bool Signed>
+	struct convert_integer_sign;
+
+	template <typename T>
+	struct convert_integer_sign<T, true> {
+		static inline T convert(object o) {
+			if(o.type == type::POSITIVE_INTEGER) {
+				if(o.via.u64 > (uint64_t)std::numeric_limits<T>::max())
+					{ throw type_error(); }
+				return o.via.u64;
+			} else if(o.type == type::NEGATIVE_INTEGER) {
+				if(o.via.i64 < (int64_t)std::numeric_limits<T>::min())
+					{ throw type_error(); }
+				return o.via.i64;
+			}
+			throw type_error();
+		}
+	};
+	
+	template <typename T>
+	struct convert_integer_sign<T, false> {
+		static inline T convert(object o) {
+			if(o.type == type::POSITIVE_INTEGER) {
+				if(o.via.u64 > (uint64_t)std::numeric_limits<T>::max())
+					{ throw type_error(); }
+				return o.via.u64;
+			}
+			throw type_error();
+		}
+	};
+
+	template <typename T>
+	static inline T convert_integer(object o)
+	{
+		return detail::convert_integer_sign<T, std::numeric_limits<T>::is_signed>::convert(o);
+	}
+
+}  // namespace detail
+}  // namespace type
+
+
+inline signed char& operator>> (object o, signed char& v)
+	{ v = type::detail::convert_integer<signed char>(o); return v; }
+
+inline signed short& operator>> (object o, signed short& v)
+	{ v = type::detail::convert_integer<signed short>(o); return v; }
+
+inline signed int& operator>> (object o, signed int& v)
+	{ v = type::detail::convert_integer<signed int>(o); return v; }
+
+inline signed long& operator>> (object o, signed long& v)
+	{ v = type::detail::convert_integer<signed long>(o); return v; }
+
+inline signed long long& operator>> (object o, signed long long& v)
+	{ v = type::detail::convert_integer<signed long long>(o); return v; }
+
+
+inline unsigned char& operator>> (object o, unsigned char& v)
+	{ v = type::detail::convert_integer<unsigned char>(o); return v; }
+
+inline unsigned short& operator>> (object o, unsigned short& v)
+	{ v = type::detail::convert_integer<unsigned short>(o); return v; }
+
+inline unsigned int& operator>> (object o, unsigned int& v)
+	{ v = type::detail::convert_integer<unsigned int>(o); return v; }
+
+inline unsigned long& operator>> (object o, unsigned long& v)
+	{ v = type::detail::convert_integer<unsigned long>(o); return v; }
+
+inline unsigned long long& operator>> (object o, unsigned long long& v)
+	{ v = type::detail::convert_integer<unsigned long long>(o); return v; }
+
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const signed char& v)
+	{ o.pack_int8(v); return o; }
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const signed short& v)
+	{ o.pack_short(v); return o; }
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const signed int& v)
+	{ o.pack_int(v); return o; }
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const signed long& v)
+	{ o.pack_long(v); return o; }
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const signed long long& v)
+	{ o.pack_long_long(v); return o; }
+
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned char& v)
+	{ o.pack_uint8(v); return o; }
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned short& v)
+	{ o.pack_unsigned_short(v); return o; }
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned int& v)
+	{ o.pack_unsigned_int(v); return o; }
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned long& v)
+	{ o.pack_unsigned_long(v); return o; }
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned long long& v)
+	{ o.pack_unsigned_long_long(v); return o; }
+
+
+inline void operator<< (object& o, signed char v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, signed short v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, signed int v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, signed long v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, signed long long v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+
+inline void operator<< (object& o, unsigned char v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, unsigned short v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, unsigned int v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, unsigned long v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, unsigned long long v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+
+inline void operator<< (object::with_zone& o, signed char v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, signed short v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, signed int v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, signed long v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, signed long long v)
+	{ static_cast<object&>(o) << v; }
+
+
+inline void operator<< (object::with_zone& o, unsigned char v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, unsigned short v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, unsigned int v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, unsigned long v)
+	{ static_cast<object&>(o) << v; }
+
+inline void operator<< (object::with_zone& o, unsigned long long v)
+	{ static_cast<object&>(o) << v; }
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/int.hpp */
+

cpp/src/msgpack/type/list.hpp

@@ -0,0 +1,77 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_LIST_HPP__
+#define MSGPACK_TYPE_LIST_HPP__
+
+#include "msgpack/object.hpp"
+#include <list>
+
+namespace msgpack {
+
+
+template <typename T>
+inline std::list<T>& operator>> (object o, std::list<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	v.resize(o.via.array.size);
+	object* p = o.via.array.ptr;
+	object* const pend = o.via.array.ptr + o.via.array.size;
+	typename std::list<T>::iterator it = v.begin();
+	for(; p < pend; ++p, ++it) {
+		p->convert(&*it);
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::list<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::list<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::list<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::list<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/list.hpp */
+

cpp/src/msgpack/type/map.hpp

@@ -0,0 +1,205 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_MAP_HPP__
+#define MSGPACK_TYPE_MAP_HPP__
+
+#include "msgpack/object.hpp"
+#include <map>
+#include <vector>
+#include <algorithm>
+
+namespace msgpack {
+
+
+namespace type {
+
+template <typename K, typename V>
+class assoc_vector : public std::vector< std::pair<K, V> > {};
+
+namespace detail {
+	template <typename K, typename V>
+	struct pair_first_less {
+		bool operator() (const std::pair<K, V>& x, const std::pair<K, V>& y) const
+			{ return x.first < y.first; }
+	};
+}
+
+}  //namespace type
+
+
+template <typename K, typename V>
+inline type::assoc_vector<K,V>& operator>> (object o, type::assoc_vector<K,V>& v)
+{
+	if(o.type != type::MAP) { throw type_error(); }
+	v.resize(o.via.map.size);
+	object_kv* p = o.via.map.ptr;
+	object_kv* const pend = o.via.map.ptr + o.via.map.size;
+	std::pair<K, V>* it(&v.front());
+	for(; p < pend; ++p, ++it) {
+		p->key.convert(&it->first);
+		p->val.convert(&it->second);
+	}
+	std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
+	return v;
+}
+
+template <typename Stream, typename K, typename V>
+inline packer<Stream>& operator<< (packer<Stream>& o, const type::assoc_vector<K,V>& v)
+{
+	o.pack_map(v.size());
+	for(typename type::assoc_vector<K,V>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(it->first);
+		o.pack(it->second);
+	}
+	return o;
+}
+
+template <typename K, typename V>
+inline void operator<< (object::with_zone& o, const type::assoc_vector<K,V>& v)
+{
+	o.type = type::MAP;
+	if(v.empty()) {
+		o.via.map.ptr  = NULL;
+		o.via.map.size = 0;
+	} else {
+		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* const pend = p + v.size();
+		o.via.map.ptr  = p;
+		o.via.map.size = v.size();
+		typename type::assoc_vector<K,V>::const_iterator it(v.begin());
+		do {
+			p->key = object(it->first, o.zone);
+			p->val = object(it->second, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+template <typename K, typename V>
+inline std::map<K, V> operator>> (object o, std::map<K, V>& v)
+{
+	if(o.type != type::MAP) { throw type_error(); }
+	object_kv* p(o.via.map.ptr);
+	object_kv* const pend(o.via.map.ptr + o.via.map.size);
+	for(; p != pend; ++p) {
+		K key;
+		p->key.convert(&key);
+		typename std::map<K,V>::iterator it(v.lower_bound(key));
+		if(it != v.end() && !(key < it->first)) {
+			p->val.convert(&it->second);
+		} else {
+			V val;
+			p->val.convert(&val);
+			v.insert(it, std::pair<K,V>(key, val));
+		}
+	}
+	return v;
+}
+
+template <typename Stream, typename K, typename V>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::map<K,V>& v)
+{
+	o.pack_map(v.size());
+	for(typename std::map<K,V>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(it->first);
+		o.pack(it->second);
+	}
+	return o;
+}
+
+template <typename K, typename V>
+inline void operator<< (object::with_zone& o, const std::map<K,V>& v)
+{
+	o.type = type::MAP;
+	if(v.empty()) {
+		o.via.map.ptr  = NULL;
+		o.via.map.size = 0;
+	} else {
+		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* const pend = p + v.size();
+		o.via.map.ptr  = p;
+		o.via.map.size = v.size();
+		typename std::map<K,V>::const_iterator it(v.begin());
+		do {
+			p->key = object(it->first, o.zone);
+			p->val = object(it->second, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+template <typename K, typename V>
+inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v)
+{
+	if(o.type != type::MAP) { throw type_error(); }
+	object_kv* p(o.via.map.ptr);
+	object_kv* const pend(o.via.map.ptr + o.via.map.size);
+	for(; p != pend; ++p) {
+		std::pair<K, V> value;
+		p->key.convert(&value.first);
+		p->val.convert(&value.second);
+		v.insert(value);
+	}
+	return v;
+}
+
+template <typename Stream, typename K, typename V>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::multimap<K,V>& v)
+{
+	o.pack_map(v.size());
+	for(typename std::multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(it->first);
+		o.pack(it->second);
+	}
+	return o;
+}
+
+template <typename K, typename V>
+inline void operator<< (object::with_zone& o, const std::multimap<K,V>& v)
+{
+	o.type = type::MAP;
+	if(v.empty()) {
+		o.via.map.ptr  = NULL;
+		o.via.map.size = 0;
+	} else {
+		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* const pend = p + v.size();
+		o.via.map.ptr  = p;
+		o.via.map.size = v.size();
+		typename std::multimap<K,V>::const_iterator it(v.begin());
+		do {
+			p->key = object(it->first, o.zone);
+			p->val = object(it->second, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/map.hpp */
+

cpp/src/msgpack/type/nil.hpp

@@ -0,0 +1,65 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_NIL_HPP__
+#define MSGPACK_TYPE_NIL_HPP__
+
+#include "msgpack/object.hpp"
+
+namespace msgpack {
+
+namespace type {
+
+struct nil { };
+
+}  // namespace type
+
+
+inline type::nil& operator>> (object o, type::nil& v)
+{
+	if(o.type != type::NIL) { throw type_error(); }
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const type::nil& v)
+{
+	o.pack_nil();
+	return o;
+}
+
+inline void operator<< (object& o, type::nil v)
+{
+	o.type = type::NIL;
+}
+
+inline void operator<< (object::with_zone& o, type::nil v)
+	{ static_cast<object&>(o) << v; }
+
+
+template <>
+inline void object::as<void>() const
+{
+	msgpack::type::nil v;
+	convert(&v);
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/nil.hpp */
+

cpp/src/msgpack/type/pair.hpp

@@ -0,0 +1,61 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_PAIR_HPP__
+#define MSGPACK_TYPE_PAIR_HPP__
+
+#include "msgpack/object.hpp"
+#include <utility>
+
+namespace msgpack {
+
+
+template <typename T1, typename T2>
+inline std::pair<T1, T2>& operator>> (object o, std::pair<T1, T2>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	if(o.via.array.size != 2) { throw type_error(); }
+	o.via.array.ptr[0].convert(&v.first);
+	o.via.array.ptr[1].convert(&v.second);
+	return v;
+}
+
+template <typename Stream, typename T1, typename T2>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::pair<T1, T2>& v)
+{
+	o.pack_array(2);
+	o.pack(v.first);
+	o.pack(v.second);
+	return o;
+}
+
+template <typename T1, typename T2>
+inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
+{
+	o.type = type::ARRAY;
+	object* p = (object*)o.zone->malloc(sizeof(object)*2);
+	o.via.array.ptr = p;
+	o.via.array.size = 2;
+	p[0] = object(v.first, o.zone);
+	p[1] = object(v.second, o.zone);
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/pair.hpp */
+

cpp/src/msgpack/type/raw.hpp

@@ -0,0 +1,94 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_RAW_HPP__
+#define MSGPACK_TYPE_RAW_HPP__
+
+#include "msgpack/object.hpp"
+#include <string.h>
+#include <string>
+
+namespace msgpack {
+
+namespace type {
+
+struct raw_ref {
+	raw_ref() : size(0), ptr(NULL) {}
+	raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
+
+	uint32_t size;
+	const char* ptr;
+
+	std::string str() { return std::string(ptr, size); }
+
+	bool operator== (const raw_ref& x)
+	{
+		return size == x.size && memcmp(ptr, x.ptr, size) == 0;
+	}
+
+	bool operator!= (const raw_ref& x)
+	{
+		return !(*this != x);
+	}
+
+	bool operator< (const raw_ref& x)
+	{
+		if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; }
+		else { return size < x.size; }
+	}
+
+	bool operator> (const raw_ref& x)
+	{
+		if(size == x.size) { return memcmp(ptr, x.ptr, size) > 0; }
+		else { return size > x.size; }
+	}
+};
+
+}  // namespace type
+
+
+inline type::raw_ref& operator>> (object o, type::raw_ref& v)
+{
+	if(o.type != type::RAW) { throw type_error(); }
+	v.ptr  = o.via.raw.ptr;
+	v.size = o.via.raw.size;
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const type::raw_ref& v)
+{
+	o.pack_raw(v.size);
+	o.pack_raw_body(v.ptr, v.size);
+	return o;
+}
+
+inline void operator<< (object& o, const type::raw_ref& v)
+{
+	o.type = type::RAW;
+	o.via.raw.ptr = v.ptr;
+	o.via.raw.size = v.size;
+}
+
+inline void operator<< (object::with_zone& o, const type::raw_ref& v)
+	{ static_cast<object&>(o) << v; }
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/raw.hpp */
+

cpp/src/msgpack/type/set.hpp

@@ -0,0 +1,122 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_SET_HPP__
+#define MSGPACK_TYPE_SET_HPP__
+
+#include "msgpack/object.hpp"
+#include <set>
+
+namespace msgpack {
+
+
+template <typename T>
+inline std::set<T>& operator>> (object o, std::set<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	object* p = o.via.array.ptr + o.via.array.size;
+	object* const pbegin = o.via.array.ptr;
+	while(p > pbegin) {
+		--p;
+		v.insert(p->as<T>());
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::set<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::set<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::set<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::set<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+template <typename T>
+inline std::multiset<T>& operator>> (object o, std::multiset<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	object* p = o.via.array.ptr + o.via.array.size;
+	object* const pbegin = o.via.array.ptr;
+	while(p > pbegin) {
+		--p;
+		v.insert(p->as<T>());
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::multiset<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::multiset<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::multiset<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::multiset<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/set.hpp */
+

cpp/src/msgpack/type/string.hpp

@@ -0,0 +1,62 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_STRING_HPP__
+#define MSGPACK_TYPE_STRING_HPP__
+
+#include "msgpack/object.hpp"
+#include <string>
+
+namespace msgpack {
+
+
+inline std::string& operator>> (object o, std::string& v)
+{
+	if(o.type != type::RAW) { throw type_error(); }
+	v.assign(o.via.raw.ptr, o.via.raw.size);
+	return v;
+}
+
+template <typename Stream>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
+{
+	o.pack_raw(v.size());
+	o.pack_raw_body(v.data(), v.size());
+	return o;
+}
+
+inline void operator<< (object::with_zone& o, const std::string& v)
+{
+	o.type = type::RAW;
+	char* ptr = (char*)o.zone->malloc(v.size());
+	o.via.raw.ptr = ptr;
+	o.via.raw.size = v.size();
+	memcpy(ptr, v.data(), v.size());
+}
+
+inline void operator<< (object& o, const std::string& v)
+{
+	o.type = type::RAW;
+	o.via.raw.ptr = v.data();
+	o.via.raw.size = v.size();
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/string.hpp */
+

cpp/src/msgpack/type/tr1/unordered_map.hpp

@@ -0,0 +1,129 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_TR1_UNORDERED_MAP_HPP__
+#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__
+
+#include "msgpack/object.hpp"
+#include <tr1/unordered_map>
+
+namespace msgpack {
+
+
+template <typename K, typename V>
+inline std::tr1::unordered_map<K, V> operator>> (object o, std::tr1::unordered_map<K, V>& v)
+{
+	if(o.type != type::MAP) { throw type_error(); }
+	object_kv* p(o.via.map.ptr);
+	object_kv* const pend(o.via.map.ptr + o.via.map.size);
+	for(; p != pend; ++p) {
+		K key;
+		p->key.convert(&key);
+		p->val.convert(&v[key]);
+	}
+	return v;
+}
+
+template <typename Stream, typename K, typename V>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_map<K,V>& v)
+{
+	o.pack_map(v.size());
+	for(typename std::tr1::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(it->first);
+		o.pack(it->second);
+	}
+	return o;
+}
+
+template <typename K, typename V>
+inline void operator<< (object::with_zone& o, const std::tr1::unordered_map<K,V>& v)
+{
+	o.type = type::MAP;
+	if(v.empty()) {
+		o.via.map.ptr  = NULL;
+		o.via.map.size = 0;
+	} else {
+		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* const pend = p + v.size();
+		o.via.map.ptr  = p;
+		o.via.map.size = v.size();
+		typename std::tr1::unordered_map<K,V>::const_iterator it(v.begin());
+		do {
+			p->key = object(it->first, o.zone);
+			p->val = object(it->second, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+template <typename K, typename V>
+inline std::tr1::unordered_multimap<K, V> operator>> (object o, std::tr1::unordered_multimap<K, V>& v)
+{
+	if(o.type != type::MAP) { throw type_error(); }
+	object_kv* p(o.via.map.ptr);
+	object_kv* const pend(o.via.map.ptr + o.via.map.size);
+	for(; p != pend; ++p) {
+		std::pair<K, V> value;
+		p->key.convert(&value.first);
+		p->val.convert(&value.second);
+		v.insert(value);
+	}
+	return v;
+}
+
+template <typename Stream, typename K, typename V>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_multimap<K,V>& v)
+{
+	o.pack_map(v.size());
+	for(typename std::tr1::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(it->first);
+		o.pack(it->second);
+	}
+	return o;
+}
+
+template <typename K, typename V>
+inline void operator<< (object::with_zone& o, const std::tr1::unordered_multimap<K,V>& v)
+{
+	o.type = type::MAP;
+	if(v.empty()) {
+		o.via.map.ptr  = NULL;
+		o.via.map.size = 0;
+	} else {
+		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* const pend = p + v.size();
+		o.via.map.ptr  = p;
+		o.via.map.size = v.size();
+		typename std::tr1::unordered_multimap<K,V>::const_iterator it(v.begin());
+		do {
+			p->key = object(it->first, o.zone);
+			p->val = object(it->second, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/map.hpp */
+

cpp/src/msgpack/type/tr1/unordered_set.hpp

@@ -0,0 +1,122 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_TR1_UNORDERED_SET_HPP__
+#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__
+
+#include "msgpack/object.hpp"
+#include <tr1/unordered_set>
+
+namespace msgpack {
+
+
+template <typename T>
+inline std::tr1::unordered_set<T>& operator>> (object o, std::tr1::unordered_set<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	object* p = o.via.array.ptr + o.via.array.size;
+	object* const pbegin = o.via.array.ptr;
+	while(p > pbegin) {
+		--p;
+		v.insert(p->as<T>());
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_set<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::tr1::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::tr1::unordered_set<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::tr1::unordered_set<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+template <typename T>
+inline std::tr1::unordered_multiset<T>& operator>> (object o, std::tr1::unordered_multiset<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	object* p = o.via.array.ptr + o.via.array.size;
+	object* const pbegin = o.via.array.ptr;
+	while(p > pbegin) {
+		--p;
+		v.insert(p->as<T>());
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_multiset<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::tr1::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::tr1::unordered_multiset<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::tr1::unordered_multiset<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/set.hpp */
+

cpp/src/msgpack/type/tuple.hpp.erb

@@ -0,0 +1,191 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_TUPLE_HPP__
+#define MSGPACK_TYPE_TUPLE_HPP__
+
+#include "msgpack/object.hpp"
+
+namespace msgpack {
+
+namespace type {
+
+// FIXME operator==
+// FIXME operator!=
+<% GENERATION_LIMIT = 31 %>
+
+template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
+struct tuple;
+
+template <typename Tuple, int N>
+struct tuple_element;
+
+template <typename Tuple, int N>
+struct const_tuple_element;
+
+template <typename T>
+struct tuple_type {
+	typedef T type;
+	typedef T value_type;
+	typedef T& reference;
+	typedef const T& const_reference;
+	typedef const T& transparent_reference;
+};
+
+template <typename T>
+struct tuple_type<T&> {
+	typedef T type;
+	typedef T& value_type;
+	typedef T& reference;
+	typedef const T& const_reference;
+	typedef T& transparent_reference;
+};
+
+template <typename T>
+struct tuple_type<const T&> {
+	typedef T type;
+	typedef T& value_type;
+	typedef T& reference;
+	typedef const T& const_reference;
+	typedef const T& transparent_reference;
+};
+
+<%0.upto(GENERATION_LIMIT) {|i|%>
+<%0.upto(i) {|j|%>
+template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
+struct tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
+	tuple_element(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : _x(x.a<%=j%>) {}
+	typename tuple_type<A<%=j%>>::reference get() { return _x; }
+	typename tuple_type<A<%=j%>>::const_reference get() const { return _x; }
+private:
+	typename tuple_type<A<%=j%>>::reference _x;
+};
+<%}%>
+<%}%>
+
+<%0.upto(GENERATION_LIMIT) {|i|%>
+<%0.upto(i) {|j|%>
+template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
+struct const_tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
+	const_tuple_element(const tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>& x) : _x(x.a<%=j%>) {}
+	typename tuple_type<A<%=j%>>::const_reference get() const { return _x; }
+private:
+	typename tuple_type<A<%=j%>>::const_reference _x;
+};
+<%}%>
+<%}%>
+
+template <>
+struct tuple<> {
+	tuple() {}
+	tuple(object o) { o.convert(this); }
+	typedef tuple<> value_type;
+};
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
+	typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
+	tuple() {}
+	tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
+		a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
+	tuple(object o) { o.convert(this); }
+	template <int N> typename tuple_element<value_type, N>::reference get()
+		{ return tuple_element<value_type, N>(*this).get(); }
+	template <int N> typename const_tuple_element<value_type, N>::const_reference get() const
+		{ return const_tuple_element<value_type, N>(*this).get(); }
+	<%0.upto(i) {|j|%>
+	A<%=j%> a<%=j%>;<%}%>
+};
+<%}%>
+
+inline tuple<> make_tuple()
+{
+	return tuple<>();
+}
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
+{
+	return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
+}
+<%}%>
+
+}  // namespace type
+
+
+inline type::tuple<>& operator>> (
+		object o,
+		type::tuple<>& v) {
+	if(o.type != type::ARRAY) { throw type_error(); }
+	return v;
+}
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& operator>> (
+		object o,
+		type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
+	if(o.type != type::ARRAY) { throw type_error(); }
+	if(o.via.array.size < <%=i+1%>) { throw type_error(); }
+	<%0.upto(i) {|j|%>
+	o.via.array.ptr[<%=j%>].convert<typename type::tuple_type<A<%=j%>>::type>(&v.template get<<%=j%>>());<%}%>
+	return v;
+}
+<%}%>
+
+template <typename Stream>
+const packer<Stream>& operator<< (
+		packer<Stream>& o,
+		const type::tuple<>& v) {
+	o.pack_array(0);
+	return o;
+}
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename Stream, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+const packer<Stream>& operator<< (
+		packer<Stream>& o,
+		const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
+	o.pack_array(<%=i+1%>);
+	<%0.upto(i) {|j|%>
+	o.pack(v.template get<<%=j%>>());<%}%>
+	return o;
+}
+<%}%>
+
+inline void operator<< (
+		object::with_zone& o,
+		const type::tuple<>& v) {
+	o.type = type::ARRAY;
+	o.via.array.ptr = NULL;
+	o.via.array.size = 0;
+}
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+inline void operator<< (
+		object::with_zone& o,
+		const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
+	o.type = type::ARRAY;
+	o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*<%=i+1%>);
+	o.via.array.size = <%=i+1%>;
+	<%0.upto(i) {|j|%>
+	o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%>
+}
+<%}%>
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/tuple.hpp */
+

cpp/src/msgpack/type/vector.hpp

@@ -0,0 +1,81 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_TYPE_VECTOR_HPP__
+#define MSGPACK_TYPE_VECTOR_HPP__
+
+#include "msgpack/object.hpp"
+#include <vector>
+
+namespace msgpack {
+
+
+template <typename T>
+inline std::vector<T>& operator>> (object o, std::vector<T>& v)
+{
+	if(o.type != type::ARRAY) { throw type_error(); }
+	v.resize(o.via.array.size);
+	if(o.via.array.size > 0) {
+		object* p = o.via.array.ptr;
+		object* const pend = o.via.array.ptr + o.via.array.size;
+		T* it = &v[0];
+		do {
+			p->convert(it);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+	return v;
+}
+
+template <typename Stream, typename T>
+inline packer<Stream>& operator<< (packer<Stream>& o, const std::vector<T>& v)
+{
+	o.pack_array(v.size());
+	for(typename std::vector<T>::const_iterator it(v.begin()), it_end(v.end());
+			it != it_end; ++it) {
+		o.pack(*it);
+	}
+	return o;
+}
+
+template <typename T>
+inline void operator<< (object::with_zone& o, const std::vector<T>& v)
+{
+	o.type = type::ARRAY;
+	if(v.empty()) {
+		o.via.array.ptr = NULL;
+		o.via.array.size = 0;
+	} else {
+		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* const pend = p + v.size();
+		o.via.array.ptr = p;
+		o.via.array.size = v.size();
+		typename std::vector<T>::const_iterator it(v.begin());
+		do {
+			*p = object(*it, o.zone);
+			++p;
+			++it;
+		} while(p < pend);
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/type/vector.hpp */
+

cpp/src/msgpack/unpack.h

@@ -0,0 +1,123 @@
+/*
+ * MessagePack for C unpacking routine
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ *    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_UNPACKER_H__
+#define MSGPACK_UNPACKER_H__
+
+#include "msgpack/zone.h"
+#include "msgpack/object.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct msgpack_unpacker {
+	char* buffer;
+	size_t used;
+	size_t free;
+	size_t off;
+	size_t parsed;
+	msgpack_zone* z;
+	size_t initial_buffer_size;
+	void* ctx;
+} msgpack_unpacker;
+
+
+bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size);
+void msgpack_unpacker_destroy(msgpack_unpacker* mpac);
+
+msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size);
+void msgpack_unpacker_free(msgpack_unpacker* mpac);
+
+static inline bool   msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size);
+static inline char*  msgpack_unpacker_buffer(msgpack_unpacker* mpac);
+static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac);
+static inline void   msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size);
+
+
+int msgpack_unpacker_execute(msgpack_unpacker* mpac);
+
+msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac);
+
+msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac);
+
+void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac);
+
+void msgpack_unpacker_reset(msgpack_unpacker* mpac);
+
+static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac);
+
+
+
+typedef enum {
+	MSGPACK_UNPACK_SUCCESS				=  2,
+	MSGPACK_UNPACK_EXTRA_BYTES			=  1,
+	MSGPACK_UNPACK_CONTINUE				=  0,
+	MSGPACK_UNPACK_PARSE_ERROR			= -1,
+} msgpack_unpack_return;
+
+msgpack_unpack_return
+msgpack_unpack(const char* data, size_t len, size_t* off,
+		msgpack_zone* z, msgpack_object* result);
+
+
+static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac);
+
+bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac);
+
+bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size);
+
+bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size)
+{
+	if(mpac->free >= size) { return true; }
+	return msgpack_unpacker_expand_buffer(mpac, size);
+}
+
+char* msgpack_unpacker_buffer(msgpack_unpacker* mpac)
+{
+	return mpac->buffer + mpac->used;
+}
+
+size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac)
+{
+	return mpac->free;
+}
+
+void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size)
+{
+	mpac->used += size;
+	mpac->free -= size;
+}
+
+size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac)
+{
+	return mpac->parsed - mpac->off + mpac->used;
+}
+
+size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac)
+{
+	return mpac->parsed;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/unpack.h */
+

cpp/src/msgpack/unpack.hpp

@@ -0,0 +1,383 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_UNPACK_HPP__
+#define MSGPACK_UNPACK_HPP__
+
+#include "msgpack/unpack.h"
+#include "msgpack/object.hpp"
+#include "msgpack/zone.hpp"
+#include <memory>
+#include <stdexcept>
+
+#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE
+#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE (32*1024)
+#endif
+
+namespace msgpack {
+
+
+struct unpack_error : public std::runtime_error {
+	unpack_error(const std::string& msg) :
+		std::runtime_error(msg) { }
+};
+
+
+class unpacked {
+public:
+	unpacked() { }
+
+	unpacked(object obj, std::auto_ptr<msgpack::zone> z) :
+		m_obj(obj), m_zone(z) { }
+
+	object& get()
+		{ return m_obj; }
+
+	const object& get() const
+		{ return m_obj; }
+
+	std::auto_ptr<msgpack::zone>& zone()
+		{ return m_zone; }
+
+	const std::auto_ptr<msgpack::zone>& zone() const
+		{ return m_zone; }
+
+private:
+	object m_obj;
+	std::auto_ptr<msgpack::zone> m_zone;
+};
+
+
+class unpacker : public msgpack_unpacker {
+public:
+	unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE);
+	~unpacker();
+
+public:
+	/*! 1. reserve buffer. at least `size' bytes of capacity will be ready */
+	void reserve_buffer(size_t size);
+
+	/*! 2. read data to the buffer() up to buffer_capacity() bytes */
+	char* buffer();
+	size_t buffer_capacity() const;
+
+	/*! 3. specify the number of bytes actually copied */
+	void buffer_consumed(size_t size);
+
+	/*! 4. repeat next() until it retunrs false */
+	bool next(unpacked* result);
+
+	/*! 5. check if the size of message doesn't exceed assumption. */
+	size_t message_size() const;
+
+	// Basic usage of the unpacker is as following:
+	//
+	// msgpack::unpacker pac;
+	// while( /* input is readable */ ) {
+	//
+	//     // 1.
+	//     pac.reserve_buffer(32*1024);
+	//
+	//     // 2.
+	//     size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity());
+	//
+	//     // error handling ...
+	//
+	//     // 3.
+	//     pac.buffer_consumed(bytes);
+	//
+	//     // 4.
+	//     msgpack::unpacked result;
+	//     while(pac.next(&result)) {
+	//         // do some with the object with the zone.
+	//         msgpack::object obj = result.get();
+	//         std::auto_ptr<msgpack:zone> z = result.zone();
+	//         on_message(obj, z);
+	//
+	//         //// boost::shared_ptr is also usable:
+	//         // boost::shared_ptr<msgpack::zone> life(z.release());
+	//         // on_message(result.get(), life);
+	//     }
+	//
+	//     // 5.
+	//     if(pac.message_size() > 10*1024*1024) {
+	//         throw std::runtime_error("message is too large");
+	//     }
+	// }
+	//
+
+	/*! for backward compatibility */
+	bool execute();
+
+	/*! for backward compatibility */
+	object data();
+
+	/*! for backward compatibility */
+	zone* release_zone();
+
+	/*! for backward compatibility */
+	void reset_zone();
+
+	/*! for backward compatibility */
+	void reset();
+
+public:
+	// These functions are usable when non-MessagePack message follows after
+	// MessagePack message.
+	size_t parsed_size() const;
+
+	/*! get address of the buffer that is not parsed */
+	char* nonparsed_buffer();
+	size_t nonparsed_size() const;
+
+	/*! skip specified size of non-parsed buffer, leaving the buffer */
+	// Note that the `size' argument must be smaller than nonparsed_size()
+	void skip_nonparsed_buffer(size_t size);
+
+	/*! remove unparsed buffer from unpacker */
+	// Note that reset() leaves non-parsed buffer.
+	void remove_nonparsed_buffer();
+
+private:
+	typedef msgpack_unpacker base;
+
+private:
+	unpacker(const unpacker&);
+};
+
+
+static bool unpack(unpacked* result,
+		const char* data, size_t len, size_t* offset = NULL);
+
+
+// obsolete
+typedef enum {
+	UNPACK_SUCCESS				=  2,
+	UNPACK_EXTRA_BYTES			=  1,
+	UNPACK_CONTINUE				=  0,
+	UNPACK_PARSE_ERROR			= -1,
+} unpack_return;
+
+// obsolete
+static unpack_return unpack(const char* data, size_t len, size_t* off,
+		zone* z, object* result);
+
+
+// obsolete
+static object unpack(const char* data, size_t len, zone& z, size_t* off = NULL);
+
+
+inline unpacker::unpacker(size_t initial_buffer_size)
+{
+	if(!msgpack_unpacker_init(this, initial_buffer_size)) {
+		throw std::bad_alloc();
+	}
+}
+
+inline unpacker::~unpacker()
+{
+	msgpack_unpacker_destroy(this);
+}
+
+
+inline void unpacker::reserve_buffer(size_t size)
+{
+	if(!msgpack_unpacker_reserve_buffer(this, size)) {
+		throw std::bad_alloc();
+	}
+}
+
+inline char* unpacker::buffer()
+{
+	return msgpack_unpacker_buffer(this);
+}
+
+inline size_t unpacker::buffer_capacity() const
+{
+	return msgpack_unpacker_buffer_capacity(this);
+}
+
+inline void unpacker::buffer_consumed(size_t size)
+{
+	return msgpack_unpacker_buffer_consumed(this, size);
+}
+
+inline bool unpacker::next(unpacked* result)
+{
+	int ret = msgpack_unpacker_execute(this);
+
+	if(ret < 0) {
+		throw unpack_error("parse error");
+	}
+
+	if(ret == 0) {
+		result->zone().reset();
+		result->get() = object();
+		return false;
+
+	} else {
+		result->zone().reset( release_zone() );
+		result->get() = data();
+		reset();
+		return true;
+	}
+}
+
+
+inline bool unpacker::execute()
+{
+	int ret = msgpack_unpacker_execute(this);
+	if(ret < 0) {
+		throw unpack_error("parse error");
+	} else if(ret == 0) {
+		return false;
+	} else {
+		return true;
+	}
+}
+
+inline object unpacker::data()
+{
+	return msgpack_unpacker_data(this);
+}
+
+inline zone* unpacker::release_zone()
+{
+	if(!msgpack_unpacker_flush_zone(this)) {
+		throw std::bad_alloc();
+	}
+
+	zone* r = new zone();
+
+	msgpack_zone old = *base::z;
+	*base::z = *r;
+	*static_cast<msgpack_zone*>(r) = old;
+
+	return r;
+}
+
+inline void unpacker::reset_zone()
+{
+	msgpack_unpacker_reset_zone(this);
+}
+
+inline void unpacker::reset()
+{
+	msgpack_unpacker_reset(this);
+}
+
+
+inline size_t unpacker::message_size() const
+{
+	return msgpack_unpacker_message_size(this);
+}
+
+inline size_t unpacker::parsed_size() const
+{
+	return msgpack_unpacker_parsed_size(this);
+}
+
+inline char* unpacker::nonparsed_buffer()
+{
+	return base::buffer + base::off;
+}
+
+inline size_t unpacker::nonparsed_size() const
+{
+	return base::used - base::off;
+}
+
+inline void unpacker::skip_nonparsed_buffer(size_t size)
+{
+	base::off += size;
+}
+
+inline void unpacker::remove_nonparsed_buffer()
+{
+	base::used = base::off;
+}
+
+
+inline bool unpack(unpacked* result,
+		const char* data, size_t len, size_t* offset)
+{
+	msgpack::object obj;
+	std::auto_ptr<msgpack::zone> z(new zone());
+
+	unpack_return ret = (unpack_return)msgpack_unpack(
+			data, len, offset, z.get(),
+			reinterpret_cast<msgpack_object*>(&obj));
+
+	switch(ret) {
+	case UNPACK_SUCCESS:
+		result->get() = obj;
+		result->zone() = z;
+		return false;
+
+	case UNPACK_EXTRA_BYTES:
+		result->get() = obj;
+		result->zone() = z;
+		return true;
+
+	case UNPACK_CONTINUE:
+		throw unpack_error("insufficient bytes");
+
+	case UNPACK_PARSE_ERROR:
+	default:
+		throw unpack_error("parse error");
+	}
+}
+
+
+// obsolete
+inline unpack_return unpack(const char* data, size_t len, size_t* off,
+		zone* z, object* result)
+{
+	return (unpack_return)msgpack_unpack(data, len, off,
+			z, reinterpret_cast<msgpack_object*>(result));
+}
+
+// obsolete
+inline object unpack(const char* data, size_t len, zone& z, size_t* off)
+{
+	object result;
+
+	switch( msgpack::unpack(data, len, off, &z, &result) ) {
+	case UNPACK_SUCCESS:
+		return result;
+
+	case UNPACK_EXTRA_BYTES:
+		if(off) {
+			return result;
+		} else {
+			throw unpack_error("extra bytes");
+		}
+
+	case UNPACK_CONTINUE:
+		throw unpack_error("insufficient bytes");
+
+	case UNPACK_PARSE_ERROR:
+	default:
+		throw unpack_error("parse error");
+	}
+}
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/unpack.hpp */
+

cpp/src/msgpack/vrefbuffer.h

@@ -0,0 +1,113 @@
+/*
+ * MessagePack for C zero-copy buffer implementation
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ *    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_VREFBUFFER_H__
+#define MSGPACK_VREFBUFFER_H__
+
+#include "msgpack/zone.h"
+
+#ifndef _WIN32
+#include <sys/uio.h>
+#else
+struct iovec {
+	void  *iov_base;
+	size_t iov_len;
+};
+#endif
+
+#ifndef MSGPACK_VREFBUFFER_REF_SIZE
+#define MSGPACK_VREFBUFFER_REF_SIZE 32
+#endif
+
+#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE
+#define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct msgpack_vrefbuffer_chunk;
+typedef struct msgpack_vrefbuffer_chunk msgpack_vrefbuffer_chunk;
+
+typedef struct msgpack_vrefbuffer_inner_buffer {
+	size_t free;
+	char*  ptr;
+	msgpack_vrefbuffer_chunk* head;
+} msgpack_vrefbuffer_inner_buffer;
+
+typedef struct msgpack_vrefbuffer {
+	struct iovec* tail;
+	struct iovec* end;
+	struct iovec* array;
+
+	size_t chunk_size;
+	size_t ref_size;
+
+	msgpack_vrefbuffer_inner_buffer inner_buffer;
+} msgpack_vrefbuffer;
+
+
+bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf,
+		size_t ref_size, size_t chunk_size);
+void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf);
+
+static inline int msgpack_vrefbuffer_write(void* data, const char* buf, unsigned int len);
+
+static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref);
+static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref);
+
+int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf,
+		const char* buf, unsigned int len);
+
+int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf,
+		const char* buf, unsigned int len);
+
+int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to);
+
+void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vref);
+
+
+int msgpack_vrefbuffer_write(void* data, const char* buf, unsigned int len)
+{
+	msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data;
+
+	if(len < vbuf->ref_size) {
+		return msgpack_vrefbuffer_append_copy(vbuf, buf, len);
+	} else {
+		return msgpack_vrefbuffer_append_ref(vbuf, buf, len);
+	}
+}
+
+const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref)
+{
+	return vref->array;
+}
+
+size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref)
+{
+	return vref->tail - vref->array;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/vrefbuffer.h */
+

cpp/src/msgpack/vrefbuffer.hpp

@@ -0,0 +1,97 @@
+//
+// MessagePack for C++ zero-copy buffer implementation
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_VREFBUFFER_HPP__
+#define MSGPACK_VREFBUFFER_HPP__
+
+#include "msgpack/vrefbuffer.h"
+#include <stdexcept>
+
+namespace msgpack {
+
+
+class vrefbuffer : public msgpack_vrefbuffer {
+public:
+	vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE,
+			size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE)
+	{
+		msgpack_vrefbuffer_init(this, ref_size, chunk_size);
+	}
+
+	~vrefbuffer()
+	{
+		msgpack_vrefbuffer_destroy(this);
+	}
+
+public:
+	void write(const char* buf, unsigned int len)
+	{
+		if(len < base::ref_size) {
+			append_copy(buf, len);
+		} else {
+			append_ref(buf, len);
+		}
+	}
+
+	void append_ref(const char* buf, size_t len)
+	{
+		if(msgpack_vrefbuffer_append_ref(this, buf, len) < 0) {
+			throw std::bad_alloc();
+		}
+	}
+
+	void append_copy(const char* buf, size_t len)
+	{
+		if(msgpack_vrefbuffer_append_copy(this, buf, len) < 0) {
+			throw std::bad_alloc();
+		}
+	}
+
+	const struct iovec* vector() const
+	{
+		return msgpack_vrefbuffer_vec(this);
+	}
+
+	size_t vector_size() const
+	{
+		return msgpack_vrefbuffer_veclen(this);
+	}
+
+	void migrate(vrefbuffer* to)
+	{
+		if(msgpack_vrefbuffer_migrate(this, to) < 0) {
+			throw std::bad_alloc();
+		}
+	}
+
+	void clear()
+	{
+		msgpack_vrefbuffer_clear(this);
+	}
+
+private:
+	typedef msgpack_vrefbuffer base;
+
+private:
+	vrefbuffer(const vrefbuffer&);
+};
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/vrefbuffer.hpp */
+

cpp/src/msgpack/zbuffer.h

@@ -0,0 +1,180 @@
+/*
+ * MessagePack for C deflate buffer implementation
+ *
+ * Copyright (C) 2010 FURUHASHI Sadayuki
+ *
+ *    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_ZBUFFER_H__
+#define MSGPACK_ZBUFFER_H__
+
+#include "msgpack/sysdep.h"
+#include <stdlib.h>
+#include <string.h>
+#include <zlib.h>
+
+#ifndef MSGPACK_ZBUFFER_INIT_SIZE
+#define MSGPACK_ZBUFFER_INIT_SIZE 8192
+#endif
+
+#ifndef MSGPACK_ZBUFFER_RESERVE_SIZE
+#define MSGPACK_ZBUFFER_RESERVE_SIZE 512
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct msgpack_zbuffer {
+	z_stream stream;
+	char* data;
+	size_t init_size;
+} msgpack_zbuffer;
+
+
+static inline bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf,
+		int level, size_t init_size);
+static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf);
+
+static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf);
+
+static inline const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf);
+static inline size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf);
+
+static inline bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf);
+static inline void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf);
+static inline char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf);
+
+
+static inline int msgpack_zbuffer_write(void* data, const char* buf, unsigned int len);
+
+static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf);
+
+
+bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf,
+		int level, size_t init_size)
+{
+	memset(zbuf, 0, sizeof(msgpack_zbuffer));
+	zbuf->init_size = init_size;
+	if(deflateInit(&zbuf->stream, level) != Z_OK) {
+		free(zbuf->data);
+		return false;
+	}
+	return true;
+}
+
+void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf)
+{
+	deflateEnd(&zbuf->stream);
+	free(zbuf->data);
+}
+
+bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf)
+{
+	size_t used = (char*)zbuf->stream.next_out - zbuf->data;
+	size_t csize = used + zbuf->stream.avail_out;
+	size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2;
+
+	char* tmp = (char*)realloc(zbuf->data, nsize);
+	if(tmp == NULL) {
+		return false;
+	}
+
+	zbuf->data = tmp;
+	zbuf->stream.next_out  = (Bytef*)(tmp + used);
+	zbuf->stream.avail_out = nsize - used;
+
+	return true;
+}
+
+int msgpack_zbuffer_write(void* data, const char* buf, unsigned int len)
+{
+	msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data;
+
+	zbuf->stream.next_in = (Bytef*)buf;
+	zbuf->stream.avail_in = len;
+
+	do {
+		if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
+			if(!msgpack_zbuffer_expand(zbuf)) {
+				return -1;
+			}
+		}
+
+		if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) {
+			return -1;
+		}
+	} while(zbuf->stream.avail_in > 0);
+
+	return 0;
+}
+
+char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf)
+{
+	while(true) {
+		switch(deflate(&zbuf->stream, Z_FINISH)) {
+		case Z_STREAM_END:
+			return zbuf->data;
+		case Z_OK:
+			if(!msgpack_zbuffer_expand(zbuf)) {
+				return NULL;
+			}
+			break;
+		default:
+			return NULL;
+		}
+	}
+}
+
+const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf)
+{
+	return zbuf->data;
+}
+
+size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf)
+{
+	return (char*)zbuf->stream.next_out - zbuf->data;
+}
+
+void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf)
+{
+	zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data;
+	zbuf->stream.next_out = (Bytef*)zbuf->data;
+}
+
+bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf)
+{
+	if(deflateReset(&zbuf->stream) != Z_OK) {
+		return false;
+	}
+	msgpack_zbuffer_reset_buffer(zbuf);
+	return true;
+}
+
+char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf)
+{
+	char* tmp = zbuf->data;
+	zbuf->data = NULL;
+	zbuf->stream.next_out = NULL;
+	zbuf->stream.avail_out = 0;
+	return tmp;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/zbuffer.h */
+

cpp/src/msgpack/zbuffer.hpp

@@ -0,0 +1,100 @@
+//
+// MessagePack for C++ deflate buffer implementation
+//
+// Copyright (C) 2010 FURUHASHI Sadayuki
+//
+//    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_ZBUFFER_HPP__
+#define MSGPACK_ZBUFFER_HPP__
+
+#include "msgpack/zbuffer.h"
+#include <stdexcept>
+
+namespace msgpack {
+
+
+class zbuffer : public msgpack_zbuffer {
+public:
+	zbuffer(int level = Z_DEFAULT_COMPRESSION,
+			size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE)
+	{
+		msgpack_zbuffer_init(this, level, init_size);
+	}
+
+	~zbuffer()
+	{
+		msgpack_zbuffer_destroy(this);
+	}
+
+public:
+	void write(const char* buf, unsigned int len)
+	{
+		if(msgpack_zbuffer_write(this, buf, len) < 0) {
+			throw std::bad_alloc();
+		}
+	}
+
+	char* flush()
+	{
+		char* buf = msgpack_zbuffer_flush(this);
+		if(!buf) {
+			throw std::bad_alloc();
+		}
+		return buf;
+	}
+
+	char* data()
+	{
+		return base::data;
+	}
+
+	const char* data() const
+	{
+		return base::data;
+	}
+
+	size_t size() const
+	{
+		return msgpack_zbuffer_size(this);
+	}
+
+	void reset()
+	{
+		if(!msgpack_zbuffer_reset(this)) {
+			throw std::bad_alloc();
+		}
+	}
+
+	void reset_buffer()
+	{
+		msgpack_zbuffer_reset_buffer(this);
+	}
+
+	char* release_buffer()
+	{
+		return msgpack_zbuffer_release_buffer(this);
+	}
+
+private:
+	typedef msgpack_zbuffer base;
+
+private:
+	zbuffer(const zbuffer&);
+};
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/zbuffer.hpp */
+

cpp/src/msgpack/zone.h

@@ -0,0 +1,131 @@
+/*
+ * MessagePack for C memory pool implementation
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ *    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_ZONE_H__
+#define MSGPACK_ZONE_H__
+
+#include "msgpack/sysdep.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct msgpack_zone_finalizer {
+	void (*func)(void* data);
+	void* data;
+} msgpack_zone_finalizer;
+
+typedef struct msgpack_zone_finalizer_array {
+	msgpack_zone_finalizer* tail;
+	msgpack_zone_finalizer* end;
+	msgpack_zone_finalizer* array;
+} msgpack_zone_finalizer_array;
+
+struct msgpack_zone_chunk;
+typedef struct msgpack_zone_chunk msgpack_zone_chunk;
+
+typedef struct msgpack_zone_chunk_list {
+	size_t free;
+	char* ptr;
+	msgpack_zone_chunk* head;
+} msgpack_zone_chunk_list;
+
+typedef struct msgpack_zone {
+	msgpack_zone_chunk_list chunk_list;
+	msgpack_zone_finalizer_array finalizer_array;
+	size_t chunk_size;
+} msgpack_zone;
+
+#ifndef MSGPACK_ZONE_CHUNK_SIZE
+#define MSGPACK_ZONE_CHUNK_SIZE 8192
+#endif
+
+bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size);
+void msgpack_zone_destroy(msgpack_zone* zone);
+
+msgpack_zone* msgpack_zone_new(size_t chunk_size);
+void msgpack_zone_free(msgpack_zone* zone);
+
+static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size);
+static inline void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size);
+
+static inline bool msgpack_zone_push_finalizer(msgpack_zone* zone,
+		void (*func)(void* data), void* data);
+
+bool msgpack_zone_is_empty(msgpack_zone* zone);
+
+void msgpack_zone_clear(msgpack_zone* zone);
+
+
+
+#ifndef MSGPACK_ZONE_ALIGN
+#define MSGPACK_ZONE_ALIGN sizeof(int)
+#endif
+
+void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size);
+
+void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size)
+{
+	msgpack_zone_chunk_list* cl = &zone->chunk_list;
+
+	if(zone->chunk_list.free < size) {
+		return msgpack_zone_malloc_expand(zone, size);
+	}
+
+	char* ptr = cl->ptr;
+	cl->free -= size;
+	cl->ptr  += size;
+
+	return ptr;
+}
+
+void* msgpack_zone_malloc(msgpack_zone* zone, size_t size)
+{
+	return msgpack_zone_malloc_no_align(zone,
+			((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1));
+}
+
+
+bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone,
+		void (*func)(void* data), void* data);
+
+bool msgpack_zone_push_finalizer(msgpack_zone* zone,
+		void (*func)(void* data), void* data)
+{
+	msgpack_zone_finalizer_array* const fa = &zone->finalizer_array;
+	msgpack_zone_finalizer* fin = fa->tail;
+
+	if(fin == fa->end) {
+		return msgpack_zone_push_finalizer_expand(zone, func, data);
+	}
+
+	fin->func = func;
+	fin->data = data;
+
+	++fa->tail;
+
+	return true;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/zone.h */
+

cpp/src/msgpack/zone.hpp.erb

@@ -0,0 +1,148 @@
+//
+// MessagePack for C++ memory pool
+//
+// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+//
+//    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_ZONE_HPP__
+#define MSGPACK_ZONE_HPP__
+
+#include "msgpack/zone.h"
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+<% GENERATION_LIMIT = 15 %>
+namespace msgpack {
+
+
+class zone : public msgpack_zone {
+public:
+	zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE);
+	~zone();
+
+public:
+	void* malloc(size_t size);
+	void* malloc_no_align(size_t size);
+
+	void push_finalizer(void (*func)(void*), void* data);
+
+	template <typename T>
+	void push_finalizer(std::auto_ptr<T> obj);
+
+	void clear();
+
+	<%0.upto(GENERATION_LIMIT) {|i|%>
+	template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+	T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>);
+	<%}%>
+
+private:
+	void undo_malloc(size_t size);
+
+	template <typename T>
+	static void object_destructor(void* obj);
+
+	typedef msgpack_zone base;
+
+private:
+	zone(const zone&);
+};
+
+
+
+inline zone::zone(size_t chunk_size)
+{
+	msgpack_zone_init(this, chunk_size);
+}
+
+inline zone::~zone()
+{
+	msgpack_zone_destroy(this);
+}
+
+inline void* zone::malloc(size_t size)
+{
+	void* ptr = msgpack_zone_malloc(this, size);
+	if(!ptr) {
+		throw std::bad_alloc();
+	}
+	return ptr;
+}
+
+inline void* zone::malloc_no_align(size_t size)
+{
+	void* ptr = msgpack_zone_malloc_no_align(this, size);
+	if(!ptr) {
+		throw std::bad_alloc();
+	}
+	return ptr;
+}
+
+inline void zone::push_finalizer(void (*func)(void*), void* data)
+{
+	if(!msgpack_zone_push_finalizer(this, func, data)) {
+		throw std::bad_alloc();
+	}
+}
+
+template <typename T>
+inline void zone::push_finalizer(std::auto_ptr<T> obj)
+{
+	if(!msgpack_zone_push_finalizer(this, &zone::object_destructor<T>, obj.get())) {
+		throw std::bad_alloc();
+	}
+	obj.release();
+}
+
+inline void zone::clear()
+{
+	msgpack_zone_clear(this);
+}
+
+template <typename T>
+void zone::object_destructor(void* obj)
+{
+	reinterpret_cast<T*>(obj)->~T();
+}
+
+inline void zone::undo_malloc(size_t size)
+{
+	base::chunk_list.ptr  -= size;
+	base::chunk_list.free += size;
+}
+
+<%0.upto(GENERATION_LIMIT) {|i|%>
+template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
+T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
+{
+	void* x = malloc(sizeof(T));
+	if(!msgpack_zone_push_finalizer(this, &zone::object_destructor<T>, x)) {
+		undo_malloc(sizeof(T));
+		throw std::bad_alloc();
+	}
+	try {
+		return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>);
+	} catch (...) {
+		--base::finalizer_array.tail;
+		undo_malloc(sizeof(T));
+		throw;
+	}
+}
+<%}%>
+
+}  // namespace msgpack
+
+#endif /* msgpack/zone.hpp */
+