c,cpp: 0.4.1

configure.in

@@ -1,6 +1,6 @@
 AC_INIT(msgpack/unpack_template.h)
 AC_CONFIG_AUX_DIR(ac)
-AM_INIT_AUTOMAKE(msgpack, 0.4.0)
+AM_INIT_AUTOMAKE(msgpack, 0.4.1)
 AC_CONFIG_HEADER(config.h)
 
 AC_SUBST(CFLAGS)
@@ -12,7 +12,6 @@ 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],
@@ -25,11 +24,32 @@ if test "$enable_cxx" != "no"; then
 	fi
 fi
 
-# FIXME
+# 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")
 

cpp/test.cpp

@@ -10,6 +10,10 @@
 
 #include <gtest/gtest.h>
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
 using namespace std;
 
 const unsigned int kLoop = 10000;
@@ -227,6 +231,8 @@ TEST(MSGPACK, simple_buffer_false)
 
 //-----------------------------------------------------------------------------
 
+// STL
+
 TEST(MSGPACK_STL, simple_buffer_string)
 {
   for (unsigned int k = 0; k < kLoop; k++) {
@@ -365,6 +371,190 @@ TEST(MSGPACK_STL, simple_buffer_pair)
   }
 }
 
+TEST(MSGPACK_STL, simple_buffer_multimap)
+{
+  for (unsigned int k = 0; k < kLoop; k++) {
+    multimap<int, int> val1;
+    for (unsigned int i = 0; i < kElements; i++) {
+      int i1 = rand();
+      val1.insert(make_pair(i1, rand()));
+      val1.insert(make_pair(i1, rand()));
+    }
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    multimap<int, int> val2;
+    obj.convert(&val2);
+
+    vector<pair<int, int> > v1, v2;
+    multimap<int, int>::const_iterator it;
+    for (it = val1.begin(); it != val1.end(); ++it)
+      v1.push_back(make_pair(it->first, it->second));
+    for (it = val2.begin(); it != val2.end(); ++it)
+      v2.push_back(make_pair(it->first, it->second));
+    EXPECT_EQ(val1.size(), val2.size());
+    EXPECT_EQ(v1.size(), v2.size());
+    sort(v1.begin(), v1.end());
+    sort(v2.begin(), v2.end());
+    EXPECT_TRUE(v1 == v2);
+  }
+}
+
+TEST(MSGPACK_STL, simple_buffer_multiset)
+{
+  for (unsigned int k = 0; k < kLoop; k++) {
+    multiset<int> val1;
+    for (unsigned int i = 0; i < kElements; i++)
+      val1.insert(rand());
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    multiset<int> val2;
+    obj.convert(&val2);
+
+    vector<int> v1, v2;
+    multiset<int>::const_iterator it;
+    for (it = val1.begin(); it != val1.end(); ++it)
+      v1.push_back(*it);
+    for (it = val2.begin(); it != val2.end(); ++it)
+      v2.push_back(*it);
+    EXPECT_EQ(val1.size(), val2.size());
+    EXPECT_EQ(v1.size(), v2.size());
+    sort(v1.begin(), v1.end());
+    sort(v2.begin(), v2.end());
+    EXPECT_TRUE(v1 == v2);
+  }
+}
+
+// TR1
+
+#ifdef HAVE_TR1_UNORDERED_MAP
+#include <tr1/unordered_map>
+#include "cpp/type/tr1/unordered_map.hpp"
+TEST(MSGPACK_TR1, simple_buffer_unordered_map)
+{
+  for (unsigned int k = 0; k < kLoop; k++) {
+    tr1::unordered_map<int, int> val1;
+    for (unsigned int i = 0; i < kElements; i++)
+      val1[rand()] = rand();
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    tr1::unordered_map<int, int> val2;
+    obj.convert(&val2);
+    EXPECT_EQ(val1.size(), val2.size());
+    tr1::unordered_map<int, int>::const_iterator it;
+    for (it = val1.begin(); it != val1.end(); ++it) {
+      EXPECT_TRUE(val2.find(it->first) != val2.end());
+      EXPECT_EQ(it->second, val2.find(it->first)->second);
+    }
+  }
+}
+
+TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
+{
+  for (unsigned int k = 0; k < kLoop; k++) {
+    tr1::unordered_multimap<int, int> val1;
+    for (unsigned int i = 0; i < kElements; i++) {
+      int i1 = rand();
+      val1.insert(make_pair(i1, rand()));
+      val1.insert(make_pair(i1, rand()));
+    }
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    tr1::unordered_multimap<int, int> val2;
+    obj.convert(&val2);
+
+    vector<pair<int, int> > v1, v2;
+    tr1::unordered_multimap<int, int>::const_iterator it;
+    for (it = val1.begin(); it != val1.end(); ++it)
+      v1.push_back(make_pair(it->first, it->second));
+    for (it = val2.begin(); it != val2.end(); ++it)
+      v2.push_back(make_pair(it->first, it->second));
+    EXPECT_EQ(val1.size(), val2.size());
+    EXPECT_EQ(v1.size(), v2.size());
+    sort(v1.begin(), v1.end());
+    sort(v2.begin(), v2.end());
+    EXPECT_TRUE(v1 == v2);
+  }
+}
+#endif
+
+#ifdef HAVE_TR1_UNORDERED_SET
+#include <tr1/unordered_set>
+#include "cpp/type/tr1/unordered_set.hpp"
+TEST(MSGPACK_TR1, simple_buffer_unordered_set)
+{
+  for (unsigned int k = 0; k < kLoop; k++) {
+    tr1::unordered_set<int> val1;
+    for (unsigned int i = 0; i < kElements; i++)
+      val1.insert(rand());
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    tr1::unordered_set<int> val2;
+    obj.convert(&val2);
+    EXPECT_EQ(val1.size(), val2.size());
+    tr1::unordered_set<int>::const_iterator it;
+    for (it = val1.begin(); it != val1.end(); ++it)
+      EXPECT_TRUE(val2.find(*it) != val2.end());
+  }
+}
+
+TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
+{
+  for (unsigned int k = 0; k < kLoop; k++) {
+    tr1::unordered_multiset<int> val1;
+    for (unsigned int i = 0; i < kElements; i++)
+      val1.insert(rand());
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, val1);
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret =
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+    EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
+    tr1::unordered_multiset<int> val2;
+    obj.convert(&val2);
+
+    vector<int> v1, v2;
+    tr1::unordered_multiset<int>::const_iterator it;
+    for (it = val1.begin(); it != val1.end(); ++it)
+      v1.push_back(*it);
+    for (it = val2.begin(); it != val2.end(); ++it)
+      v2.push_back(*it);
+    EXPECT_EQ(val1.size(), val2.size());
+    EXPECT_EQ(v1.size(), v2.size());
+    sort(v1.begin(), v1.end());
+    sort(v2.begin(), v2.end());
+    EXPECT_TRUE(v1 == v2);
+  }
+}
+#endif
+
+// User-Defined Structures
+
 class TestClass
 {
 public:

msgpack/pack_template.h

@@ -554,19 +554,19 @@ if(sizeof(unsigned long long) == 2) {
 
 msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d)
 {
-	union { char buf[4]; uint32_t num; } f;
-	*((float*)&f.buf) = d;  // FIXME
+	union { float f; uint32_t i; } mem;
+	mem.f = d;
 	unsigned char buf[5];
-	buf[0] = 0xca; *(uint32_t*)&buf[1] = _msgpack_be32(f.num);
+	buf[0] = 0xca; *(uint32_t*)&buf[1] = _msgpack_be32(mem.i);
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
 msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
 {
-	union { char buf[8]; uint64_t num; } f;
-	*((double*)&f.buf) = d;  // FIXME
+	union { double f; uint64_t i; } mem;
+	mem.f = d;
 	unsigned char buf[9];
-	buf[0] = 0xcb; *(uint64_t*)&buf[1] = _msgpack_be64(f.num);
+	buf[0] = 0xcb; *(uint64_t*)&buf[1] = _msgpack_be64(mem.i);
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 

msgpack/unpack_template.h

@@ -222,13 +222,13 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 			//case CS_
 			//case CS_
 			case CS_FLOAT: {
-					union { uint32_t num; char buf[4]; } f;
-					f.num = PTR_CAST_32(n);  // FIXME
-					push_fixed_value(_float, *((float*)f.buf)); }
+					union { uint32_t i; float f; } mem;
+					mem.i = PTR_CAST_32(n);
+					push_fixed_value(_float, mem.f); }
 			case CS_DOUBLE: {
-					union { uint64_t num; char buf[8]; } f;
-					f.num = PTR_CAST_64(n);  // FIXME
-					push_fixed_value(_double, *((double*)f.buf)); }
+					union { uint64_t i; double f; } mem;
+					mem.i = PTR_CAST_64(n);
+					push_fixed_value(_double, mem.f); }
 			case CS_UINT_8:
 				push_fixed_value(_uint8, (uint8_t)PTR_CAST_8(n));
 			case CS_UINT_16: