Simplify the inner workings of Protocol

The CompoundDef hierarchy was basically just a polymorphic wrapper for
Serializer.  Might as well make Serializer itself polymorphic.

diff --git a/source/net/protocol.cpp b/source/net/protocol.cpp
index bcad032b4cb4fcc86a9de9702312806bf640b3b3..cee18367b7cb254abf220e33eaad1f76958679f0 100644 (file)
--- a/source/net/protocol.cpp
+++ b/source/net/protocol.cpp
@@ -14,7 +14,7 @@ Protocol::Protocol(unsigned npi):
        header_def(0),
        next_packet_id(npi)
 {
-       PacketDefBuilder<PacketHeader, NullSerializer<PacketHeader> >(*this, header_def, NullSerializer<PacketHeader>())
+       PacketDefBuilder<PacketHeader, Serializer<PacketHeader>>(*this, header_def, Serializer<PacketHeader>())
                (&PacketHeader::type)(&PacketHeader::length);
 }
 

diff --git a/source/net/protocol.h b/source/net/protocol.h
index 6d15a330295a0592b3e921d7737cde6cf515507d..f9a2f37035891729a0b0af9153b52a396385badf 100644 (file)
--- a/source/net/protocol.h
+++ b/source/net/protocol.h
@@ -35,26 +35,7 @@ private:
        struct Traits;
 
        template<typename C>
-       struct CompoundTypeDef
-       {
-               virtual ~CompoundTypeDef() = default;
-
-               virtual std::uint64_t get_hash() const = 0;
-               virtual char *serialize(const C &, char *, char *) const = 0;
-               virtual const char *deserialize(C &, const char *, const char *) const = 0;
-       };
-
-       template<typename C, typename S>
-       struct CompoundDef: public CompoundTypeDef<C>
-       {
-               S serializer;
-
-               CompoundDef(const S &);
-
-               std::uint64_t get_hash() const override;
-               char *serialize(const C &, char *, char *) const override;
-               const char *deserialize(C &, const char *, const char *) const override;
-       };
+       class Serializer;
 
        template<typename T>
        class BasicSerializer
@@ -110,52 +91,55 @@ private:
                typedef C ValueType;
 
        private:
