cpp: update ChangeLog

wrong size checking on !defined(SIZEOF_SHORT) && !defined(SHRT_MAX)"

Makefile.am

@@ -1,13 +0,0 @@
-if ENABLE_CXX
-SUBDIRS = c cpp
-else
-SUBDIRS = c
-endif
-
-nobase_include_HEADERS = \
-		msgpack/pack_define.h \
-		msgpack/pack_template.h \
-		msgpack/unpack_define.h \
-		msgpack/unpack_template.h \
-		msgpack/sysdep.h
-

README

@@ -1,70 +0,0 @@
-MessagePack
------------
-Binary-based efficient data interchange format.
-
-
-*Requirements
-
-  MessagePack is only tested on Linux and Mac OS X, but it may run on other
-  UNIX-like platforms.
-
-  gcc >= 4.1 is required to build.
-
-
-*Installation
-
-  Simply run ./configure && make && make install to install C and C++ binding.
-
-    $ ./configure
-    $ make
-    $ sudo make install
-
-  To install Ruby binding, run ./gengem.sh script on ruby/ directory and install
-  generated gem package.
-
-    $ cd ruby
-    $ ./gengem.sh
-    $ gem install gem/pkg/msgpack-*.gem
-
-
-*Usage
-
-  C++:
-    include msgpack.hpp header and link libmsgpack library.
-    see example/simple.cc for example.
-
-      g++ simple.cc -lmsgpack
-      g++ stream.cc -lmsgpack -lpthread
-
-
-  C:
-    include msgpack.h   header and link libmsgpackc library.
-    see example/simple.c  for example.
-
-      gcc simple.c  -lmsgpackc
-
-
-  Ruby:
-    require msgpack library.
-    see example/simple.rb for example.
-
-	  ruby -rubygems simple.rb
-
-
-  API Document is available at http://msgpack.sourceforge.jp/.
-
-
-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.
-

README.md

