From 120e8bffd7917e9529229e796b21ececc51df016 Mon Sep 17 00:00:00 2001
From: frsyuki <frsyuki@users.sourceforge.jp>
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 ++++++++++++++++++++------------------------------
 1 file changed, 33 insertions(+), 52 deletions(-)

(limited to 'cpp/msgpack/object.hpp')

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));
 }
 
 
-- 
cgit v1.2.1