Add a dynamic receiver class for more flexible packet handling

[libs/net.git] / source / net / protocol.h

diff --git a/source/net/protocol.h b/source/net/protocol.h
index 75b3514bb43b2729c915902f7a33374e8b1b608c..5051338f3911558c8e2ee19fe2d0665c0e10eec3 100644 (file)
--- a/source/net/protocol.h
+++ b/source/net/protocol.h
@@ -1,174 +1,475 @@
 #ifndef MSP_NET_PROTOCOL_H_
 #define MSP_NET_PROTOCOL_H_
 
 #ifndef MSP_NET_PROTOCOL_H_
 #define MSP_NET_PROTOCOL_H_
 

+#include <cstdint>

 #include <map>
 #include <map>

+#include <memory>

 #include <stdexcept>
 #include <vector>
 #include <stdexcept>
 #include <vector>

+#include <msp/core/hash.h>
+#include "mspnet_api.h"

 #include "receiver.h"
 
 namespace Msp {
 namespace Net {
 
 #include "receiver.h"
 
 namespace Msp {
 namespace Net {
 

-class bad_packet: public std::runtime_error
+class MSPNET_API bad_packet: public std::runtime_error

 {
 public:
        bad_packet(const std::string &w): std::runtime_error(w) { }
 {
 public:
        bad_packet(const std::string &w): std::runtime_error(w) { }

-       virtual ~bad_packet() throw() { }

 };
 
 
 };
 
 

-class buffer_error: public std::runtime_error
+class MSPNET_API buffer_error: public std::runtime_error

 {
 public:
        buffer_error(const std::string &w): std::runtime_error(w) { }
 {
 public:
        buffer_error(const std::string &w): std::runtime_error(w) { }

-       virtual ~buffer_error() throw() { }

 };
 
 
 };
 
 

-class Protocol
+class MSPNET_API Protocol

 {
 {

+public:
+       struct PacketHeader
+       {
+               std::uint16_t type = 0;
+               std::uint16_t length = 0;
+
+               PacketHeader() = default;
+               PacketHeader(std::uint16_t, std::uint16_t);
+       };
+

 private:
 private:

-       class PacketDefBase
+       template<typename T, std::uint8_t K>
+       struct BasicTraits;
+
+       template<typename T>
+       struct Traits;
+
+       template<typename C>
+       class Serializer;
+
+       template<typename T>
+       class BasicSerializer

        {
        {

-       protected:
-               unsigned id;
+       public:
+               BasicSerializer(const Protocol &) { }
+
+               std::uint64_t get_hash() const { return Traits<T>::signature; }
+               char *serialize(const T &, char *, char *) const;
+               const char *deserialize(T &, const char *, const char *) const;
+       };
+
+       class StringSerializer
+       {
+       private:
+               BasicSerializer<std::uint16_t> length_serializer;

 
 

-               PacketDefBase(unsigned i): id(i) { }

        public:
        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;
+               StringSerializer(const Protocol &);

 
 

-               static unsigned next_class_id;
+               std::uint64_t get_hash() const;
+               char *serialize(const std::string &, char *, char *) const;
+               const char *deserialize(std::string &, const char *, const char *) const;

        };
 
        };
 

-       template<typename P>
-       class FieldBase
+       template<typename A>
+       class ArraySerializer

        {
        {

-       protected:
-               FieldBase() { }
+       private:
+               BasicSerializer<std::uint16_t> length_serializer;
+               typename Traits<typename A::value_type>::Serializer element_serializer;
+

        public:
        public:

-               virtual ~FieldBase() { }
-               virtual char *assemble(const P &, char *, char *) const = 0;
-               virtual const char *disassemble(P &, const char *, const char *) const = 0;
+               ArraySerializer(const Protocol &);
+
+               std::uint64_t get_hash() const;
+               char *serialize(const A &, char *, char *) const;
+               const char *deserialize(A &, const char *, const char *) const;

        };
 
        };
 

-       template<typename P, typename T>
-       class Field: public FieldBase<P>
+       template<typename C>
+       class CompoundSerializer

        {
        private:
        {
        private:

-               T P::*ptr;
+               const Serializer<C> &serializer;

 
        public:
 
        public:

-               Field(T P::*p): ptr(p) { }
+               CompoundSerializer(const Protocol &);

 
 

-               virtual char *assemble(const P &p, char *d, char *e) const
-               { return assemble_field(p.*ptr, d, e); }
+               std::uint64_t get_hash() const;
+               char *serialize(const C &, char *, char *) const;
+               const char *deserialize(C &, const char *, const char *) const;
+       };

 
 

-               virtual const char *disassemble(P &p, const char *d, const char *e) const
-               { return disassemble_field(p.*ptr, d, e); }
+       template<typename C, typename Head, typename T>
+       class FieldSerializer: public Head
+       {
+       public:
+               template<typename N>
+               using Next = FieldSerializer<C, FieldSerializer<C, Head, T>, N>;
+
+       private:
+               T C::*ptr;
+               typename Traits<T>::Serializer ser;
+
+       public:
+               FieldSerializer(const Head &, T C::*, const Protocol &);
+
+               std::uint64_t get_hash() const;
+               char *serialize(const C &, char *, char *) const;
+               const char *deserialize(C &, const char *, const char *) const;
+       };
+
+       template<typename C>
+       class Serializer
+       {
+       public:
+               template<typename N>
+               using Next = FieldSerializer<C, Serializer<C>, N>;
+
+               virtual ~Serializer() = default;
+
+               virtual std::uint64_t get_hash() const { return 0; }
+               virtual char *serialize(const C &, char *b, char *) const { return b; }
+               virtual const char *deserialize(C &, const char *b, const char *) const { return b; }
+       };
+
+       class PacketDefBase
+       {
+       protected:
+               unsigned id;
+
+               PacketDefBase(unsigned);
+       public:
+               virtual ~PacketDefBase() = default;
+
+               virtual unsigned get_class_id() const = 0;
+               unsigned get_id() const { return id; }
+               virtual std::uint64_t get_hash() const = 0;
+               virtual const char *deserialize(Variant &, const char *, const char *) const = 0;
+               virtual const char *dispatch(ReceiverBase &, const char *, const char *) const = 0;

        };
 
        };
 

-protected:

        template<typename P>
        template<typename P>

-       class PacketDef: public PacketDefBase
+       class PacketTypeDef: public PacketDefBase

        {
        private:
        {
        private:

-               std::vector<FieldBase<P> *> fields;
+               std::unique_ptr<Serializer<P>> serializer;

 
        public:
 
        public:

-               PacketDef(unsigned i): PacketDefBase(i)
-               { if(!class_id) class_id = next_class_id++; }
+               PacketTypeDef(unsigned);

 
 

-               ~PacketDef()
-               {
-                       for(typename std::vector<FieldBase<P> *>::const_iterator i=fields.begin(); i!=fields.end(); ++i)
-                               delete *i;
-               }
+               unsigned get_class_id() const override { return get_packet_class_id<P>(); }

 
 

-               virtual unsigned get_class_id() const { return class_id; }
+               template<typename S>
+               void set_serializer(const S &);

 
 

-               template<typename T>
-               PacketDef &operator()(T P::*p)
-               { fields.push_back(new Field<P, T>(p)); return *this; }
-
-               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;
-               }
-
-               const char *disassemble(ReceiverBase &r, const char *d, const char *e) const
-               {
-                       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;
-               }
-
-               static unsigned class_id;
+               const Serializer<P> &get_serializer() const { return *serializer; }
+
+               std::uint64_t get_hash() const override { return serializer->get_hash(); }
+               char *serialize(const P &, char *, char *) const;
+               const char *deserialize(P &, const char *, const char *) const;
+               const char *deserialize(Variant &, const char *, const char *) const override;
+               const char *dispatch(ReceiverBase &, const char *, const char *) const override;

        };
 
        };
 

-       typedef std::map<unsigned, PacketDefBase *> PacketMap;
+       template<typename P, typename S>
+       class PacketDefBuilder
+       {
+       private:
+               const Protocol &protocol;
+               PacketTypeDef<P> &pktdef;
+               S serializer;

 
 

-       unsigned next_packet_id;
-       PacketMap packet_class_defs;
-       PacketMap packet_id_defs;
+       public:
+               PacketDefBuilder(const Protocol &, PacketTypeDef<P> &, const S &);

 
 

-       Protocol(unsigned = 1);
-public:
-       ~Protocol();
+               template<typename T>
+               PacketDefBuilder<P, typename S::template Next<T>> fields(T P::*);
+
+               template<typename T1, typename T2, typename... Rest>
+               auto fields(T1 P::*first, T2 P::*second, Rest P::*...rest) { return fields(first).fields(second, rest...); }
+       };
+
+       PacketTypeDef<PacketHeader> header_def;
+       unsigned next_packet_id = 1;
+       std::map<unsigned, std::unique_ptr<PacketDefBase>> packet_class_defs;
+       std::map<unsigned, PacketDefBase *> packet_id_defs;
+
+protected:
+       Protocol();

 
 private:
 
 private:

-       void add_packet(PacketDefBase &);
+       static unsigned get_next_packet_class_id();
+
+       template<typename P>
+       static unsigned get_packet_class_id();
+
+       void add_packet(std::unique_ptr<PacketDefBase>);

 
 protected:
        template<typename P>
 
 protected:
        template<typename P>

-       PacketDef<P> &add()
-       {
-               PacketDef<P> *pdef = new PacketDef<P>(next_packet_id++);
-               add_packet(*pdef);
-               return *pdef;
-       }
+       PacketDefBuilder<P, Serializer<P>> add();

 
 

-       const PacketDefBase &get_packet_by_class(unsigned) const;
+       template<typename P, typename T, typename... Rest>
+       auto add(T P::*field, Rest P::*...rest) { return add<P>().fields(field, rest...); }
+
+       const PacketDefBase &get_packet_by_class_id(unsigned) const;

        const PacketDefBase &get_packet_by_id(unsigned) const;
 
        const PacketDefBase &get_packet_by_id(unsigned) const;
 

+       template<typename P>
+       const PacketTypeDef<P> &get_packet_by_class() const;
+

 public:
        template<typename P>
 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;
-       }
+       bool has_packet() const { return packet_class_defs.count(get_packet_class_id<P>()); }

 
 

-       unsigned disassemble(ReceiverBase &, const char *, unsigned) const;
+       template<typename P>
+       unsigned get_packet_id() const { return get_item(packet_class_defs, get_packet_class_id<P>())->get_id(); }

 
 

-       unsigned get_packet_size(const char *, unsigned) const;
+       unsigned get_max_packet_id() const;

 
 

-       unsigned get_hash() const;
+       template<typename P>
+       std::size_t serialize(const P &, char *, std::size_t, unsigned = 0) const;

 
 

-private:
-       static void assemble_header(char *, unsigned, unsigned);
+       bool get_packet_header(PacketHeader &, const char *, std::size_t) const;
+       std::size_t get_packet_size(const char *, std::size_t) const;
+       std::size_t dispatch(ReceiverBase &, const char *, std::size_t, unsigned = 0) const;

 
 

-       template<typename T>
-       static char *assemble_field(const T &, char *, char *);
+       std::uint64_t get_hash() const;
+};

 
 

-       template<typename T>
-       static const char *disassemble_field(T &, const char *, const char *);
+
+template<typename P>
+unsigned Protocol::get_packet_class_id()
+{
+       static unsigned id = get_next_packet_class_id();
+       return id;
+}
+
+template<typename P>
+Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add()
+{
+       std::unique_ptr<PacketTypeDef<P>> pdef = std::make_unique<PacketTypeDef<P>>(next_packet_id++);
+       PacketDefBuilder<P, Serializer<P>> next(*this, *pdef, Serializer<P>());
+       add_packet(move(pdef));
+       return next;
+}
+
+template<typename P>
+const Protocol::PacketTypeDef<P> &Protocol::get_packet_by_class() const
+{
+       const PacketDefBase &pdef = get_packet_by_class_id(get_packet_class_id<P>());
+       return static_cast<const PacketTypeDef<P> &>(pdef);
+}
+
+template<typename P>
+std::size_t Protocol::serialize(const P &pkt, char *buf, std::size_t size, unsigned base_id) const
+{
+       const PacketTypeDef<P> &pdef = get_packet_by_class<P>();
+       if(!pdef.get_id())
+               throw std::invalid_argument("no packet id");
+       char *ptr = pdef.serialize(pkt, buf+4, buf+size);
+       size = ptr-buf;
+       header_def.serialize(PacketHeader(base_id+pdef.get_id(), size), buf, buf+4);
+       return size;
+}
+
+
+template<typename T, std::uint8_t K>
+struct Protocol::BasicTraits
+{
+       static const std::uint16_t signature = K | (sizeof(T)<<8);
+       typedef BasicSerializer<T> Serializer;
+};
+
+template<typename T>
+struct Protocol::Traits
+{
+       static const std::uint16_t signature = 'C';
+       typedef CompoundSerializer<T> Serializer;
+};
+
+template<> struct Protocol::Traits<bool>: BasicTraits<bool, 'B'> { };
+template<> struct Protocol::Traits<std::int8_t>: BasicTraits<std::int8_t, 'I'> { };
+template<> struct Protocol::Traits<std::uint8_t>: BasicTraits<std::uint8_t, 'U'> { };
+template<> struct Protocol::Traits<std::int16_t>: BasicTraits<std::int16_t, 'I'> { };
+template<> struct Protocol::Traits<std::uint16_t>: BasicTraits<std::uint16_t, 'U'> { };
+template<> struct Protocol::Traits<std::int32_t>: BasicTraits<std::int32_t, 'I'> { };
+template<> struct Protocol::Traits<std::uint32_t>: BasicTraits<std::uint32_t, 'U'> { };
+template<> struct Protocol::Traits<std::int64_t>: BasicTraits<std::int64_t, 'I'> { };
+template<> struct Protocol::Traits<std::uint64_t>: BasicTraits<std::uint64_t, '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 std::uint16_t signature = 'S';
+       typedef StringSerializer Serializer;

 };
 
 };
 

+template<typename T>
+struct Protocol::Traits<std::vector<T>>
+{
+       static const std::uint16_t signature = 'A';
+       typedef ArraySerializer<std::vector<T>> Serializer;
+};
+
+
+inline std::uint64_t Protocol::StringSerializer::get_hash() const
+{
+       return Traits<std::string>::signature;
+}
+
+
+template<typename A>
+Protocol::ArraySerializer<A>::ArraySerializer(const Protocol &proto):
+       length_serializer(proto),
+       element_serializer(proto)
+{ }
+
+template<typename A>
+std::uint64_t Protocol::ArraySerializer<A>::get_hash() const
+{
+       return hash_round<64>(element_serializer.get_hash(), 'A');
+}
+
+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(const auto &e: array)
+               buf = element_serializer.serialize(e, buf, end);
+       return buf;
+}
+
+template<typename A>
+const char *Protocol::ArraySerializer<A>::deserialize(A &array, const char *buf, const char *end) const
+{
+       std::uint16_t 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):
+       serializer(proto.get_packet_by_class<C>().get_serializer())
+{ }
+
+template<typename C>
+std::uint64_t Protocol::CompoundSerializer<C>::get_hash() const
+{
+       return hash_round<64>(serializer.get_hash(), 'C');
+}
+
+template<typename C>
+char *Protocol::CompoundSerializer<C>::serialize(const C &com, char *buf, char *end) const
+{
+       return serializer.serialize(com, buf, end);
+}
+
+template<typename C>
+const char *Protocol::CompoundSerializer<C>::deserialize(C &com, const char *buf, const char *end) const
+{
+       return serializer.deserialize(com, buf, end);
+}
+
+
+template<typename C, typename Head, typename T>
+Protocol::FieldSerializer<C, Head, T>::FieldSerializer(const Head &h, T C::*p, const Protocol &proto):
+       Head(h),
+       ptr(p),
+       ser(proto)
+{ }
+
+template<typename C, typename Head, typename T>
+std::uint64_t Protocol::FieldSerializer<C, Head, T>::get_hash() const
+{
+       return hash_update<64>(Head::get_hash(), ser.get_hash());
+}
+
+template<typename C, typename Head, typename T>
+char *Protocol::FieldSerializer<C, Head, T>::serialize(const C &com, char *buf, char *end) const
+{
+       buf = Head::serialize(com, buf, end);
+       return ser.serialize(com.*ptr, buf, end);
+}
+
+template<typename C, typename Head, typename T>
+const char *Protocol::FieldSerializer<C, Head, T>::deserialize(C &com, const char *buf, const char *end) const
+{
+       buf = Head::deserialize(com, buf, end);
+       return ser.deserialize(com.*ptr, buf, end);
+}
+
+
+template<typename P>
+Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
+       PacketDefBase(i),
+       serializer(std::make_unique<Serializer<P>>())
+{ }
+
+template<typename P>
+template<typename S>
+void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
+{
+       serializer = std::make_unique<S>(ser);
+}
+
+template<typename P>
+char *Protocol::PacketTypeDef<P>::serialize(const P &pkt, char *buf, char *end) const
+{
+       return serializer->serialize(pkt, buf, end);
+}
+

 template<typename P>
 template<typename P>

-unsigned Protocol::PacketDef<P>::class_id = 0;
+const char *Protocol::PacketTypeDef<P>::deserialize(P &pkt, const char *buf, const char *end) const
+{
+       return serializer->deserialize(pkt, buf, end);
+}
+
+template<typename P>
+const char *Protocol::PacketTypeDef<P>::deserialize(Variant &var_pkt, const char *buf, const char *end) const
+{
+       P pkt;
+       const char *ptr = serializer->deserialize(pkt, buf, end);
+       var_pkt = std::move(pkt);
+       return ptr;
+}
+
+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>> Protocol::PacketDefBuilder<P, S>::fields(T P::*ptr)
+{
+       typename S::template Next<T> next_ser(serializer, ptr, protocol);
+       pktdef.set_serializer(next_ser);
+       return PacketDefBuilder<P, typename S::template Next<T>>(protocol, pktdef, next_ser);
+}

 
 } // namespace Net
 } // namespace Msp
 
 } // namespace Net
 } // namespace Msp