@@ -0,0 +1,37 @@
+MessagePack
+===========
+Extremely efficient object serialization library. It's like JSON, but very fast and small.
+
+
+## What's MessagePack?
+
+MessagePack is a binary-based efficient object serialization library. It enables to exchange structured objects between many languages like JSON. But unlike JSON, it is very fast and small.
+
+Typical small integer (like flags or error code) is saved only in 1 byte, and typical short string only needs 1 byte except the length of the string itself. \[1,2,3\] (3 elements array) is serialized in 4 bytes using MessagePack as follows:
+
+    require 'msgpack'
+    msg = [1,2,3].to_msgpack  #=> "\x93\x01\x02\x03"
+    MessagePack.unpack(msg)   #=> [1,2,3]
+
+
+## Performance
+
+![Serialization + Deserialization Speed Test](http://msgpack.sourceforge.net/index/speedtest.png)
+
+In this test, it measured the elapsed time of serializing and deserializing 200,000 target objects. The target object consists of the three integers and 512 bytes string.
+The source code of this test is available from [frsyuki' serializer-speed-test repository.](http://github.com/frsyuki/serializer-speed-test)
+
+
+## Getting Started
+
+Usage and other documents about implementations in each language are found at [the web site.](http://msgpack.sourceforge.net/)
+
+
+## Learn More
+
+  - [Project Web Site](http://msgpack.sourceforge.net/)
+  - [MessagePack format specification](http://msgpack.sourceforge.net/spec)
+  - [Repository at github](http://github.com/msgpack/msgpack)
+  - [Wiki](http://msgpack.sourceforge.net/start)
+  - [MessagePack-RPC](http://github.com/msgpack/msgpack-rpc)
+

c/Makefile.am

@@ -1,28 +0,0 @@
-lib_LTLIBRARIES = libmsgpackc.la
-
-libmsgpackc_la_SOURCES = \
-		unpack.c \
-		object.c \
-		vrefbuffer.c \
-		zone.c
-
-nobase_include_HEADERS = \
-		msgpack.h \
-		msgpack/sbuffer.h \
-		msgpack/vrefbuffer.h \
-		msgpack/pack.h \
-		msgpack/unpack.h \
-		msgpack/object.h \
-		msgpack/zone.h
-
-# -version-info CURRENT:REVISION:AGE
-libmsgpackc_la_LDFLAGS = -version-info 2:0:0
-
-check_PROGRAMS = \
-  msgpackc_test
-
-msgpackc_test_SOURCES = test.cpp
-msgpackc_test_CXXFLAGS = -I$(top_srcdir) -I$(top_srcdir)/c
-msgpackc_test_LDFLAGS = libmsgpackc.la -lgtest_main
-
-TESTS = $(check_PROGRAMS)

c/bench.c

@@ -1,323 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/time.h>
-
-#include <msgpack/pack.h>
-#include <msgpack/unpack.h>
-#include <yajl/yajl_parse.h>
-#include <yajl/yajl_gen.h>
-
-
-static struct timeval g_timer;
-
-void reset_timer()
-{
-	gettimeofday(&g_timer, NULL);
-}
-
-void show_timer(size_t bufsz)
-{
-	struct timeval endtime;
-	gettimeofday(&endtime, NULL);
-	double sec = (endtime.tv_sec - g_timer.tv_sec)
-		+ (double)(endtime.tv_usec - g_timer.tv_usec) / 1000 / 1000;
-	printf("%f sec\n", sec);
-	printf("%f MB\n", ((double)bufsz)/1024/1024);
-	printf("%f Mbps\n", ((double)bufsz)*8/sec/1000/1000);
-}
-
-
-static int reformat_null(void * ctx) { return 1; }
-static int reformat_boolean(void * ctx, int boolean) { return 1; }
-static int reformat_number(void * ctx, const char * s, unsigned int l) { return 1; }
-static int reformat_string(void * ctx, const unsigned char * stringVal, unsigned int stringLen) { return 1; }
-static int reformat_map_key(void * ctx, const unsigned char * stringVal, unsigned int stringLen) { return 1; }
-static int reformat_start_map(void * ctx) { return 1; }
-static int reformat_end_map(void * ctx) { return 1; }
-static int reformat_start_array(void * ctx) { return 1; }
-static int reformat_end_array(void * ctx) { return 1; }
-
-
-static void* unpack_uint8(void* data, uint8_t d) { return NULL; }
-static void* unpack_uint16(void* data, uint16_t d) { return NULL; }
-static void* unpack_uint32(void* data, uint32_t d) { return NULL; }
-static void* unpack_uint64(void* data, uint64_t d) { return NULL; }
-static void* unpack_int8(void* data, int8_t d) { return NULL; }
-static void* unpack_int16(void* data, int16_t d) { return NULL; }
-static void* unpack_int32(void* data, int32_t d) { return NULL; }
-static void* unpack_int64(void* data, int64_t d) { return NULL; }
-static void* unpack_float(void* data, float d) { return NULL; }
-static void* unpack_double(void* data, double d) { return NULL; }
-static void* unpack_nil(void* data) { return NULL; }
-static void* unpack_true(void* data) { return NULL; }
-static void* unpack_false(void* data) { return NULL; }
-static void* unpack_array(void* data, unsigned int n) { return NULL; }
-static void unpack_array_item(void* data, void* c, void* o) { }
-static void* unpack_map(void* data, unsigned int n) { return NULL; }
-static void unpack_map_item(void* data, void* c, void* k, void* v) { }
-static void* unpack_raw(void* data, const char* b, const char* p, unsigned int l) { /*printf("unpack raw %p %lu\n",p,l);*/ return NULL; }
-
-
-typedef struct {
-	size_t allocated;
-	size_t length;
-	char* buffer;
-} pack_buffer;
-
-static const size_t PACK_INITIAL_BUFFER_SIZE = 32*1024;
-
-static void pack_buffer_init(pack_buffer* data)
-{
-	data->buffer = malloc(PACK_INITIAL_BUFFER_SIZE);
-	data->length = 0;
-	data->allocated = PACK_INITIAL_BUFFER_SIZE;
-}
-
-static void pack_buffer_reset(pack_buffer* data)
-{
-	data->buffer = realloc(data->buffer, PACK_INITIAL_BUFFER_SIZE);
-	data->allocated = PACK_INITIAL_BUFFER_SIZE;
-	data->length = 0;
-}
-
-static void pack_buffer_free(pack_buffer* data)
-{
-	free(data->buffer);
-}
-
-static void pack_append_buffer(void* user, const char* b, unsigned int l)
-{
-	pack_buffer* data = (pack_buffer*)user;
-	if(data->allocated - data->length < l) {
-		data->buffer = realloc(data->buffer, data->allocated*2);
-		data->allocated *= 2;
-	}
-	memcpy(data->buffer + data->length, b, l);
-	data->length += l;
-}
-
-
-static const unsigned int TASK_INT_NUM = 1<<24;
-static const unsigned int TASK_STR_LEN = 1<<15;
-//static const unsigned int TASK_INT_NUM = 1<<20;
-//static const unsigned int TASK_STR_LEN = 1<<12;
-static const char* TASK_STR_PTR;
-
-
-void bench_json(void)
-{
-	puts("== JSON ==");
-
-
-	yajl_gen_config gcfg = {0, NULL};
-	yajl_gen g = yajl_gen_alloc(&gcfg);
-
-	yajl_parser_config hcfg = { 0, 0 };
-	yajl_callbacks callbacks = {
-	    reformat_null,
-	    reformat_boolean,
-	    NULL,
-	    NULL,
-	    reformat_number,
-		reformat_string,
-	    reformat_start_map,
-	    reformat_map_key,
-	    reformat_end_map,
-	    reformat_start_array,
-	    reformat_end_array
-	};
-	yajl_handle h = yajl_alloc(&callbacks, &hcfg, NULL);
-
-
-	const unsigned char * buf;
-	unsigned int len;
-
-
-	puts("generate integer");
-	reset_timer();
-	{
-		unsigned int i;
-		yajl_gen_array_open(g);
-		for(i=0; i < TASK_INT_NUM; ++i) {
-			yajl_gen_integer(g, i);
-		}
-		yajl_gen_array_close(g);
-	}
-	show_timer(len);
-
-	yajl_gen_get_buf(g, &buf, &len);
-
-	puts("----");
-	puts("parse integer");
-	reset_timer();
-	{
-		yajl_status stat = yajl_parse(h, buf, len);
-		if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
-			unsigned char * str = yajl_get_error(h, 1, buf, len);
-			fprintf(stderr, (const char *) str);
-		}
-	}
-	show_timer(len);
-
-
-	//yajl_gen_clear(g);
-	yajl_gen_free(g);
-	g = yajl_gen_alloc(&gcfg);
-	yajl_free(h);
-	h = yajl_alloc(&callbacks, &hcfg, NULL);
-
-
-	puts("----");
-	puts("generate string");
-	reset_timer();
-	{
-		unsigned int i;
-		yajl_gen_array_open(g);
-		for(i=0; i < TASK_STR_LEN; ++i) {
-			yajl_gen_string(g, (const unsigned char*)TASK_STR_PTR, i);
-		}
-		yajl_gen_array_close(g);
-	}
-	show_timer(len);
-
-	yajl_gen_get_buf(g, &buf, &len);
-
-	puts("----");
-	puts("parse string");
-	reset_timer();
-	{
-		yajl_status stat = yajl_parse(h, buf, len);
-		if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
-			unsigned char * str = yajl_get_error(h, 1, buf, len);
-			fprintf(stderr, (const char *) str);
-		}
-	}
-	show_timer(len);
-
-
-	yajl_gen_free(g);
-	yajl_free(h);
-}
-
-
-void bench_msgpack(void)
-{
-	puts("== MessagePack ==");
-
-
-	pack_buffer mpkbuf;
-	pack_buffer_init(&mpkbuf);
-
-	msgpack_pack_t* mpk = msgpack_pack_new(
-			&mpkbuf, pack_append_buffer);
-
-	msgpack_unpack_callback cb = {
-		unpack_uint8,
-		unpack_uint16,
-		unpack_uint32,
-		unpack_uint64,
-		unpack_int8,
-		unpack_int16,
-		unpack_int32,
-		unpack_int64,
-		unpack_float,
-		unpack_double,
-		unpack_nil,
-		unpack_true,
-		unpack_false,
-		unpack_array,
-		unpack_array_item,
-		unpack_map,
-		unpack_map_item,
-		unpack_raw,
-	};
-	msgpack_unpack_t* mupk = msgpack_unpack_new(NULL, &cb);
-
-
-	size_t len;
-	const char* buf;
-
-
-	puts("pack integer");
-	reset_timer();
-	{
-		unsigned int i;
-		msgpack_pack_array(mpk, TASK_INT_NUM);
-		for(i=0; i < TASK_INT_NUM; ++i) {
-			msgpack_pack_unsigned_int(mpk, i);
-		}
-	}
-	show_timer(mpkbuf.length);
-
-	len = mpkbuf.length;
-	buf = mpkbuf.buffer;
-
-	puts("----");
-	puts("unpack integer");
-	reset_timer();
-	{
-		size_t off = 0;
-		int ret = msgpack_unpack_execute(mupk, buf, len, &off);
-		if(ret < 0) {
-			fprintf(stderr, "Parse error.\n");
-		} else if(ret == 0) {
-			fprintf(stderr, "Not finished.\n");
-		}
-	}
-	show_timer(mpkbuf.length);
-
-
-	pack_buffer_reset(&mpkbuf);
-	msgpack_unpack_reset(mupk);
-
-
-	puts("----");
-	puts("pack string");
-	reset_timer();
-	{
-		unsigned int i;
-		msgpack_pack_array(mpk, TASK_STR_LEN);
-		for(i=0; i < TASK_STR_LEN; ++i) {
-			msgpack_pack_raw(mpk, i);
-			msgpack_pack_raw_body(mpk, TASK_STR_PTR, i);
-		}
-	}
-	show_timer(mpkbuf.length);
-
-	len = mpkbuf.length;
-	buf = mpkbuf.buffer;
-
-	puts("----");
-	puts("unpack string");
-	reset_timer();
-	{
-		size_t off = 0;
-		int ret = msgpack_unpack_execute(mupk, buf, len, &off);
-		if(ret < 0) {
-			fprintf(stderr, "Parse error.\n");
-		} else if(ret == 0) {
-			fprintf(stderr, "Not finished.\n");
-		}
-	}
-	show_timer(mpkbuf.length);
-
-
-	msgpack_unpack_free(mupk);
-	msgpack_pack_free(mpk);
-	pack_buffer_free(&mpkbuf);
-}
-
-int main(int argc, char* argv[])
-{
-	char* str = malloc(TASK_STR_LEN);
-	memset(str, 'a', TASK_STR_LEN);
-	TASK_STR_PTR = str;
-
-	bench_msgpack();
-	bench_json();
-
-	return 0;
-}
-
-

c/bench.mk

@@ -1,9 +0,0 @@
-
-CFLAGS  += -Wall -g -I. -I.. -O4
-LDFLAGS += -lyajl
-
-all: bench
-
-bench: bench.o pack.o unpack.o pack.h unpack.h
-	$(CC) bench.o pack.o unpack.o $(CFLAGS) $(LDFLAGS) -o $@
-

c/msgpack

@@ -1 +0,0 @@
-.

configure.in

@@ -1,59 +0,0 @@
-AC_INIT(msgpack/unpack_template.h)
-AC_CONFIG_AUX_DIR(ac)
-AM_INIT_AUTOMAKE(msgpack, 0.4.1)
-AC_CONFIG_HEADER(config.h)
-
-AC_SUBST(CFLAGS)
-if test "" = "$CFLAGS"; then
-	CFLAGS="-g -O4"
-fi
-
-AC_PROG_CC
-
-CFLAGS="-O4 -Wall $CFLAGS -I.."
-
-AC_MSG_CHECKING([if c++ api is enabled])
-AC_ARG_ENABLE(cxx,
-	AS_HELP_STRING([--disable-cxx],
-				   [don't build c++ api.]) )
-AC_MSG_RESULT($enable_cxx)
-if test "$enable_cxx" != "no"; then
-	AC_SUBST(CXXFLAGS)
-	if test "" = "$CXXFLAGS"; then
-		CXXFLAGS="-g -O4"
-	fi
-fi
-
-# FIXME enable_cxx
-AC_PROG_CXX
-
-CXXFLAGS="-O4 -Wall $CXXFLAGS -I.. -I../c"
-
-# FIXME enable_cxx
-AC_LANG_PUSH([C++])
-AC_CHECK_HEADERS(tr1/unordered_map)
-AC_CHECK_HEADERS(tr1/unordered_set)
-AC_LANG_POP([C++])
-
-AC_CACHE_CHECK([for __sync_* atomic operations], msgpack_cv_atomic_ops, [
-    AC_TRY_LINK([
-        int atomic_sub(int i) { return __sync_sub_and_fetch(&i, 1); }
-        int atomic_add(int i) { return __sync_add_and_fetch(&i, 1); }
-    ], [], msgpack_cv_atomic_ops="yes")
-    ])
-if test "$msgpack_cv_atomic_ops" != "yes"; then
-    AC_MSG_ERROR([__sync_* atomic operations are not supported.
-Note that gcc < 4.1 is not supported.
-If you are using gcc-4.1 and the CPU architecture is x86, try to add
-CFLAGS"--march=i686" and CXXFLAGS="-march=i668" options to ./configure as follows:
-
-  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
-])
-fi
-
-AM_CONDITIONAL(ENABLE_CXX, test "$enable_cxx" != "no")
-
-AC_PROG_LIBTOOL
-
-AC_OUTPUT([Makefile c/Makefile cpp/Makefile])
-

cpp/COPYING

@@ -1,4 +1,4 @@
-Copyright (C) 2008-2009 FURUHASHI Sadayuki
+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.

cpp/ChangeLog

@@ -0,0 +1,10 @@
+
+2010-04-29 version 0.5.0:
+
+  * msgpack_object_type is changed. MSGPACK_OBJECT_NIL is now 0x00.
+  * New safe streaming deserializer API.
+  * Add object::object(const T&) and object::operator=(const T&)
+  * Add operator==(object, const T&)
+  * MSGPACK_DEFINE macro defines msgpack_object(object* obj, zone* z)
+  * C++ programs doesn't need to link "msgpackc" library.
+

cpp/Makefile.am

@@ -1,12 +1,51 @@
+
 lib_LTLIBRARIES = libmsgpack.la
 
 libmsgpack_la_SOURCES = \
+		unpack.c \
+		objectc.c \
+		vrefbuffer.c \
+		zone.c \
 		object.cpp
 
+# -version-info CURRENT:REVISION:AGE
+libmsgpack_la_LDFLAGS = -version-info 3:0:0
+
+
+# backward compatibility
+lib_LTLIBRARIES += libmsgpackc.la
+
+libmsgpackc_la_SOURCES = \
+		unpack.c \
+		objectc.c \
+		vrefbuffer.c \
+		zone.c
+
+libmsgpackc_la_LDFLAGS = -version-info 2:0:0
+
+# work around for duplicated file name
+kumo_manager_CFLAGS = $(AM_CFLAGS)
+kumo_manager_CXXFLAGS = $(AM_CXXFLAGS)
+
+
 nobase_include_HEADERS = \
+		msgpack/pack_define.h \
+		msgpack/pack_template.h \
+		msgpack/unpack_define.h \
+		msgpack/unpack_template.h \
+		msgpack/sysdep.h \
+		msgpack.h \
+		msgpack/sbuffer.h \
+		msgpack/vrefbuffer.h \
+		msgpack/zbuffer.h \
+		msgpack/pack.h \
+		msgpack/unpack.h \
+		msgpack/object.h \
+		msgpack/zone.h \
 		msgpack.hpp \
 		msgpack/sbuffer.hpp \
 		msgpack/vrefbuffer.hpp \
+		msgpack/zbuffer.hpp \
 		msgpack/pack.hpp \
 		msgpack/unpack.hpp \
 		msgpack/object.hpp \
@@ -29,16 +68,26 @@ nobase_include_HEADERS = \
 		msgpack/type/tr1/unordered_map.hpp \
 		msgpack/type/tr1/unordered_set.hpp
 
-libmsgpack_la_LIBADD = -L../c -lmsgpackc
 
-# -version-info CURRENT:REVISION:AGE
-libmsgpack_la_LDFLAGS = -version-info 2:0:0
+EXTRA_DIST = \
+		README.md \
+		LICENSE \
+		NOTICE \
+		msgpack_vc8.vcproj \
+		msgpack_vc8.sln \
+		msgpack_vc8.postbuild.bat
+
+SUBDIRS = test
 
 check_PROGRAMS = \
-  msgpack_test
+		msgpackc_test \
+		msgpack_test
 
-msgpack_test_SOURCES = test.cpp
-msgpack_test_CXXFLAGS = -I$(top_srcdir) -I$(top_srcdir)/c -I$(top_srcdir)/cpp
-msgpack_test_LDFLAGS = libmsgpack.la -lgtest_main
+msgpackc_test_SOURCES = msgpackc_test.cpp
+msgpackc_test_LDADD = libmsgpack.la -lgtest_main
+
+msgpack_test_SOURCES = msgpack_test.cpp
+msgpack_test_LDADD = libmsgpack.la -lgtest_main
 
 TESTS = $(check_PROGRAMS)
+

cpp/README.md

@@ -0,0 +1,78 @@
+MessagePack for C/C++
+=====================
+Binary-based efficient object serialization library.
+
+
+## Installation
+
+Download latest package from [releases of MessagePack](http://sourceforge.net/projects/msgpack/files/) and extract it.
+
+On UNIX-like platform, run ./configure && make && sudo make install:
+
+    $ ./configure
+    $ make
+    $ sudo make install
+
+On Windows, open msgpack_vc8.vcproj file and build it using batch build. DLLs are built on lib folder, and the headers are built on include folder.
+
+To use the library in your program, include msgpack.hpp header and link msgpack and msgpackc library.
+
+
+## Example
+
+    #include <msgpack.hpp>
+    #include <vector>
+    
+    int main(void) {
+        // This is target object.
+        std::vector<std::string> target;
+        target.push_back("Hello,");
+        target.push_back("World!");
+    
+        // Serialize it.
+        msgpack::sbuffer buffer;  // simple buffer
+        msgpack::pack(&buffer, target);
+    
+        // Deserialize the serialized data.
+        msgpack::zone mempool;    // this manages the life of deserialized object
+        msgpack::object obj;
+        msgpack::unpack_return ret =
+                msgpack::unpack(buffer.data, buffer.size, NULL, &mempool, &obj);
+    
+        if(ret != msgapck::UNPACK_SUCCESS) {
+            // error check
+            exit(1);
+        }
+    
+        // Print the deserialized object to stdout.
+        std::cout << obj << std::endl;    // ["Hello," "World!"]
+    
+        // Convert the deserialized object to staticaly typed object.
+        std::vector<std::string> result;
+        obj.convert(&result);
+    
+        // If the type is mismatched, it throws msgpack::type_error.
+        obj.as<int>();  // type is mismatched, msgpack::type_error is thrown
+    }
+
+API document and other example codes are available at the [wiki.](http://msgpack.sourceforge.net/start)
+
+
+## License
+
+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.
+
+See also NOTICE file.
+

cpp/bench.cpp

@@ -1,188 +0,0 @@
-#include <msgpack/unpack.hpp>
-#include <msgpack/pack.hpp>
-#include <string.h>
-#include <sys/time.h>
-#include <iostream>
-#include <stdexcept>
-#include <string>
-
-static const unsigned int TASK_INT_NUM = 1<<24;
-static const unsigned int TASK_STR_LEN = 1<<15;
-//static const unsigned int TASK_INT_NUM = 1<<22;
-//static const unsigned int TASK_STR_LEN = 1<<13;
-static const char* TASK_STR_PTR;
-
-
-class simple_timer {
-public:
-	void reset() { gettimeofday(&m_timeval, NULL); }
-	void show_stat(size_t bufsz)
-	{
-		struct timeval endtime;
-		gettimeofday(&endtime, NULL);
-		double sec = (endtime.tv_sec - m_timeval.tv_sec)
-			+ (double)(endtime.tv_usec - m_timeval.tv_usec) / 1000 / 1000;
-		std::cout << sec << " sec" << std::endl;
-		std::cout << (double(bufsz)/1024/1024) << " MB" << std::endl;
-		std::cout << (bufsz/sec/1000/1000*8) << " Mbps" << std::endl;
-	}
-private:
-	timeval m_timeval;
-};
-
-
-class simple_buffer {
-public:
-	static const size_t DEFAULT_INITIAL_SIZE = 32*1024;//512*1024*1024*2;
-
-	simple_buffer(size_t initial_size = DEFAULT_INITIAL_SIZE) :
-		m_storage((char*)malloc(initial_size)),
-		m_allocated(initial_size),
-		m_used(0)
-	{
-		if(!m_storage) { throw std::bad_alloc(); }
-	}
-
-	~simple_buffer()
-	{
-		free(m_storage);
-	}
-
-public:
-	inline void write(const char* buf, size_t len)
-	{
-		if(m_allocated - m_used < len) {
-			expand_buffer(len);
-		}
-		memcpy(m_storage + m_used, buf, len);
-		m_used += len;
-	}
-
-	void clear()
-	{
-		m_used = 0;
-	}
-
-private:
-	void expand_buffer(size_t req)
-	{
-		size_t nsize = m_allocated * 2;
-		size_t at_least = m_used + req;
-		while(nsize < at_least) { nsize *= 2; }
-		char* tmp = (char*)realloc(m_storage, nsize);
-		if(!tmp) { throw std::bad_alloc(); }
-		m_storage = tmp;
-		m_allocated = nsize;
-	}
-
-public:
-	size_t size() const { return m_used; }
-	const char* data() const { return m_storage; }
-
-private:
-	char* m_storage;
-	size_t m_allocated;
-	size_t m_used;
-};
-
-
-void bench_msgpack_int()
-{
-	simple_buffer buf;
-	simple_timer timer;
-
-	std::cout << "----" << std::endl;
-	std::cout << "pack integer" << std::endl;
-
-	timer.reset();
-	{
-		msgpack::packer<simple_buffer> pk(buf);
-		pk.pack_array(TASK_INT_NUM);
-		for(unsigned int i=0; i < TASK_INT_NUM; ++i) {
-			pk.pack_unsigned_int(i);
-		}
-	}
-	timer.show_stat(buf.size());
-
-
-	std::cout << "----" << std::endl;
-	std::cout << "unpack integer" << std::endl;
-
-	msgpack::zone z;
-	msgpack::object obj;
-
-	timer.reset();
-	{
-		obj = msgpack::unpack(buf.data(), buf.size(), z);
-	}
-	timer.show_stat(buf.size());
-
-	/*
-	std::cout << "----" << std::endl;
-	std::cout << "dynamic pack integer" << std::endl;
-
-	buf.clear();
-
-	timer.reset();
-	msgpack::pack(buf, obj);
-	timer.show_stat(buf.size());
-	*/
-}
-
-void bench_msgpack_str()
-{
-	simple_buffer buf;
-	simple_timer timer;
-
-	std::cout << "----" << std::endl;
-	std::cout << "pack string" << std::endl;
-
-	timer.reset();
-	{
-		msgpack::packer<simple_buffer> pk(buf);
-		pk.pack_array(TASK_STR_LEN);
-		for(unsigned int i=0; i < TASK_STR_LEN; ++i) {
-			pk.pack_raw(i);
-			pk.pack_raw_body(TASK_STR_PTR, i);
-		}
-	}
-	timer.show_stat(buf.size());
-
-
-	std::cout << "----" << std::endl;
-	std::cout << "unpack string" << std::endl;
-
-	msgpack::zone z;
-	msgpack::object obj;
-
-	timer.reset();
-	{
-		obj = msgpack::unpack(buf.data(), buf.size(), z);
-	}
-	timer.show_stat(buf.size());
-
-
-	/*
-	std::cout << "----" << std::endl;
-	std::cout << "dynamic pack string" << std::endl;
-
-	buf.clear();
-
-	timer.reset();
-	msgpack::pack(buf, obj);
-	timer.show_stat(buf.size());
-	*/
-}
-
-int main(void)
-{
-	char* str = (char*)malloc(TASK_STR_LEN);
-	memset(str, 'a', TASK_STR_LEN);
-	TASK_STR_PTR = str;
-
-	bench_msgpack_int();
-	bench_msgpack_str();
-
-	return 0;
-}
-

cpp/bench.mk

@@ -1,9 +0,0 @@
-
-CXXFLAGS  += -Wall -g -I. -I.. -O4
-LDFLAGS +=
-
-all: bench
-
-bench: bench.o unpack.o zone.o object.o pack.hpp unpack.hpp zone.hpp object.hpp
-	$(CXX) bench.o unpack.o zone.o object.o $(CXXFLAGS) $(LDFLAGS) -o $@
-

cpp/bootstrap

@@ -32,7 +32,16 @@ fi
 
 
 mkdir -p ac
-(cd cpp && ./preprocess.sh $@; cd ..)
+test -f AUTHORS   || touch AUTHORS
+test -f COPYING   || touch COPYING
+test -f ChangeLog || touch ChangeLog
+test -f NEWS      || touch NEWS
+test -f README    || cp -f README.md README
+
+if ! ./preprocess; then
+	exit 1
+fi
+
 
 
 ACLOCAL="aclocal"

cpp/configure.in

@@ -0,0 +1,43 @@
+AC_INIT(object.cpp)
+AC_CONFIG_AUX_DIR(ac)
+AM_INIT_AUTOMAKE(msgpack, 0.5.0)
+AC_CONFIG_HEADER(config.h)
+
+AC_SUBST(CFLAGS)
+CFLAGS="-O4 -Wall $CFLAGS"
+
+AC_SUBST(CXXFLAGS)
+CXXFLAGS="-O4 -Wall $CXXFLAGS"
+
+AC_PROG_CC
+AC_PROG_CXX
+
+AC_PROG_LIBTOOL
+AM_PROG_AS
+AM_PROG_CC_C_O
+
+AC_LANG_PUSH([C++])
+AC_CHECK_HEADERS(tr1/unordered_map)
+AC_CHECK_HEADERS(tr1/unordered_set)
+AC_LANG_POP([C++])
+
+AC_CACHE_CHECK([for __sync_* atomic operations], msgpack_cv_atomic_ops, [
+	AC_TRY_LINK([
+		int atomic_sub(int i) { return __sync_sub_and_fetch(&i, 1); }
+		int atomic_add(int i) { return __sync_add_and_fetch(&i, 1); }
+	], [], msgpack_cv_atomic_ops="yes")
+	])
+if test "$msgpack_cv_atomic_ops" != "yes"; then
+	AC_MSG_ERROR([__sync_* atomic operations are not supported.
+
+Note that gcc < 4.1 is not supported.
+
+If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
+add CFLAGS="--march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
+
+  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
+])
+fi
+
+AC_OUTPUT([Makefile test/Makefile])
+

cpp/msgpack

@@ -1 +0,0 @@
-.

cpp/msgpack/object.h

@@ -19,7 +19,6 @@
 #define MSGPACK_OBJECT_H__
 
 #include "msgpack/zone.h"
-#include "msgpack/sysdep.h"
 #include <stdio.h>
 
 #ifdef __cplusplus
@@ -28,14 +27,14 @@ extern "C" {
 
 
 typedef enum {
-	MSGPACK_OBJECT_NIL					= 0x01,
-	MSGPACK_OBJECT_BOOLEAN				= 0x02,
-	MSGPACK_OBJECT_POSITIVE_INTEGER		= 0x03,
-	MSGPACK_OBJECT_NEGATIVE_INTEGER		= 0x04,
-	MSGPACK_OBJECT_DOUBLE				= 0x05,
-	MSGPACK_OBJECT_RAW					= 0x06,
-	MSGPACK_OBJECT_ARRAY				= 0x07,
-	MSGPACK_OBJECT_MAP					= 0x08,
+	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;
 
 
@@ -80,6 +79,8 @@ typedef struct 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
 }

cpp/msgpack/object.hpp

@@ -20,6 +20,7 @@
 
 #include "msgpack/object.h"
 #include "msgpack/pack.hpp"
+#include "msgpack/zone.hpp"
 #include <string.h>
 #include <stdexcept>
 #include <typeinfo>
@@ -34,14 +35,14 @@ class type_error : public std::bad_cast { };
 
 namespace type {
 	enum object_type {
-		NIL					= 0x01,
-		BOOLEAN				= 0x02,
-		POSITIVE_INTEGER	= 0x03,
-		NEGATIVE_INTEGER	= 0x04,
-		DOUBLE				= 0x05,
-		RAW					= 0x06,
-		ARRAY				= 0x07,
-		MAP					= 0x08,
+		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,
 	};
 }
 
@@ -88,8 +89,21 @@ struct object {
 	void convert(T* v) const;
 
 	object();
-	object(msgpack_object obj);
-	operator msgpack_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;
@@ -103,18 +117,44 @@ struct object_kv {
 	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) { }
@@ -179,26 +219,40 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const T& v)
 	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; }
 
-inline object::object() { }
+template <typename T>
+inline bool operator!=(const object x, const T& y)
+{ return !(x == y); }
 
-inline object::object(msgpack_object obj)
-{
-	// FIXME beter way?
-	::memcpy(this, &obj, sizeof(obj));
-}
-
-inline object::operator msgpack_object()
-{
-	// FIXME beter way?
-	msgpack_object obj;
-	::memcpy(&obj, this, sizeof(obj));
-	return obj;
-}
+template <typename T>
+inline bool operator!=(const T& y, const object x)
+{ return x != y; }
 
 
 inline object::implicit_type object::convert() const
@@ -221,6 +275,55 @@ inline T object::as() const
 }
 
 
+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)
@@ -260,35 +363,15 @@ packer<Stream>& operator<< (packer<Stream>& o, const object& v)
 		return o;
 
 	case type::POSITIVE_INTEGER:
-		if(v.via.u64 <= (uint64_t)std::numeric_limits<uint16_t>::max()) {
-			if(v.via.u64 <= (uint16_t)std::numeric_limits<uint8_t>::max()) {
-				o.pack_uint8(v.via.u64);
-			} else {
-				o.pack_uint16(v.via.u64);
-			}
-		} else {
-			if(v.via.u64 <= (uint64_t)std::numeric_limits<uint32_t>::max()) {
-				o.pack_uint32(v.via.u64);
-			} else {
-				o.pack_uint64(v.via.u64);
-			}
-		}
+		o.pack_uint64(v.via.u64);
 		return o;
 
 	case type::NEGATIVE_INTEGER:
-		if(v.via.i64 >= (int64_t)std::numeric_limits<int16_t>::min()) {
-			if(v.via.i64 >= (int64_t)std::numeric_limits<int8_t>::min()) {
-				o.pack_int8(v.via.i64);
-			} else {
-				o.pack_int16(v.via.i64);
-			}
-		} else {
-			if(v.via.i64 >= (int64_t)std::numeric_limits<int32_t>::min()) {
-				o.pack_int64(v.via.i64);
-			} else {
-				o.pack_int64(v.via.i64);
-			}
-		}
+		o.pack_int64(v.via.i64);
+		return o;
+
+	case type::DOUBLE:
+		o.pack_double(v.via.dec);
 		return o;
 
 	case type::RAW:

cpp/msgpack/pack.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ serializing routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// 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.
@@ -28,6 +28,7 @@ namespace msgpack {
 template <typename Stream>
 class packer {
 public:
+	packer(Stream* s);
 	packer(Stream& s);
 	~packer();
 
@@ -39,12 +40,12 @@ public:
 	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(uint8_t d);
-	packer<Stream>& pack_int16(uint16_t d);
-	packer<Stream>& pack_int32(uint32_t d);
-	packer<Stream>& pack_int64(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(int 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);
@@ -111,6 +112,12 @@ private:
 };
 
 
+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)
 {
@@ -133,6 +140,9 @@ inline void pack(Stream& s, const T& v)
 #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) { }
 
@@ -156,24 +166,24 @@ 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(uint8_t d)
+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(uint16_t d)
+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(uint32_t d)
+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(uint64_t d)
+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(int d)
+inline packer<Stream>& packer<Stream>::pack_short(short d)
 { _pack_short(m_stream, d); return *this; }
 
 template <typename Stream>

cpp/msgpack/sbuffer.h

@@ -22,13 +22,14 @@
 #include <string.h>
 
 #ifndef MSGPACK_SBUFFER_INIT_SIZE
-#define MSGPACK_SBUFFER_INIT_SIZE 2048
+#define MSGPACK_SBUFFER_INIT_SIZE 8192
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+
 typedef struct msgpack_sbuffer {
 	size_t size;
 	char* data;

cpp/msgpack/type/bool.hpp

@@ -39,6 +39,15 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const bool& v)
 	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
 

cpp/msgpack/type/define.hpp.erb

@@ -27,6 +27,11 @@
 	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 {
@@ -51,6 +56,12 @@ struct define<> {
 	{
 		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%><%}%>>
@@ -73,6 +84,14 @@ struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
 		<%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%>;<%}%>
 };

cpp/msgpack/type/deque.hpp

@@ -49,6 +49,27 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::deque<T>& v)
 	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
 

cpp/msgpack/type/float.hpp

@@ -57,6 +57,25 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const double& v)
 }
 
 
+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/msgpack/type/int.hpp

@@ -56,7 +56,7 @@ namespace detail {
 			throw type_error();
 		}
 	};
-	
+
 	template <typename T>
 	static inline T convert_integer(object o)
 	{
@@ -141,6 +141,70 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned long long&
 	{ 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/msgpack/type/list.hpp

@@ -49,6 +49,27 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::list<T>& v)
 	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
 

cpp/msgpack/type/map.hpp

@@ -70,6 +70,28 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const type::assoc_vector<K
 	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)
@@ -104,6 +126,28 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::map<K,V>& v)
 	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)
@@ -132,6 +176,28 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::multimap<K,V>&
 	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
 

cpp/msgpack/type/nil.hpp

@@ -42,6 +42,14 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const type::nil& v)
 	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; }
+
 
 }  // namespace msgpack
 

cpp/msgpack/type/pair.hpp

@@ -43,6 +43,17 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::pair<T1, T2>& v
 	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
 

cpp/msgpack/type/raw.hpp

@@ -77,6 +77,16 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const type::raw_ref& v)
 	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
 

cpp/msgpack/type/set.hpp

@@ -48,6 +48,27 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::set<T>& v)
 	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)
@@ -73,6 +94,27 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::multiset<T>& v)
 	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
 

cpp/msgpack/type/string.hpp

@@ -39,6 +39,22 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
 	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
 

cpp/msgpack/type/tr1/unordered_map.hpp

@@ -50,6 +50,28 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 	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)
@@ -78,6 +100,28 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 	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
 

cpp/msgpack/type/tr1/unordered_set.hpp

@@ -48,6 +48,27 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 	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)
@@ -73,6 +94,27 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 	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
 

cpp/msgpack/type/tuple.hpp.erb

@@ -165,6 +165,26 @@ const packer<Stream>& operator<< (
 }
 <%}%>
 
+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/msgpack/type/vector.hpp

@@ -29,11 +29,15 @@ 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);
-	object* p = o.via.array.ptr;
-	object* const pend = o.via.array.ptr + o.via.array.size;
-	T* it = &v.front();
-	for(; p < pend; ++p, ++it) {
-		p->convert(it);
+	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;
 }
@@ -49,6 +53,27 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::vector<T>& v)
 	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
 

cpp/msgpack/unpack.hpp

@@ -37,6 +37,31 @@ struct unpack_error : public std::runtime_error {
 };
 
 
+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);
@@ -53,39 +78,22 @@ public:
 	/*! 3. specify the number of bytes actually copied */
 	void buffer_consumed(size_t size);
 
-	/*! 4. repeat execute() until it retunrs false */
-	bool execute();
+	/*! 4. repeat next() until it retunrs false */
+	bool next(unpacked* result);
 
-	/*! 5.1. if execute() returns true, take out the parsed object */
-	object data();
-
-	/*! 5.2. the object is valid until the zone is deleted */
-	// Note that once release_zone() from unpacker, you must delete it
-	// otherwise the memrory will leak.
-	zone* release_zone();
-
-	/*! 5.2. this method is equivalence to `delete release_zone()` */
-	void reset_zone();
-
-	/*! 5.3. after release_zone(), re-initialize unpacker */
-	void reset();
-
-	/*! 6. check if the size of message doesn't exceed assumption. */
+	/*! 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( /* readable */ ) {
+	// while( /* input is readable */ ) {
 	//
 	//     // 1.
-	//     pac.reserve(1024);
+	//     pac.reserve_buffer(32*1024);
 	//
 	//     // 2.
-	//     ssize_t bytes =
-	//         read(the_source, pac.buffer(), pac.buffer_capacity());
+	//     size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity());
 	//
 	//     // error handling ...
 	//
@@ -93,25 +101,40 @@ public:
 	//     pac.buffer_consumed(bytes);
 	//
 	//     // 4.
-	//     while(pac.execute()) {
-	//         // 5.1
-	//         object o = pac.data();
+	//     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);
 	//
-	//         // 5.2
-	//         std::auto_ptr<msgpack::zone> olife( pac.release_zone() );
+	//         //// boost::shared_ptr is also usable:
+	//         // boost::shared_ptr<msgpack::zone> life(z.release());
+	//         // on_message(result.get(), life);
+	//     }
 	//
-	//         // boost::shared_ptr is also usable:
-	//         // boost::shared_ptr<msgpack::zone> olife( pac.release_zone() );
-	//
-	//         // 5.3
-	//         pac.reset();
-	//
-	//         // do some with the object with the old zone.
-	//         do_something(o, olife);
+	//     // 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.
@@ -137,6 +160,11 @@ private:
 };
 
 
+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,
@@ -144,6 +172,7 @@ typedef enum {
 	UNPACK_PARSE_ERROR			= -1,
 } unpack_return;
 
+// obsolete
 static unpack_return unpack(const char* data, size_t len, size_t* off,
 		zone* z, object* result);
 
@@ -187,6 +216,27 @@ 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()
 {
@@ -230,12 +280,12 @@ 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);
@@ -262,6 +312,38 @@ inline void unpacker::remove_nonparsed_buffer()
 }
 
 
+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)
 {

cpp/msgpack/vrefbuffer.h

@@ -29,12 +29,6 @@ struct iovec {
 };
 #endif
 
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
 #ifndef MSGPACK_VREFBUFFER_REF_SIZE
 #define MSGPACK_VREFBUFFER_REF_SIZE 32
 #endif
@@ -43,6 +37,11 @@ extern "C" {
 #define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192
 #endif
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
 struct msgpack_vrefbuffer_chunk;
 typedef struct msgpack_vrefbuffer_chunk msgpack_vrefbuffer_chunk;
 
@@ -102,6 +101,7 @@ size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref)
 	return vref->tail - vref->array;
 }
 
+
 #ifdef __cplusplus
 }
 #endif

cpp/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/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/msgpack/zone.h

@@ -18,8 +18,7 @@
 #ifndef MSGPACK_ZONE_H__
 #define MSGPACK_ZONE_H__
 
-#include <stddef.h>
-#include <stdbool.h>
+#include "msgpack/sysdep.h"
 
 #ifdef __cplusplus
 extern "C" {

cpp/msgpack/zone.hpp.erb

@@ -18,7 +18,6 @@
 #ifndef MSGPACK_ZONE_HPP__
 #define MSGPACK_ZONE_HPP__
 
-#include "msgpack/object.hpp"
 #include "msgpack/zone.h"
 #include <cstdlib>
 #include <memory>

cpp/msgpack_test.cpp

@@ -438,7 +438,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
 
 #ifdef HAVE_TR1_UNORDERED_MAP
 #include <tr1/unordered_map>
-#include "cpp/type/tr1/unordered_map.hpp"
+#include "msgpack/type/tr1/unordered_map.hpp"
 TEST(MSGPACK_TR1, simple_buffer_unordered_map)
 {
   for (unsigned int k = 0; k < kLoop; k++) {
@@ -499,7 +499,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
 
 #ifdef HAVE_TR1_UNORDERED_SET
 #include <tr1/unordered_set>
-#include "cpp/type/tr1/unordered_set.hpp"
+#include "msgpack/type/tr1/unordered_set.hpp"
 TEST(MSGPACK_TR1, simple_buffer_unordered_set)
 {
   for (unsigned int k = 0; k < kLoop; k++) {

cpp/msgpack_vc8.postbuild.bat

@@ -0,0 +1,43 @@
+IF NOT EXIST include                  MKDIR include
+IF NOT EXIST include\msgpack          MKDIR include\msgpack
+IF NOT EXIST include\msgpack\type     MKDIR include\msgpack\type
+IF NOT EXIST include\msgpack\type\tr1 MKDIR include\msgpack\type\tr1
+copy msgpack\pack_define.h      include\msgpack\
+copy msgpack\pack_template.h    include\msgpack\
+copy msgpack\unpack_define.h    include\msgpack\
+copy msgpack\unpack_template.h  include\msgpack\
+copy msgpack\sysdep.h           include\msgpack\
+copy msgpack.h                     include\
+copy msgpack\sbuffer.h             include\msgpack\
+copy msgpack\vrefbuffer.h          include\msgpack\
+copy msgpack\zbuffer.h             include\msgpack\
+copy msgpack\pack.h                include\msgpack\
+copy msgpack\unpack.h              include\msgpack\
+copy msgpack\object.h              include\msgpack\
+copy msgpack\zone.h                include\msgpack\
+copy msgpack.hpp                   include\
+copy msgpack\sbuffer.hpp           include\msgpack\
+copy msgpack\vrefbuffer.hpp        include\msgpack\
+copy msgpack\zbuffer.hpp           include\msgpack\
+copy msgpack\pack.hpp              include\msgpack\
+copy msgpack\unpack.hpp            include\msgpack\
+copy msgpack\object.hpp            include\msgpack\
+copy msgpack\zone.hpp              include\msgpack\
+copy msgpack\type.hpp              include\msgpack\type\
+copy msgpack\type\bool.hpp         include\msgpack\type\
+copy msgpack\type\float.hpp        include\msgpack\type\
+copy msgpack\type\int.hpp          include\msgpack\type\
+copy msgpack\type\list.hpp         include\msgpack\type\
+copy msgpack\type\deque.hpp        include\msgpack\type\
+copy msgpack\type\map.hpp          include\msgpack\type\
+copy msgpack\type\nil.hpp          include\msgpack\type\
+copy msgpack\type\pair.hpp         include\msgpack\type\
+copy msgpack\type\raw.hpp          include\msgpack\type\
+copy msgpack\type\set.hpp          include\msgpack\type\
+copy msgpack\type\string.hpp       include\msgpack\type\
+copy msgpack\type\vector.hpp       include\msgpack\type\
+copy msgpack\type\tuple.hpp        include\msgpack\type\
+copy msgpack\type\define.hpp       include\msgpack\type\
+copy msgpack\type\tr1\unordered_map.hpp  include\msgpack\type\
+copy msgpack\type\tr1\unordered_set.hpp  include\msgpack\type\
+

cpp/msgpack_vc8.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual C++ Express 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MessagePack", "msgpack_vc8.vcproj", "{122A2EA4-B283-4241-9655-786DE78283B2}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|Win32.Build.0 = Debug|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|Win32.ActiveCfg = Release|Win32
+		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

cpp/msgpack_vc8.vcproj

@@ -0,0 +1,279 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="MessagePack"
+	ProjectGUID="{122A2EA4-B283-4241-9655-786DE78283B2}"
+	RootNamespace="MessagePack"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+				Description="Gathering header files"
+				CommandLine="msgpack_vc8.postbuild.bat"
+				Outputs="include"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="."
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="1"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="lib\msgpackd.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+				Description="Gathering header files"
+				CommandLine="msgpack_vc8.postbuild.bat"
+				Outputs="include"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="."
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="lib\msgpack.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\objectc.c"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\unpack.c"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\vrefbuffer.c"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\zone.c"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\object.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\msgpack\pack_define.h"
+				>
+			</File>
+			<File
+				RelativePath=".\msgpack\pack_template.h"
+				>
+			</File>
+			<File
+				RelativePath=".\msgpack\sysdep.h"
+				>
+			</File>
+			<File
+				RelativePath=".\msgpack\unpack_define.h"
+				>
+			</File>
+			<File
+				RelativePath=".\msgpack\unpack_template.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

cpp/object.cpp

@@ -16,7 +16,6 @@
 //    limitations under the License.
 //
 #include "msgpack/object.hpp"
-#include <string.h>
 
 namespace msgpack {
 
@@ -61,7 +60,6 @@ std::ostream& operator<< (std::ostream& s, const object o)
 		}
 		s << "]";
 		break;
-		// FIXME loop optimiziation
 
 	case type::MAP:
 		s << "{";
@@ -76,7 +74,6 @@ std::ostream& operator<< (std::ostream& s, const object o)
 		}
 		s << "}";
 		break;
-		// FIXME loop optimiziation
 
 	default:
 		// FIXME
@@ -86,53 +83,5 @@ std::ostream& operator<< (std::ostream& s, const object o)
 }
 
 
-bool operator==(const object x, const object y)
-{
-	if(x.type != y.type) { return false; }
-
-	switch(x.type) {
-	case type::NIL:
-		return true;
-
-	case type::BOOLEAN:
-		return x.via.boolean == y.via.boolean;
-
-	case type::POSITIVE_INTEGER:
-		return x.via.u64 == y.via.u64;
-
-	case type::NEGATIVE_INTEGER:
-		return x.via.i64 == y.via.i64;
-
-	case type::RAW:
-		return x.via.raw.size == y.via.raw.size &&
-			memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0;
-
-	case type::ARRAY:
-		if(x.via.array.size != y.via.array.size) { return false; }
-		for(object* px(x.via.array.ptr),
-				* const pxend(x.via.array.ptr + x.via.array.size),
-				* py(y.via.array.ptr);
-				px < pxend; ++px, ++py) {
-			if(*px != *py) { return false; }
-		}
-		return true;
-		// FIXME loop optimiziation
-
-	case type::MAP:
-		if(x.via.map.size != y.via.map.size) { return false; }
-		for(object_kv* px(x.via.map.ptr),
-				* const pxend(x.via.map.ptr + x.via.map.size),
-				* py(y.via.map.ptr);
-				px < pxend; ++px, ++py) {
-			if(px->key != py->key || px->val != py->val) { return false; }
-		}
-		return true;
-
-	default:
-		return false;
-	}
-}
-
-
 }  // namespace msgpack
 

cpp/objectc.c

@@ -18,6 +18,7 @@
 #include "msgpack/object.h"
 #include "msgpack/pack.h"
 #include <stdio.h>
+#include <string.h>
 
 #ifndef _MSC_VER
 #include <inttypes.h>
@@ -141,7 +142,6 @@ void msgpack_object_print(FILE* out, msgpack_object o)
 		}
 		fprintf(out, "]");
 		break;
-		// FIXME loop optimiziation
 
 	case MSGPACK_OBJECT_MAP:
 		fprintf(out, "{");
@@ -161,7 +161,6 @@ void msgpack_object_print(FILE* out, msgpack_object o)
 		}
 		fprintf(out, "}");
 		break;
-		// FIXME loop optimiziation
 
 	default:
 		// FIXME
