X-Git-Url: http://git.tdb.fi/?p=libs%2Fnet.git;a=blobdiff_plain;f=source%2Fnet%2Fprotocol.h;h=0a8110c9518182f91ada3cfe48f0f09ecd579b98;hp=75b3514bb43b2729c915902f7a33374e8b1b608c;hb=c2d202f9b482be7b439436970d6366c369837107;hpb=50e9f9ea7f7385a2c5931fca2b8fb1103078e67c

diff --git a/source/net/protocol.h b/source/net/protocol.h
index 75b3514..0a8110c 100644
--- a/source/net/protocol.h
+++ b/source/net/protocol.h
@@ -4,6 +4,7 @@
 #include <map>
 #include <stdexcept>
 #include <vector>
+#include <msp/core/inttypes.h>
 #include "receiver.h"
 
 namespace Msp {
@@ -28,147 +29,511 @@ public:
 class Protocol
 {
 private:
-	class PacketDefBase
+	template<typename T, UInt8 K>
+	struct BasicTraits;
+
+	template<typename T>
+	struct Traits;
+
+	template<typename C>
+	struct CompoundTypeDef
 	{
-	protected:
-		unsigned id;
+		virtual ~CompoundTypeDef() { }
 
-		PacketDefBase(unsigned i): id(i) { }
-	public:
-		virtual ~PacketDefBase() { }
-		virtual unsigned get_class_id() const = 0;
-		unsigned get_id() const { return id; }
-		virtual const char *disassemble(ReceiverBase &, const char *, const char *) const = 0;
+		virtual std::string describe() const = 0;
+		virtual char *serialize(const C &, char *, char *) const = 0;
+		virtual const char *deserialize(C &, const char *, const char *) const = 0;
+	};
 
-		static unsigned next_class_id;
+	template<typename C, typename S>
+	struct CompoundDef: public CompoundTypeDef<C>
+	{
+		S *serializer;
+
+		CompoundDef(const S &);
+		virtual ~CompoundDef();
+
+		virtual std::string describe() const;
+		virtual char *serialize(const C &, char *, char *) const;
+		virtual const char *deserialize(C &, const char *, const char *) const;
 	};
 
-	template<typename P>
-	class FieldBase
+	template<typename T>
+	class BasicSerializer
 	{
-	protected:
-		FieldBase() { }
 	public:
-		virtual ~FieldBase() { }
-		virtual char *assemble(const P &, char *, char *) const = 0;
-		virtual const char *disassemble(P &, const char *, const char *) const = 0;
+		typedef T ValueType;
+
+		BasicSerializer(const Protocol &) { }
+
+		std::string describe() const { return get_type_signature<T>(); }
+		char *serialize(const T &, char *, char *) const;
+		const char *deserialize(T &, const char *, const char *) const;
 	};
 
-	template<typename P, typename T>
-	class Field: public FieldBase<P>
+	class StringSerializer
 	{
+	public:
+		typedef std::string ValueType;
+
 	private:
-		T P::*ptr;
+		BasicSerializer<UInt16> length_serializer;
 
 	public:
-		Field(T P::*p): ptr(p) { }
+		StringSerializer(const Protocol &);
 
-		virtual char *assemble(const P &p, char *d, char *e) const
-		{ return assemble_field(p.*ptr, d, e); }
+		std::string describe() const { return get_type_signature<std::string>(); }
+		char *serialize(const std::string &, char *, char *) const;
+		const char *deserialize(std::string &, const char *, const char *) const;
+	};
+
+	template<typename A>
+	class ArraySerializer
+	{
+	public:
+		typedef A ValueType;
+
+	private:
+		BasicSerializer<UInt16> length_serializer;
+		typename Traits<typename A::value_type>::Serializer element_serializer;
 
-		virtual const char *disassemble(P &p, const char *d, const char *e) const
-		{ return disassemble_field(p.*ptr, d, e); }
+	public:
+		ArraySerializer(const Protocol &);
+
+		std::string describe() const;
+		char *serialize(const A &, char *, char *) const;
+		const char *deserialize(A &, const char *, const char *) const;
 	};
 
-protected:
-	template<typename P>
-	class PacketDef: public PacketDefBase
+	template<typename C>
+	class CompoundSerializer
 	{
+	public:
+		typedef C ValueType;
+
 	private:
-		std::vector<FieldBase<P> *> fields;
+		const CompoundTypeDef<C> &def;
 
 	public:
-		PacketDef(unsigned i): PacketDefBase(i)
-		{ if(!class_id) class_id = next_class_id++; }
+		CompoundSerializer(const Protocol &);
+
+		std::string describe() const { return def.describe(); }
+		char *serialize(const C &, char *, char *) const;
+		const char *deserialize(C &, const char *, const char *) const;
+	};
 
-		~PacketDef()
+	template<typename P, typename Head, typename S>
+	class Serializer: public Head
+	{
+	public:
+		template<typename N>
+		struct Next
 		{
-			for(typename std::vector<FieldBase<P> *>::const_iterator i=fields.begin(); i!=fields.end(); ++i)
-				delete *i;
-		}
+			typedef Serializer<P, Serializer<P, Head, S>, typename Traits<N>::Serializer> Type;
+		};
 
-		virtual unsigned get_class_id() const { return class_id; }
+	private:
+		typedef typename S::ValueType P::*Pointer;
 
-		template<typename T>
-		PacketDef &operator()(T P::*p)
-		{ fields.push_back(new Field<P, T>(p)); return *this; }
+		Pointer ptr;
+		S ser;
 
-		char *assemble(const P &p, char *d, char *e) const
-		{
-			for(typename std::vector<FieldBase<P> *>::const_iterator i=fields.begin(); i!=fields.end(); ++i)
-				d = (*i)->assemble(p, d, e);
-			return d;
-		}
+	public:
+		Serializer(const Head &, Pointer, const Protocol &);
 
-		const char *disassemble(ReceiverBase &r, const char *d, const char *e) const
+		std::string describe() const;
+		char *serialize(const P &, char *, char *) const;
+		const char *deserialize(P &, const char *, const char *) const;
+	};
+
+	template<typename P>
+	class NullSerializer
+	{
+	public:
+		template<typename N>
+		struct Next
 		{
-			PacketReceiver<P> *prcv = dynamic_cast<PacketReceiver<P> *>(&r);
-			if(!prcv)
-				throw bad_packet("unsupported");
-			P pkt;
-			for(typename std::vector<FieldBase<P> *>::const_iterator i=fields.begin(); i!=fields.end(); ++i)
-				d = (*i)->disassemble(pkt, d, e);
-			prcv->receive(pkt);
-			return d;
-		}
+			typedef Serializer<P, NullSerializer, typename Traits<N>::Serializer> Type;
+		};
+
+		std::string describe() const { return std::string(); }
+		char *serialize(const P &, char *b, char *) const { return b; }
+		const char *deserialize(P &, const char *b, const char *) const { return b; }
+	};
+
+	class PacketDefBase
+	{
+	protected:
+		unsigned id;
+
+		static unsigned next_class_id;
+
+		PacketDefBase(unsigned);
+	public:
+		virtual ~PacketDefBase() { }
+		virtual unsigned get_class_id() const = 0;
+		unsigned get_id() const { return id; }
+		virtual std::string describe() const = 0;
+		virtual const char *dispatch(ReceiverBase &, const char *, const char *) const = 0;
+	};
+
+	template<typename P>
+	class PacketTypeDef: public PacketDefBase
+	{
+	private:
+		CompoundTypeDef<P> *compound;
 
 		static unsigned class_id;
+
+	public:
+		PacketTypeDef(unsigned);
+		~PacketTypeDef();
+
+		static unsigned get_static_class_id() { return class_id; }
+		virtual unsigned get_class_id() const { return class_id; }
+
+		template<typename S>
+		void set_serializer(const S &);
+
+		const CompoundTypeDef<P> &get_compound() const { return *compound; }
+
+		virtual std::string describe() const;
+		char *serialize(const P &, char *, char *) const;
+		const char *deserialize(P &, const char *, const char *) const;
+		virtual const char *dispatch(ReceiverBase &, const char *, const char *) const;
+	};
+
+	template<typename P, typename S>
+	class PacketDefBuilder
+	{
+	private:
+		const Protocol &protocol;
+		PacketTypeDef<P> &pktdef;
+		S serializer;
+
+	public:
+		PacketDefBuilder(const Protocol &, PacketTypeDef<P> &, const S &);
+		
+		template<typename T>
+		PacketDefBuilder<P, typename S::template Next<T>::Type> operator()(T P::*);
+	};
+
+	struct PacketHeader
+	{
+		UInt16 type;
+		UInt16 length;
+
+		PacketHeader();
+		PacketHeader(UInt16, UInt16);
 	};
 
 	typedef std::map<unsigned, PacketDefBase *> PacketMap;
 
+	PacketTypeDef<PacketHeader> header_def;
 	unsigned next_packet_id;
 	PacketMap packet_class_defs;
 	PacketMap packet_id_defs;
 
+protected:
 	Protocol(unsigned = 1);
 public:
 	~Protocol();
 
 private:
-	void add_packet(PacketDefBase &);
+	void add_packet(PacketDefBase *);
 
 protected:
 	template<typename P>
-	PacketDef<P> &add()
-	{
-		PacketDef<P> *pdef = new PacketDef<P>(next_packet_id++);
-		add_packet(*pdef);
-		return *pdef;
-	}
+	PacketDefBuilder<P, NullSerializer<P> > add(unsigned);
 
-	const PacketDefBase &get_packet_by_class(unsigned) const;
+	template<typename P>
+	PacketDefBuilder<P, NullSerializer<P> > add();
+
+	const PacketDefBase &get_packet_by_class_id(unsigned) const;
 	const PacketDefBase &get_packet_by_id(unsigned) const;
 
-public:
 	template<typename P>
-	unsigned assemble(const P &pkt, char *buf, unsigned size) const
-	{
-		unsigned id = PacketDef<P>::class_id;
-		const PacketDef<P> &pdef = static_cast<const PacketDef<P> &>(get_packet_by_class(id));
-		char *ptr = pdef.assemble(pkt, buf+4, buf+size);
-		assemble_header(buf, pdef.get_id(), (size = ptr-buf));
-		return size;
-	}
+	const PacketTypeDef<P> &get_packet_by_class() const;
 
