source/protocol.h

   1 /* $Id$
   2
   3 This file is part of libmspnet
   4 Copyright © 2009  Mikkosoft Productions, Mikko Rasa
   5 Distributed under the LGPL
   6 */
   7
   8 #ifndef MSP_NET_PROTOCOL_H_
   9 #define MSP_NET_PROTOCOL_H_
  10
  11 #include <map>
  12 #include <vector>
  13 #include <msp/core/except.h>
  14 #include "receiver.h"
  15
  16 namespace Msp {
  17 namespace Net {
  18
  19 class Protocol
  20 {
  21 private:
  22         class PacketDefBase
  23         {
  24         protected:
  25                 unsigned id;
  26
  27                 PacketDefBase(unsigned i): id(i) { }
  28         public:
  29                 virtual ~PacketDefBase() { }
  30                 virtual unsigned get_class_id() const =0;
  31                 unsigned get_id() const { return id; }
  32                 virtual const char *disassemble(ReceiverBase &, const char *, const char *) const =0;
  33
  34                 static unsigned next_class_id;
  35         };
  36
  37         template<typename P>
  38         class FieldBase
  39         {
  40         protected:
  41                 FieldBase() { }
  42         public:
  43                 virtual ~FieldBase() { }
  44                 virtual char *assemble(const P &, char *, char *) const =0;
  45                 virtual const char *disassemble(P &, const char *, const char *) const =0;
  46         };
  47
  48         template<typename P, typename T>
  49         class Field: public FieldBase<P>
  50         {
  51         private:
  52                 T P::*ptr;
  53
  54         public:
  55                 Field(T P::*p): ptr(p) { }
  56
  57                 virtual char *assemble(const P &p, char *d, char *e) const
  58                 { return assemble_field(p.*ptr, d, e); }
  59
  60                 virtual const char *disassemble(P &p, const char *d, const char *e) const
  61                 { return disassemble_field(p.*ptr, d, e); }
  62         };
  63
  64 protected:
  65         template<typename P>
  66         class PacketDef: public PacketDefBase
  67         {
  68         private:
  69                 std::vector<FieldBase<P> *> fields;
  70
  71         public:
  72                 PacketDef(unsigned i): PacketDefBase(i)
  73                 { if(!class_id) class_id=next_class_id++; }
  74
  75                 virtual unsigned get_class_id() const { return class_id; }
  76
  77                 template<typename T>
  78                 PacketDef &operator()(T P::*p)
  79                 { fields.push_back(new Field<P, T>(p)); return *this; }
  80
  81                 char *assemble(const P &p, char *d, char *e) const
  82                 {
  83                         for(typename std::vector<FieldBase<P> *>::const_iterator i=fields.begin(); i!=fields.end(); ++i)
  84                                 d=(*i)->assemble(p, d, e);
  85                         return d;
  86                 }
  87
  88                 const char *disassemble(ReceiverBase &r, const char *d, const char *e) const
  89                 {
  90                         PacketReceiver<P> *prcv=dynamic_cast<PacketReceiver<P> *>(&r);
  91                         if(!prcv)
  92                                 throw Exception("Packet type not supported by receiver");
  93                         P pkt;
  94                         for(typename std::vector<FieldBase<P> *>::const_iterator i=fields.begin(); i!=fields.end(); ++i)
  95                                 d=(*i)->disassemble(pkt, d, e);
  96                         prcv->receive(pkt);
  97                         return d;
  98                 }
  99
 100                 static unsigned class_id;
 101         };
 102
 103         typedef std::map<unsigned, PacketDefBase *> PacketMap;
 104
 105         unsigned next_packet_id;
 106         PacketMap packet_class_defs;
 107         PacketMap packet_id_defs;
 108
 109         Protocol(unsigned =1);
 110 public:
 111         ~Protocol();
 112
 113 private:
 114         void add_packet(PacketDefBase &);
 115
 116 protected:
 117         template<typename P>
 118         PacketDef<P> &add()
 119         {
 120                 PacketDef<P> *pdef=new PacketDef<P>(next_packet_id++);
 121                 add_packet(*pdef);
 122                 return *pdef;
 123         }
 124
 125         const PacketDefBase &get_packet_by_class(unsigned) const;
 126         const PacketDefBase &get_packet_by_id(unsigned) const;
 127
 128 public:
 129         template<typename P>
 130         unsigned assemble(const P &pkt, char *buf, unsigned size) const
 131         {
 132                 unsigned id=PacketDef<P>::class_id;
 133                 const PacketDef<P> &pdef=static_cast<const PacketDef<P> &>(get_packet_by_class(id));
 134                 char *ptr=pdef.assemble(pkt, buf+4, buf+size);
 135                 assemble_header(buf, pdef.get_id(), (size=ptr-buf));
 136                 return size;
 137         }
 138
 139         unsigned disassemble(ReceiverBase &, const char *, unsigned) const;
 140
 141         unsigned get_packet_size(const char *, unsigned) const;
 142
 143         unsigned get_hash() const;
 144
 145 private:
 146         static void assemble_header(char *, unsigned, unsigned);
 147
 148         template<typename T>
 149         static char *assemble_field(const T &, char *, char *);
 150
 151         template<typename T>
 152         static const char *disassemble_field(T &, const char *, const char *);
 153 };
 154
 155 template<typename P>
 156 unsigned Protocol::PacketDef<P>::class_id=0;
 157
 158 } // namespace Net
 159 } // namespace Msp
 160
 161 #endif