cpp: object::object(const T& v) and object::operator=(const T& v)

5 files changed, 90 insertions, 53 deletions

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 <typename T>
 	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 <typename T>
+	object(const T& v);
+
+	template <typename T>
+	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 <typename Stream, typename T>
 packer<Stream>& operator<< (packer<Stream>& o, const T& v);
 
+// convert operator
 template <typename T>
 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 <typename T>
+inline void object::convert(T* v) const
 {
-	type = type::BOOLEAN;
-	via.boolean = v;
+	*this >> *v;
 }
 
-inline object::object(uint64_t v)
+template <typename T>
+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 <typename T>
+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 <typename T>
+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 <typename T>
-inline void object::convert(T* v) const
-{
-	*this >> *v;
-}
-
-template <typename T>
-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<Stream>& operator<< (packer<Stream>& 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<Stream>& operator<< (packer<Stream>& 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 <typename T>
 	static inline T convert_integer(object o)
 	{
@@ -141,6 +141,38 @@ inline packer<Stream>& operator<< (packer<Stream>& 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<Stream>& operator<< (packer<Stream>& o, const type::nil& v)
 	return o;
 }
 
+inline void operator<< (object& o, type::nil v)
+{
+	o.type = type::NIL;
+}
+
 
 }  // namespace msgpack