From 8a08548f365660a17f41f14ee05c21f3201db15d Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 13:28:23 +0900 Subject: [PATCH] Modified passed by value of object to const reference of object. Removed C function call in operator==. --- cpp11/define.hpp | 12 ++-- cpp11/tuple.hpp | 6 +- src/msgpack/object.hpp | 102 +++++++++++++++++++++++++------- src/msgpack/type/define.hpp.erb | 8 +-- src/msgpack/type/tuple.hpp.erb | 8 +-- 5 files changed, 99 insertions(+), 37 deletions(-) diff --git a/cpp11/define.hpp b/cpp11/define.hpp index 526a4aea..9804aa1d 100644 --- a/cpp11/define.hpp +++ b/cpp11/define.hpp @@ -24,7 +24,7 @@ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ } \ - void msgpack_unpack(msgpack::object o) \ + void msgpack_unpack(msgpack::object const& o) \ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ }\ @@ -38,7 +38,7 @@ #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ template <> \ - inline enum& operator>> (object o, enum& v) \ + inline enum& operator>> (object const& o, enum& v) \ { \ int tmp; \ o >> tmp; \ @@ -71,7 +71,7 @@ struct define_imp { define_imp::pack(pk, t); pk.pack(std::get(t)); } - static void unpack(msgpack::object o, Tuple& t) { + static void unpack(msgpack::object const& o, Tuple& t) { define_imp::unpack(o, t); const size_t size = o.via.array.size; if(size <= N-1) { return; } @@ -89,7 +89,7 @@ struct define_imp { static void pack(Packer& pk, Tuple const& t) { pk.pack(std::get<0>(t)); } - static void unpack(msgpack::object o, Tuple& t) { + static void unpack(msgpack::object const& o, Tuple& t) { const size_t size = o.via.array.size; if(size <= 0) { return; } o.via.array.ptr[0].convert(&std::get<0>(t)); @@ -112,7 +112,7 @@ struct define { define_imp, sizeof...(Args)>::pack(pk, a); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } @@ -139,7 +139,7 @@ struct define<> { { pk.pack_array(0); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } } diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp index 30f9f54f..0ef661f5 100644 --- a/cpp11/tuple.hpp +++ b/cpp11/tuple.hpp @@ -138,7 +138,7 @@ const packer& operator<< ( template struct Converter { static void convert( - object o, + object const& o, Tuple& v) { Converter::convert(o, v); o.via.array.ptr[N-1].convert(v))>::type>(&type::get(v)); @@ -148,7 +148,7 @@ struct Converter { template struct Converter { static void convert ( - object o, + object const& o, Tuple& v) { o.via.array.ptr[0].convert(v))>::type>(&type::get<0>(v)); } @@ -156,7 +156,7 @@ struct Converter { template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < sizeof...(Args)) { throw type_error(); } diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index 1f2de2b5..c80da41b 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -125,22 +125,22 @@ private: }; -bool operator==(const object x, const object y); -bool operator!=(const object x, const object y); +bool operator==(const object& x, const object& y); +bool operator!=(const object& x, const object& y); template -bool operator==(const object x, const T& y); +bool operator==(const object& x, const T& y); template -bool operator==(const T& y, const object x); +bool operator==(const T& y, const object& x); template -bool operator!=(const object x, const T& y); +bool operator!=(const object& x, const T& y); template -bool operator!=(const T& y, const object x); +bool operator!=(const T& y, const object& x); -std::ostream& operator<< (std::ostream& s, const object o); +std::ostream& operator<< (std::ostream& s, const object& o); // serialize operator @@ -149,7 +149,7 @@ packer& operator<< (packer& o, const T& v); // convert operator template -T& operator>> (object o, T& v); +T& operator>> (object const& o, T& v); // deconvert operator template @@ -157,7 +157,7 @@ void operator<< (object::with_zone& o, const T& v); struct object::implicit_type { - implicit_type(object o) : obj(o) { } + implicit_type(object const& o) : obj(o) { } ~implicit_type() { } template @@ -184,7 +184,7 @@ public: o << static_cast(*this); } - void msgpack_unpack(object o) + void msgpack_unpack(object const& o) { o >> static_cast(*this); } @@ -199,14 +199,14 @@ inline packer& packer::pack(const T& v) return *this; } -inline object& operator>> (object o, object& v) +inline object& operator>> (object const& o, object& v) { v = o; return v; } template -inline T& operator>> (object o, T& v) +inline T& operator>> (object const& o, T& v) { v.msgpack_unpack(o.convert()); return v; @@ -235,20 +235,82 @@ void operator<< (object::with_zone& o, const T& v) } -inline bool operator==(const object x, const object y) +inline bool operator==(const object& x, const object& y) { - return msgpack_object_equal(x, y); + if(x.type != y.type) { return false; } + + switch(x.type) { + case type::NIL: + return true; + + case type::BOOLEAN: + return x.via.boolean == y.via.boolean; + + case type::POSITIVE_INTEGER: + return x.via.u64 == y.via.u64; + + case type::NEGATIVE_INTEGER: + return x.via.i64 == y.via.i64; + + case type::DOUBLE: + return x.via.dec == y.via.dec; + + case type::RAW: + return x.via.raw.size == y.via.raw.size && + memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0; + + case type::ARRAY: + if(x.via.array.size != y.via.array.size) { + return false; + } else if(x.via.array.size == 0) { + return true; + } else { + object* px = x.via.array.ptr; + object* const pxend = x.via.array.ptr + x.via.array.size; + object* py = y.via.array.ptr; + do { + if(!(*px == *py)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + case type::MAP: + if(x.via.map.size != y.via.map.size) { + return false; + } else if(x.via.map.size == 0) { + return true; + } else { + object_kv* px = x.via.map.ptr; + object_kv* const pxend = x.via.map.ptr + x.via.map.size; + object_kv* py = y.via.map.ptr; + do { + if(!(px->key == py->key) || !(px->val == py->val)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + default: + return false; + } } template -inline bool operator==(const object x, const T& y) +inline bool operator==(const object& x, const T& y) try { return x == object(y); } catch (msgpack::type_error&) { return false; } -inline bool operator!=(const object x, const object y) +inline bool operator!=(const object& x, const object& y) { return !(x == y); } template @@ -256,11 +318,11 @@ inline bool operator==(const T& y, const object x) { return x == y; } template -inline bool operator!=(const object x, const T& y) +inline bool operator!=(const object& x, const T& y) { return !(x == y); } template -inline bool operator!=(const T& y, const object x) +inline bool operator!=(const T& y, const object& x) { return x != y; } @@ -335,7 +397,7 @@ inline object::operator msgpack_object() const // obsolete template -inline void convert(T& v, object o) +inline void convert(T& v, object const& o) { o.convert(&v); } @@ -412,7 +474,7 @@ packer& operator<< (packer& o, const object& v) } } -std::ostream& operator<< (std::ostream& s, const object o) +std::ostream& operator<< (std::ostream& s, const object& o) { switch(o.type) { case type::NIL: diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb index 8aead021..905b4496 100644 --- a/src/msgpack/type/define.hpp.erb +++ b/src/msgpack/type/define.hpp.erb @@ -24,7 +24,7 @@ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ } \ - void msgpack_unpack(msgpack::object o) \ + void msgpack_unpack(msgpack::object const& o) \ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ }\ @@ -38,7 +38,7 @@ #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ template <> \ - inline enum& operator>> (object o, enum& v) \ + inline enum& operator>> (object const& o, enum& v) \ { \ int tmp; \ o >> tmp; \ @@ -78,7 +78,7 @@ struct define<> { { pk.pack_array(0); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } } @@ -103,7 +103,7 @@ struct define, A<%=j%><%}%>> { <%0.upto(i) {|j|%> pk.pack(a<%=j%>);<%}%> } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index 4f73eb20..cc0f1ea9 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -92,7 +92,7 @@ private: template <> struct tuple<> { tuple() {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(this); } typedef tuple<> value_type; }; <%0.upto(GENERATION_LIMIT) {|i|%> @@ -102,7 +102,7 @@ struct tuple, A<%=j%><%}%>> { tuple() {} tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -134,7 +134,7 @@ tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::tr } // namespace type inline type::tuple<>& operator>> ( - object o, + object const& o, type::tuple<>& v) { if(o.type != type::ARRAY) { throw type_error(); } return v; @@ -142,7 +142,7 @@ inline type::tuple<>& operator>> ( <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> type::tuple, A<%=j%><%}%>>& operator>> ( - object o, + object const& o, type::tuple, A<%=j%><%}%>>& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < <%=i+1%>) { throw type_error(); }