source/net/protocol.h

   1 #ifndef MSP_NET_PROTOCOL_H_
   2 #define MSP_NET_PROTOCOL_H_
   3
   4 #include <cstdint>
   5 #include <map>
   6 #include <stdexcept>
   7 #include <vector>
   8 #include <msp/core/hash.h>
   9 #include "receiver.h"
  10
  11 namespace Msp {
  12 namespace Net {
  13
  14 class bad_packet: public std::runtime_error
  15 {
  16 public:
  17         bad_packet(const std::string &w): std::runtime_error(w) { }
  18 };
  19
  20
  21 class buffer_error: public std::runtime_error
  22 {
  23 public:
  24         buffer_error(const std::string &w): std::runtime_error(w) { }
  25 };
  26
  27
  28 class Protocol
  29 {
  30 private:
  31         template<typename T, std::uint8_t K>
  32         struct BasicTraits;
  33
  34         template<typename T>
  35         struct Traits;
  36
  37         template<typename C>
  38         class Serializer;
  39
  40         template<typename T>
  41         class BasicSerializer
  42         {
  43         public:
  44                 BasicSerializer(const Protocol &) { }
  45
  46                 std::uint64_t get_hash() const { return Traits<T>::signature; }
  47                 char *serialize(const T &, char *, char *) const;
  48                 const char *deserialize(T &, const char *, const char *) const;
  49         };
  50
  51         class StringSerializer
  52         {
  53         private:
  54                 BasicSerializer<std::uint16_t> length_serializer;
  55
  56         public:
  57                 StringSerializer(const Protocol &);
  58
  59                 std::uint64_t get_hash() const;
  60                 char *serialize(const std::string &, char *, char *) const;
  61                 const char *deserialize(std::string &, const char *, const char *) const;
  62         };
  63
  64         template<typename A>
  65         class ArraySerializer
  66         {
  67         private:
  68                 BasicSerializer<std::uint16_t> length_serializer;
  69                 typename Traits<typename A::value_type>::Serializer element_serializer;
  70
  71         public:
  72                 ArraySerializer(const Protocol &);
  73
  74                 std::uint64_t get_hash() const;
  75                 char *serialize(const A &, char *, char *) const;
  76                 const char *deserialize(A &, const char *, const char *) const;
  77         };
  78
  79         template<typename C>
  80         class CompoundSerializer
  81         {
  82         private:
  83                 const Serializer<C> &serializer;
  84
  85         public:
  86                 CompoundSerializer(const Protocol &);
  87
  88                 std::uint64_t get_hash() const;
  89                 char *serialize(const C &, char *, char *) const;
  90                 const char *deserialize(C &, const char *, const char *) const;
  91         };
  92
  93         template<typename C, typename Head, typename T>
  94         class FieldSerializer: public Head
  95         {
  96         public:
  97                 template<typename N>
  98                 using Next = FieldSerializer<C, FieldSerializer<C, Head, T>, N>;
  99
 100         private:
 101                 T C::*ptr;
 102                 typename Traits<T>::Serializer ser;
 103
 104         public:
 105                 FieldSerializer(const Head &, T C::*, const Protocol &);
 106
 107                 std::uint64_t get_hash() const;
 108                 char *serialize(const C &, char *, char *) const;
 109                 const char *deserialize(C &, const char *, const char *) const;
 110         };
 111
 112         template<typename C>
 113         class Serializer
 114         {
 115         public:
 116                 template<typename N>
 117                 using Next = FieldSerializer<C, Serializer<C>, N>;
 118
 119                 virtual ~Serializer() = default;
 120
 121                 virtual std::uint64_t get_hash() const { return 0; }
 122                 virtual char *serialize(const C &, char *b, char *) const { return b; }
 123                 virtual const char *deserialize(C &, const char *b, const char *) const { return b; }
 124         };
 125
 126         class PacketDefBase
 127         {
 128         protected:
 129                 unsigned id;
 130
 131                 PacketDefBase(unsigned);
 132         public:
 133                 virtual ~PacketDefBase() = default;
 134
 135                 virtual unsigned get_class_id() const = 0;
 136                 unsigned get_id() const { return id; }
 137                 virtual std::uint64_t get_hash() const = 0;
 138                 virtual const char *dispatch(ReceiverBase &, const char *, const char *) const = 0;
 139         };
 140
 141         template<typename P>
 142         class PacketTypeDef: public PacketDefBase
 143         {
 144         private:
 145                 Serializer<P> *serializer;
 146
 147         public:
 148                 PacketTypeDef(unsigned);
 149                 ~PacketTypeDef();
 150
 151                 unsigned get_class_id() const override { return get_packet_class_id<P>(); }
 152
 153                 template<typename S>
 154                 void set_serializer(const S &);
 155
 156                 const Serializer<P> &get_serializer() const { return *serializer; }
 157
 158                 std::uint64_t get_hash() const override { return serializer->get_hash(); }
 159                 char *serialize(const P &, char *, char *) const;
 160                 const char *deserialize(P &, const char *, const char *) const;
 161                 const char *dispatch(ReceiverBase &, const char *, const char *) const override;
 162         };
 163
 164         template<typename P, typename S>
 165         class PacketDefBuilder
 166         {
 167         private:
 168                 const Protocol &protocol;
 169                 PacketTypeDef<P> &pktdef;
 170                 S serializer;
 171
 172         public:
 173                 PacketDefBuilder(const Protocol &, PacketTypeDef<P> &, const S &);
 174
 175                 template<typename T>
 176                 PacketDefBuilder<P, typename S::template Next<T>> operator()(T P::*);
 177         };
 178
 179         struct PacketHeader
 180         {
 181                 std::uint16_t type = 0;
 182                 std::uint16_t length = 0;
 183
 184                 PacketHeader() = default;
 185                 PacketHeader(std::uint16_t, std::uint16_t);
 186         };
 187
 188         typedef std::map<unsigned, PacketDefBase *> PacketMap;
 189
 190         PacketTypeDef<PacketHeader> header_def;
 191         unsigned next_packet_id;
 192         PacketMap packet_class_defs;
 193         PacketMap packet_id_defs;
 194
 195 protected:
 196         Protocol(unsigned = 1);
 197 public:
 198         ~Protocol();
 199
 200 private:
 201         static unsigned get_next_packet_class_id();
 202
 203         template<typename P>
 204         static unsigned get_packet_class_id();
 205
 206         void add_packet(PacketDefBase *);
 207
 208 protected:
 209         template<typename P>
 210         PacketDefBuilder<P, Serializer<P>> add(unsigned);
 211
 212         template<typename P>
 213         PacketDefBuilder<P, Serializer<P>> add();
 214
 215         const PacketDefBase &get_packet_by_class_id(unsigned) const;
 216         const PacketDefBase &get_packet_by_id(unsigned) const;
 217
 218         template<typename P>
 219         const PacketTypeDef<P> &get_packet_by_class() const;
 220
 221 public:
 222         template<typename P>
 223         std::size_t serialize(const P &, char *, std::size_t) const;
 224
 225         std::size_t get_packet_size(const char *, std::size_t) const;
 226         std::size_t dispatch(ReceiverBase &, const char *, std::size_t) const;
 227
 228         std::uint64_t get_hash() const;
 229 };
 230
 231
 232 template<typename P>
 233 unsigned Protocol::get_packet_class_id()
 234 {
 235         static unsigned id = get_next_packet_class_id();
 236         return id;
 237 }
 238
 239 template<typename P>
 240 Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add(unsigned id)
 241 {
 242         PacketTypeDef<P> *pdef = new PacketTypeDef<P>(id);
 243         add_packet(pdef);
 244         return PacketDefBuilder<P, Serializer<P>>(*this, *pdef, Serializer<P>());
 245 }
 246
 247 template<typename P>
 248 Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add()
 249 {
 250         return add<P>(next_packet_id++);
 251 }
 252
 253 template<typename P>
 254 const Protocol::PacketTypeDef<P> &Protocol::get_packet_by_class() const
 255 {
 256         const PacketDefBase &pdef = get_packet_by_class_id(get_packet_class_id<P>());
 257         return static_cast<const PacketTypeDef<P> &>(pdef);
 258 }
 259
 260 template<typename P>
 261 std::size_t Protocol::serialize(const P &pkt, char *buf, std::size_t size) const
 262 {
 263         const PacketTypeDef<P> &pdef = get_packet_by_class<P>();
 264         if(!pdef.get_id())
 265                 throw std::invalid_argument("no packet id");
 266         char *ptr = pdef.serialize(pkt, buf+4, buf+size);
 267         size = ptr-buf;
 268         header_def.serialize(PacketHeader(pdef.get_id(), size), buf, buf+4);
 269         return size;
 270 }
 271
 272
 273 template<typename T, std::uint8_t K>
 274 struct Protocol::BasicTraits
 275 {
 276         static const std::uint16_t signature = K | (sizeof(T)<<8);
 277         typedef BasicSerializer<T> Serializer;
 278 };
 279
 280 template<typename T>
 281 struct Protocol::Traits
 282 {
 283         static const std::uint16_t signature = 'C';
 284         typedef CompoundSerializer<T> Serializer;
 285 };
 286
 287 template<> struct Protocol::Traits<bool>: BasicTraits<bool, 'B'> { };
 288 template<> struct Protocol::Traits<std::int8_t>: BasicTraits<std::int8_t, 'I'> { };
 289 template<> struct Protocol::Traits<std::uint8_t>: BasicTraits<std::uint8_t, 'U'> { };
 290 template<> struct Protocol::Traits<std::int16_t>: BasicTraits<std::int16_t, 'I'> { };
 291 template<> struct Protocol::Traits<std::uint16_t>: BasicTraits<std::uint16_t, 'U'> { };
 292 template<> struct Protocol::Traits<std::int32_t>: BasicTraits<std::int32_t, 'I'> { };
 293 template<> struct Protocol::Traits<std::uint32_t>: BasicTraits<std::uint32_t, 'U'> { };
 294 template<> struct Protocol::Traits<std::int64_t>: BasicTraits<std::int64_t, 'I'> { };
 295 template<> struct Protocol::Traits<std::uint64_t>: BasicTraits<std::uint64_t, 'U'> { };
 296 template<> struct Protocol::Traits<float>: BasicTraits<float, 'F'> { };
 297 template<> struct Protocol::Traits<double>: BasicTraits<double, 'F'> { };
 298
 299 template<> struct Protocol::Traits<std::string>
 300 {
 301         static const std::uint16_t signature = 'S';
 302         typedef StringSerializer Serializer;
 303 };
 304
 305 template<typename T>
 306 struct Protocol::Traits<std::vector<T>>
 307 {
 308         static const std::uint16_t signature = 'A';
 309         typedef ArraySerializer<std::vector<T>> Serializer;
 310 };
 311
 312
 313 inline std::uint64_t Protocol::StringSerializer::get_hash() const
 314 {
 315         return Traits<std::string>::signature;
 316 }
 317
 318
 319 template<typename A>
 320 Protocol::ArraySerializer<A>::ArraySerializer(const Protocol &proto):
 321         length_serializer(proto),
 322         element_serializer(proto)
 323 { }
 324
 325 template<typename A>
 326 std::uint64_t Protocol::ArraySerializer<A>::get_hash() const
 327 {
 328         return hash_round<64>(element_serializer.get_hash(), 'A');
 329 }
 330
 331 template<typename A>
 332 char *Protocol::ArraySerializer<A>::serialize(const A &array, char *buf, char *end) const
 333 {
 334         buf = length_serializer.serialize(array.size(), buf, end);
 335         for(const auto &e: array)
 336                 buf = element_serializer.serialize(e, buf, end);
 337         return buf;
 338 }
 339
 340 template<typename A>
 341 const char *Protocol::ArraySerializer<A>::deserialize(A &array, const char *buf, const char *end) const
 342 {
 343         std::uint16_t length;
 344         buf = length_serializer.deserialize(length, buf, end);
 345         array.resize(length);
 346         for(unsigned i=0; i<length; ++i)
 347                 buf = element_serializer.deserialize(array[i], buf, end);
 348         return buf;
 349 }
 350
 351
 352 template<typename C>
 353 Protocol::CompoundSerializer<C>::CompoundSerializer(const Protocol &proto):
 354         serializer(proto.get_packet_by_class<C>().get_serializer())
 355 { }
 356
 357 template<typename C>
 358 std::uint64_t Protocol::CompoundSerializer<C>::get_hash() const
 359 {
 360         return hash_round<64>(serializer.get_hash(), 'C');
 361 }
 362
 363 template<typename C>
 364 char *Protocol::CompoundSerializer<C>::serialize(const C &com, char *buf, char *end) const
 365 {
 366         return serializer.serialize(com, buf, end);
 367 }
 368
 369 template<typename C>
 370 const char *Protocol::CompoundSerializer<C>::deserialize(C &com, const char *buf, const char *end) const
 371 {
 372         return serializer.deserialize(com, buf, end);
 373 }
 374
 375
 376 template<typename C, typename Head, typename T>
 377 Protocol::FieldSerializer<C, Head, T>::FieldSerializer(const Head &h, T C::*p, const Protocol &proto):
 378         Head(h),
 379         ptr(p),
 380         ser(proto)
 381 { }
 382
 383 template<typename C, typename Head, typename T>
 384 std::uint64_t Protocol::FieldSerializer<C, Head, T>::get_hash() const
 385 {
 386         return hash_update<64>(Head::get_hash(), ser.get_hash());
 387 }
 388
 389 template<typename C, typename Head, typename T>
 390 char *Protocol::FieldSerializer<C, Head, T>::serialize(const C &com, char *buf, char *end) const
 391 {
 392         buf = Head::serialize(com, buf, end);
 393         return ser.serialize(com.*ptr, buf, end);
 394 }
 395
 396 template<typename C, typename Head, typename T>
 397 const char *Protocol::FieldSerializer<C, Head, T>::deserialize(C &com, const char *buf, const char *end) const
 398 {
 399         buf = Head::deserialize(com, buf, end);
 400         return ser.deserialize(com.*ptr, buf, end);
 401 }
 402
 403
 404 template<typename P>
 405 Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
 406         PacketDefBase(i),
 407         serializer(new Serializer<P>)
 408 { }
 409
 410 template<typename P>
 411 Protocol::PacketTypeDef<P>::~PacketTypeDef()
 412 {
 413         delete serializer;
 414 }
 415
 416 template<typename P>
 417 template<typename S>
 418 void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
 419 {
 420         delete serializer;
 421         serializer = new S(ser);
 422 }
 423
 424 template<typename P>
 425 char *Protocol::PacketTypeDef<P>::serialize(const P &pkt, char *buf, char *end) const
 426 {
 427         return serializer->serialize(pkt, buf, end);
 428 }
 429
 430 template<typename P>
 431 const char *Protocol::PacketTypeDef<P>::deserialize(P &pkt, const char *buf, const char *end) const
 432 {
 433         return serializer->deserialize(pkt, buf, end);
 434 }
 435
 436 template<typename P>
 437 const char *Protocol::PacketTypeDef<P>::dispatch(ReceiverBase &rcv, const char *buf, const char *end) const
 438 {
 439         PacketReceiver<P> *prcv = dynamic_cast<PacketReceiver<P> *>(&rcv);
 440         if(!prcv)
 441                 throw bad_packet("unsupported");
 442         P pkt;
 443         buf = deserialize(pkt, buf, end);
 444         prcv->receive(pkt);
 445         return buf;
 446 }
 447
 448
 449 template<typename P, typename S>
 450 Protocol::PacketDefBuilder<P, S>::PacketDefBuilder(const Protocol &p, PacketTypeDef<P> &k, const S &s):
 451         protocol(p),
 452         pktdef(k),
 453         serializer(s)
 454 { }
 455
 456 template<typename P, typename S>
 457 template<typename T>
 458 Protocol::PacketDefBuilder<P, typename S::template Next<T>> Protocol::PacketDefBuilder<P, S>::operator()(T P::*ptr)
 459 {
 460         typename S::template Next<T> next_ser(serializer, ptr, protocol);
 461         pktdef.set_serializer(next_ser);
 462         return PacketDefBuilder<P, typename S::template Next<T>>(protocol, pktdef, next_ser);
 463 }
 464
 465 } // namespace Net
 466 } // namespace Msp
 467
 468 #endif