lang/c/msgpack: reimplemented C++ binding with template-based static resolution design

git-svn-id: file:///Users/frsyuki/project/msgpack-git/svn/x@67 5a5092ae-2292-43ba-b2d5-dcab9c1a2731

1 files changed, 72 insertions, 268 deletions

diff --git a/cpp/object.hpp b/cpp/object.hpp
index 456210c..7007b90 100644
--- a/cpp/object.hpp
+++ b/cpp/object.hpp
@@ -1,5 +1,5 @@
 //
-// MessagePack for C++ dynamic typed objects
+// MessagePack for C++ static resolution routine
 //
 // Copyright (C) 2008 FURUHASHI Sadayuki
 //
@@ -18,305 +18,109 @@
 #ifndef MSGPACK_OBJECT_HPP__
 #define MSGPACK_OBJECT_HPP__
 
-#include <cstddef>
+#include "msgpack/pack.hpp"
+#include <stdint.h>
 #include <stdexcept>
 #include <typeinfo>
 #include <ostream>
-#include <vector>
-#include <map>
-#include <string>
 
 namespace msgpack {
 
 
-class type_error      : public std::bad_cast { };
-class cast_error      : public type_error { };
-class overflow_error  : public type_error { };
-class underflow_error : public type_error { };
-class positive_overflow_error : public overflow_error { };
-class negative_overflow_error : public overflow_error { };
-
-
-struct mutable_raw {
-	explicit mutable_raw() : ptr(NULL), len(0) {}
-	explicit mutable_raw(char* p, size_t l) : ptr(p), len(l) {}
-public:
-	char* ptr;
-	size_t len;
-public:
-	std::string str() { return std::string(ptr, len); }
-};
-
-struct raw {
-	explicit raw() : ptr(NULL), len(0) {}
-	explicit raw(const char* p, size_t l) : ptr(p), len(l) {}
-	raw(const mutable_raw& m) : ptr(m.ptr), len(m.len) {}
-public:
-	const char* ptr;
-	size_t len;
-public:
-	std::string str() { return std::string(ptr, len); }
-};
-
-
-struct object;
-
-typedef std::map<object, object> map;
-typedef std::vector<object> array;
-
-class dynamic_packer;
-
-
-struct object_class {
-	virtual ~object_class() {}
-	virtual bool     isnil  () const { return false; }
-	virtual bool     xbool  () const { throw cast_error(); }
-	virtual uint8_t  xu8    () const { throw cast_error(); }
-	virtual uint16_t xu16   () const { throw cast_error(); }
-	virtual uint32_t xu32   () const { throw cast_error(); }
-	virtual uint64_t xu64   () const { throw cast_error(); }
-	virtual int8_t   xi8    () const { throw cast_error(); }
-	virtual int16_t  xi16   () const { throw cast_error(); }
-	virtual int32_t  xi32   () const { throw cast_error(); }
-	virtual int64_t  xi64   () const { throw cast_error(); }
-	virtual float    xfloat () const { throw cast_error(); }
-	virtual double   xdouble() const { throw cast_error(); }
-	//virtual mutable_raw xraw  () { throw cast_error(); }  // FIXME
-	virtual array&      xarray() { throw cast_error(); }
-	virtual map&        xmap  () { throw cast_error(); }
-	virtual raw          xraw  () const { throw cast_error(); }
-	virtual const array& xarray() const { throw cast_error(); }
-	virtual const map&   xmap  () const { throw cast_error(); }
-	virtual bool operator== (const object_class* x) const { return false; }
-	virtual bool operator<  (const object_class* x) const { throw cast_error(); }
-	virtual bool operator>  (const object_class* x) const { throw cast_error(); }
-	bool operator!= (const object_class* x) const { return !(this->operator==(x)); }
-	virtual void pack(dynamic_packer& p) const = 0;
-	operator     bool() const { return   xbool(); } // FIXME !isnil();
-	operator  uint8_t() const { return     xu8(); }
-	operator uint16_t() const { return    xu16(); }
-	operator uint32_t() const { return    xu32(); }
-	operator uint64_t() const { return    xu64(); }
-	operator   int8_t() const { return     xi8(); }
-	operator  int16_t() const { return    xi16(); }
-	operator  int32_t() const { return    xi32(); }
-	operator  int64_t() const { return    xi64(); }
-	operator    float() const { return  xfloat(); }
-	operator   double() const { return xdouble(); }
-	//operator mutable_raw() { return   xraw(); }  // FIXME
-	operator      array&() { return xarray(); }
-	operator        map&() { return   xmap(); }
-	operator          raw() const { return   xraw(); }
-	operator const array&() const { return xarray(); }
-	operator const   map&() const { return   xmap(); }
-	virtual const object_class* inspect(std::ostream& s) const
-		{ s << '<' << typeid(*this).name() << '>'; return this; }
-};
-
-inline std::ostream& operator<< (std::ostream& s, const object_class* o)
-	{ o->inspect(s); return s; }
-
-
-struct object_container_mixin {};
-struct object_constructor_mixin {};
+class type_error : public std::bad_cast { };
 
 
 struct object {
-	explicit object() : val(NULL) {}
-	object(object_class* v) : val(v) {}
-	//object(object_class& v) : val(&v) {}
-	~object() {}
-	bool     isnil  () const { return val->isnil();   }
-	bool     xbool  () const { return val->xbool();   }
-	uint8_t  xu8    () const { return val->xu8();     }
-	uint16_t xu16   () const { return val->xu16();    }
-	uint32_t xu32   () const { return val->xu32();    }
-	uint64_t xu64   () const { return val->xu64();    }
-	int8_t   xi8    () const { return val->xi8();     }
-	int16_t  xi16   () const { return val->xi16();    }
-	int32_t  xi32   () const { return val->xi32();    }
-	int64_t  xi64   () const { return val->xi64();    }
-	float    xfloat () const { return val->xfloat();  }
-	double   xdouble() const { return val->xdouble(); }
-	//mutable_raw xraw  () { return val->xraw();   }  // FIXME
-	array&      xarray() { return val->xarray(); }
-	map&        xmap  () { return val->xmap();   }
-	raw          xraw  () const { return const_cast<const object_class*>(val)->xraw();   }
-	const array& xarray() const { return const_cast<const object_class*>(val)->xarray(); }
-	const map&   xmap  () const { return const_cast<const object_class*>(val)->xmap();   }
-	bool operator== (object x) const { return val->operator== (x.val); }
-	bool operator!= (object x) const { return val->operator!= (x.val); }
-	bool operator<  (object x) const { return val->operator<  (x.val); }
-	bool operator>  (object x) const { return val->operator>  (x.val); }
-	void pack(dynamic_packer& p) const { val->pack(p); }
-	template <typename Stream>
-		void pack(Stream& s) const { dynamic_packer p(s); pack(p); }
-	operator     bool() const { return val->operator bool();     }
-	operator  uint8_t() const { return val->operator uint8_t();  }
-	operator uint16_t() const { return val->operator uint16_t(); }
-	operator uint32_t() const { return val->operator uint32_t(); }
-	operator uint64_t() const { return val->operator uint64_t(); }
-	operator   int8_t() const { return val->operator int8_t();   }
-	operator  int16_t() const { return val->operator int16_t();  }
-	operator  int32_t() const { return val->operator int32_t();  }
-	operator  int64_t() const { return val->operator int64_t();  }
-	operator    float() const { return val->operator float();    }
-	operator   double() const { return val->operator double();   }
-	//operator mutable_raw() { return val->operator mutable_raw(); }  // FIXME
-	operator      array&() { return val->operator array&();      }
-	operator        map&() { return val->operator map&();        }
-	operator          raw() const { return val->operator raw();          }
-	operator const array&() const { return val->operator const array&(); }
-	operator const   map&() const { return val->operator const map&();   }
-	const object& inspect(std::ostream& s) const
-		{ val->inspect(s); return *this; }
-private:
-	friend class object_container_mixin;
-	friend class object_constructor_mixin;
-	object_class* val;
+	unsigned char type;
+	union {
+		bool boolean;
+		uint64_t u64;
+		int64_t  i64;
+		double   dec;
+		struct {
+			object* ptr;
+			uint32_t size;
+		} container;
+		struct {
+			const char* ptr;
+			uint32_t size;
+		} ref;
+	} via;
+	// FIXME template <typename T> operator T() { T v; convert(*this, v); return v; };
 };
 
-inline std::ostream& operator<< (std::ostream& s, const object& o)
-	{ o.inspect(s); return s; }
+std::ostream& operator<< (std::ostream& s, const object o);
 
+bool operator==(const object x, const object y);
+inline bool operator!=(const object x, const object y) { return !(x == y); }
 
-struct object_nil : object_class {
-	bool isnil() const;
-	bool operator== (const object_class* x) const;
-	void pack(dynamic_packer& p) const;
-	const object_class* inspect(std::ostream& s) const;
-};
 
-struct object_true : object_class {
-	bool xbool() const;
-	bool operator== (const object_class* x) const;
-	void pack(dynamic_packer& p) const;
-	const object_class* inspect(std::ostream& s) const;
-};
+template <typename Stream>
+const object& operator>> (const object& v, packer<Stream>& o);
 
-struct object_false : object_class {
-	bool xbool() const;
-	bool operator== (const object_class* x) const;
-	void pack(dynamic_packer& p) const;
-	const object_class* inspect(std::ostream& s) const;
-};
 
-#define INTEGER_CLASS(TYPE, NAME) \
-struct object_##NAME : object_class {						\
-	explicit object_##NAME(TYPE v) : val(v) {}				\
-	uint8_t  xu8    () const;								\
-	uint16_t xu16   () const;								\
-	uint32_t xu32   () const;								\
-	uint64_t xu64   () const;								\
-	int8_t   xi8    () const;								\
-	int16_t  xi16   () const;								\
-	int32_t  xi32   () const;								\
-	int64_t  xi64   () const;								\
-	float    xfloat () const;								\
-	double   xdouble() const;								\
-	bool operator== (const object_class* x) const;			\
-	bool operator<  (const object_class* x) const;			\
-	bool operator>  (const object_class* x) const;			\
-	void pack(dynamic_packer& p) const;						\
-	const object_class* inspect(std::ostream& s) const;		\
-private:													\
-	TYPE val;												\
-};
+namespace type {
+	static const unsigned char NIL					= 0x01;
+	static const unsigned char BOOLEAN				= 0x02;
+	static const unsigned char POSITIVE_INTEGER		= 0x03;
+	static const unsigned char NEGATIVE_INTEGER		= 0x04;
+	static const unsigned char DOUBLE				= 0x05;
+	static const unsigned char RAW					= 0x06;
+	static const unsigned char ARRAY				= 0x07;
+	static const unsigned char MAP					= 0x08;
 
-INTEGER_CLASS(uint8_t,  u8)
-INTEGER_CLASS(uint16_t, u16)
-INTEGER_CLASS(uint32_t, u32)
-INTEGER_CLASS(uint64_t, u64)
-INTEGER_CLASS(int8_t,  i8)
-INTEGER_CLASS(int16_t, i16)
-INTEGER_CLASS(int32_t, i32)
-INTEGER_CLASS(int64_t, i64)
 
-#undef INTEGER_CLASS
+	template <typename T>
+	inline T& operator<< (T& v, object o)
+	{
+		v = o;
+		return v;
+	}
 
 
-#define FLOAT_CLASS(TYPE, NAME) \
-struct object_##NAME : object_class {						\
-	object_##NAME(TYPE v) : val(v) {}						\
-	uint8_t  xu8    () const;								\
-	uint16_t xu16   () const;								\
-	uint32_t xu32   () const;								\
-	uint64_t xu64   () const;								\
-	int8_t   xi8    () const;								\
-	int16_t  xi16   () const;								\
-	int32_t  xi32   () const;								\
-	int64_t  xi64   () const;								\
-	float    xfloat () const;								\
-	double   xdouble() const;								\
-	bool operator== (const object_class* x) const;			\
-	bool operator<  (const object_class* x) const;			\
-	bool operator>  (const object_class* x) const;			\
-	void pack(dynamic_packer& p) const;						\
-	const object_class* inspect(std::ostream& s) const;		\
-private:													\
-	TYPE val;												\
-};
+	namespace detail {
+		template <typename Stream, typename T>
+		inline void pack_copy(T v, packer<Stream>& o)
+			{ pack(v, o); }
+	}
 
-FLOAT_CLASS(float, float)
-FLOAT_CLASS(double, double)
+	template <typename Stream, typename T>
+	inline const T& operator>> (const T& v, packer<Stream>& o)
+	{
+		detail::pack_copy(v.pack(), o);
+		return v;
+	}
 
-#undef FLOAT_CLASS
+}  // namespace type
 
 
-#define RAW_CLASS(NAME, TYPE, EXTRA) \
-struct object_##NAME : object_class {									\
-	explicit object_##NAME(TYPE p, uint32_t l) : ptr(p), len(l) {}		\
-	EXTRA																\
-	bool operator== (const object_class* x) const;						\
-	bool operator<  (const object_class* x) const;						\
-	bool operator>  (const object_class* x) const;						\
-	void pack(dynamic_packer& p) const;									\
-	const object_class* inspect(std::ostream& s) const;					\
-private:																\
-	TYPE ptr;															\
-	uint32_t len;														\
-};
-
-// FIXME
-RAW_CLASS(mutable_raw_ref, char*, /*mutable_raw xraw();*/ raw xraw() const; )
-RAW_CLASS(raw_ref, const char*, raw xraw() const; )
-
-#undef RAW_CLASS
+template <typename T>
+inline void convert(T& v, object o)
+{
+	using namespace type;
+	v << o;
+}
 
 
-struct object_array : object_class, object_container_mixin {
-	explicit object_array() {}
-	explicit object_array(uint32_t n) { val.reserve(n); }
-	array& xarray();
-	const array& xarray() const;
-	bool operator== (const object_class* x) const;
-	// FIXME operator<, operator>
-	void pack(dynamic_packer& p) const;
-	const object_class* inspect(std::ostream& s) const;
-public:
-	void push_back(object o) { val.push_back(o); }
-private:
-	std::vector<object> val;
-};
+template <typename Stream, typename T>
+inline void pack(T& v, packer<Stream>& o)
+{
+	using namespace type;
+	v >> o;
+}
 
 
-// FIXME hash, operator==: nil, true, false, array, mapを入れられない
-struct object_map : object_class, object_container_mixin {
-	explicit object_map() {}
-	map& xmap();
-	const map& xmap() const;
-	bool operator== (const object_class* x) const;
-	// FIXME operator<, operator>
-	void pack(dynamic_packer& p) const;
-	const object_class* inspect(std::ostream& s) const;
-public:
-	void store(object k, object v) { val[k] = v; }
-private:
-	std::map<object, object> val;
-};
+template <typename Stream, typename T>
+inline void pack(T& v, Stream& s)
+{
+	packer<Stream> pk(s);
+	pack(v, pk);
+}
 
 
 }  // namespace msgpack
 
+#include "msgpack/type.hpp"
+
 #endif /* msgpack/object.hpp */