Merge pull request #69 from redboltz/support_libcpp_and_vcxx_unordered

Support libcpp and vcxx unordered

src/msgpack/type/tr1/unordered_map.hpp

@@ -19,13 +19,32 @@
 #define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__
 
 #include "msgpack/object.hpp"
+
+#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#define MSGPACK_HAS_STD_UNOURDERED_MAP
+#include <unordered_map>
+#define MSGPACK_STD_TR1 std
+
+#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#if __GNUC__ >= 4
+
+#define MSGPACK_HAS_STD_TR1_UNOURDERED_MAP
+
 #include <tr1/unordered_map>
+#define MSGPACK_STD_TR1 std::tr1
+
+#endif // __GNUC__ >= 4
+
+#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
 
 namespace msgpack {
 
 
 template <typename K, typename V>
-inline std::tr1::unordered_map<K, V> operator>> (object o, std::tr1::unordered_map<K, V>& v)
+inline MSGPACK_STD_TR1::unordered_map<K, V> operator>> (object o, MSGPACK_STD_TR1::unordered_map<K, V>& v)
 {
 	if(o.type != type::MAP) { throw type_error(); }
 	object_kv* p(o.via.map.ptr);
@@ -39,10 +58,10 @@ inline std::tr1::unordered_map<K, V> operator>> (object o, std::tr1::unordered_m
 }
 
 template <typename Stream, typename K, typename V>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_map<K,V>& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v)
 {
 	o.pack_map(v.size());
-	for(typename std::tr1::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
+	for(typename MSGPACK_STD_TR1::unordered_map<K,V>::const_iterator it(v.begin()), it_end(v.end());
 			it != it_end; ++it) {
 		o.pack(it->first);
 		o.pack(it->second);
@@ -51,7 +70,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 }
 
 template <typename K, typename V>
-inline void operator<< (object::with_zone& o, const std::tr1::unordered_map<K,V>& v)
+inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_map<K,V>& v)
 {
 	o.type = type::MAP;
 	if(v.empty()) {
@@ -62,7 +81,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_map<K,V>
 		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());
+		typename MSGPACK_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);
@@ -74,7 +93,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_map<K,V>
 
 
 template <typename K, typename V>
-inline std::tr1::unordered_multimap<K, V> operator>> (object o, std::tr1::unordered_multimap<K, V>& v)
+inline MSGPACK_STD_TR1::unordered_multimap<K, V> operator>> (object o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v)
 {
 	if(o.type != type::MAP) { throw type_error(); }
 	object_kv* p(o.via.map.ptr);
@@ -89,10 +108,10 @@ inline std::tr1::unordered_multimap<K, V> operator>> (object o, std::tr1::unorde
 }
 
 template <typename Stream, typename K, typename V>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_multimap<K,V>& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v)
 {
 	o.pack_map(v.size());
-	for(typename std::tr1::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
+	for(typename MSGPACK_STD_TR1::unordered_multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
 			it != it_end; ++it) {
 		o.pack(it->first);
 		o.pack(it->second);
@@ -101,7 +120,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 }
 
 template <typename K, typename V>
-inline void operator<< (object::with_zone& o, const std::tr1::unordered_multimap<K,V>& v)
+inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap<K,V>& v)
 {
 	o.type = type::MAP;
 	if(v.empty()) {
@@ -112,7 +131,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_multimap
 		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());
+		typename MSGPACK_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);
@@ -125,5 +144,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_multimap
 
 }  // namespace msgpack
 
+#undef MSGPACK_STD_TR1
+
 #endif /* msgpack/type/map.hpp */
 

src/msgpack/type/tr1/unordered_set.hpp

@@ -19,13 +19,31 @@
 #define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__
 
 #include "msgpack/object.hpp"
+
+#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#define MSGPACK_HAS_STD_UNOURDERED_SET
+#include <unordered_set>
+#define MSGPACK_STD_TR1 std
+
+#else   // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
+
+#if __GNUC__ >= 4
+
+#define MSGPACK_HAS_STD_TR1_UNOURDERED_SET
+
 #include <tr1/unordered_set>
+#define MSGPACK_STD_TR1 std::tr1
+
+#endif // __GNUC__ >= 4
+
+#endif  // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700)
 
 namespace msgpack {
 
 
 template <typename T>
-inline std::tr1::unordered_set<T>& operator>> (object o, std::tr1::unordered_set<T>& v)
+inline MSGPACK_STD_TR1::unordered_set<T>& operator>> (object o, MSGPACK_STD_TR1::unordered_set<T>& v)
 {
 	if(o.type != type::ARRAY) { throw type_error(); }
 	object* p = o.via.array.ptr + o.via.array.size;
@@ -38,10 +56,10 @@ inline std::tr1::unordered_set<T>& operator>> (object o, std::tr1::unordered_set
 }
 
 template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_set<T>& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, const MSGPACK_STD_TR1::unordered_set<T>& v)
 {
 	o.pack_array(v.size());
-	for(typename std::tr1::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
+	for(typename MSGPACK_STD_TR1::unordered_set<T>::const_iterator it(v.begin()), it_end(v.end());
 			it != it_end; ++it) {
 		o.pack(*it);
 	}
@@ -49,7 +67,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 }
 
 template <typename T>
-inline void operator<< (object::with_zone& o, const std::tr1::unordered_set<T>& v)
+inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_set<T>& v)
 {
 	o.type = type::ARRAY;
 	if(v.empty()) {
@@ -60,7 +78,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_set<T>&
 		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());
+		typename MSGPACK_STD_TR1::unordered_set<T>::const_iterator it(v.begin());
 		do {
 			*p = object(*it, o.zone);
 			++p;
@@ -71,7 +89,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_set<T>&
 
 
 template <typename T>
-inline std::tr1::unordered_multiset<T>& operator>> (object o, std::tr1::unordered_multiset<T>& v)
+inline MSGPACK_STD_TR1::unordered_multiset<T>& operator>> (object o, MSGPACK_STD_TR1::unordered_multiset<T>& v)
 {
 	if(o.type != type::ARRAY) { throw type_error(); }
 	object* p = o.via.array.ptr + o.via.array.size;
@@ -84,10 +102,10 @@ inline std::tr1::unordered_multiset<T>& operator>> (object o, std::tr1::unordere
 }
 
 template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_multiset<T>& v)
+inline packer<Stream>& operator<< (packer<Stream>& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v)
 {
 	o.pack_array(v.size());
-	for(typename std::tr1::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
+	for(typename MSGPACK_STD_TR1::unordered_multiset<T>::const_iterator it(v.begin()), it_end(v.end());
 			it != it_end; ++it) {
 		o.pack(*it);
 	}
@@ -95,7 +113,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::tr1::unordered_
 }
 
 template <typename T>
-inline void operator<< (object::with_zone& o, const std::tr1::unordered_multiset<T>& v)
+inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset<T>& v)
 {
 	o.type = type::ARRAY;
 	if(v.empty()) {
@@ -106,7 +124,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_multiset
 		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());
+		typename MSGPACK_STD_TR1::unordered_multiset<T>::const_iterator it(v.begin());
 		do {
 			*p = object(*it, o.zone);
 			++p;
@@ -118,5 +136,7 @@ inline void operator<< (object::with_zone& o, const std::tr1::unordered_multiset
 
 }  // namespace msgpack
 
+#undef MSGPACK_STD_TR1
+
 #endif /* msgpack/type/set.hpp */
 

test/msgpack_test.cpp

@@ -452,10 +452,10 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
 
 // TR1
 
-#ifdef HAVE_TR1_UNORDERED_MAP
+#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP
 #include <tr1/unordered_map>
 #include "msgpack/type/tr1/unordered_map.hpp"
-TEST(MSGPACK_TR1, simple_buffer_unordered_map)
+TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
 {
   for (unsigned int k = 0; k < kLoop; k++) {
     tr1::unordered_map<int, int> val1;
@@ -479,7 +479,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map)
   }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
+TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
 {
   for (unsigned int k = 0; k < kLoop; k++) {
     tr1::unordered_multimap<int, int> val1;
@@ -513,10 +513,10 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
 }
 #endif
 
-#ifdef HAVE_TR1_UNORDERED_SET
+#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET
 #include <tr1/unordered_set>
 #include "msgpack/type/tr1/unordered_set.hpp"
-TEST(MSGPACK_TR1, simple_buffer_unordered_set)
+TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
 {
   for (unsigned int k = 0; k < kLoop; k++) {
     tr1::unordered_set<int> val1;
@@ -538,7 +538,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set)
   }
 }
 
-TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
+TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
 {
   for (unsigned int k = 0; k < kLoop; k++) {
     tr1::unordered_multiset<int> val1;
@@ -569,6 +569,123 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
 }
 #endif
 
+#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP
+#include <unordered_map>
+#include "msgpack/type/tr1/unordered_map.hpp"
+TEST(MSGPACK_TR1, simple_buffer_unordered_map)
+{
+  for (unsigned int k = 0; k < kLoop; k++) {
+    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);
+    unordered_map<int, int> val2;
+    obj.convert(&val2);
+    EXPECT_EQ(val1.size(), val2.size());
+    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++) {
+    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);
+    unordered_multimap<int, int> val2;
+    obj.convert(&val2);
+
+    vector<pair<int, int> > v1, v2;
+    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 MSGPACK_HAS_STD_UNOURDERED_SET
+#include <unordered_set>
+#include "msgpack/type/tr1/unordered_set.hpp"
+TEST(MSGPACK_TR1, simple_buffer_unordered_set)
+{
+  for (unsigned int k = 0; k < kLoop; k++) {
+    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);
+    unordered_set<int> val2;
+    obj.convert(&val2);
+    EXPECT_EQ(val1.size(), val2.size());
+    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++) {
+    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);
+    unordered_multiset<int> val2;
+    obj.convert(&val2);
+
+    vector<int> v1, v2;
+    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