-	unsigned disassemble(ReceiverBase &, const char *, unsigned) const;
+public:
+	template<typename P>
+	unsigned serialize(const P &, char *, unsigned) const;
 
 	unsigned get_packet_size(const char *, unsigned) const;
+	unsigned dispatch(ReceiverBase &, const char *, unsigned) const;
 
-	unsigned get_hash() const;
+	UInt64 get_hash() const;
 
 private:
-	static void assemble_header(char *, unsigned, unsigned);
-
 	template<typename T>
-	static char *assemble_field(const T &, char *, char *);
+	static std::string get_type_signature();
+};
 
-	template<typename T>
-	static const char *disassemble_field(T &, const char *, const char *);
+
+template<typename P>
+Protocol::PacketDefBuilder<P, Protocol::NullSerializer<P> > Protocol::add(unsigned id)
+{
+	PacketTypeDef<P> *pdef = new PacketTypeDef<P>(id);
+	add_packet(pdef);
+	return PacketDefBuilder<P, NullSerializer<P> >(*this, *pdef, NullSerializer<P>());
+}
+
+template<typename P>
+Protocol::PacketDefBuilder<P, Protocol::NullSerializer<P> > Protocol::add()
+{
+	return add<P>(next_packet_id++);
+}
+
+template<typename P>
+const Protocol::PacketTypeDef<P> &Protocol::get_packet_by_class() const
+{
+	const PacketDefBase &pdef = get_packet_by_class_id(PacketTypeDef<P>::get_static_class_id());
+	return static_cast<const PacketTypeDef<P> &>(pdef);
+}
+
+template<typename P>
+unsigned Protocol::serialize(const P &pkt, char *buf, unsigned size) const
+{
+	const PacketTypeDef<P> &pdef = get_packet_by_class<P>();
+	char *ptr = pdef.serialize(pkt, buf+4, buf+size);
+	size = ptr-buf;
+	header_def.serialize(PacketHeader(pdef.get_id(), size), buf, buf+4);
+	return size;
+}
+
+template<typename T>
+std::string Protocol::get_type_signature()
+{
+	const UInt16 sig = Traits<T>::signature;
+	std::string result;
+	result += sig&0xFF;
+	if(sig>=0x100)
+		result += '0'+(sig>>8);
+	return result;
+}
+
+
+template<typename T, UInt8 K>
+struct Protocol::BasicTraits
+{
+	static const UInt16 signature = K | (sizeof(T)<<8);
+	typedef BasicSerializer<T> Serializer;
+};
+
+template<typename T>
+struct Protocol::Traits
+{
+	static const UInt16 signature = 'C';
+	typedef CompoundSerializer<T> Serializer;
 };
 