@@ -169,3 +168,70 @@ void msgpack_object_print(FILE* out, msgpack_object o)
 	}
 }
 
+bool msgpack_object_equal(const msgpack_object x, const msgpack_object y)
+{
+	if(x.type != y.type) { return false; }
+
+	switch(x.type) {
+	case MSGPACK_OBJECT_NIL:
+		return true;
+
+	case MSGPACK_OBJECT_BOOLEAN:
+		return x.via.boolean == y.via.boolean;
+
+	case MSGPACK_OBJECT_POSITIVE_INTEGER:
+		return x.via.u64 == y.via.u64;
+
+	case MSGPACK_OBJECT_NEGATIVE_INTEGER:
+		return x.via.i64 == y.via.i64;
+
+	case MSGPACK_OBJECT_DOUBLE:
+		return x.via.dec == y.via.dec;
+
+	case MSGPACK_OBJECT_RAW:
+		return x.via.raw.size == y.via.raw.size &&
+			memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0;
+
+	case MSGPACK_OBJECT_ARRAY:
+		if(x.via.array.size != y.via.array.size) {
+			return false;
+		} else if(x.via.array.size == 0) {
+			return true;
+		} else {
+			msgpack_object* px = x.via.array.ptr;
+			msgpack_object* const pxend = x.via.array.ptr + x.via.array.size;
+			msgpack_object* py = y.via.array.ptr;
+			do {
+				if(!msgpack_object_equal(*px, *py)) {
+					return false;
+				}
+				++px;
+				++py;
+			} while(px < pxend);
+			return true;
+		}
+
+	case MSGPACK_OBJECT_MAP:
+		if(x.via.map.size != y.via.map.size) {
+			return false;
+		} else if(x.via.map.size == 0) {
+			return true;
+		} else {
+			msgpack_object_kv* px = x.via.map.ptr;
+			msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size;
+			msgpack_object_kv* py = y.via.map.ptr;
+			do {
+				if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) {
+					return false;
+				}
+				++px;
+				++py;
+			} while(px < pxend);
+			return true;
+		}
+
+	default:
+		return false;
+	}
+}
+

cpp/preprocess

@@ -14,4 +14,9 @@ preprocess() {
 preprocess msgpack/type/tuple.hpp
 preprocess msgpack/type/define.hpp
 preprocess msgpack/zone.hpp
+cp -f ../msgpack/sysdep.h          msgpack/
+cp -f ../msgpack/pack_define.h     msgpack/
+cp -f ../msgpack/pack_template.h   msgpack/
+cp -f ../msgpack/unpack_define.h   msgpack/
+cp -f ../msgpack/unpack_template.h msgpack/
 

cpp/test/Makefile.am

@@ -0,0 +1,28 @@
+
+AM_CPPFLAGS   = -I..
+AM_C_CPPFLAGS = -I..
+AM_LDFLAGS = ../libmsgpack.la -lgtest_main
+
+check_PROGRAMS = \
+		zone \
+		pack_unpack \
+		streaming \
+		object \
+		convert \
+		buffer
+
+TESTS = $(check_PROGRAMS)
+
+zone_SOURCES = zone.cc
+
+pack_unpack_SOURCES = pack_unpack.cc
+
+streaming_SOURCES = streaming.cc
+
+object_SOURCES = object.cc
+
+convert_SOURCES = convert.cc
+
+buffer_SOURCES = buffer.cc
+buffer_LDADD = -lz
+

cpp/test/buffer.cc

@@ -0,0 +1,50 @@
+#include <msgpack.hpp>
+#include <msgpack/zbuffer.hpp>
+#include <gtest/gtest.h>
+#include <string.h>
+
+TEST(buffer, sbuffer)
+{
+	msgpack::sbuffer sbuf;
+	sbuf.write("a", 1);
+	sbuf.write("a", 1);
+	sbuf.write("a", 1);
+
+	EXPECT_EQ(3, sbuf.size());
+	EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
+}
+
+
+TEST(buffer, vrefbuffer)
+{
+	msgpack::vrefbuffer vbuf;
+	vbuf.write("a", 1);
+	vbuf.write("a", 1);
+	vbuf.write("a", 1);
+
+	const struct iovec* vec = vbuf.vector();
+	size_t veclen = vbuf.vector_size();
+
+	msgpack::sbuffer sbuf;
+	for(size_t i=0; i < veclen; ++i) {
+		sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len);
+	}
+
+	EXPECT_EQ(3, sbuf.size());
+	EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 );
+}
+
+
+TEST(buffer, zbuffer)
+{
+	msgpack::zbuffer zbuf;
+	zbuf.write("a", 1);
+	zbuf.write("a", 1);
+	zbuf.write("a", 1);
+
+	zbuf.flush();
+
+	char* data = zbuf.data();
+	size_t size = zbuf.size();
+}
+

cpp/test/convert.cc

@@ -0,0 +1,74 @@
+#include <msgpack.hpp>
+#include <gtest/gtest.h>
+
+class compatibility {
+public:
+	compatibility() : str1("default"), str2("default") { }
+
+	std::string str1;
+	std::string str2;
+
+	MSGPACK_DEFINE(str1, str2);
+};
+
+TEST(convert, compatibility_less)
+{
+	std::vector<std::string> src(1);
+	src[0] = "kumofs";
+
+	msgpack::zone z;
+	msgpack::object obj(src, &z);
+
+	compatibility c;
+	EXPECT_NO_THROW( obj.convert(&c) );
+
+	EXPECT_EQ("kumofs",  c.str1);
+	EXPECT_EQ("default", c.str2);
+}
+
+TEST(convert, compatibility_more)
+{
+	std::vector<std::string> src(3);
+	src[0] = "kumofs";
+	src[1] = "mpio";
+	src[2] = "cloudy";
+
+	msgpack::zone z;
+	msgpack::object obj(src, &z);
+
+	compatibility to;
+	EXPECT_NO_THROW( obj.convert(&to) );
+
+	EXPECT_EQ("kumofs", to.str1);
+	EXPECT_EQ("mpio",   to.str2);
+}
+
+
+class enum_member {
+public:
+	enum_member() : flag(A) { }
+
+	enum flags_t {
+		A = 0,
+		B = 1,
+	};
+
+	flags_t flag;
+
+	MSGPACK_DEFINE((int&)flag);
+};
+
+TEST(convert, enum_member)
+{
+	enum_member src;
+	src.flag = enum_member::B;
+
+	msgpack::zone z;
+	msgpack::object obj(src, &z);
+
+	enum_member to;
+	EXPECT_NO_THROW( obj.convert(&to) );
+
+	EXPECT_EQ(enum_member::B, to.flag);
+}
+

cpp/test/object.cc

@@ -0,0 +1,134 @@
+#include <msgpack.hpp>
+#include <gtest/gtest.h>
+
+struct myclass {
+	myclass() : num(0), str("default") { }
+
+	myclass(int num, const std::string& str) :
+		num(0), str("default") { }
+
+	~myclass() { }
+
+	int num;
+	std::string str;
+
+	MSGPACK_DEFINE(num, str);
+
+	bool operator==(const myclass& o) const
+	{
+		return num == o.num && str == o.str;
+	}
+};
+
+std::ostream& operator<<(std::ostream& o, const myclass& m)
+{
+	return o << "myclass("<<m.num<<",\""<<m.str<<"\")";
+}
+
+
+TEST(object, convert)
+{
+	myclass m1;
+
+	msgpack::sbuffer sbuf;
+	msgpack::pack(sbuf, m1);
+
+	msgpack::zone z;
+	msgpack::object obj;
+
+	msgpack::unpack_return ret =
+		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+
+	myclass m2;
+	obj.convert(&m2);
+
+	EXPECT_EQ(m1, m2);
+}
+
+
+TEST(object, as)
+{
+	myclass m1;
+
+	msgpack::sbuffer sbuf;
+	msgpack::pack(sbuf, m1);
+
+	msgpack::zone z;
+	msgpack::object obj;
+
+	msgpack::unpack_return ret =
+		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+
+	EXPECT_EQ(m1, obj.as<myclass>());
+}
+
+
+TEST(object, print)
+{
+	msgpack::object obj;
+	std::cout << obj << std::endl;
+}
+
+
+TEST(object, is_nil)
+{
+	msgpack::object obj;
+	EXPECT_TRUE(obj.is_nil());
+}
+
+
+TEST(object, type_error)
+{
+	msgpack::object obj(1);
+	EXPECT_THROW(obj.as<std::string>(), msgpack::type_error);
+	EXPECT_THROW(obj.as<std::vector<int> >(), msgpack::type_error);
+	EXPECT_EQ(1, obj.as<int>());
+	EXPECT_EQ(1, obj.as<short>());
+	EXPECT_EQ(1u, obj.as<unsigned int>());
+	EXPECT_EQ(1u, obj.as<unsigned long>());
+}
+
+
+TEST(object, equal_primitive)
+{
+	msgpack::object obj_nil;
+	EXPECT_EQ(obj_nil, msgpack::object());
+
+	msgpack::object obj_int(1);
+	EXPECT_EQ(obj_int, msgpack::object(1));
+	EXPECT_EQ(obj_int, 1);
+
+	msgpack::object obj_double(1.2);
+	EXPECT_EQ(obj_double, msgpack::object(1.2));
+	EXPECT_EQ(obj_double, 1.2);
+
+	msgpack::object obj_bool(true);
+	EXPECT_EQ(obj_bool, msgpack::object(true));
+	EXPECT_EQ(obj_bool, true);
+}
+
+
+TEST(object, construct_primitive)
+{
+	msgpack::object obj_nil;
+	EXPECT_EQ(msgpack::type::NIL, obj_nil.type);
+
+	msgpack::object obj_uint(1);
+	EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type);
+	EXPECT_EQ(1u, obj_uint.via.u64);
+
+	msgpack::object obj_int(-1);
+	EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
+	EXPECT_EQ(-1, obj_int.via.i64);
+
+	msgpack::object obj_double(1.2);
+	EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type);
+	EXPECT_EQ(1.2, obj_double.via.dec);
+
+	msgpack::object obj_bool(true);
+	EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type);
+	EXPECT_EQ(true, obj_bool.via.boolean);
+}
+

cpp/test/pack_unpack.cc

@@ -0,0 +1,127 @@
+#include <msgpack.hpp>
+#include <gtest/gtest.h>
+#include <sstream>
+
+TEST(pack, num)
+{
+	msgpack::sbuffer sbuf;
+	msgpack::pack(sbuf, 1);
+}
+
+
+TEST(pack, vector)
+{
+	msgpack::sbuffer sbuf;
+	std::vector<int> vec;
+	vec.push_back(1);
+	vec.push_back(2);
+	vec.push_back(3);
+	msgpack::pack(sbuf, vec);
+}
+
+
+TEST(pack, to_ostream)
+{
+	std::ostringstream stream;
+	msgpack::pack(stream, 1);
+}
+
+
+struct myclass {
+	myclass() : num(0), str("default") { }
+
+	myclass(int num, const std::string& str) :
+		num(0), str("default") { }
+
+	~myclass() { }
+
+	int num;
+	std::string str;
+
+	MSGPACK_DEFINE(num, str);
+};
+
+
+TEST(pack, myclass)
+{
+	msgpack::sbuffer sbuf;
+	myclass m(1, "msgpack");
+	msgpack::pack(sbuf, m);
+}
+
+
+TEST(unpack, myclass)
+{
+	msgpack::sbuffer sbuf;
+	myclass m1(1, "phraser");
+	msgpack::pack(sbuf, m1);
+
+	msgpack::zone z;
+	msgpack::object obj;
+
+	msgpack::unpack_return ret =
+		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+
+	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+
+	myclass m2 = obj.as<myclass>();
+	EXPECT_EQ(m1.num, m2.num);
+	EXPECT_EQ(m1.str, m2.str);
+}
+
+
+TEST(unpack, sequence)
+{
+	msgpack::sbuffer sbuf;
+	msgpack::pack(sbuf, 1);
+	msgpack::pack(sbuf, 2);
+	msgpack::pack(sbuf, 3);
+
+	bool cont;
+	size_t offset = 0;
+
+	msgpack::unpacked msg;
+
+	cont = msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
+	EXPECT_TRUE(cont);
+	EXPECT_EQ(1, msg.get().as<int>());
+
+	cont = msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
+	EXPECT_TRUE(cont);
+	EXPECT_EQ(2, msg.get().as<int>());
+
+	cont = msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
+	EXPECT_FALSE(cont);
+	EXPECT_EQ(3, msg.get().as<int>());
+}
+
+
+TEST(unpack, sequence_compat)
+{
+	msgpack::sbuffer sbuf;
+	msgpack::pack(sbuf, 1);
+	msgpack::pack(sbuf, 2);
+	msgpack::pack(sbuf, 3);
+
+	size_t offset = 0;
+
+	msgpack::zone z;
+	msgpack::object obj;
+	msgpack::unpack_return ret;
+
+	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
+	EXPECT_TRUE(ret >= 0);
+	EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
+	EXPECT_EQ(1, obj.as<int>());
+
+	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
+	EXPECT_TRUE(ret >= 0);
+	EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
+	EXPECT_EQ(2, obj.as<int>());
+
+	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
+	EXPECT_TRUE(ret >= 0);
+	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+	EXPECT_EQ(3, obj.as<int>());
+}
+

cpp/test/streaming.cc

@@ -0,0 +1,213 @@
+#include <msgpack.hpp>
+#include <gtest/gtest.h>
+#include <sstream>
+
+
+TEST(streaming, basic)
+{
+	std::ostringstream stream;
+	msgpack::packer<std::ostream> pk(&stream);
+
+	pk.pack(1);
+	pk.pack(2);
+	pk.pack(3);
+
+	std::istringstream input(stream.str());
+
+	msgpack::unpacker pac;
+
+	int count = 0;
+	while(count < 3) {
+		pac.reserve_buffer(32*1024);
+
+		size_t len = input.readsome(pac.buffer(), pac.buffer_capacity());
+		pac.buffer_consumed(len);
+
+		msgpack::unpacked result;
+		while(pac.next(&result)) {
+			msgpack::object obj = result.get();
+			switch(count++) {
+			case 0:
+				EXPECT_EQ(1, obj.as<int>());
+				break;
+			case 1:
+				EXPECT_EQ(2, obj.as<int>());
+				break;
+			case 2:
+				EXPECT_EQ(3, obj.as<int>());
+				return;
+			}
+		}
+	}
+}
+
+
+class event_handler {
+public:
+	event_handler(std::istream& input) : input(input) { }
+	~event_handler() { }
+
+	void on_read()
+	{
+		while(true) {
+			pac.reserve_buffer(32*1024);
+
+			size_t len = input.readsome(pac.buffer(), pac.buffer_capacity());
+
+			if(len == 0) {
+				return;
+			}
+
+			pac.buffer_consumed(len);
+
+			msgpack::unpacked result;
+			while(pac.next(&result)) {
+				on_message(result.get(), result.zone());
+			}
+
+			if(pac.message_size() > 10*1024*1024) {
+				throw std::runtime_error("message is too large");
+			}
+		}
+	}
+
+	void on_message(msgpack::object obj, std::auto_ptr<msgpack::zone> z)
+	{
+		EXPECT_EQ(expect, obj.as<int>());
+	}
+
+	int expect;
+
+private:
+	std::istream& input;
+	msgpack::unpacker pac;
+};
+
+TEST(streaming, event)
+{
+	std::stringstream stream;
+	msgpack::packer<std::ostream> pk(&stream);
+
+	event_handler handler(stream);
+
+	pk.pack(1);
+	handler.expect = 1;
+	handler.on_read();
+
+	pk.pack(2);
+	handler.expect = 2;
+	handler.on_read();
+
+	pk.pack(3);
+	handler.expect = 3;
+	handler.on_read();
+}
+
+
+// backward compatibility
+TEST(streaming, basic_compat)
+{
+	std::ostringstream stream;
+	msgpack::packer<std::ostream> pk(&stream);
+
+	pk.pack(1);
+	pk.pack(2);
+	pk.pack(3);
+
+	std::istringstream input(stream.str());
+
+	msgpack::unpacker pac;
+
+	int count = 0;
+	while(count < 3) {
+		pac.reserve_buffer(32*1024);
+
+		size_t len = input.readsome(pac.buffer(), pac.buffer_capacity());
+		pac.buffer_consumed(len);
+
+		while(pac.execute()) {
+			std::auto_ptr<msgpack::zone> z(pac.release_zone());
+			msgpack::object obj = pac.data();
+			pac.reset();
+
+			switch(count++) {
+			case 0:
+				EXPECT_EQ(1, obj.as<int>());
+				break;
+			case 1:
+				EXPECT_EQ(2, obj.as<int>());
+				break;
+			case 2:
+				EXPECT_EQ(3, obj.as<int>());
+				return;
+			}
+
+		}
+	}
+}
+
+
+// backward compatibility
+class event_handler_compat {
+public:
+	event_handler_compat(std::istream& input) : input(input) { }
+	~event_handler_compat() { }
+
+	void on_read()
+	{
+		while(true) {
+			pac.reserve_buffer(32*1024);
+
+			size_t len = input.readsome(pac.buffer(), pac.buffer_capacity());
+
+			if(len == 0) {
+				return;
+			}
+
+			pac.buffer_consumed(len);
+
+			while(pac.execute()) {
+				std::auto_ptr<msgpack::zone> z(pac.release_zone());
+				msgpack::object obj = pac.data();
+				pac.reset();
+				on_message(obj, z);
+			}
+
+			if(pac.message_size() > 10*1024*1024) {
+				throw std::runtime_error("message is too large");
+			}
+		}
+	}
+
+	void on_message(msgpack::object obj, std::auto_ptr<msgpack::zone> z)
+	{
+		EXPECT_EQ(expect, obj.as<int>());
+	}
+
+	int expect;
+
+private:
+	std::istream& input;
+	msgpack::unpacker pac;
+};
+
+TEST(streaming, event_compat)
+{
+	std::stringstream stream;
+	msgpack::packer<std::ostream> pk(&stream);
+
+	event_handler_compat handler(stream);
+
+	pk.pack(1);
+	handler.expect = 1;
+	handler.on_read();
+
+	pk.pack(2);
+	handler.expect = 2;
+	handler.on_read();
+
+	pk.pack(3);
+	handler.expect = 3;
+	handler.on_read();
+}
+

