Use size_t to represent sizes

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

diff --git a/source/net/protocol.h b/source/net/protocol.h
index 0a8110c9518182f91ada3cfe48f0f09ecd579b98..e078caff57ac8569d36a1fd24b3e5e1f2686f8fe 100644 (file)
--- a/source/net/protocol.h
+++ b/source/net/protocol.h
@@ -48,10 +48,9 @@ private:
        template<typename C, typename S>
        struct CompoundDef: public CompoundTypeDef<C>
        {
-               S *serializer;
+               S serializer;
 
                CompoundDef(const S &);
-               virtual ~CompoundDef();
 
                virtual std::string describe() const;
                virtual char *serialize(const C &, char *, char *) const;
@@ -197,7 +196,7 @@ private:
 
                const CompoundTypeDef<P> &get_compound() const { return *compound; }
 
-               virtual std::string describe() const;
+               virtual std::string describe() const { return compound->describe(); }
                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;
@@ -257,10 +256,10 @@ protected:
 
 public:
        template<typename P>
-       unsigned serialize(const P &, char *, unsigned) const;
+       std::size_t serialize(const P &, char *, std::size_t) const;
 
-       unsigned get_packet_size(const char *, unsigned) const;
-       unsigned dispatch(ReceiverBase &, const char *, unsigned) const;
+       std::size_t get_packet_size(const char *, std::size_t) const;
+       std::size_t dispatch(ReceiverBase &, const char *, std::size_t) const;
 
        UInt64 get_hash() const;
 
@@ -292,9 +291,11 @@ const Protocol::PacketTypeDef<P> &Protocol::get_packet_by_class() const
 }
 
 template<typename P>
-unsigned Protocol::serialize(const P &pkt, char *buf, unsigned size) const
+std::size_t Protocol::serialize(const P &pkt, char *buf, std::size_t size) 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(pdef.get_id(), size), buf, buf+4);
@@ -327,6 +328,7 @@ struct Protocol::Traits
        typedef CompoundSerializer<T> Serializer;
 };
 
+template<> struct Protocol::Traits<bool>: BasicTraits<bool, 'B'> { };
 template<> struct Protocol::Traits<Int8>: BasicTraits<Int8, 'I'> { };
 template<> struct Protocol::Traits<UInt8>: BasicTraits<UInt8, 'U'> { };
 template<> struct Protocol::Traits<Int16>: BasicTraits<Int16, 'I'> { };
@@ -355,31 +357,25 @@ struct Protocol::Traits<std::vector<T> >
 
 template<typename C, typename S>
 Protocol::CompoundDef<C, S>::CompoundDef(const S &s):
-       serializer(new S(s))
+       serializer(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()+"}";
+       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);
+       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);
+       return serializer.deserialize(com, buf, end);
 }
 
 
@@ -448,23 +444,20 @@ std::string Protocol::Serializer<P, Head, S>::describe() const
 }
 
 template<typename P, typename Head, typename S>
-char * Protocol::Serializer<P, Head, S>::serialize(const P &pkt, char *buf, char *end) const
+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
+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>
 Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
        PacketDefBase(i),
@@ -488,12 +481,6 @@ void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
        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
 {