#include <map>
#include <stdexcept>
#include <vector>
+#include <msp/core/inttypes.h>
#include "receiver.h"
namespace Msp {
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 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 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 &) { }
+
+ 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) { }
-
- virtual char *assemble(const P &p, char *d, char *e) const
- { return assemble_field(p.*ptr, d, e); }
+ StringSerializer(const Protocol &);
- virtual const char *disassemble(P &p, const char *d, const char *e) const
- { return disassemble_field(p.*ptr, d, e); }
+ char *serialize(const std::string &, char *, char *) const;
+ const char *deserialize(std::string &, const char *, const char *) const;
};
-protected:
- template<typename P>
- class PacketDef: public PacketDefBase
+ template<typename A>
+ class ArraySerializer
{
+ public:
+ typedef A ValueType;
+
private:
- std::vector<FieldBase<P> *> fields;
+ BasicSerializer<UInt16> length_serializer;
+ typename Traits<typename A::value_type>::Serializer element_serializer;
public:
- PacketDef(unsigned i): PacketDefBase(i)
- { if(!class_id) class_id = next_class_id++; }
+ ArraySerializer(const Protocol &);
- ~PacketDef()
+ char *serialize(const A &, char *, char *) const;
+ const char *deserialize(A &, const char *, const char *) const;
+ };
+
+ 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
+ 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;
+ };
+
+ 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 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; }
+
+ 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();
- const PacketDefBase &get_packet_by_class(unsigned) const;
+ 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;
+};
-private:
- static void assemble_header(char *, unsigned, unsigned);
- template<typename T>
- static char *assemble_field(const T &, char *, char *);
+template<typename P>
+Protocol::PacketDefBuilder<P, Protocol::NullSerializer<P> > Protocol::add()
+{
+ PacketTypeDef<P> *pdef = new PacketTypeDef<P>(next_packet_id++);
+ add_packet(pdef);
+ return PacketDefBuilder<P, NullSerializer<P> >(*this, *pdef, NullSerializer<P>());
+}
- template<typename T>
- static const char *disassemble_field(T &, const char *, const char *);
+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, UInt8 K>
+struct Protocol::BasicTraits
+{
+ typedef BasicSerializer<T> Serializer;
};
+template<> struct Protocol::Traits<Int8>: BasicTraits<Int8> { };
+template<> struct Protocol::Traits<UInt8>: BasicTraits<UInt8> { };
+template<> struct Protocol::Traits<Int16>: BasicTraits<Int16> { };
+template<> struct Protocol::Traits<UInt16>: BasicTraits<UInt16> { };
+template<> struct Protocol::Traits<Int32>: BasicTraits<Int32> { };
+template<> struct Protocol::Traits<UInt32>: BasicTraits<UInt32> { };
+template<> struct Protocol::Traits<Int64>: BasicTraits<Int64> { };
+template<> struct Protocol::Traits<UInt64>: BasicTraits<UInt64> { };
+template<> struct Protocol::Traits<float>: BasicTraits<float> { };
+template<> struct Protocol::Traits<double>: BasicTraits<double> { };
+
+template<> struct Protocol::Traits<std::string>
+{
+ typedef StringSerializer Serializer;
+};
+
+template<typename T>
+struct Protocol::Traits<std::vector<T> >
+{
+ 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>
+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>
+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 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>
+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::PacketTypeDef<P>::class_id = 0;
+
template<typename P>
-unsigned Protocol::PacketDef<P>::class_id = 0;
+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>
+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
projects / libs / net.git / blobdiff