cpp/test/zone.cc

@@ -0,0 +1,78 @@
+#include <msgpack.hpp>
+#include <gtest/gtest.h>
+
+TEST(zone, malloc)
+{
+	msgpack::zone z;
+	char* buf1 = (char*)z.malloc(4);
+	memcpy(buf1, "test", 4);
+	char* buf2 = (char*)z.malloc(4);
+	memcpy(buf2, "test", 4);
+}
+
+
+class myclass {
+public:
+	myclass() : num(0), str("default") { }
+
+	myclass(int num, const std::string& str) :
+		num(num), str(str) { }
+
+	~myclass() { }
+
+	int num;
+	std::string str;
+
+private:
+	myclass(const myclass&);
+};
+
+
+TEST(zone, allocate)
+{
+	msgpack::zone z;
+	myclass* m = z.allocate<myclass>();
+	EXPECT_EQ(m->num, 0);
+	EXPECT_EQ(m->str, "default");
+}
+
+
+TEST(zone, allocate_constructor)
+{
+	msgpack::zone z;
+	myclass* m = z.allocate<myclass>(7, "msgpack");
+	EXPECT_EQ(m->num, 7);
+	EXPECT_EQ(m->str, "msgpack");
+}
+
+
+static void custom_finalizer_func(void* user)
+{
+	myclass* m = (myclass*)user;
+	delete m;
+}
+
+TEST(zone, push_finalizer)
+{
+	msgpack::zone z;
+	myclass* m = new myclass();
+	z.push_finalizer(custom_finalizer_func, (void*)m);
+}
+
+
+TEST(zone, push_finalizer_auto_ptr)
+{
+	msgpack::zone z;
+	std::auto_ptr<myclass> am(new myclass());
+	z.push_finalizer(am);
+}
+
+
+TEST(zone, malloc_no_align)
+{
+	msgpack::zone z;
+	char* buf1 = (char*)z.malloc_no_align(4);
+	char* buf2 = (char*)z.malloc_no_align(4);
+	EXPECT_EQ(buf1+4, buf2);
+}
+

cpp/unpack.c

@@ -52,7 +52,7 @@ static int template_execute(template_context* ctx,
 
 
 static inline msgpack_object template_callback_root(unpack_user* u)
-{ msgpack_object o; return o; }
+{ msgpack_object o = {}; return o; }
 
 static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack_object* o)
 { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
@@ -377,14 +377,14 @@ msgpack_unpack(const char* data, size_t len, size_t* off,
 	size_t noff = 0;
 	if(off != NULL) { noff = *off; }
 
-	int ret = template_execute(&ctx, data, len, &noff);
-	if(ret < 0) {
+	int e = template_execute(&ctx, data, len, &noff);
+	if(e < 0) {
 		return MSGPACK_UNPACK_PARSE_ERROR;
 	}
 
 	if(off != NULL) { *off = noff; }
 
-	if(ret == 0) {
+	if(e == 0) {
 		return MSGPACK_UNPACK_CONTINUE;
 	}
 

cpp/vrefbuffer.c

@@ -30,7 +30,6 @@ bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf,
 	vbuf->chunk_size = chunk_size;
 	vbuf->ref_size = ref_size;
 
-	// glibcは72バイト以下のmallocが高速
 	size_t nfirst = (sizeof(struct iovec) < 72/2) ?
 			72 / sizeof(struct iovec) : 8;
 

cpp/zone.c

@@ -104,7 +104,6 @@ static inline void init_finalizer_array(msgpack_zone_finalizer_array* fa)
 
 static inline void call_finalizer_array(msgpack_zone_finalizer_array* fa)
 {
-	// 逆順に呼び出し
 	msgpack_zone_finalizer* fin = fa->tail;
 	for(; fin != fa->array; --fin) {
 		(*(fin-1)->func)((fin-1)->data);
@@ -132,9 +131,6 @@ bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone,
 
 	size_t nnext;
 	if(nused == 0) {
-		// 初回の呼び出し：fa->tail == fa->end == fa->array == NULL
-
-		// glibcは72バイト以下のmallocが高速
 		nnext = (sizeof(msgpack_zone_finalizer) < 72/2) ?
 				72 / sizeof(msgpack_zone_finalizer) : 8;
 

haskell/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2009, Hideyuki Tanaka
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Hideyuki Tanaka nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY Hideyuki Tanaka ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

haskell/Setup.lhs

@@ -0,0 +1,3 @@
+#!/usr/bin/env runhaskell
+> import Distribution.Simple
+> main = defaultMain

haskell/cbits/msgpack.c

@@ -0,0 +1,137 @@
+#include <msgpack.h>
+
+void msgpack_sbuffer_init_wrap(msgpack_sbuffer* sbuf)
+{
+  msgpack_sbuffer_init(sbuf);
+}
+
+void msgpack_sbuffer_destroy_wrap(msgpack_sbuffer* sbuf)
+{
+  msgpack_sbuffer_destroy(sbuf);
+}
+
+int msgpack_sbuffer_write_wrap(void* data, const char* buf, unsigned int len)
+{
+  return msgpack_sbuffer_write(data, buf, len);
+}
+
+msgpack_packer* msgpack_packer_new_wrap(void *data, msgpack_packer_write callback)
+{
+  return msgpack_packer_new(data, callback);
+}
+
+void msgpack_packer_free_wrap(msgpack_packer* pk)
+{
+  msgpack_packer_free(pk);
+}
+
+int msgpack_pack_uint8_wrap(msgpack_packer* pk, uint8_t d)
+{
+  return msgpack_pack_uint8(pk, d);
+}
+
+int msgpack_pack_uint16_wrap(msgpack_packer* pk, uint16_t d)
+{
+  return msgpack_pack_uint16(pk, d);
+}
+
+int msgpack_pack_uint32_wrap(msgpack_packer* pk, uint32_t d)
+{
+  return msgpack_pack_uint32(pk, d);
+}
+
+int msgpack_pack_uint64_wrap(msgpack_packer* pk, uint64_t d)
+{
+  return msgpack_pack_uint64(pk, d);
+}
+
+int msgpack_pack_int8_wrap(msgpack_packer* pk, int8_t d)
+{
+  return msgpack_pack_int8(pk, d);
+}
+
+int msgpack_pack_int16_wrap(msgpack_packer* pk, int16_t d)
+{
+  return msgpack_pack_int16(pk, d);
+}
+
+int msgpack_pack_int32_wrap(msgpack_packer* pk, int32_t d)
+{
+  return msgpack_pack_int32(pk, d);
+}
+
+int msgpack_pack_int64_wrap(msgpack_packer* pk, int64_t d)
+{
+  return msgpack_pack_int64(pk, d);
+}
+
+int msgpack_pack_double_wrap(msgpack_packer* pk, double d)
+{
+  return msgpack_pack_double(pk, d);
+}
+
+int msgpack_pack_nil_wrap(msgpack_packer* pk)
+{
+  return msgpack_pack_nil(pk);
+}
+
+int msgpack_pack_true_wrap(msgpack_packer* pk)
+{
+  return msgpack_pack_true(pk);
+}
+
+int msgpack_pack_false_wrap(msgpack_packer* pk)
+{
+  return msgpack_pack_false(pk);
+}
+
+int msgpack_pack_array_wrap(msgpack_packer* pk, unsigned int n)
+{
+  return msgpack_pack_array(pk, n);
+}
+
+int msgpack_pack_map_wrap(msgpack_packer* pk, unsigned int n)
+{
+  return msgpack_pack_map(pk, n);
+}
+
+int msgpack_pack_raw_wrap(msgpack_packer* pk, size_t l)
+{
+  return msgpack_pack_raw(pk, l);
+}
+
+int msgpack_pack_raw_body_wrap(msgpack_packer* pk, const void *b, size_t l)
+{
+  return msgpack_pack_raw_body(pk, b, l);
+}
+
+bool msgpack_unpacker_reserve_buffer_wrap(msgpack_unpacker *mpac, size_t size)
+{
+  return msgpack_unpacker_reserve_buffer(mpac, size);
+}
+
+char *msgpack_unpacker_buffer_wrap(msgpack_unpacker *mpac)
+{
+  return msgpack_unpacker_buffer(mpac);
+}
+
+size_t msgpack_unpacker_buffer_capacity_wrap(const msgpack_unpacker *mpac)
+{
+  return msgpack_unpacker_buffer_capacity(mpac);
+}
+
+void msgpack_unpacker_buffer_consumed_wrap(msgpack_unpacker *mpac, size_t size)
+{
+  msgpack_unpacker_buffer_consumed(mpac, size);
+}
+
+void msgpack_unpacker_data_wrap(msgpack_unpacker *mpac, msgpack_object *obj)
+{
+  *obj=msgpack_unpacker_data(mpac);
+}
+
+size_t msgpack_unpacker_message_size_wrap(const msgpack_unpacker *mpac)
+{
+  return msgpack_unpacker_message_size(mpac);
+}
+

haskell/msgpack.cabal

@@ -0,0 +1,32 @@
+Name:                msgpack
+Version:             0.2.0
+License:             BSD3
+License-File:        LICENSE
+Author:              Hideyuki Tanaka
+Maintainer:          Hideyuki Tanaka <tanaka.hideyuki@gmail.com>
+Category:            Data
+Synopsis:            A Haskell binding to MessagePack
+Description:
+  A Haskell binding to MessagePack <http://msgpack.sourceforge.jp/>
+Homepage:	     http://github.com/tanakh/hsmsgpack
+Stability:	     Experimental
+Tested-with:	     GHC==6.10.4
+Cabal-Version:	     >=1.2
+Build-Type:          Simple
+
+library
+  build-depends:	base>=4 && <5, mtl, bytestring
+  ghc-options:		-O2 -Wall
+  hs-source-dirs:	src
+  extra-libraries:	msgpackc
+
+  Exposed-modules:
+    Data.MessagePack
+    Data.MessagePack.Base
+    Data.MessagePack.Class
+    Data.MessagePack.Feed
+    Data.MessagePack.Monad
+    Data.MessagePack.Stream
+
+  C-Sources:
+    cbits/msgpack.c

haskell/src/Data/MessagePack.hs

@@ -0,0 +1,63 @@
+--------------------------------------------------------------------
+-- |
+-- Module    : Data.MessagePack
+-- Copyright : (c) Hideyuki Tanaka, 2009
+-- License   : BSD3
+--
+-- Maintainer:  tanaka.hideyuki@gmail.com
+-- Stability :  experimental
+-- Portability: portable
+--
+-- Simple interface to pack and unpack MessagePack data.
+--
+--------------------------------------------------------------------
+
+module Data.MessagePack(
+  module Data.MessagePack.Base,
+  module Data.MessagePack.Class,
+  module Data.MessagePack.Feed,
+  module Data.MessagePack.Monad,
+  module Data.MessagePack.Stream,
+  
+  -- * Pack and Unpack
+  packb,
+  unpackb,
+  
+  -- * Pure version of Pack and Unpack
+  packb',
+  unpackb',
+  ) where
+
+import Data.ByteString (ByteString)
+import System.IO.Unsafe
+
+import Data.MessagePack.Base
+import Data.MessagePack.Class
+import Data.MessagePack.Feed
+import Data.MessagePack.Monad
+import Data.MessagePack.Stream
+
+-- | Pack Haskell data to MessagePack string.
+packb :: OBJECT a => a -> IO ByteString
+packb dat = do
+  sb <- newSimpleBuffer
+  pc <- newPacker sb
+  pack pc dat
+  simpleBufferData sb
+
+-- | Unpack MessagePack string to Haskell data.
+unpackb :: OBJECT a => ByteString -> IO (Result a)
+unpackb bs = do
+  withZone $ \z -> do
+    r <- unpackObject z bs
+    return $ case r of
+      Left err -> Left (show err)
+      Right (_, dat) -> fromObject dat
+
+-- | Pure version of 'packb'.
+packb' :: OBJECT a => a -> ByteString
+packb' dat = unsafePerformIO $ packb dat
+
+-- | Pure version of 'unpackb'.
+unpackb' :: OBJECT a => ByteString -> Result a
+unpackb' bs = unsafePerformIO $ unpackb bs

haskell/src/Data/MessagePack/Base.hsc

@@ -0,0 +1,581 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+
+--------------------------------------------------------------------
+-- |
+-- Module    : Data.MessagePack.Base
+-- Copyright : (c) Hideyuki Tanaka, 2009
+-- License   : BSD3
+--
+-- Maintainer:  tanaka.hideyuki@gmail.com
+-- Stability :  experimental
+-- Portability: portable
+--
+-- Low Level Interface to MessagePack C API
+--
+--------------------------------------------------------------------
+
+module Data.MessagePack.Base(
+  -- * Simple Buffer
+  SimpleBuffer,
+  newSimpleBuffer,
+  simpleBufferData,
+  
+  -- * Serializer
+  Packer,
+  newPacker,
+  
+  packU8,
+  packU16,
+  packU32,
+  packU64,  
+  packS8,
+  packS16,
+  packS32,
+  packS64,
+  
+  packTrue,
+  packFalse,
+  
+  packInt,
+  packDouble,
+  packNil,
+  packBool,
+  
+  packArray,
+  packMap,
+  packRAW,
+  packRAWBody,
+  packRAW',
+  
+  -- * Stream Deserializer
+  Unpacker,
+  defaultInitialBufferSize,
+  newUnpacker,
+  unpackerReserveBuffer,
+  unpackerBuffer,
+  unpackerBufferCapacity,
+  unpackerBufferConsumed,
+  unpackerFeed,
+  unpackerExecute,
+  unpackerData,
+  unpackerReleaseZone,
+  unpackerResetZone,
+  unpackerReset,
+  unpackerMessageSize,
+  
+  -- * MessagePack Object
+  Object(..),
+  packObject,
+  
+  UnpackReturn(..),
+  unpackObject,
+  
+  -- * Memory Zone
+  Zone,
+  newZone,
+  freeZone,
+  withZone,
+  ) where
+
+import Control.Exception
+import Control.Monad
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS hiding (pack, unpack)
+import Data.Int
+import Data.Word
+import Foreign.C
+import Foreign.Concurrent
+import Foreign.ForeignPtr hiding (newForeignPtr)
+import Foreign.Marshal.Alloc
+import Foreign.Marshal.Array
+import Foreign.Ptr
+import Foreign.Storable
+
+#include <msgpack.h>
+
+type SimpleBuffer = ForeignPtr ()
+
+type WriteCallback = Ptr () -> CString -> CUInt -> IO CInt
+
+-- | Create a new Simple Buffer. It will be deleted automatically.
+newSimpleBuffer :: IO SimpleBuffer
+newSimpleBuffer = do
+  ptr <- mallocBytes (#size msgpack_sbuffer)
+  fptr <- newForeignPtr ptr $ do
+    msgpack_sbuffer_destroy ptr
+    free ptr
+  withForeignPtr fptr $ \p ->
+    msgpack_sbuffer_init p
+  return fptr
+
+-- | Get data of Simple Buffer.
+simpleBufferData :: SimpleBuffer -> IO ByteString
+simpleBufferData sb =
+  withForeignPtr sb $ \ptr -> do
+    size <- (#peek msgpack_sbuffer, size) ptr
+    dat  <- (#peek msgpack_sbuffer, data) ptr
+    BS.packCStringLen (dat, fromIntegral (size :: CSize))
+
+foreign import ccall "msgpack_sbuffer_init_wrap" msgpack_sbuffer_init ::
+  Ptr () -> IO ()
+
+foreign import ccall "msgpack_sbuffer_destroy_wrap" msgpack_sbuffer_destroy ::
+  Ptr () -> IO ()
+
+foreign import ccall "msgpack_sbuffer_write_wrap" msgpack_sbuffer_write ::
+  WriteCallback
+
+type Packer = ForeignPtr ()
+
+-- | Create new Packer. It will be deleted automatically.
+newPacker :: SimpleBuffer -> IO Packer
+newPacker sbuf = do
+  cb <- wrap_callback msgpack_sbuffer_write
+  ptr <- withForeignPtr sbuf $ \ptr ->
+    msgpack_packer_new ptr cb
+  fptr <- newForeignPtr ptr $ do
+    msgpack_packer_free ptr
+  return fptr
+
+foreign import ccall "msgpack_packer_new_wrap" msgpack_packer_new ::
+  Ptr () -> FunPtr WriteCallback -> IO (Ptr ())
+
+foreign import ccall "msgpack_packer_free_wrap" msgpack_packer_free ::
+  Ptr () -> IO ()
+
+foreign import ccall "wrapper" wrap_callback ::
+  WriteCallback -> IO (FunPtr WriteCallback)
+
+packU8 :: Packer -> Word8 -> IO Int
+packU8 pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_uint8 ptr n
+
+foreign import ccall "msgpack_pack_uint8_wrap" msgpack_pack_uint8 ::
+  Ptr () -> Word8 -> IO CInt
+
+packU16 :: Packer -> Word16 -> IO Int
+packU16 pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_uint16 ptr n
+
+foreign import ccall "msgpack_pack_uint16_wrap" msgpack_pack_uint16 ::
+  Ptr () -> Word16 -> IO CInt
+
+packU32 :: Packer -> Word32 -> IO Int
+packU32 pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_uint32 ptr n
+
+foreign import ccall "msgpack_pack_uint32_wrap" msgpack_pack_uint32 ::
+  Ptr () -> Word32 -> IO CInt
+
+packU64 :: Packer -> Word64 -> IO Int
+packU64 pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_uint64 ptr n
+
+foreign import ccall "msgpack_pack_uint64_wrap" msgpack_pack_uint64 ::
+  Ptr () -> Word64 -> IO CInt
+
+packS8 :: Packer -> Int8 -> IO Int
+packS8 pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_int8 ptr n
+
+foreign import ccall "msgpack_pack_int8_wrap" msgpack_pack_int8 ::
+  Ptr () -> Int8 -> IO CInt
+
+packS16 :: Packer -> Int16 -> IO Int
+packS16 pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_int16 ptr n
+
+foreign import ccall "msgpack_pack_int16_wrap" msgpack_pack_int16 ::
+  Ptr () -> Int16 -> IO CInt
+
+packS32 :: Packer -> Int32 -> IO Int
+packS32 pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_int32 ptr n
+
+foreign import ccall "msgpack_pack_int32_wrap" msgpack_pack_int32 ::
+  Ptr () -> Int32 -> IO CInt
+
+packS64 :: Packer -> Int64 -> IO Int
+packS64 pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_int64 ptr n
+
+foreign import ccall "msgpack_pack_int64_wrap" msgpack_pack_int64 ::
+  Ptr () -> Int64 -> IO CInt
+
+-- | Pack an integral data.
+packInt :: Integral a => Packer -> a -> IO Int
+packInt pc n = packS64 pc $ fromIntegral n
+
+-- | Pack a double data.
+packDouble :: Packer -> Double -> IO Int
+packDouble pc d =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_double ptr (realToFrac d)
+
+foreign import ccall "msgpack_pack_double_wrap" msgpack_pack_double ::
+  Ptr () -> CDouble -> IO CInt
+
+-- | Pack a nil.
+packNil :: Packer -> IO Int
+packNil pc =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_nil ptr
+
+foreign import ccall "msgpack_pack_nil_wrap" msgpack_pack_nil ::
+  Ptr () -> IO CInt
+
+packTrue :: Packer -> IO Int
+packTrue pc =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_true ptr
+
+foreign import ccall "msgpack_pack_true_wrap" msgpack_pack_true ::
+  Ptr () -> IO CInt
+
+packFalse :: Packer -> IO Int
+packFalse pc =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_false ptr
+
+foreign import ccall "msgpack_pack_false_wrap" msgpack_pack_false ::
+  Ptr () -> IO CInt
+
+-- | Pack a bool data.
+packBool :: Packer -> Bool -> IO Int
+packBool pc True  = packTrue pc
+packBool pc False = packFalse pc
+
+-- | 'packArray' @p n@ starts packing an array. 
+-- Next @n@ data will consist this array.
+packArray :: Packer -> Int -> IO Int
+packArray pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_array ptr (fromIntegral n)
+
+foreign import ccall "msgpack_pack_array_wrap" msgpack_pack_array ::
+  Ptr () -> CUInt -> IO CInt
+
+-- | 'packMap' @p n@ starts packing a map. 
+-- Next @n@ pairs of data (2*n data) will consist this map.
+packMap :: Packer -> Int -> IO Int
+packMap pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_map ptr (fromIntegral n)
+
+foreign import ccall "msgpack_pack_map_wrap" msgpack_pack_map ::
+  Ptr () -> CUInt -> IO CInt
+
+-- | 'packRAW' @p n@ starts packing a byte sequence. 
+-- Next total @n@ bytes of 'packRAWBody' call will consist this sequence.
+packRAW :: Packer -> Int -> IO Int
+packRAW pc n =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+    msgpack_pack_raw ptr (fromIntegral n)
+
+foreign import ccall "msgpack_pack_raw_wrap" msgpack_pack_raw ::
+  Ptr () -> CSize -> IO CInt
+
+-- | Pack a byte sequence.
+packRAWBody :: Packer -> ByteString -> IO Int
+packRAWBody pc bs =
+  liftM fromIntegral $ withForeignPtr pc $ \ptr ->
+  BS.useAsCStringLen bs $ \(str, len) ->
+    msgpack_pack_raw_body ptr (castPtr str) (fromIntegral len)
+
+foreign import ccall "msgpack_pack_raw_body_wrap" msgpack_pack_raw_body ::
+  Ptr () -> Ptr () -> CSize -> IO CInt
+
+-- | Pack a single byte stream. It calls 'packRAW' and 'packRAWBody'.
+packRAW' :: Packer -> ByteString -> IO Int
+packRAW' pc bs = do
+  packRAW pc (BS.length bs)
+  packRAWBody pc bs
+
+type Unpacker = ForeignPtr ()
+
+defaultInitialBufferSize :: Int
+defaultInitialBufferSize = 32 * 1024 -- #const MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE
+
+-- | 'newUnpacker' @initialBufferSize@ creates a new Unpacker. It will be deleted automatically.
+newUnpacker :: Int -> IO Unpacker
+newUnpacker initialBufferSize = do
+  ptr <- msgpack_unpacker_new (fromIntegral initialBufferSize)
+  fptr <- newForeignPtr ptr $ do
+    msgpack_unpacker_free ptr
+  return fptr
+
+foreign import ccall "msgpack_unpacker_new" msgpack_unpacker_new ::
+  CSize -> IO (Ptr ())
+
+foreign import ccall "msgpack_unpacker_free" msgpack_unpacker_free ::
+  Ptr() -> IO ()
+
+-- | 'unpackerReserveBuffer' @up size@ reserves at least @size@ bytes of buffer.
+unpackerReserveBuffer :: Unpacker -> Int -> IO Bool
+unpackerReserveBuffer up size =
+  withForeignPtr up $ \ptr ->
+  liftM (/=0) $ msgpack_unpacker_reserve_buffer ptr (fromIntegral size)
+
+foreign import ccall "msgpack_unpacker_reserve_buffer_wrap" msgpack_unpacker_reserve_buffer ::
+  Ptr () -> CSize -> IO CChar
+
+-- | Get a pointer of unpacker buffer.
+unpackerBuffer :: Unpacker -> IO (Ptr CChar)
+unpackerBuffer up =
+  withForeignPtr up $ \ptr ->
+  msgpack_unpacker_buffer ptr
+
+foreign import ccall "msgpack_unpacker_buffer_wrap" msgpack_unpacker_buffer ::
+  Ptr () -> IO (Ptr CChar)
+
+-- | Get size of allocated buffer.
+unpackerBufferCapacity :: Unpacker -> IO Int
+unpackerBufferCapacity up =
+  withForeignPtr up $ \ptr ->
+  liftM fromIntegral $ msgpack_unpacker_buffer_capacity ptr
+
+foreign import ccall "msgpack_unpacker_buffer_capacity_wrap" msgpack_unpacker_buffer_capacity ::
+  Ptr () -> IO CSize
+
+-- | 'unpackerBufferConsumed' @up size@ notices that writed @size@ bytes to buffer.
+unpackerBufferConsumed :: Unpacker -> Int -> IO ()
+unpackerBufferConsumed up size =
+  withForeignPtr up $ \ptr ->
+  msgpack_unpacker_buffer_consumed ptr (fromIntegral size)
+
+foreign import ccall "msgpack_unpacker_buffer_consumed_wrap" msgpack_unpacker_buffer_consumed ::
+  Ptr () -> CSize -> IO ()
+
+-- | Write byte sequence to Unpacker. It is utility funciton, calls 'unpackerReserveBuffer', 'unpackerBuffer' and 'unpackerBufferConsumed'.
+unpackerFeed :: Unpacker -> ByteString -> IO ()
+unpackerFeed up bs =
+  BS.useAsCStringLen bs $ \(str, len) -> do
+    True <- unpackerReserveBuffer up len
+    ptr <- unpackerBuffer up
+    copyArray ptr str len
+    unpackerBufferConsumed up len
+
+-- | Execute deserializing. It returns 0 when buffer contains not enough bytes, returns 1 when succeeded, returns negative value when it failed.
+unpackerExecute :: Unpacker -> IO Int
+unpackerExecute up =
+  withForeignPtr up $ \ptr ->
+  liftM fromIntegral $ msgpack_unpacker_execute ptr
+
+foreign import ccall "msgpack_unpacker_execute" msgpack_unpacker_execute ::
+  Ptr () -> IO CInt
+
+-- | Returns a deserialized object when 'unpackerExecute' returned 1.
+unpackerData :: Unpacker -> IO Object
+unpackerData up =
+  withForeignPtr up $ \ptr ->
+  allocaBytes (#size msgpack_object) $ \pobj -> do
+    msgpack_unpacker_data ptr pobj
+    peekObject pobj
+
+foreign import ccall "msgpack_unpacker_data_wrap" msgpack_unpacker_data ::
+  Ptr () -> Ptr () -> IO ()
+
+-- | Release memory zone. The returned zone must be freed by calling 'freeZone'.
+unpackerReleaseZone :: Unpacker -> IO Zone
+unpackerReleaseZone up =
+  withForeignPtr up $ \ptr ->
+  msgpack_unpacker_release_zone ptr
+
+foreign import ccall "msgpack_unpacker_release_zone" msgpack_unpacker_release_zone ::
+  Ptr () -> IO (Ptr ())
+
+-- | Free memory zone used by Unapcker.
+unpackerResetZone :: Unpacker -> IO ()
+unpackerResetZone up =
+  withForeignPtr up $ \ptr ->
+  msgpack_unpacker_reset_zone ptr
+
+foreign import ccall "msgpack_unpacker_reset_zone" msgpack_unpacker_reset_zone ::
+  Ptr () -> IO ()
+
+-- | Reset Unpacker state except memory zone.
+unpackerReset :: Unpacker -> IO ()
+unpackerReset up =
+  withForeignPtr up $ \ptr ->
+  msgpack_unpacker_reset ptr
+
+foreign import ccall "msgpack_unpacker_reset" msgpack_unpacker_reset ::
+  Ptr () -> IO ()
+
+-- | Returns number of bytes of sequence of deserializing object.
+unpackerMessageSize :: Unpacker -> IO Int
+unpackerMessageSize up =
+  withForeignPtr up $ \ptr ->
+  liftM fromIntegral $ msgpack_unpacker_message_size ptr
+
+foreign import ccall "msgpack_unpacker_message_size_wrap" msgpack_unpacker_message_size ::
+  Ptr () -> IO CSize
+
+type Zone = Ptr ()
+
+-- | Create a new memory zone. It must be freed manually.
+newZone :: IO Zone
+newZone =
+  msgpack_zone_new (#const MSGPACK_ZONE_CHUNK_SIZE)
+
+-- | Free a memory zone.
+freeZone :: Zone -> IO ()
+freeZone z =
+  msgpack_zone_free z
+
+-- | Create a memory zone, then execute argument, then free memory zone.
+withZone :: (Zone -> IO a) -> IO a
+withZone z =
+  bracket newZone freeZone z
+
+foreign import ccall "msgpack_zone_new" msgpack_zone_new ::
+  CSize -> IO Zone
+
+foreign import ccall "msgpack_zone_free" msgpack_zone_free ::
+  Zone -> IO ()
+
+-- | Object Representation of MessagePack data.
+data Object =
+  ObjectNil
+  | ObjectBool Bool
+  | ObjectInteger Int
+  | ObjectDouble Double
+  | ObjectRAW ByteString
+  | ObjectArray [Object]
+  | ObjectMap [(Object, Object)]
+  deriving (Show)
+
+peekObject :: Ptr a -> IO Object
+peekObject ptr = do
+  typ <- (#peek msgpack_object, type) ptr
+  case (typ :: CInt) of
+    (#const MSGPACK_OBJECT_NIL) ->
+      return ObjectNil
+    (#const MSGPACK_OBJECT_BOOLEAN) ->
+      peekObjectBool ptr
+    (#const MSGPACK_OBJECT_POSITIVE_INTEGER) ->
+      peekObjectPositiveInteger ptr
+    (#const MSGPACK_OBJECT_NEGATIVE_INTEGER) ->
+      peekObjectNegativeInteger ptr
+    (#const MSGPACK_OBJECT_DOUBLE) ->
+      peekObjectDouble ptr
+    (#const MSGPACK_OBJECT_RAW) ->
+      peekObjectRAW ptr
+    (#const MSGPACK_OBJECT_ARRAY) ->
+      peekObjectArray ptr
+    (#const MSGPACK_OBJECT_MAP) ->
+      peekObjectMap ptr
+    _ ->
+      fail "peekObject: unknown object type"
+
+peekObjectBool :: Ptr a -> IO Object
+peekObjectBool ptr = do
+  b <- (#peek msgpack_object, via.boolean) ptr
+  return $ ObjectBool $ (b :: CUChar) /= 0
+
+peekObjectPositiveInteger :: Ptr a -> IO Object
+peekObjectPositiveInteger ptr = do
+  n <- (#peek msgpack_object, via.u64) ptr
+  return $ ObjectInteger $ fromIntegral (n :: Word64)
+
+peekObjectNegativeInteger :: Ptr a -> IO Object
+peekObjectNegativeInteger ptr = do
+  n <- (#peek msgpack_object, via.i64) ptr
+  return $ ObjectInteger $ fromIntegral (n :: Int64)
+
+peekObjectDouble :: Ptr a -> IO Object
+peekObjectDouble ptr = do
+  d <- (#peek msgpack_object, via.dec) ptr
+  return $ ObjectDouble $ realToFrac (d :: CDouble)
+
+peekObjectRAW :: Ptr a -> IO Object
+peekObjectRAW ptr = do
+  size <- (#peek msgpack_object, via.raw.size) ptr
+  p    <- (#peek msgpack_object, via.raw.ptr) ptr
+  bs   <- BS.packCStringLen (p, fromIntegral (size :: Word32))
+  return $ ObjectRAW bs
+
+peekObjectArray :: Ptr a -> IO Object
+peekObjectArray ptr = do
+  size <- (#peek msgpack_object, via.array.size) ptr
+  p    <- (#peek msgpack_object, via.array.ptr) ptr
+  objs <- mapM (\i -> peekObject $ p `plusPtr`
+                      ((#size msgpack_object) * i))
+          [0..size-1]
+  return $ ObjectArray objs
+
+peekObjectMap :: Ptr a -> IO Object
+peekObjectMap ptr = do
+  size <- (#peek msgpack_object, via.map.size) ptr
+  p    <- (#peek msgpack_object, via.map.ptr) ptr
+  dat  <- mapM (\i -> peekObjectKV $ p `plusPtr`
+                      ((#size msgpack_object_kv) * i))
+          [0..size-1]
+  return $ ObjectMap dat
+
+peekObjectKV :: Ptr a -> IO (Object, Object)
+peekObjectKV ptr = do
+  k <- peekObject $ ptr `plusPtr` (#offset msgpack_object_kv, key)
+  v <- peekObject $ ptr `plusPtr` (#offset msgpack_object_kv, val)
+  return (k, v)
+
+-- | Pack a Object.
+packObject :: Packer -> Object -> IO ()
+packObject pc ObjectNil = packNil pc >> return ()
+
+packObject pc (ObjectBool b) = packBool pc b >> return ()
+
+packObject pc (ObjectInteger n) = packInt pc n >> return ()
+
+packObject pc (ObjectDouble d) = packDouble pc d >> return ()
+
+packObject pc (ObjectRAW bs) = packRAW' pc bs >> return ()
+
+packObject pc (ObjectArray ls) = do
+  packArray pc (length ls)
+  mapM_ (packObject pc) ls
+
+packObject pc (ObjectMap ls) = do
+  packMap pc (length ls)
+  mapM_ (\(a, b) -> packObject pc a >> packObject pc b) ls
+
+data UnpackReturn =
+  UnpackContinue     -- ^ not enough bytes to unpack object
+  | UnpackParseError -- ^ got invalid bytes
+  | UnpackError      -- ^ other error
+  deriving (Eq, Show)
+
+-- | Unpack a single MessagePack object from byte sequence.
+unpackObject :: Zone -> ByteString -> IO (Either UnpackReturn (Int, Object))
+unpackObject z dat =
+  allocaBytes (#size msgpack_object) $ \ptr ->
+  BS.useAsCStringLen dat $ \(str, len) ->
+  alloca $ \poff -> do
+    ret <- msgpack_unpack str (fromIntegral len) poff z ptr
+    case ret of
+      (#const MSGPACK_UNPACK_SUCCESS) -> do
+        off <- peek poff
+        obj <- peekObject ptr
+        return $ Right (fromIntegral off, obj)
+      (#const MSGPACK_UNPACK_EXTRA_BYTES) -> do
+        off <- peek poff
+        obj <- peekObject ptr
+        return $ Right (fromIntegral off, obj)
+      (#const MSGPACK_UNPACK_CONTINUE) ->
+        return $ Left UnpackContinue
+      (#const MSGPACK_UNPACK_PARSE_ERROR) ->
+        return $ Left UnpackParseError
+      _ ->
+        return $ Left UnpackError
+
+foreign import ccall "msgpack_unpack" msgpack_unpack ::
+  Ptr CChar -> CSize -> Ptr CSize -> Zone -> Ptr () -> IO CInt

haskell/src/Data/MessagePack/Class.hs

@@ -0,0 +1,97 @@
+{-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE OverlappingInstances #-}
+{-# LANGUAGE IncoherentInstances #-}
+
+--------------------------------------------------------------------
+-- |
+-- Module    : Data.MessagePack.Class
+-- Copyright : (c) Hideyuki Tanaka, 2009
+-- License   : BSD3
+--
+-- Maintainer:  tanaka.hideyuki@gmail.com
+-- Stability :  experimental
+-- Portability: portable
+--
+-- Serializing Haskell values to and from MessagePack Objects.
+--
+--------------------------------------------------------------------
+
+module Data.MessagePack.Class(
+  -- * Serialization to and from Object
+  OBJECT(..),
+  Result,
+  pack,
+  ) where
+
+import Control.Monad.Error
+import Data.ByteString.Char8 (ByteString)
+import qualified Data.ByteString.Char8 as C8
+import Data.Either
+
+import Data.MessagePack.Base
+
+-- | The class of types serializable to and from MessagePack object
+class OBJECT a where
+  toObject :: a -> Object
+  fromObject :: Object -> Result a
+
+-- | A type for parser results
+type Result a = Either String a
+
+instance OBJECT Object where
+  toObject = id
+  fromObject = Right
+
+fromObjectError :: String
+fromObjectError = "fromObject: cannot cast"
+
+instance OBJECT Int where
+  toObject = ObjectInteger
+  fromObject (ObjectInteger n) = Right n
+  fromObject _ = Left fromObjectError
+
+instance OBJECT Bool where
+  toObject = ObjectBool
+  fromObject (ObjectBool b) = Right b
+  fromObject _ = Left fromObjectError
+
+instance OBJECT Double where
+  toObject = ObjectDouble
+  fromObject (ObjectDouble d) = Right d
+  fromObject _ = Left fromObjectError
+
+instance OBJECT ByteString where
+  toObject = ObjectRAW
+  fromObject (ObjectRAW bs) = Right bs
+  fromObject _ = Left fromObjectError
+
+instance OBJECT String where
+  toObject = toObject . C8.pack
+  fromObject obj = liftM C8.unpack $ fromObject obj
+
+instance OBJECT a => OBJECT [a] where
+  toObject = ObjectArray . map toObject
+  fromObject (ObjectArray arr) =
+    mapM fromObject arr
+  fromObject _ =
+    Left fromObjectError
+
+instance (OBJECT a, OBJECT b) => OBJECT [(a, b)] where
+  toObject =
+    ObjectMap . map (\(a, b) -> (toObject a, toObject b))
+  fromObject (ObjectMap mem) = do
+    mapM (\(a, b) -> liftM2 (,) (fromObject a) (fromObject b)) mem
+  fromObject _ =
+    Left fromObjectError
+
+instance OBJECT a => OBJECT (Maybe a) where
+  toObject (Just a) = toObject a
+  toObject Nothing = ObjectNil
+  
+  fromObject ObjectNil = return Nothing
+  fromObject obj = liftM Just $ fromObject obj
+
+-- | Pack a serializable Haskell value.
+pack :: OBJECT a => Packer -> a -> IO ()
+pack pc = packObject pc . toObject

haskell/src/Data/MessagePack/Feed.hs

@@ -0,0 +1,59 @@
+--------------------------------------------------------------------
+-- |
+-- Module    : Data.MessagePack.Feed
+-- Copyright : (c) Hideyuki Tanaka, 2009
+-- License   : BSD3
+--
+-- Maintainer:  tanaka.hideyuki@gmail.com
+-- Stability :  experimental
+-- Portability: portable
+--
+-- Feeders for Stream Deserializers
+--
+--------------------------------------------------------------------
+
+module Data.MessagePack.Feed(
+  -- * Feeder type
+  Feeder,
+  -- * Feeders
+  feederFromHandle,
+  feederFromFile,
+  feederFromString,
+  ) where
+
+import Control.Monad
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
+import Data.IORef
+import System.IO
+
+-- | Feeder returns Just ByteString when bytes remains, otherwise Nothing.
+type Feeder = IO (Maybe ByteString)
+
+-- | Feeder from Handle
+feederFromHandle :: Handle -> IO Feeder
+feederFromHandle h = return $ do
+  bs <- BS.hGet h bufSize
+  if BS.length bs > 0
+    then return $ Just bs
+    else do
+    hClose h
+    return Nothing
+  where
+    bufSize = 4096
+
+-- | Feeder from File
+feederFromFile :: FilePath -> IO Feeder
+feederFromFile path =
+  openFile path ReadMode >>= feederFromHandle
+
+-- | Feeder from ByteString
+feederFromString :: ByteString -> IO Feeder
+feederFromString bs = do
+  r <- newIORef (Just bs)
+  return $ f r
+  where
+    f r = do
+      mb <- readIORef r
+      writeIORef r Nothing
+      return mb

haskell/src/Data/MessagePack/Monad.hs

@@ -0,0 +1,153 @@
+--------------------------------------------------------------------
+-- |
+-- Module    : Data.MessagePack.Monad
+-- Copyright : (c) Hideyuki Tanaka, 2009
+-- License   : BSD3
+--
+-- Maintainer:  tanaka.hideyuki@gmail.com
+-- Stability :  experimental
+-- Portability: portable
+--
+-- Monadic Stream Serializers and Deserializers
+--
+--------------------------------------------------------------------
+
+module Data.MessagePack.Monad(
+  -- * Classes
+  MonadPacker(..),
+  MonadUnpacker(..),
+  
+  -- * Packer and Unpacker type
+  PackerT(..),
+  UnpackerT(..),
+  
+  -- * Packers
+  packToString,
+  packToHandle,
+  packToFile,
+  
+  -- * Unpackers
+  unpackFrom,
+  unpackFromString,
+  unpackFromHandle,
+  unpackFromFile,
+  ) where
+
+import Control.Monad
+import Control.Monad.Trans
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
+import System.IO
+
+import Data.MessagePack.Base hiding (Unpacker)
+import qualified Data.MessagePack.Base as Base
+import Data.MessagePack.Class
+import Data.MessagePack.Feed
+
+class Monad m => MonadPacker m where
+  -- | Serialize a object
+  put :: OBJECT a => a -> m ()
+
+class Monad m => MonadUnpacker m where
+  -- | Deserialize a object
+  get :: OBJECT a => m a
+
+-- | Serializer Type
+newtype PackerT m r = PackerT { runPackerT :: Base.Packer -> m r }
+
+instance Monad m => Monad (PackerT m) where
+  a >>= b =
+    PackerT $ \pc -> do
+      r <- runPackerT a pc
+      runPackerT (b r) pc
+  
+  return r =
+    PackerT $ \_ -> return r
+
+instance MonadTrans PackerT where
+  lift m = PackerT $ \_ -> m
+
+instance MonadIO m => MonadIO (PackerT m) where
+  liftIO = lift . liftIO
+
+instance MonadIO m => MonadPacker (PackerT m) where
+  put v = PackerT $ \pc -> liftIO $ do
+    pack pc v
+
+-- | Execute given serializer and returns byte sequence.
+packToString :: MonadIO m => PackerT m r -> m ByteString
+packToString m = do
+  sb <- liftIO $ newSimpleBuffer
+  pc <- liftIO $ newPacker sb
+  runPackerT m pc
+  liftIO $ simpleBufferData sb
+
+-- | Execcute given serializer and write byte sequence to Handle.
+packToHandle :: MonadIO m => Handle -> PackerT m r -> m ()
+packToHandle h m = do
+  sb <- packToString m
+  liftIO $ BS.hPut h sb
+  liftIO $ hFlush h
+
+-- | Execute given serializer and write byte sequence to file.
+packToFile :: MonadIO m => FilePath -> PackerT m r -> m ()
+packToFile p m = do
+  sb <- packToString m
+  liftIO $ BS.writeFile p sb
+
+-- | Deserializer type
+newtype UnpackerT m r = UnpackerT { runUnpackerT :: Base.Unpacker -> Feeder -> m r }
+
+instance Monad m => Monad (UnpackerT m) where
+  a >>= b =
+    UnpackerT $ \up feed -> do
+      r <- runUnpackerT a up feed
+      runUnpackerT (b r) up feed
+  
+  return r =
+    UnpackerT $ \_ _ -> return r
+
+instance MonadTrans UnpackerT where
+  lift m = UnpackerT $ \_ _ -> m
+
+instance MonadIO m => MonadIO (UnpackerT m) where
+  liftIO = lift . liftIO
+
+instance MonadIO m => MonadUnpacker (UnpackerT m) where
+  get = UnpackerT $ \up feed -> liftIO $ do
+    resp <- unpackerExecute up
+    guard $ resp>=0
+    when (resp==0) $ do
+      Just bs <- feed
+      unpackerFeed up bs
+      resp2 <- unpackerExecute up
+      guard $ resp2==1
+    obj <- unpackerData up
+    freeZone =<< unpackerReleaseZone up
+    unpackerReset up
+    let Right r = fromObject obj
+    return r
+
+-- | Execute deserializer using given feeder.
+unpackFrom :: MonadIO m => Feeder -> UnpackerT m r -> m r
+unpackFrom f m = do
+  up <- liftIO $ newUnpacker defaultInitialBufferSize
+  runUnpackerT m up f
+
+-- | Execute deserializer using given handle.
+unpackFromHandle :: MonadIO m => Handle -> UnpackerT m r -> m r
+unpackFromHandle h m =
+  flip unpackFrom m =<< liftIO (feederFromHandle h)
+
+-- | Execute deserializer using given file content.
+unpackFromFile :: MonadIO m => FilePath -> UnpackerT m r -> m r
+unpackFromFile p m = do
+  h <- liftIO $ openFile p ReadMode
+  r <- flip unpackFrom m =<< liftIO (feederFromHandle h)
+  liftIO $ hClose h
+  return r
+
+-- | Execute deserializer from given byte sequence.
+unpackFromString :: MonadIO m => ByteString -> UnpackerT m r -> m r
+unpackFromString bs m = do
+  flip unpackFrom m =<< liftIO (feederFromString bs)

haskell/src/Data/MessagePack/Stream.hs

@@ -0,0 +1,84 @@
+--------------------------------------------------------------------
+-- |
+-- Module    : Data.MessagePack.Stream
+-- Copyright : (c) Hideyuki Tanaka, 2009
+-- License   : BSD3
+--
+-- Maintainer:  tanaka.hideyuki@gmail.com
+-- Stability :  experimental
+-- Portability: portable
+--
+-- Lazy Stream Serializers and Deserializers
+--
+--------------------------------------------------------------------
+
+module Data.MessagePack.Stream(
+  unpackObjects,
+  unpackObjectsFromFile,
+  unpackObjectsFromHandle,
+  unpackObjectsFromString,
+  ) where
+
+import Control.Monad
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
+import System.IO
+import System.IO.Unsafe
+
+import Data.MessagePack.Base
+import Data.MessagePack.Feed
+
+-- | Unpack objects using given feeder.
+unpackObjects :: Feeder -> IO [Object]
+unpackObjects feeder = do
+  up <- newUnpacker defaultInitialBufferSize
+  f up
+  where
+  f up = unsafeInterleaveIO $ do
+    mbo <- unpackOnce up
+    case mbo of
+      Just o -> do
+        os <- f up
+        return $ o:os
+      Nothing ->
+        return []
+
+  unpackOnce up = do
+    resp <- unpackerExecute up
+    case resp of
+      0 -> do
+        r <- feedOnce up
+        if r
+          then unpackOnce up
+          else return Nothing
+      1 -> do
+        obj <- unpackerData up
+        freeZone =<< unpackerReleaseZone up
+        unpackerReset up
+        return $ Just obj
+      _ ->
+        error $ "unpackerExecute fails: " ++ show resp
+
+  feedOnce up = do
+    dat <- feeder
+    case dat of
+      Nothing ->
+        return False
+      Just bs -> do
+        unpackerFeed up bs
+        return True
+
+-- | Unpack objects from file.
+unpackObjectsFromFile :: FilePath -> IO [Object]
+unpackObjectsFromFile fname =
+  unpackObjects =<< feederFromFile fname
+
+-- | Unpack objects from handle.
+unpackObjectsFromHandle :: Handle -> IO [Object]
+unpackObjectsFromHandle h =
+  unpackObjects =<< feederFromHandle h
+  
+-- | Unpack oobjects from given byte sequence.
+unpackObjectsFromString :: ByteString -> IO [Object]
+unpackObjectsFromString bs =
+  unpackObjects =<< feederFromString bs

haskell/test/Monad.hs

@@ -0,0 +1,16 @@
+import Control.Monad.Trans
+import Data.MessagePack
+
+main = do
+  sb <- packToString $ do
+    put [1,2,3::Int]
+    put (3.14 :: Double)
+    put "Hoge"
+  
+  print sb
+  
+  unpackFromString sb $ do
+    arr <- get
+    dbl <- get
+    str <- get
+    liftIO $ print (arr :: [Int], dbl :: Double, str :: String)

haskell/test/Stream.hs

@@ -0,0 +1,14 @@
+import Control.Applicative
+import qualified Data.ByteString as BS
+import Data.MessagePack
+
+main = do
+  sb <- newSimpleBuffer
+  pc <- newPacker sb
+  pack pc [1,2,3::Int]
+  pack pc True
+  pack pc "hoge"
+  bs <- simpleBufferData sb
+  
+  os <- unpackObjectsFromString bs
+  mapM_ print os

haskell/test/Test.hs

@@ -0,0 +1,36 @@
+import Control.Monad
+import Data.MessagePack
+
+{-
+main = do
+  sb <- newSimpleBuffer
+  pc <- newPacker sb
+  
+  pack pc [(1,2),(2,3),(3::Int,4::Int)]
+  pack pc [4,5,6::Int]
+  pack pc "hoge"
+  
+  bs <- simpleBufferData sb
+  print bs
+  
+  up <- newUnpacker defaultInitialBufferSize
+  
+  unpackerFeed up bs
+
+  let f = do
+        res <- unpackerExecute up
+        when (res==1) $ do
+          obj <- unpackerData up
+          print obj
+          f
+  
+  f
+
+  return ()
+-}
+
+main = do
+  bs <- packb [(1,2),(2,3),(3::Int,4::Int)]
+  print bs
+  dat <- unpackb bs
+  print (dat :: Result [(Int, Int)])

java/.gitignore

@@ -0,0 +1,4 @@
+target
+.project
+.classpath
+*~

java/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,5 @@
+#Mon Apr 19 22:18:48 JST 2010
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.compliance=1.6

java/Makefile

@@ -0,0 +1,24 @@
+
+.PHONY: compile test eclipse clean package
+
+all:
+	compile
+
+package:
+	mvn package
+
+install:
+	mvn install
+
+compile:
+	mvn compile
+
+test:
+	mvn test
+
+# generate .project and .classpath file for Eclipse
+eclipse:
+	mvn eclipse:eclipse
+
+clean:
+	mvn clean

java/README

@@ -0,0 +1,28 @@
+
+To build the JAR file of Message Pack, you need to install Maven (http://maven.apache.org), then type the following command:
+
+$ mvn package
+
+To locally install the project, type
+$ mvn install
+
+To generate project files (.project, .classpath) for Eclipse, do 
+
+$ mvn eclipse:eclipse
+
+then import the folder from your Eclipse. 
+
+Next, open the preference page in Eclipse and add the CLASSPATH variable:
+
+M2_REPO = $HOME/.m2/repository
+
+where $HOME is your home directory. In Windows XP, $HOME is:
+C:/Documents and Settings/(user name)/.m2/repository 
+
+
+# How to release the project (compile, test, tagging, deploy)
+
+$ mvn release:prepare
+$ mvn release:perform
+
+

java/build.xml

@@ -1,18 +1,303 @@
-<project name="MessagePack for Java">
-	<target name="prepare">
-		<mkdir dir="build" />
-		<mkdir dir="dist" />
-	</target>
-	<target name="clean">
-		<delete dir="build"/>
-		<delete dir="dist"/>
-	</target>
-	<target name="compile" depends="prepare">
-		<javac srcdir="src" destdir="build" source="1.5" target="1.5">
-			<compilerarg value="-Xlint:unchecked" />
-		</javac>
-	</target>
-	<target name="jar" depends="compile">
-		<jar jarfile="dist/msgpack-0.0.0.jar" basedir="build" />
-	</target>
+<project name="MessagePack for Java" default="jar"
+    xmlns:ivy="antlib:org.apache.ivy.ant"
+    xmlns:mvn="urn:maven-artifact-ant">
+
+  <property name="Name" value="MessagePack"/>
+  <property name="name" value="msgpack"/>
+  <property name="version" value="0.0.1"/>
+  <property name="fullname" value="${name}-${version}"/>
+  <property name="year" value="2010"/>
+
+  <!-- Load user's default properties. -->
+  <property file="${user.home}/build.properties" />
+
+  <property name="src.dir" value="${basedir}/src/main/java"/>  	
+  <property name="java.src.dir" value="${src.dir}/"/>
+  <property name="build.dir" value="${basedir}/build"/>
+  <property name="lib.dir" value="${basedir}/lib"/>
+  <property name="dist.dir" value="${basedir}/dist"/>
+
+  <property name="build.classes" value="${build.dir}/classes"/>
+  <property name="build.doc" value="${build.dir}/doc"/>
+  <property name="build.javadoc" value="${build.doc}/api/"/>
+  <property name="build.javadoc.log" value="${build.dir}/javadoc.log"/>
+
+  <property name="test.count" value="100"/>
+  <property name="test.junit.output.format" value="plain"/>
+  <property name="test.java.src.dir" value="${basedir}/src/test/java"/>
+  <property name="test.java.build.dir" value="${build.dir}/test"/>
+  <property name="test.java.classes" value="${test.java.build.dir}/classes"/>
+  <property name="test.java.include" value="Test*"/>
+ 
+  <property name="javac.encoding" value="ISO-8859-1"/>
+  <property name="javac.debug" value="on"/>
+  <property name="javac.optimize" value="on"/>
+  <property name="javac.deprecation" value="off"/>
+  <property name="javac.version" value="1.6"/>
+  <property name="javac.args" value=""/>
+  <property name="javac.args.warnings" value="-Xlint:unchecked"/>
+
+  <property name="javadoc.link.java"
+	    value="http://java.sun.com/javase/6/docs/api/"/>
+  <property name="javadoc.packages" value="org.${name}.*"/>
+
+  <!-- ivy settings -->
+  <property name="ivy.version" value="2.1.0"/>
+  <property name="ivy.url"
+	    value="http://repo2.maven.org/maven2/org/apache/ivy/ivy" />
+  <property name="ivy.home" value="${user.home}/.ant" />
+  <property name="ivy.lib" value="${build.dir}/lib"/>
+  <property name="ivy.test.lib" value="${build.dir}/test/lib"/>
+  <property name="mvn.repo"
+	    value="https://repository.apache.org/content/repositories/snapshots"/>
+
+  <!-- the normal classpath -->
+  <path id="libs">
+    <fileset dir="${ivy.lib}">
+      <include name="**/*.jar" />
+    </fileset>
+  </path>
+  <path id="java.classpath">
+    <pathelement location="${build.classes}"/>
+    <fileset dir="${lib.dir}">
+      <include name="**/*.jar" />
+      <exclude name="**/excluded/" />
+    </fileset>
+    <fileset dir="${ant.home}/lib">
+      <include name="ant.jar" />
+    </fileset>
+    <path refid="libs" />
+  </path>
+  <path id="test.libs">
+    <fileset dir="${ivy.test.lib}">
+      <include name="**/*.jar" />
+    </fileset>
+  </path>
+  <path id="test.java.classpath">
+    <pathelement location="${test.java.classes}" />
+    <path refid="java.classpath"/>
+    <path refid="test.libs"/>
+  </path>
+
+  <!-- init & clean -->
+  <target name="init">
+    <mkdir dir="${build.dir}" />
+    <mkdir dir="${lib.dir}" />
+    <mkdir dir="${build.classes}" />
+
+    <mkdir dir="${test.java.build.dir}"/>
+    <mkdir dir="${test.java.classes}"/>
+
+    <mkdir dir="${ivy.lib}"/>
+    <mkdir dir="${ivy.test.lib}"/>
+    <condition property="ivy.jar.exists">
+      <available file="${lib.dir}/ivy-${ivy.version}.jar"/>
+    </condition>
+  </target>
+  <target name="clean">
+    <delete dir="${build.dir}" />
+  </target>
+
+  <!-- ivy targets -->
+  <target name="ivy-download" unless="ivy.jar.exists" depends="init">
+    <delete dir="${lib.dir}"
+	    includes="ivy-*.jar" excludes="ivy-${ivy.version}.jar"/>
+    <get src="${ivy.url}/${ivy.version}/ivy-${ivy.version}.jar"
+         dest="${lib.dir}/ivy-${ivy.version}.jar" usetimestamp="true"/>
+  </target>
+  <target name="ivy-init" depends="ivy-download" unless="ivy.initialized">
+    <taskdef resource="org/apache/ivy/ant/antlib.xml"
+             uri="antlib:org.apache.ivy.ant" classpathref="java.classpath"/>
+    <!-- ensure that ivy taskdef is only run once, otw ant will error -->
+    <property name="ivy.initialized" value="true"/>
+  </target>
+   
+ <target name="ivy-retrieve-build" depends="init,ivy-init">
+    <ivy:retrieve type="jar" conf="build"
+		  pattern="${ivy.lib}/[artifact]-[revision].[ext]"/>
+ </target>
+ <target name="ivy-retrieve-test" depends="init,ivy-init">
+    <ivy:retrieve type="jar" conf="test"
+		  pattern="${ivy.test.lib}/[artifact]-[revision].[ext]"/>
+ </target>
+
+  <!-- compiler -->
+  <macrodef name="java-compiler">
+    <attribute name="dest" default="${build.classes}"/>
+    <attribute name="includes" default="**/*.java"/>
+    <attribute name="excludes" default=""/>
+    <attribute name="classpath" default="java.classpath"/>
+    <element name="src" implicit="yes"/>
+    <sequential>
+      <javac 
+	 destdir="@{dest}"
+         includes="@{includes}"
+         excludes="@{excludes}" 
+	 encoding="${javac.encoding}" 
+	 debug="${javac.debug}"
+	 optimize="${javac.optimize}"
+	 target="${javac.version}"
+	 source="${javac.version}"
+	 deprecation="${javac.deprecation}">
+	<compilerarg line="${javac.args} ${javac.args.warnings}" />
+	<classpath refid="@{classpath}"/>
+        <src />
+      </javac>
+    </sequential>
+  </macrodef>
+
+  <!-- compile -->
+  <target name="compile" depends="init,ivy-retrieve-build">
+    <java-compiler>
+      <src path="${java.src.dir}"/>
+    </java-compiler>
+  </target>
+
+  <!-- test -->
+  <macrodef name="test-runner">
+    <attribute name="files.location" />
+    <attribute name="tests.pattern" />
+    <attribute name="test.dir" default="${test.java.build.dir}" />
+    <sequential>
+      <junit showoutput="yes"
+             printsummary="withOutAndErr"
+             haltonfailure="no"
+             fork="yes" forkMode="once"
+             errorProperty="tests.failed" failureProperty="tests.failed">
+        <sysproperty key="test.count" value="${test.count}"/>
+        <sysproperty key="test.dir" value="@{test.dir}"/>
+        <classpath refid="test.java.classpath"/>
+        <formatter type="${test.junit.output.format}"/>
+        <batchtest todir="${test.java.build.dir}" unless="testcase">
+          <fileset dir="@{files.location}"
+		   includes="@{tests.pattern}"
+		   excludes="**/${test.java.exclude}.java" />
+        </batchtest>
+        <batchtest todir="${test.java.build.dir}" if="testcase">
+          <fileset dir="@{files.location}" includes="**/${testcase}.java"/>
+        </batchtest>
+      </junit>
+      <fail if="tests.failed">Tests Failed!</fail>
+    </sequential>
+  </macrodef>
+  <target name="compile-test" depends="ivy-retrieve-test,compile">
+    <java-compiler dest="${test.java.classes}"
+		   classpath="test.java.classpath">
+      <src path="${test.java.src.dir}/org" />
+    </java-compiler>
+  </target>
+  <target name="test" depends="init,compile-test">
+    <test-runner files.location="${test.java.src.dir}"
+                 tests.pattern="**/${test.java.include}.java"/>
+  </target>
+
+  <!-- jar -->
+  <target name="jar" depends="compile">
+    <jar jarfile="${build.dir}/${name}-${version}.jar" basedir="${build.classes}" >
+      <manifest>
+        <section name="org/${name}">
+          <attribute name="Implementation-Title" value="${Name}"/>
+          <attribute name="Implementation-Version" value="${version}"/>
+        </section>
+      </manifest>
+    </jar>
+  </target>
+
+  <!-- javadoc -->
+  <target name="javadoc" depends="compile" description="Generate javadoc">
+    <mkdir dir="${build.javadoc}"/>
+    <record name="${build.javadoc.log}" action="start"/>
+    <javadoc
+      Locale="en_US"
+      packagenames="org.${org}.${name}.*"
+      destdir="${build.javadoc}"
+      encoding="UTF-8"
+      docencoding="UTF-8"
+      author="true"
+      version="true"
+      use="true"
+      windowtitle="${Name} ${version} API"
+      doctitle="${Name} ${version} API"
+      bottom="Copyright &amp;copy; ${year} The ${Name} Project"
+      >
+        <packageset dir="${java.src.dir}"/>
+        <link href="${javadoc.link.java}"/>
+        <classpath >
+          <path refid="java.classpath" />
+        </classpath>
+    </javadoc>
+    <record name="${build.javadoc.log}" action="stop"/>
+    <condition property="javadoc.warnings">
+      <isfileselected file="${build.javadoc.log}">
+	<contains text=": warning - "/>
+      </isfileselected>
+    </condition>
+    <fail if="javadoc.warnings">Javadoc warnings!</fail>
+  </target>
+  <target name="javadoc-jar" depends="javadoc">
+    <jar jarfile="${build.dir}/${fullname}-javadoc.jar">
+      <fileset dir="${build.javadoc}" includes="**/*"/>
+    </jar>
+  </target>
+
+  <!-- sources -->
+  <target name="source">
+    <jar jarfile="${build.dir}/${fullname}-sources.jar">
+      <fileset dir="${java.src.dir}" includes="**/*.java"/>
+    </jar>
+  </target>
+
+  <!-- pom -->
+  <target name="pom" depends="ivy-init">
+    <ivy:makepom ivyfile="${basedir}/ivy.xml"
+		 pomfile="${dist.dir}/${fullname}.pom">
+      <mapping conf="default" scope="compile"/>
+      <mapping conf="test" scope="test"/>
+    </ivy:makepom>
+  </target>
+
+  <!-- dist -->
+  <target name="dist" depends="jar, pom, source, javadoc-jar"
+	  description="Build distribution">
+    <mkdir dir="${dist.dir}"/>
+    <copy todir="${dist.dir}"> 
+      <fileset file="${build.dir}/${fullname}.jar"/>
+      <fileset file="${build.dir}/${fullname}-sources.jar"/>
+      <fileset file="${build.dir}/${fullname}-javadoc.jar"/>
+    </copy>
+  </target>
+
+  <!-- maven: install msgpack into local m2 cache -->
+  <target name="mvn-install" depends="jar, pom, source, javadoc-jar"
+	  description="Installs msgpack to local m2 cache">
+    <typedef resource="org/apache/maven/artifact/ant/antlib.xml"
+	     uri="urn:maven-artifact-ant"
+	     classpathref="java.classpath"/>
+    <mvn:pom file="${dist.dir}/${fullname}.pom" id="msgpack"/>
+    <mvn:install file="${build.dir}/${fullname}.jar">
+      <attach file="${build.dir}/${fullname}-sources.jar"
+           classifier="sources" />
+      <attach file="${build.dir}/${fullname}-javadoc.jar"
+           classifier="javadoc" />
+      <pom refid="msgpack"/>
+    </mvn:install>
+  </target>
+
+  <!-- maven: create local repository into ${basedir}/maven2 -->
+  <target name="mvn-deploy" depends="jar, pom, source, javadoc-jar"
+     description="Deploys MessagePack to Maven repo.">
+    <typedef resource="org/apache/maven/artifact/ant/antlib.xml"
+	     uri="urn:maven-artifact-ant"
+	     classpathref="java.classpath"/>
+    <mvn:pom file="${dist.dir}/${fullname}.pom" id="msgpack"/>
+    <mvn:deploy file="${build.dir}/${fullname}.jar">
+      <remoteRepository url="file://localhost/${basedir}/maven2/"/>
+      <attach file="${build.dir}/${fullname}-sources.jar"
+           classifier="sources" />
+      <attach file="${build.dir}/${fullname}-javadoc.jar"
+           classifier="javadoc" />
+      <pom refid="msgpack"/>
+    </mvn:deploy>
+  </target>
+
 </project>

java/ivy.xml

@@ -0,0 +1,19 @@
+<ivy-module version="2.0"
+            xmlns:e="http://ant.apache.org/ivy/extra">
+
+  <info organisation="org"
+    module="${name}" revision="${version}">
+    <ivyauthor name="MessagePack Project" url="http://msgpack.sourceforge.net/"/>
+    <description>MessagePack</description>
+  </info>
+
+  <configurations defaultconfmapping="default">
+    <conf name="default"/> <!-- "runtime" configuration -->
+    <conf name="test"/>
+    <conf name="build" extends="default"/>
+  </configurations>
+
+  <dependencies>
+    <dependency org="junit" name="junit" rev="4.8.1" conf="test->default"/>
+  </dependencies>
+</ivy-module>

java/pom.xml

@@ -0,0 +1,109 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.msgpack</groupId>
+  <artifactId>msgpack</artifactId>
+  <name>MessagePack for Java</name>
+  <version>1.0-SNAPSHOT</version>
+  <description>MessagePack for Java</description>
+
+  <licenses>
+    <license>
+      <name>The Apache Software License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <scm>
+    <connection>scm:git://github.com/msgpack/msgpack.git</connection>
+  </scm>
+
+  <build>
+    <resources>
+      <resource>
+        <directory>src/main/resources</directory>
+      </resource>
+    </resources>
+    <testResources>
+      <testResource>
+        <directory>src/test/resources</directory>
+      </testResource>
+    </testResources>
+
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
+
+      <plugin>
+      	<artifactId>maven-eclipse-plugin</artifactId>
+      	<version>2.5.1</version>
+      </plugin>
+      
+      <plugin>
+        <artifactId>maven-release-plugin</artifactId>
+        <configuration>
+          <!--  do not run site-deploy goal, which is included in the default setting  -->
+          <goals>deploy</goals>
+          <connectionUrl>scm:git://github.com/msgpack/msgpack.git</connectionUrl>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+
+  <reporting>
+    <plugins>
+      <!-- Generating JavaDoc -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <configuration>
+          <doctitle>${project.name} ${project.version} API</doctitle>
+          <aggregate>true</aggregate>
+          <locale>en_US</locale>
+	  <encoding>UTF-8</encoding>
+        </configuration>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jxr-plugin</artifactId>
+      </plugin>
+      
+      <plugin>
+	<groupId>org.apache.maven.plugins</groupId>
+	<artifactId>maven-surefire-report-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </reporting>
+
+  <profiles>
+    <!-- for sending artifacts to sourceforge.net repository -->
+    <profile>
+      <id>sourceforge</id>
+      <distributionManagement>
+	<repository>
+          <id>sourceforge.net</id>
+          <name>Repository at sourceforge.net</name>
+          <url>scpexe://shell.sourceforge.net/home/groups/m/ms/msgpack/htdocs/maven2/</url>
+	</repository>
+      </distributionManagement>
+    </profile>
+  </profiles>
+
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.8.1</version>
+      <scope>test</scope>
+    </dependency>
+
+  </dependencies>
+</project>

java/src/main/java/org/msgpack/Packer.java

@@ -20,7 +20,6 @@ package org.msgpack;
 import java.io.OutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
 import java.util.List;
 import java.util.Map;
 

java/src/main/java/org/msgpack/Unpacker.java

@@ -21,6 +21,7 @@ import java.lang.Iterable;
 import java.io.InputStream;
 import java.io.IOException;
 import java.util.Iterator;
+import java.nio.ByteBuffer;
 import org.msgpack.impl.UnpackerImpl;
 
 public class Unpacker extends UnpackerImpl implements Iterable<Object> {
@@ -103,6 +104,14 @@ public class Unpacker extends UnpackerImpl implements Iterable<Object> {
 		used += size;
 	}
 
+	public void feed(ByteBuffer buffer) {
+		int length = buffer.remaining();
+		if (length == 0) return;
+		reserveBuffer(length);
+		buffer.get(this.buffer, this.offset, length);
+		bufferConsumed(length);
+	}
+
 	public void feed(byte[] buffer) {
 		feed(buffer, 0, buffer.length);
 	}