-               const CompoundTypeDef<C> &def;
+               const Serializer<C> &serializer;
 
        public:
                CompoundSerializer(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 P, typename Head, typename S>
-       class Serializer: public Head
+       template<typename C, typename Head, typename S>
+       class FieldSerializer: public Head
        {
        public:
                template<typename N>
                struct Next
                {
-                       typedef Serializer<P, Serializer<P, Head, S>, typename Traits<N>::Serializer> Type;
+                       typedef FieldSerializer<C, FieldSerializer<C, Head, S>, typename Traits<N>::Serializer> Type;
                };
 
        private:
-               typedef typename S::ValueType P::*Pointer;
+               typedef typename S::ValueType C::*Pointer;
 
                Pointer ptr;
                S ser;
 
        public:
-               Serializer(const Head &, Pointer, const Protocol &);
+               FieldSerializer(const Head &, Pointer, const Protocol &);
 
                std::uint64_t get_hash() const;
-               char *serialize(const P &, char *, char *) const;
-               const char *deserialize(P &, const char *, const char *) const;
+               char *serialize(const C &, char *, char *) const;
+               const char *deserialize(C &, const char *, const char *) const;
        };
 
-       template<typename P>
-       class NullSerializer
+       template<typename C>
+       class Serializer
        {
        public:
                template<typename N>
                struct Next
                {
-                       typedef Serializer<P, NullSerializer, typename Traits<N>::Serializer> Type;
+                       typedef FieldSerializer<C, Serializer<C>, typename Traits<N>::Serializer> Type;
                };
 
-               std::uint64_t get_hash() const { return 0; }
-               char *serialize(const P &, char *b, char *) const { return b; }
-               const char *deserialize(P &, const char *b, const char *) const { return b; }
+               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
@@ -177,7 +161,7 @@ private:
        class PacketTypeDef: public PacketDefBase
        {
        private:
-               CompoundTypeDef<P> *compound;
+               Serializer<P> *serializer;
 
        public:
                PacketTypeDef(unsigned);
@@ -188,9 +172,9 @@ private:
                template<typename S>
                void set_serializer(const S &);
 
-               const CompoundTypeDef<P> &get_compound() const { return *compound; }
+               const Serializer<P> &get_serializer() const { return *serializer; }
 
-               std::uint64_t get_hash() const override { return compound->get_hash(); }
+               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 *dispatch(ReceiverBase &, const char *, const char *) const override;
@@ -242,10 +226,10 @@ private:
 
 protected:
        template<typename P>
-       PacketDefBuilder<P, NullSerializer<P> > add(unsigned);
+       PacketDefBuilder<P, Serializer<P>> add(unsigned);
 
        template<typename P>
-       PacketDefBuilder<P, NullSerializer<P> > add();
+       PacketDefBuilder<P, Serializer<P>> add();
 
        const PacketDefBase &get_packet_by_class_id(unsigned) const;
        const PacketDefBase &get_packet_by_id(unsigned) const;
@@ -272,15 +256,15 @@ unsigned Protocol::get_packet_class_id()
 }
 
 template<typename P>
-Protocol::PacketDefBuilder<P, Protocol::NullSerializer<P> > Protocol::add(unsigned id)
+Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add(unsigned id)
 {
        PacketTypeDef<P> *pdef = new PacketTypeDef<P>(id);
        add_packet(pdef);
-       return PacketDefBuilder<P, NullSerializer<P> >(*this, *pdef, NullSerializer<P>());
+       return PacketDefBuilder<P, Serializer<P>>(*this, *pdef, Serializer<P>());
 }
 
 template<typename P>
-Protocol::PacketDefBuilder<P, Protocol::NullSerializer<P> > Protocol::add()
+Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add()
 {
        return add<P>(next_packet_id++);
 }
@@ -338,38 +322,13 @@ template<> struct Protocol::Traits<std::string>
 };
 
 template<typename T>
-struct Protocol::Traits<std::vector<T> >
+struct Protocol::Traits<std::vector<T>>
 {
        static const std::uint16_t signature = 'A';
-       typedef ArraySerializer<std::vector<T> > Serializer;
+       typedef ArraySerializer<std::vector<T>> Serializer;
 };
 
 
-
-template<typename C, typename S>
-Protocol::CompoundDef<C, S>::CompoundDef(const S &s):
-       serializer(s)
-{ }
-
-template<typename C, typename S>
-std::uint64_t Protocol::CompoundDef<C, S>::get_hash() const
-{
-       return hash_round<64>(serializer.get_hash(), 'C');
-}
-
-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);
-}
-
-
 inline std::uint64_t Protocol::StringSerializer::get_hash() const
 {
        return Traits<std::string>::signature;
@@ -411,44 +370,50 @@ const char *Protocol::ArraySerializer<A>::deserialize(A &array, const char *buf,
 
 template<typename C>
 Protocol::CompoundSerializer<C>::CompoundSerializer(const Protocol &proto):
-       def(proto.get_packet_by_class<C>().get_compound())
+       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 def.serialize(com, buf, end);
+       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 def.deserialize(com, buf, end);
+       return serializer.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):
+Protocol::FieldSerializer<P, Head, S>::FieldSerializer(const Head &h, Pointer p, const Protocol &proto):
        Head(h),
        ptr(p),
        ser(proto)
 { }
 
 template<typename P, typename Head, typename S>
-std::uint64_t Protocol::Serializer<P, Head, S>::get_hash() const
+std::uint64_t Protocol::FieldSerializer<P, Head, S>::get_hash() const
 {
        return hash_update<64>(Head::get_hash(), ser.get_hash());
 }
 
 template<typename P, typename Head, typename S>
-char *Protocol::Serializer<P, Head, S>::serialize(const P &pkt, char *buf, char *end) const
+char *Protocol::FieldSerializer<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
+const char *Protocol::FieldSerializer<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);
@@ -458,33 +423,33 @@ const char *Protocol::Serializer<P, Head, S>::deserialize(P &pkt, const char *bu
 template<typename P>
 Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
        PacketDefBase(i),
-       compound(new CompoundDef<P, NullSerializer<P> >(NullSerializer<P>()))
+       serializer(new Serializer<P>)
 { }
 
 template<typename P>
 Protocol::PacketTypeDef<P>::~PacketTypeDef()
 {
-       delete compound;
+       delete serializer;
 }
 
 template<typename P>
 template<typename S>
 void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
 {
-       delete compound;
-       compound = new CompoundDef<P, S>(ser);
+       delete serializer;
+       serializer = new S(ser);
 }
 
 template<typename P>
 char *Protocol::PacketTypeDef<P>::serialize(const P &pkt, char *buf, char *end) const
 {
-       return compound->serialize(pkt, buf, end);
+       return serializer->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);
+       return serializer->deserialize(pkt, buf, end);
 }
 
 template<typename P>