+template<> struct Protocol::Traits<Int8>: BasicTraits<Int8, 'I'> { };
+template<> struct Protocol::Traits<UInt8>: BasicTraits<UInt8, 'U'> { };
+template<> struct Protocol::Traits<Int16>: BasicTraits<Int16, 'I'> { };
+template<> struct Protocol::Traits<UInt16>: BasicTraits<UInt16, 'U'> { };
+template<> struct Protocol::Traits<Int32>: BasicTraits<Int32, 'I'> { };
+template<> struct Protocol::Traits<UInt32>: BasicTraits<UInt32, 'U'> { };
+template<> struct Protocol::Traits<Int64>: BasicTraits<Int64, 'I'> { };
+template<> struct Protocol::Traits<UInt64>: BasicTraits<UInt64, 'U'> { };
+template<> struct Protocol::Traits<float>: BasicTraits<float, 'F'> { };
+template<> struct Protocol::Traits<double>: BasicTraits<double, 'F'> { };
+
+template<> struct Protocol::Traits<std::string>
+{
+	static const UInt16 signature = 'S';
+	typedef StringSerializer Serializer;
+};
+
+template<typename T>
+struct Protocol::Traits<std::vector<T> >
+{
+	static const UInt16 signature = 'A';
+	typedef ArraySerializer<std::vector<T> > Serializer;
+};
+
+
+
+template<typename C, typename S>
+Protocol::CompoundDef<C, S>::CompoundDef(const S &s):
+	serializer(new S(s))
+{ }
+
+template<typename C, typename S>
+Protocol::CompoundDef<C, S>::~CompoundDef()
+{
+	delete serializer;
+}
+
+template<typename C, typename S>
+std::string Protocol::CompoundDef<C, S>::describe() const
+{
+	return "{"+serializer->describe()+"}";
+}
+
+template<typename C, typename S>
+char *Protocol::CompoundDef<C, S>::serialize(const C &com, char *buf, char *end) const
+{
+	return serializer->serialize(com, buf, end);
+}
+
+template<typename C, typename S>
+const char *Protocol::CompoundDef<C, S>::deserialize(C &com, const char *buf, const char *end) const
+{
+	return serializer->deserialize(com, buf, end);
+}
+
+
+template<typename A>
+Protocol::ArraySerializer<A>::ArraySerializer(const Protocol &proto):
+	length_serializer(proto),
+	element_serializer(proto)
+{ }
+
+template<typename A>
+std::string Protocol::ArraySerializer<A>::describe() const
+{
+	return "["+element_serializer.describe()+"]";
+}
+
+template<typename A>
+char *Protocol::ArraySerializer<A>::serialize(const A &array, char *buf, char *end) const
+{
+	buf = length_serializer.serialize(array.size(), buf, end);
+	for(typename A::const_iterator i=array.begin(); i!=array.end(); ++i)
+		buf = element_serializer.serialize(*i, buf, end);
+	return buf;
+}
+
+template<typename A>
+const char *Protocol::ArraySerializer<A>::deserialize(A &array, const char *buf, const char *end) const
+{
+	UInt16 length;
+	buf = length_serializer.deserialize(length, buf, end);
+	array.resize(length);
+	for(unsigned i=0; i<length; ++i)
+		buf = element_serializer.deserialize(array[i], buf, end);
+	return buf;
+}
+
+
+template<typename C>
+Protocol::CompoundSerializer<C>::CompoundSerializer(const Protocol &proto):
+	def(proto.get_packet_by_class<C>().get_compound())
+{ }
+
+template<typename C>
+char *Protocol::CompoundSerializer<C>::serialize(const C &com, char *buf, char *end) const
+{
+	return def.serialize(com, buf, end);
+}
+
+template<typename C>
+const char *Protocol::CompoundSerializer<C>::deserialize(C &com, const char *buf, const char *end) const
+{
+	return def.deserialize(com, buf, end);
+}
+
+
+template<typename P, typename Head, typename S>
+Protocol::Serializer<P, Head, S>::Serializer(const Head &h, Pointer p, const Protocol &proto):
+	Head(h),
+	ptr(p),
+	ser(proto)
+{ }
+
+template<typename P, typename Head, typename S>
+std::string Protocol::Serializer<P, Head, S>::describe() const
+{
+	return Head::describe()+ser.describe();
+}
+
+template<typename P, typename Head, typename S>
+char * Protocol::Serializer<P, Head, S>::serialize(const P &pkt, char *buf, char *end) const
+{
+	buf = Head::serialize(pkt, buf, end);
+	return ser.serialize(pkt.*ptr, buf, end);
+}
+
+template<typename P, typename Head, typename S>
+const char * Protocol::Serializer<P, Head, S>::deserialize(P &pkt, const char *buf, const char *end) const
+{
+	buf = Head::deserialize(pkt, buf, end);
+	return ser.deserialize(pkt.*ptr, buf, end);
+}
+
+
 template<typename P>
