From 298c97ec08f91d0613802e50b2c54f4c12b5eb74 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 3 Aug 2015 15:43:44 +0900 Subject: [PATCH] Added all template parameters support for containers. e.g.) allocator. Added tests. Replaced variadic template parameters with individual template parameters on C++11 unordered containers. --- .../msgpack/adaptor/cpp11/forward_list.hpp | 26 +- .../msgpack/adaptor/cpp11/unordered_map.hpp | 64 +- .../msgpack/adaptor/cpp11/unordered_set.hpp | 64 +- include/msgpack/adaptor/deque.hpp | 24 +- include/msgpack/adaptor/list.hpp | 32 +- include/msgpack/adaptor/map.hpp | 108 +-- include/msgpack/adaptor/set.hpp | 64 +- include/msgpack/adaptor/tr1/unordered_map.hpp | 48 +- include/msgpack/adaptor/tr1/unordered_set.hpp | 48 +- include/msgpack/adaptor/vector.hpp | 32 +- include/msgpack/adaptor/vector_bool.hpp | 24 +- include/msgpack/adaptor/vector_char.hpp | 24 +- test/msgpack_container.cpp | 651 ++++++++++-------- test/msgpack_cpp11.cpp | 194 +++--- test/test_allocator.hpp | 87 +++ 15 files changed, 846 insertions(+), 644 deletions(-) create mode 100644 test/test_allocator.hpp diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp index d4cdfceb..6f1c97d8 100644 --- a/include/msgpack/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -33,11 +33,11 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template -struct as, typename std::enable_if::value>::type> { - std::forward_list operator()(msgpack::object const& o) const { +template + struct as, typename std::enable_if::value>::type> { + std::forward_list operator()(msgpack::object const& o) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - std::forward_list v; + std::forward_list v; msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pend = o.via.array.ptr; while (p != pend) { @@ -48,9 +48,9 @@ struct as, typename std::enable_if::valu } }; -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::forward_list& v) const { +template +struct convert> { + msgpack::object const& operator()(msgpack::object const& o, std::forward_list& v) const { if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } v.resize(o.via.array.size); msgpack::object* p = o.via.array.ptr; @@ -62,10 +62,10 @@ struct convert> { } }; -template -struct pack> { +template +struct pack> { template - msgpack::packer& operator()(msgpack::packer& o, const std::forward_list& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::forward_list& v) const { uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end())); o.pack_array(size); for(auto const& e : v) o.pack(e); @@ -73,9 +73,9 @@ struct pack> { } }; -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::forward_list& v) const { +template +struct object_with_zone> { + void operator()(msgpack::object::with_zone& o, const std::forward_list& v) const { o.type = msgpack::type::ARRAY; if(v.empty()) { o.via.array.ptr = nullptr; diff --git a/include/msgpack/adaptor/cpp11/unordered_map.hpp b/include/msgpack/adaptor/cpp11/unordered_map.hpp index 8792adf3..9880b355 100644 --- a/include/msgpack/adaptor/cpp11/unordered_map.hpp +++ b/include/msgpack/adaptor/cpp11/unordered_map.hpp @@ -32,15 +32,15 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template +template struct as< - std::unordered_map, + std::unordered_map, typename std::enable_if::value && msgpack::has_as::value>::type> { - std::unordered_map operator()(msgpack::object const& o) const { + std::unordered_map operator()(msgpack::object const& o) const { if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::unordered_map v; + std::unordered_map v; for (; p != pend; ++p) { v.emplace(p->key.as(), p->val.as()); } @@ -48,13 +48,13 @@ struct as< } }; -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::unordered_map& v) const { +template +struct convert> { + msgpack::object const& operator()(msgpack::object const& o, std::unordered_map& v) const { if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::unordered_map tmp; + std::unordered_map tmp; for(; p != pend; ++p) { K key; p->key.convert(key); @@ -65,13 +65,13 @@ struct convert> { } }; -template -struct pack> { +template +struct pack> { template - msgpack::packer& operator()(msgpack::packer& o, const std::unordered_map& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::unordered_map& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_map(size); - for(typename std::unordered_map::const_iterator it(v.begin()), it_end(v.end()); + for(typename std::unordered_map::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); @@ -80,9 +80,9 @@ struct pack> { } }; -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::unordered_map& v) const { +template +struct object_with_zone> { + void operator()(msgpack::object::with_zone& o, const std::unordered_map& v) const { o.type = msgpack::type::MAP; if(v.empty()) { o.via.map.ptr = nullptr; @@ -93,7 +93,7 @@ struct object_with_zone> { msgpack::object_kv* const pend = p + size; o.via.map.ptr = p; o.via.map.size = size; - typename std::unordered_map::const_iterator it(v.begin()); + typename std::unordered_map::const_iterator it(v.begin()); do { p->key = msgpack::object(it->first, o.zone); p->val = msgpack::object(it->second, o.zone); @@ -105,15 +105,15 @@ struct object_with_zone> { }; -template +template struct as< - std::unordered_multimap, + std::unordered_multimap, typename std::enable_if::value && msgpack::has_as::value>::type> { - std::unordered_multimap operator()(msgpack::object const& o) const { + std::unordered_multimap operator()(msgpack::object const& o) const { if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::unordered_multimap v; + std::unordered_multimap v; for (; p != pend; ++p) { v.emplace(p->key.as(), p->val.as()); } @@ -121,13 +121,13 @@ struct as< } }; -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::unordered_multimap& v) const { +template +struct convert> { + msgpack::object const& operator()(msgpack::object const& o, std::unordered_multimap& v) const { if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::unordered_multimap tmp; + std::unordered_multimap tmp; for(; p != pend; ++p) { std::pair value; p->key.convert(value.first); @@ -139,13 +139,13 @@ struct convert> { } }; -template -struct pack> { +template +struct pack> { template - msgpack::packer& operator()(msgpack::packer& o, const std::unordered_multimap& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::unordered_multimap& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_map(size); - for(typename std::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); + for(typename std::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); @@ -154,9 +154,9 @@ struct pack> { } }; -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::unordered_multimap& v) const { +template +struct object_with_zone> { + void operator()(msgpack::object::with_zone& o, const std::unordered_multimap& v) const { o.type = msgpack::type::MAP; if(v.empty()) { o.via.map.ptr = nullptr; @@ -167,7 +167,7 @@ struct object_with_zone> { msgpack::object_kv* const pend = p + size; o.via.map.ptr = p; o.via.map.size = size; - typename std::unordered_multimap::const_iterator it(v.begin()); + typename std::unordered_multimap::const_iterator it(v.begin()); do { p->key = msgpack::object(it->first, o.zone); p->val = msgpack::object(it->second, o.zone); diff --git a/include/msgpack/adaptor/cpp11/unordered_set.hpp b/include/msgpack/adaptor/cpp11/unordered_set.hpp index 77a1640f..e03128ab 100644 --- a/include/msgpack/adaptor/cpp11/unordered_set.hpp +++ b/include/msgpack/adaptor/cpp11/unordered_set.hpp @@ -32,13 +32,13 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template -struct as, typename std::enable_if::value>::type> { - std::unordered_set operator()(msgpack::object const& o) const { +template +struct as, typename std::enable_if::value>::type> { + std::unordered_set operator()(msgpack::object const& o) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - std::unordered_set v; + std::unordered_set v; while (p > pbegin) { --p; v.insert(p->as()); @@ -47,13 +47,13 @@ struct as, typename std::enable_if -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::unordered_set& v) const { +template +struct convert> { + msgpack::object const& operator()(msgpack::object const& o, std::unordered_set& v) const { if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - std::unordered_set tmp; + std::unordered_set tmp; while(p > pbegin) { --p; tmp.insert(p->as()); @@ -63,13 +63,13 @@ struct convert> { } }; -template -struct pack> { +template +struct pack> { template - msgpack::packer& operator()(msgpack::packer& o, const std::unordered_set& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::unordered_set& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for(typename std::unordered_set::const_iterator it(v.begin()), it_end(v.end()); + for(typename std::unordered_set::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -77,9 +77,9 @@ struct pack> { } }; -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::unordered_set& v) const { +template +struct object_with_zone> { + void operator()(msgpack::object::with_zone& o, const std::unordered_set& v) const { o.type = msgpack::type::ARRAY; if(v.empty()) { o.via.array.ptr = nullptr; @@ -90,7 +90,7 @@ struct object_with_zone> { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename std::unordered_set::const_iterator it(v.begin()); + typename std::unordered_set::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; @@ -101,13 +101,13 @@ struct object_with_zone> { }; -template -struct as, typename std::enable_if::value>::type> { - std::unordered_multiset operator()(msgpack::object const& o) const { +template +struct as, typename std::enable_if::value>::type> { + std::unordered_multiset operator()(msgpack::object const& o) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - std::unordered_multiset v; + std::unordered_multiset v; while (p > pbegin) { --p; v.insert(p->as()); @@ -116,13 +116,13 @@ struct as, typename std::enable_if -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::unordered_multiset& v) const { +template +struct convert> { + msgpack::object const& operator()(msgpack::object const& o, std::unordered_multiset& v) const { if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - std::unordered_multiset tmp; + std::unordered_multiset tmp; while(p > pbegin) { --p; tmp.insert(p->as()); @@ -132,13 +132,13 @@ struct convert> { } }; -template -struct pack> { +template +struct pack> { template - msgpack::packer& operator()(msgpack::packer& o, const std::unordered_multiset& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::unordered_multiset& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for(typename std::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); + for(typename std::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -146,9 +146,9 @@ struct pack> { } }; -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::unordered_multiset& v) const { +template +struct object_with_zone> { + void operator()(msgpack::object::with_zone& o, const std::unordered_multiset& v) const { o.type = msgpack::type::ARRAY; if(v.empty()) { o.via.array.ptr = nullptr; @@ -159,7 +159,7 @@ struct object_with_zone> { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename std::unordered_multiset::const_iterator it(v.begin()); + typename std::unordered_multiset::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp index 42a5740b..3be120bc 100644 --- a/include/msgpack/adaptor/deque.hpp +++ b/include/msgpack/adaptor/deque.hpp @@ -32,14 +32,14 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::deque& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::deque& v) const { if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } v.resize(o.via.array.size); msgpack::object* p = o.via.array.ptr; msgpack::object* const pend = o.via.array.ptr + o.via.array.size; - typename std::deque::iterator it = v.begin(); + typename std::deque::iterator it = v.begin(); for(; p < pend; ++p, ++it) { p->convert(*it); } @@ -47,13 +47,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::deque& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::deque& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); + for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -61,9 +61,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::deque& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::deque& v) const { o.type = msgpack::type::ARRAY; if(v.empty()) { o.via.array.ptr = nullptr; @@ -74,7 +74,7 @@ struct object_with_zone > { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename std::deque::const_iterator it(v.begin()); + typename std::deque::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp index 938e6d75..48fced27 100644 --- a/include/msgpack/adaptor/list.hpp +++ b/include/msgpack/adaptor/list.hpp @@ -34,11 +34,11 @@ namespace adaptor { #if !defined(MSGPACK_USE_CPP03) -template -struct as, typename std::enable_if::value>::type> { - std::list operator()(msgpack::object const& o) const { +template +struct as, typename std::enable_if::value>::type> { + std::list operator()(msgpack::object const& o) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - std::list v; + std::list v; msgpack::object* p = o.via.array.ptr; msgpack::object* const pend = o.via.array.ptr + o.via.array.size; for (; p < pend; ++p) { @@ -50,14 +50,14 @@ struct as, typename std::enable_if::value>::type #endif // !defined(MSGPACK_USE_CPP03) -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::list& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::list& v) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } v.resize(o.via.array.size); msgpack::object* p = o.via.array.ptr; msgpack::object* const pend = o.via.array.ptr + o.via.array.size; - typename std::list::iterator it = v.begin(); + typename std::list::iterator it = v.begin(); for (; p < pend; ++p, ++it) { p->convert(*it); } @@ -65,13 +65,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::list& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::list& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for (typename std::list::const_iterator it(v.begin()), it_end(v.end()); + for (typename std::list::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -79,9 +79,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::list& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::list& v) const { o.type = msgpack::type::ARRAY; if (v.empty()) { o.via.array.ptr = nullptr; @@ -93,7 +93,7 @@ struct object_with_zone > { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename std::list::const_iterator it(v.begin()); + typename std::list::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index 26b176b8..120d3af4 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -34,18 +34,18 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace type { -template -class assoc_vector : public std::vector< std::pair > { +template , typename Alloc = std::allocator > > +class assoc_vector : public std::vector< std::pair, Alloc > { #if !defined(MSGPACK_USE_CPP03) - using std::vector>::vector; + using std::vector, Alloc>::vector; #endif // !defined(MSGPACK_USE_CPP03) }; namespace detail { - template + template struct pair_first_less { bool operator() (const std::pair& x, const std::pair& y) const - { return x.first < y.first; } + { return Compare()(x.first, y.first); } }; } @@ -55,29 +55,29 @@ namespace adaptor { #if !defined(MSGPACK_USE_CPP03) -template +template struct as< - type::assoc_vector, + type::assoc_vector, typename std::enable_if::value && msgpack::has_as::value>::type> { - type::assoc_vector operator()(msgpack::object const& o) const { + type::assoc_vector operator()(msgpack::object const& o) const { if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); } - type::assoc_vector v; + type::assoc_vector v; v.reserve(o.via.map.size); msgpack::object_kv* p = o.via.map.ptr; msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size; for (; p < pend; ++p) { v.emplace_back(p->key.as(), p->val.as()); } - std::sort(v.begin(), v.end(), type::detail::pair_first_less()); + std::sort(v.begin(), v.end(), type::detail::pair_first_less()); return v; } }; #endif // !defined(MSGPACK_USE_CPP03) -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, type::assoc_vector& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, type::assoc_vector& v) const { if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); } v.resize(o.via.map.size); msgpack::object_kv* p = o.via.map.ptr; @@ -87,18 +87,18 @@ struct convert > { p->key.convert(it->first); p->val.convert(it->second); } - std::sort(v.begin(), v.end(), type::detail::pair_first_less()); + std::sort(v.begin(), v.end(), type::detail::pair_first_less()); return o; } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const type::assoc_vector& v) const { + msgpack::packer& operator()(msgpack::packer& o, const type::assoc_vector& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_map(size); - for (typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); + for (typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); @@ -107,9 +107,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const type::assoc_vector& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const type::assoc_vector& v) const { o.type = msgpack::type::MAP; if (v.empty()) { o.via.map.ptr = nullptr; @@ -121,7 +121,7 @@ struct object_with_zone > { msgpack::object_kv* const pend = p + size; o.via.map.ptr = p; o.via.map.size = size; - typename type::assoc_vector::const_iterator it(v.begin()); + typename type::assoc_vector::const_iterator it(v.begin()); do { p->key = msgpack::object(it->first, o.zone); p->val = msgpack::object(it->second, o.zone); @@ -134,15 +134,15 @@ struct object_with_zone > { #if !defined(MSGPACK_USE_CPP03) -template +template struct as< - std::map, + std::map, typename std::enable_if::value && msgpack::has_as::value>::type> { - std::map operator()(msgpack::object const& o) const { + std::map operator()(msgpack::object const& o) const { if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::map v; + std::map v; for (; p != pend; ++p) { v.emplace(p->key.as(), p->val.as()); } @@ -152,13 +152,13 @@ struct as< #endif // !defined(MSGPACK_USE_CPP03) -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::map& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::map& v) const { if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::map tmp; + std::map tmp; for (; p != pend; ++p) { K key; p->key.convert(key); @@ -177,13 +177,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::map& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::map& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_map(size); - for (typename std::map::const_iterator it(v.begin()), it_end(v.end()); + for (typename std::map::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); @@ -192,9 +192,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::map& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::map& v) const { o.type = msgpack::type::MAP; if (v.empty()) { o.via.map.ptr = nullptr; @@ -206,7 +206,7 @@ struct object_with_zone > { msgpack::object_kv* const pend = p + size; o.via.map.ptr = p; o.via.map.size = size; - typename std::map::const_iterator it(v.begin()); + typename std::map::const_iterator it(v.begin()); do { p->key = msgpack::object(it->first, o.zone); p->val = msgpack::object(it->second, o.zone); @@ -219,15 +219,15 @@ struct object_with_zone > { #if !defined(MSGPACK_USE_CPP03) -template +template struct as< - std::multimap, + std::multimap, typename std::enable_if::value && msgpack::has_as::value>::type> { - std::multimap operator()(msgpack::object const& o) const { + std::multimap operator()(msgpack::object const& o) const { if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::multimap v; + std::multimap v; for (; p != pend; ++p) { v.emplace(p->key.as(), p->val.as()); } @@ -237,13 +237,13 @@ struct as< #endif // !defined(MSGPACK_USE_CPP03) -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::multimap& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::multimap& v) const { if (o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::multimap tmp; + std::multimap tmp; for (; p != pend; ++p) { std::pair value; p->key.convert(value.first); @@ -263,13 +263,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::multimap& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::multimap& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_map(size); - for (typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); + for (typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); @@ -278,9 +278,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::multimap& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::multimap& v) const { o.type = msgpack::type::MAP; if (v.empty()) { o.via.map.ptr = nullptr; @@ -292,7 +292,7 @@ struct object_with_zone > { msgpack::object_kv* const pend = p + size; o.via.map.ptr = p; o.via.map.size = size; - typename std::multimap::const_iterator it(v.begin()); + typename std::multimap::const_iterator it(v.begin()); do { p->key = msgpack::object(it->first, o.zone); p->val = msgpack::object(it->second, o.zone); diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index eb43d630..545ac098 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -34,13 +34,13 @@ namespace adaptor { #if !defined(MSGPACK_USE_CPP03) -template -struct as, typename std::enable_if::value>::type> { - std::set operator()(msgpack::object const& o) const { +template +struct as, typename std::enable_if::value>::type> { + std::set operator()(msgpack::object const& o) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - std::set v; + std::set v; while (p > pbegin) { --p; v.insert(p->as()); @@ -51,13 +51,13 @@ struct as, typename std::enable_if::value>::type> #endif // !defined(MSGPACK_USE_CPP03) -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::set& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::set& v) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - std::set tmp; + std::set tmp; while (p > pbegin) { --p; tmp.insert(p->as()); @@ -71,13 +71,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::set& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::set& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for (typename std::set::const_iterator it(v.begin()), it_end(v.end()); + for (typename std::set::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -85,9 +85,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::set& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::set& v) const { o.type = msgpack::type::ARRAY; if (v.empty()) { o.via.array.ptr = nullptr; @@ -99,7 +99,7 @@ struct object_with_zone > { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename std::set::const_iterator it(v.begin()); + typename std::set::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; @@ -111,13 +111,13 @@ struct object_with_zone > { #if !defined(MSGPACK_USE_CPP03) -template -struct as, typename std::enable_if::value>::type> { - std::multiset operator()(msgpack::object const& o) const { +template +struct as, typename std::enable_if::value>::type> { + std::multiset operator()(msgpack::object const& o) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - std::multiset v; + std::multiset v; while (p > pbegin) { --p; v.insert(p->as()); @@ -128,13 +128,13 @@ struct as, typename std::enable_if::value>:: #endif // !defined(MSGPACK_USE_CPP03) -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::multiset& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::multiset& v) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - std::multiset tmp; + std::multiset tmp; while (p > pbegin) { --p; tmp.insert(p->as()); @@ -148,13 +148,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::multiset& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::multiset& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for (typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); + for (typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -162,9 +162,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::multiset& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::multiset& v) const { o.type = msgpack::type::ARRAY; if (v.empty()) { o.via.array.ptr = nullptr; @@ -175,7 +175,7 @@ struct object_with_zone > { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename std::multiset::const_iterator it(v.begin()); + typename std::multiset::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index 793f4cc2..30b5908d 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -51,13 +51,13 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_map& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_map& v) const { if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - MSGPACK_STD_TR1::unordered_map tmp; + MSGPACK_STD_TR1::unordered_map tmp; for(; p != pend; ++p) { K key; p->key.convert(key); @@ -68,13 +68,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_map& v) const { + msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_map& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_map(size); - for(typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); + for(typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); @@ -83,9 +83,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map& v) const { o.type = msgpack::type::MAP; if(v.empty()) { o.via.map.ptr = nullptr; @@ -96,7 +96,7 @@ struct object_with_zone > { msgpack::object_kv* const pend = p + size; o.via.map.ptr = p; o.via.map.size = size; - typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()); + typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()); do { p->key = msgpack::object(it->first, o.zone); p->val = msgpack::object(it->second, o.zone); @@ -107,13 +107,13 @@ struct object_with_zone > { } }; -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap& v) const { if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } msgpack::object_kv* p(o.via.map.ptr); msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - MSGPACK_STD_TR1::unordered_multimap tmp; + MSGPACK_STD_TR1::unordered_multimap tmp; for(; p != pend; ++p) { std::pair value; p->key.convert(value.first); @@ -125,13 +125,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_multimap& v) const { + msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_multimap& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_map(size); - for(typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); + for(typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(it->first); o.pack(it->second); @@ -140,9 +140,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap& v) const { o.type = msgpack::type::MAP; if(v.empty()) { o.via.map.ptr = nullptr; @@ -153,7 +153,7 @@ struct object_with_zone > { msgpack::object_kv* const pend = p + size; o.via.map.ptr = p; o.via.map.size = size; - typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()); + typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()); do { p->key = msgpack::object(it->first, o.zone); p->val = msgpack::object(it->second, o.zone); diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index 6512ac37..0ba8067a 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -51,13 +51,13 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_set& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_set& v) const { if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - MSGPACK_STD_TR1::unordered_set tmp; + MSGPACK_STD_TR1::unordered_set tmp; while(p > pbegin) { --p; tmp.insert(p->as()); @@ -67,13 +67,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_set& v) const { + msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_set& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for(typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); + for(typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -81,9 +81,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set& v) const { o.type = msgpack::type::ARRAY; if(v.empty()) { o.via.array.ptr = nullptr; @@ -94,7 +94,7 @@ struct object_with_zone > { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()); + typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; @@ -105,13 +105,13 @@ struct object_with_zone > { }; -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset& v) const { if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } msgpack::object* p = o.via.array.ptr + o.via.array.size; msgpack::object* const pbegin = o.via.array.ptr; - MSGPACK_STD_TR1::unordered_multiset tmp; + MSGPACK_STD_TR1::unordered_multiset tmp; while(p > pbegin) { --p; tmp.insert(p->as()); @@ -121,13 +121,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_multiset& v) const { + msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_multiset& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for(typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); + for(typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -135,9 +135,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset& v) const { o.type = msgpack::type::ARRAY; if(v.empty()) { o.via.array.ptr = nullptr; @@ -148,7 +148,7 @@ struct object_with_zone > { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()); + typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()); do { *p = msgpack::object(*it, o.zone); ++p; diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp index 30bb8bbe..8617dc00 100644 --- a/include/msgpack/adaptor/vector.hpp +++ b/include/msgpack/adaptor/vector.hpp @@ -34,11 +34,11 @@ namespace adaptor { #if !defined(MSGPACK_USE_CPP03) -template -struct as, typename std::enable_if::value>::type> { - std::vector operator()(const msgpack::object& o) const { +template +struct as, typename std::enable_if::value>::type> { + std::vector operator()(const msgpack::object& o) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - std::vector v; + std::vector v; v.reserve(o.via.array.size); if (o.via.array.size > 0) { msgpack::object* p = o.via.array.ptr; @@ -54,15 +54,15 @@ struct as, typename std::enable_if::value>::ty #endif // !defined(MSGPACK_USE_CPP03) -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } v.resize(o.via.array.size); if (o.via.array.size > 0) { msgpack::object* p = o.via.array.ptr; msgpack::object* const pend = o.via.array.ptr + o.via.array.size; - typename std::vector::iterator it = v.begin(); + typename std::vector::iterator it = v.begin(); do { p->convert(*it); ++p; @@ -73,13 +73,13 @@ struct convert > { } }; -template -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for (typename std::vector::const_iterator it(v.begin()), it_end(v.end()); + for (typename std::vector::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(*it); } @@ -87,9 +87,9 @@ struct pack > { } }; -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::vector& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::vector& v) const { o.type = msgpack::type::ARRAY; if (v.empty()) { o.via.array.ptr = nullptr; @@ -101,7 +101,7 @@ struct object_with_zone > { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - typename std::vector::const_iterator it(v.begin()); + typename std::vector::const_iterator it(v.begin()); do { #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && !defined(__clang__) #pragma GCC diagnostic push diff --git a/include/msgpack/adaptor/vector_bool.hpp b/include/msgpack/adaptor/vector_bool.hpp index 516c552c..02e7dda4 100644 --- a/include/msgpack/adaptor/vector_bool.hpp +++ b/include/msgpack/adaptor/vector_bool.hpp @@ -30,14 +30,14 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template <> -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } if (o.via.array.size > 0) { v.resize(o.via.array.size); msgpack::object* p = o.via.array.ptr; - for (std::vector::iterator it = v.begin(), end = v.end(); + for (typename std::vector::iterator it = v.begin(), end = v.end(); it != end; ++it) { *it = p->as(); @@ -48,13 +48,13 @@ struct convert > { } }; -template <> -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_array(size); - for(std::vector::const_iterator it(v.begin()), it_end(v.end()); + for(typename std::vector::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it) { o.pack(static_cast(*it)); } @@ -62,9 +62,9 @@ struct pack > { } }; -template <> -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::vector& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::vector& v) const { o.type = msgpack::type::ARRAY; if(v.empty()) { o.via.array.ptr = nullptr; @@ -75,7 +75,7 @@ struct object_with_zone > { msgpack::object* const pend = p + size; o.via.array.ptr = p; o.via.array.size = size; - std::vector::const_iterator it(v.begin()); + typename std::vector::const_iterator it(v.begin()); do { *p = msgpack::object(static_cast(*it), o.zone); ++p; diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp index f59a0ef4..4338e08d 100644 --- a/include/msgpack/adaptor/vector_char.hpp +++ b/include/msgpack/adaptor/vector_char.hpp @@ -32,9 +32,9 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace adaptor { -template <> -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { +template +struct convert > { + msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { switch (o.type) { case msgpack::type::BIN: v.resize(o.via.bin.size); @@ -52,10 +52,10 @@ struct convert > { } }; -template <> -struct pack > { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { + msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { uint32_t size = checked_get_container_size(v.size()); o.pack_bin(size); o.pack_bin_body(&v.front(), size); @@ -64,9 +64,9 @@ struct pack > { } }; -template <> -struct object > { - void operator()(msgpack::object& o, const std::vector& v) const { +template +struct object > { + void operator()(msgpack::object& o, const std::vector& v) const { uint32_t size = checked_get_container_size(v.size()); o.type = msgpack::type::BIN; o.via.bin.ptr = &v.front(); @@ -74,9 +74,9 @@ struct object > { } }; -template <> -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::vector& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const std::vector& v) const { uint32_t size = checked_get_container_size(v.size()); o.type = msgpack::type::BIN; char* ptr = static_cast(o.zone.allocate_align(size)); diff --git a/test/msgpack_container.cpp b/test/msgpack_container.cpp index f82687bd..14908e08 100644 --- a/test/msgpack_container.cpp +++ b/test/msgpack_container.cpp @@ -9,6 +9,8 @@ #include #include +#include "test_allocator.hpp" + #include #ifdef HAVE_CONFIG_H @@ -21,187 +23,227 @@ using namespace std; const unsigned int kLoop = 1000; const unsigned int kElements = 100; +// strong typedefs +namespace test { + +template +struct equal_to : std::equal_to { +}; + +template +struct less : std::less { +}; + +} // namespace test + TEST(MSGPACK_STL, simple_buffer_vector) { - for (unsigned int k = 0; k < kLoop; k++) { - vector val1; + typedef vector > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); + type const& val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_vector_char) +{ + typedef vector > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::BIN); + type const& val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_vector_bool) +{ + typedef vector > type; + type val1; for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); + val1.push_back(i % 2 ? false : true); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); msgpack::unpacked ret; msgpack::unpack(ret, sbuf.data(), sbuf.size()); EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); - vector val2 = ret.get().as >(); + type const& val2 = ret.get().as(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } } -TEST(MSGPACK_STL, simple_buffer_vector_char) + +TEST(MSGPACK_STL, simple_buffer_assoc_vector) { - for (unsigned int k = 0; k < kLoop; k++) { - vector val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::BIN); - vector val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } + typedef msgpack::type::assoc_vector, test::allocator > >type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + val1.push_back(std::make_pair(1, 2)); + val1.push_back(std::make_pair(3, 4)); + val1.push_back(std::make_pair(5, 6)); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type const& val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } } -TEST(MSGPACK_STL, simple_buffer_vector_bool) -{ - vector val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(i % 2 ? false : true); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); - vector val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); -} - - TEST(MSGPACK_STL, simple_buffer_map) { - for (unsigned int k = 0; k < kLoop; k++) { - map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } + typedef map, test::allocator > > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type const& val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } } TEST(MSGPACK_STL, simple_buffer_deque) { - for (unsigned int k = 0; k < kLoop; k++) { - deque val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - deque val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } + typedef deque > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type const& val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } } TEST(MSGPACK_STL, simple_buffer_list) { - for (unsigned int k = 0; k < kLoop; k++) { - list val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - list val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } + typedef list > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type const& val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } } TEST(MSGPACK_STL, simple_buffer_set) { - for (unsigned int k = 0; k < kLoop; k++) { - set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } + typedef set, test::allocator > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } } TEST(MSGPACK_STL, simple_buffer_pair) { - for (unsigned int k = 0; k < kLoop; k++) { - pair val1 = make_pair(rand(), rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - pair val2 = ret.get().as >(); - EXPECT_EQ(val1.first, val2.first); - EXPECT_EQ(val1.second, val2.second); - } + for (unsigned int k = 0; k < kLoop; k++) { + pair val1 = make_pair(rand(), rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + pair val2 = ret.get().as >(); + EXPECT_EQ(val1.first, val2.first); + EXPECT_EQ(val1.second, val2.second); + } } TEST(MSGPACK_STL, simple_buffer_multimap) { - for (unsigned int k = 0; k < kLoop; k++) { - multimap 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::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - multimap val2 = ret.get().as >(); + typedef multimap, test::allocator > > type; + for (unsigned int k = 0; k < kLoop; k++) { + type 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::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); - vector > v1, v2; - multimap::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); - } + vector > v1, v2; + type::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 val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - multiset val2 = ret.get().as >(); + typedef multiset, test::allocator > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); - vector v1, v2; - multiset::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); - } + vector v1, v2; + type::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); + } } TEST(MSGPACK_TUPLE, simple_tuple) @@ -233,56 +275,72 @@ TEST(MSGPACK_TUPLE, simple_tuple_empty) // TR1 +#if defined(MSGPACK_HAS_STD_TR1_UNORDERED_MAP) || defined(MSGPACK_HAS_STD_TR1_UNORDERED_SET) + +#include + +namespace test { + +template +struct tr1_hash : std::tr1::hash { +}; + +} // namespace test + +#endif // defined(MSGPACK_HAS_STD_TR1_UNORDERED_MAP) || defined(MSGPACK_HAS_STD_TR1_UNORDERED_SET) + #ifdef MSGPACK_HAS_STD_TR1_UNORDERED_MAP #include #include "msgpack/adaptor/tr1/unordered_map.hpp" TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) { - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - tr1::unordered_map::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); + typedef tr1::unordered_map, test::equal_to, test::allocator > > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + type::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_tr1_unordered_multimap) { - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_multimap 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::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_multimap val2 = ret.get().as >(); + typedef tr1::unordered_multimap, test::equal_to, test::allocator > > type; + for (unsigned int k = 0; k < kLoop; k++) { + type 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::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); - vector > v1, v2; - tr1::unordered_multimap::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); - } + vector > v1, v2; + type::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 @@ -291,146 +349,167 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) #include "msgpack/adaptor/tr1/unordered_set.hpp" TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) { - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - tr1::unordered_set::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - EXPECT_TRUE(val2.find(*it) != val2.end()); - } + typedef tr1::unordered_set, test::equal_to, test::allocator > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + type::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + EXPECT_TRUE(val2.find(*it) != val2.end()); + } } TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) { - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_multiset val2 = ret.get().as >(); + typedef tr1::unordered_multiset, test::equal_to, test::allocator > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); - vector v1, v2; - tr1::unordered_multiset::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); - } + vector v1, v2; + type::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 +#if defined (MSGPACK_HAS_STD_UNORDERED_MAP) || defined (MSGPACK_HAS_STD_UNORDERED_SET) + +#include + +namespace test { + +template +struct hash : std::hash { +}; + +} // namespace test + +#endif // defined (MSGPACK_HAS_STD_UNORDERED_MAP) || defined (MSGPACK_HAS_STD_UNORDERED_SET) + #ifdef MSGPACK_HAS_STD_UNORDERED_MAP #include #include "msgpack/adaptor/tr1/unordered_map.hpp" TEST(MSGPACK_TR1, simple_buffer_unordered_map) { - for (unsigned int k = 0; k < kLoop; k++) { - unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - unordered_map::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); + typedef unordered_map, test::equal_to, test::allocator > > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + type::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 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::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_multimap val2 = ret.get().as >(); + typedef unordered_multimap, test::equal_to, test::allocator > > type; + for (unsigned int k = 0; k < kLoop; k++) { + type 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::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); - vector > v1, v2; - unordered_multimap::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); - } + vector > v1, v2; + type::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_UNORDERED_SET + #include #include "msgpack/adaptor/tr1/unordered_set.hpp" TEST(MSGPACK_TR1, simple_buffer_unordered_set) { - for (unsigned int k = 0; k < kLoop; k++) { - unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - unordered_set::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - EXPECT_TRUE(val2.find(*it) != val2.end()); - } + typedef unordered_set, test::equal_to, test::allocator > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + type::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 val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_multiset val2 = ret.get().as >(); + typedef unordered_multiset, test::equal_to, test::allocator > type; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); - vector v1, v2; - unordered_multiset::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); - } + vector v1, v2; + type::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 diff --git a/test/msgpack_cpp11.cpp b/test/msgpack_cpp11.cpp index d25864aa..bd1432e3 100644 --- a/test/msgpack_cpp11.cpp +++ b/test/msgpack_cpp11.cpp @@ -93,83 +93,119 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char) } } +// strong typedefs +namespace test { + +template +struct hash : std::hash { + using std::hash::hash; +}; + +template +struct equal_to : std::equal_to { + using std::equal_to::equal_to; +}; + +template +struct set_allocator : std::allocator { + using std::allocator::allocator; +}; + +template +struct map_allocator : std::allocator> { + using std::allocator>::allocator; +}; + +template +struct allocator : std::allocator { + using std::allocator::allocator; +}; + +} // namespace test + + TEST(MSGPACK_STL, simple_buffer_forward_list) { + using type = forward_list>; for (unsigned int k = 0; k < kLoop; k++) { - forward_list val1; + type val1; for (unsigned int i = 0; i < kElements; i++) val1.push_front(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); msgpack::unpacked ret; msgpack::unpack(ret, sbuf.data(), sbuf.size()); - forward_list val2 = ret.get().as >(); + type val2 = ret.get().as(); EXPECT_EQ(val1, val2); } } TEST(MSGPACK_STL, simple_buffer_unordered_map) { - for (unsigned int k = 0; k < kLoop; k++) { - unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_map val2 = ret.get().as >(); - EXPECT_EQ(val1, val2); - } + using type = unordered_map, test::equal_to, test::map_allocator>; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); + EXPECT_EQ(val1, val2); + } } TEST(MSGPACK_STL, simple_buffer_unordered_multimap) { - for (unsigned int k = 0; k < kLoop; k++) { - unordered_multimap 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::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_multimap val2 = ret.get().as >(); + using type = unordered_multimap, test::equal_to, test::map_allocator>; + for (unsigned int k = 0; k < kLoop; k++) { + type 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::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); - EXPECT_EQ(val1, val2); - } + EXPECT_EQ(val1, val2); + } } TEST(MSGPACK_STL, simple_buffer_unordered_set) { - for (unsigned int k = 0; k < kLoop; k++) { - unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_set val2 = ret.get().as >(); - EXPECT_EQ(val1, val2); - } + using type = unordered_set, test::equal_to, test::set_allocator>; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); + EXPECT_EQ(val1, val2); + } } TEST(MSGPACK_STL, simple_buffer_unordered_multiset) { - for (unsigned int k = 0; k < kLoop; k++) { - unordered_multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_multiset val2 = ret.get().as >(); - EXPECT_EQ(val1, val2); - } + using type = unordered_multiset, test::equal_to, test::set_allocator>; + for (unsigned int k = 0; k < kLoop; k++) { + type val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + type val2 = ret.get().as(); + EXPECT_EQ(val1, val2); + } } TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) @@ -206,16 +242,16 @@ inline bool operator<(no_def_con const& lhs, no_def_con const& rhs) { namespace msgpack { MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { -namespace adaptor { -template <> -struct as { - no_def_con operator()(msgpack::object const& o) const { - if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); - if (o.via.array.size != 1) throw msgpack::type_error(); - return no_def_con(o.via.array.ptr[0].as()); - } -}; -} // adaptor + namespace adaptor { + template <> + struct as { + no_def_con operator()(msgpack::object const& o) const { + if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); + if (o.via.array.size != 1) throw msgpack::type_error(); + return no_def_con(o.via.array.ptr[0].as()); + } + }; + } // adaptor } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) } // msgpack @@ -261,16 +297,16 @@ inline bool operator<(no_def_con_composite const& lhs, no_def_con_composite cons namespace msgpack { MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { -namespace adaptor { -template <> -struct as { - no_def_con_composite operator()(msgpack::object const& o) const { - if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); - if (o.via.array.size != 1) throw msgpack::type_error(); - return no_def_con_composite(o.via.array.ptr[0].as()); - } -}; -} // adaptor + namespace adaptor { + template <> + struct as { + no_def_con_composite operator()(msgpack::object const& o) const { + if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); + if (o.via.array.size != 1) throw msgpack::type_error(); + return no_def_con_composite(o.via.array.ptr[0].as()); + } + }; + } // adaptor } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) } // msgpack @@ -293,16 +329,16 @@ struct no_def_con_inherit : no_def_con { namespace msgpack { MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { -namespace adaptor { -template <> -struct as { - no_def_con_inherit operator()(msgpack::object const& o) const { - if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); - if (o.via.array.size != 1) throw msgpack::type_error(); - return no_def_con_inherit(o.via.array.ptr[0].as()); - } -}; -} // adaptor + namespace adaptor { + template <> + struct as { + no_def_con_inherit operator()(msgpack::object const& o) const { + if (o.type != msgpack::type::ARRAY) throw msgpack::type_error(); + if (o.via.array.size != 1) throw msgpack::type_error(); + return no_def_con_inherit(o.via.array.ptr[0].as()); + } + }; + } // adaptor } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) } // msgpack diff --git a/test/test_allocator.hpp b/test/test_allocator.hpp new file mode 100644 index 00000000..76a66b29 --- /dev/null +++ b/test/test_allocator.hpp @@ -0,0 +1,87 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2015 KONDO Takatoshi +// +// 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 TEST_ALLOCATOR_HPP +#define TEST_ALLOCATOR_HPP + +#include + +namespace test { + +template +struct allocator { + typedef typename std::allocator::value_type value_type; + typedef typename std::allocator::pointer pointer; + typedef typename std::allocator::reference reference; + typedef typename std::allocator::const_pointer const_pointer; + typedef typename std::allocator::const_reference const_reference; + typedef typename std::allocator::size_type size_type; + typedef typename std::allocator::difference_type difference_type; + template struct rebind { typedef allocator other; }; +#if defined(MSGPACK_USE_CPP03) + allocator() throw() {} + allocator (const allocator& alloc) throw() + :alloc_(alloc.alloc_) {} + template + allocator (const allocator& alloc) throw() + :alloc_(alloc.alloc_) {} + + + void construct ( pointer p, const_reference val ) { + return alloc_.construct(p, val); + } + size_type max_size() const throw() { return alloc_.max_size(); } +#else // defined(MSGPACK_USE_CPP03) + allocator() noexcept {} + allocator (const allocator& alloc) noexcept + :alloc_(alloc.alloc_) {} + template + allocator (const allocator& alloc) noexcept + :alloc_(alloc.alloc_) {} + template + void construct (U* p, Args&&... args) { + return alloc_.construct(p, std::forward(args)...); + } + size_type max_size() const noexcept { return alloc_.max_size(); } +#endif // defined(MSGPACK_USE_CPP03) + pointer allocate (size_type n) { + return alloc_.allocate(n); + } + void deallocate (pointer p, size_type n) { + return alloc_.deallocate(p, n); + } + void destroy (pointer p) { + alloc_.destroy(p); + } + + std::allocator alloc_; +}; + +template +inline bool operator==(allocator const& lhs, allocator const& rhs) { + return lhs.alloc_ == rhs.alloc_; +} + +template +inline bool operator!=(allocator const& lhs, allocator const& rhs) { + return lhs.alloc_ != rhs.alloc_; +} + +} // namespace test + +#endif // TEST_ALLOCATOR_HPP