From 120e8bffd7917e9529229e796b21ececc51df016 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 25 Apr 2010 00:03:09 +0900 Subject: cpp: object::object(const T& v) and object::operator=(const T& v) --- cpp/msgpack/object.hpp | 85 ++++++++++++++++++---------------------------- cpp/msgpack/type/bool.hpp | 6 ++++ cpp/msgpack/type/float.hpp | 13 +++++++ cpp/msgpack/type/int.hpp | 34 ++++++++++++++++++- cpp/msgpack/type/nil.hpp | 5 +++ 5 files changed, 90 insertions(+), 53 deletions(-) (limited to 'cpp/msgpack') diff --git a/cpp/msgpack/object.hpp b/cpp/msgpack/object.hpp index 3b42a8e..0125d0a 100644 --- a/cpp/msgpack/object.hpp +++ b/cpp/msgpack/object.hpp @@ -87,15 +87,15 @@ struct object { template void convert(T* v) const; - operator msgpack_object(); - object(msgpack_object obj); - object(); - object(bool v); - object(uint64_t v); - object(int64_t v); - object(double v); - object(const char* ptr, size_t size); + + template + object(const T& v); + + template + object& operator=(const T& v); + + operator msgpack_object(); private: struct implicit_type; @@ -115,9 +115,11 @@ bool operator!=(const object x, const object y); std::ostream& operator<< (std::ostream& s, const object o); +// serialize operator template packer& operator<< (packer& o, const T& v); +// convert operator template T& operator>> (object o, T& v); @@ -190,53 +192,45 @@ inline bool operator!=(const object x, const object y) { return !(x == y); } -inline object::object() +inline object::implicit_type object::convert() const { - type = type::NIL; + return implicit_type(*this); } -inline object::object(bool v) +template +inline void object::convert(T* v) const { - type = type::BOOLEAN; - via.boolean = v; + *this >> *v; } -inline object::object(uint64_t v) +template +inline T object::as() const { - type = type::POSITIVE_INTEGER; - via.u64 = v; + T v; + convert(&v); + return v; } -inline object::object(int64_t v) -{ - if(v >= 0) { - type = type::POSITIVE_INTEGER; - via.u64 = v; - } else { - type = type::NEGATIVE_INTEGER; - via.i64 = v; - } -} -inline object::object(double v) +inline object::object() { - type = type::DOUBLE; - via.dec = v; + type = type::NIL; } -inline object::object(const char* ptr, size_t size) +template +inline object::object(const T& v) { - type = type::RAW; - via.raw.size = size; - via.raw.ptr = ptr; + *this << v; } -inline object::object(msgpack_object obj) +template +inline object& object::operator=(const T& v) { - // FIXME beter way? - ::memcpy(this, &obj, sizeof(obj)); + *this << v; + return *this; } + inline object::operator msgpack_object() { // FIXME beter way? @@ -245,23 +239,10 @@ inline object::operator msgpack_object() return obj; } -inline object::implicit_type object::convert() const -{ - return implicit_type(*this); -} - -template -inline void object::convert(T* v) const -{ - *this >> *v; -} - -template -inline T object::as() const +inline void operator<< (object& o, msgpack_object v) { - T v; - convert(&v); - return v; + // FIXME beter way? + ::memcpy(&o, &v, sizeof(v)); } diff --git a/cpp/msgpack/type/bool.hpp b/cpp/msgpack/type/bool.hpp index b945d85..9d63435 100644 --- a/cpp/msgpack/type/bool.hpp +++ b/cpp/msgpack/type/bool.hpp @@ -39,6 +39,12 @@ inline packer& operator<< (packer& o, const bool& v) return o; } +inline void operator<< (object& o, bool v) +{ + o.type = type::BOOLEAN; + o.via.boolean = v; +} + } // namespace msgpack diff --git a/cpp/msgpack/type/float.hpp b/cpp/msgpack/type/float.hpp index 390e340..28131d1 100644 --- a/cpp/msgpack/type/float.hpp +++ b/cpp/msgpack/type/float.hpp @@ -57,6 +57,19 @@ inline packer& operator<< (packer& o, const double& v) } +inline void operator<< (object& o, float v) +{ + o.type = type::DOUBLE; + o.via.dec = v; +} + +inline void operator<< (object& o, double v) +{ + o.type = type::DOUBLE; + o.via.dec = v; +} + + } // namespace msgpack #endif /* msgpack/type/float.hpp */ diff --git a/cpp/msgpack/type/int.hpp b/cpp/msgpack/type/int.hpp index 03500f7..2dab78b 100644 --- a/cpp/msgpack/type/int.hpp +++ b/cpp/msgpack/type/int.hpp @@ -56,7 +56,7 @@ namespace detail { throw type_error(); } }; - + template static inline T convert_integer(object o) { @@ -141,6 +141,38 @@ inline packer& operator<< (packer& o, const unsigned long long& { o.pack_unsigned_long_long(v); return o; } +inline void operator<< (object& o, signed char v) + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, signed short v) + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, signed int v) + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, signed long v) + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, signed long long v) + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + + +inline void operator<< (object& o, unsigned char v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, unsigned short v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, unsigned int v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, unsigned long v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + +inline void operator<< (object& o, unsigned long long v) + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + + } // namespace msgpack #endif /* msgpack/type/int.hpp */ diff --git a/cpp/msgpack/type/nil.hpp b/cpp/msgpack/type/nil.hpp index 93e66ff..ed58384 100644 --- a/cpp/msgpack/type/nil.hpp +++ b/cpp/msgpack/type/nil.hpp @@ -42,6 +42,11 @@ inline packer& operator<< (packer& o, const type::nil& v) return o; } +inline void operator<< (object& o, type::nil v) +{ + o.type = type::NIL; +} + } // namespace msgpack -- cgit v1.2.1