-unsigned Protocol::PacketDef<P>::class_id = 0;
+unsigned Protocol::PacketTypeDef<P>::class_id = 0;
+
+template<typename P>
+Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
+	PacketDefBase(i),
+	compound(new CompoundDef<P, NullSerializer<P> >(NullSerializer<P>()))
+{
+	if(!class_id)
+		class_id = next_class_id++;
+}
+
+template<typename P>
+Protocol::PacketTypeDef<P>::~PacketTypeDef()
+{
+	delete compound;
+}
+
+template<typename P>
+template<typename S>
+void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
+{
+	delete compound;
+	compound = new CompoundDef<P, S>(ser);
+}
+
+template<typename P>
+std::string Protocol::PacketTypeDef<P>::describe() const
+{
+	return compound->describe();
+}
+
+template<typename P>
+char *Protocol::PacketTypeDef<P>::serialize(const P &pkt, char *buf, char *end) const
+{
+	return compound->serialize(pkt, buf, end);
+}
+
+template<typename P>
+const char *Protocol::PacketTypeDef<P>::deserialize(P &pkt, const char *buf, const char *end) const
+{
+	return compound->deserialize(pkt, buf, end);
+}
+
+template<typename P>
+const char *Protocol::PacketTypeDef<P>::dispatch(ReceiverBase &rcv, const char *buf, const char *end) const
+{
+	PacketReceiver<P> *prcv = dynamic_cast<PacketReceiver<P> *>(&rcv);
+	if(!prcv)
+		throw bad_packet("unsupported");
+	P pkt;
+	buf = deserialize(pkt, buf, end);
+	prcv->receive(pkt);
+	return buf;
+}
+
+
+template<typename P, typename S>
+Protocol::PacketDefBuilder<P, S>::PacketDefBuilder(const Protocol &p, PacketTypeDef<P> &k, const S &s):
+	protocol(p),
+	pktdef(k),
+	serializer(s)
+{ }
+
+template<typename P, typename S>
+template<typename T>
+Protocol::PacketDefBuilder<P, typename S::template Next<T>::Type> Protocol::PacketDefBuilder<P, S>::operator()(T P::*ptr)
+{
+	typename S::template Next<T>::Type next_ser(serializer, ptr, protocol);
+	pktdef.set_serializer(next_ser);
+	return PacketDefBuilder<P, typename S::template Next<T>::Type>(protocol, pktdef, next_ser);
+}
 
 } // namespace Net
 } // namespace Msp