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>> fields(T P::*);
 177
 178                 template<typename T1, typename T2, typename... Rest>
 179                 auto fields(T1 P::*first, T2 P::*second, Rest P::*...rest) { return fields(first).fields(second, rest...); }
 180         };
 181
 182         struct PacketHeader
 183         {
 184                 std::uint16_t type = 0;
 185                 std::uint16_t length = 0;
 186
 187                 PacketHeader() = default;
 188                 PacketHeader(std::uint16_t, std::uint16_t);
 189         };
 190
 191         typedef std::map<unsigned, PacketDefBase *> PacketMap;
 192
 193         PacketTypeDef<PacketHeader> header_def;
 194         unsigned next_packet_id;
 195         PacketMap packet_class_defs;
 196         PacketMap packet_id_defs;
 197
 198 protected:
 199         Protocol(unsigned = 1);
 200 public:
 201         ~Protocol();
 202
 203 private:
 204         static unsigned get_next_packet_class_id();
 205
 206         template<typename P>
 207         static unsigned get_packet_class_id();
 208
 209         void add_packet(PacketDefBase *);
 210
 211 protected:
 212         template<typename P>
 213         PacketDefBuilder<P, Serializer<P>> add(unsigned);
 214
 215         template<typename P, typename T, typename... Rest>
 216         auto add(unsigned id, T P::*field, Rest P::*...rest) { return add<P>(id).fields(field, rest...); }
 217
 218         template<typename P>
 219         PacketDefBuilder<P, Serializer<P>> add();
 220
 221         template<typename P, typename T, typename... Rest>
 222         auto add(T P::*field, Rest P::*...rest) { return add<P>().fields(field, rest...); }
 223
 224         const PacketDefBase &get_packet_by_class_id(unsigned) const;
 225         const PacketDefBase &get_packet_by_id(unsigned) const;
 226
 227         template<typename P>
 228         const PacketTypeDef<P> &get_packet_by_class() const;
 229
 230 public:
 231         template<typename P>
 232         std::size_t serialize(const P &, char *, std::size_t) const;
 233
 234         std::size_t get_packet_size(const char *, std::size_t) const;
 235         std::size_t dispatch(ReceiverBase &, const char *, std::size_t) const;
 236
 237         std::uint64_t get_hash() const;
 238 };
 239
 240
 241 template<typename P>
 242 unsigned Protocol::get_packet_class_id()
 243 {
 244         static unsigned id = get_next_packet_class_id();
 245         return id;
 246 }
 247
 248 template<typename P>
 249 Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add(unsigned id)
 250 {
 251         PacketTypeDef<P> *pdef = new PacketTypeDef<P>(id);
 252         add_packet(pdef);
 253         return PacketDefBuilder<P, Serializer<P>>(*this, *pdef, Serializer<P>());
 254 }
 255
 256 template<typename P>
 257 Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add()
 258 {
 259         return add<P>(next_packet_id++);
 260 }
 261
 262 template<typename P>
 263 const Protocol::PacketTypeDef<P> &Protocol::get_packet_by_class() const
 264 {
 265         const PacketDefBase &pdef = get_packet_by_class_id(get_packet_class_id<P>());
 266         return static_cast<const PacketTypeDef<P> &>(pdef);
 267 }
 268
 269 template<typename P>
 270 std::size_t Protocol::serialize(const P &pkt, char *buf, std::size_t size) const
 271 {
 272         const PacketTypeDef<P> &pdef = get_packet_by_class<P>();
 273         if(!pdef.get_id())
 274                 throw std::invalid_argument("no packet id");
 275         char *ptr = pdef.serialize(pkt, buf+4, buf+size);
 276         size = ptr-buf;
 277         header_def.serialize(PacketHeader(pdef.get_id(), size), buf, buf+4);
 278         return size;
 279 }
 280
 281
 282 template<typename T, std::uint8_t K>
 283 struct Protocol::BasicTraits
 284 {
 285         static const std::uint16_t signature = K | (sizeof(T)<<8);
 286         typedef BasicSerializer<T> Serializer;
 287 };
 288
 289 template<typename T>
 290 struct Protocol::Traits
 291 {
 292         static const std::uint16_t signature = 'C';
 293         typedef CompoundSerializer<T> Serializer;
 294 };
 295
 296 template<> struct Protocol::Traits<bool>: BasicTraits<bool, 'B'> { };
 297 template<> struct Protocol::Traits<std::int8_t>: BasicTraits<std::int8_t, 'I'> { };
 298 template<> struct Protocol::Traits<std::uint8_t>: BasicTraits<std::uint8_t, 'U'> { };
 299 template<> struct Protocol::Traits<std::int16_t>: BasicTraits<std::int16_t, 'I'> { };
 300 template<> struct Protocol::Traits<std::uint16_t>: BasicTraits<std::uint16_t, 'U'> { };
 301 template<> struct Protocol::Traits<std::int32_t>: BasicTraits<std::int32_t, 'I'> { };
 302 template<> struct Protocol::Traits<std::uint32_t>: BasicTraits<std::uint32_t, 'U'> { };
 303 template<> struct Protocol::Traits<std::int64_t>: BasicTraits<std::int64_t, 'I'> { };
 304 template<> struct Protocol::Traits<std::uint64_t>: BasicTraits<std::uint64_t, 'U'> { };
 305 template<> struct Protocol::Traits<float>: BasicTraits<float, 'F'> { };
 306 template<> struct Protocol::Traits<double>: BasicTraits<double, 'F'> { };
 307
 308 template<> struct Protocol::Traits<std::string>
 309 {
 310         static const std::uint16_t signature = 'S';
 311         typedef StringSerializer Serializer;
 312 };
 313
 314 template<typename T>
 315 struct Protocol::Traits<std::vector<T>>
 316 {
 317         static const std::uint16_t signature = 'A';
 318         typedef ArraySerializer<std::vector<T>> Serializer;
 319 };
 320
 321
 322 inline std::uint64_t Protocol::StringSerializer::get_hash() const
 323 {
 324         return Traits<std::string>::signature;
 325 }
 326
 327
 328 template<typename A>
 329 Protocol::ArraySerializer<A>::ArraySerializer(const Protocol &proto):
 330         length_serializer(proto),
 331         element_serializer(proto)
 332 { }
 333
 334 template<typename A>
 335 std::uint64_t Protocol::ArraySerializer<A>::get_hash() const
 336 {
 337         return hash_round<64>(element_serializer.get_hash(), 'A');
 338 }
 339
 340 template<typename A>
 341 char *Protocol::ArraySerializer<A>::serialize(const A &array, char *buf, char *end) const
 342 {
 343         buf = length_serializer.serialize(array.size(), buf, end);
 344         for(const auto &e: array)
 345                 buf = element_serializer.serialize(e, buf, end);
 346         return buf;
 347 }
 348
 349 template<typename A>
 350 const char *Protocol::ArraySerializer<A>::deserialize(A &array, const char *buf, const char *end) const
 351 {
 352         std::uint16_t length;
 353         buf = length_serializer.deserialize(length, buf, end);
 354         array.resize(length);
 355         for(unsigned i=0; i<length; ++i)
 356                 buf = element_serializer.deserialize(array[i], buf, end);
 357         return buf;
 358 }
 359
 360
 361 template<typename C>
 362 Protocol::CompoundSerializer<C>::CompoundSerializer(const Protocol &proto):
 363         serializer(proto.get_packet_by_class<C>().get_serializer())
 364 { }
 365
 366 template<typename C>
 367 std::uint64_t Protocol::CompoundSerializer<C>::get_hash() const
 368 {
 369         return hash_round<64>(serializer.get_hash(), 'C');
 370 }
 371
 372 template<typename C>
 373 char *Protocol::CompoundSerializer<C>::serialize(const C &com, char *buf, char *end) const
 374 {
 375         return serializer.serialize(com, buf, end);
 376 }
 377
 378 template<typename C>
 379 const char *Protocol::CompoundSerializer<C>::deserialize(C &com, const char *buf, const char *end) const
 380 {
 381         return serializer.deserialize(com, buf, end);
 382 }
 383
 384
 385 template<typename C, typename Head, typename T>
 386 Protocol::FieldSerializer<C, Head, T>::FieldSerializer(const Head &h, T C::*p, const Protocol &proto):
 387         Head(h),
 388         ptr(p),
 389         ser(proto)
 390 { }
 391
 392 template<typename C, typename Head, typename T>
 393 std::uint64_t Protocol::FieldSerializer<C, Head, T>::get_hash() const
 394 {
 395         return hash_update<64>(Head::get_hash(), ser.get_hash());
 396 }
 397
 398 template<typename C, typename Head, typename T>
 399 char *Protocol::FieldSerializer<C, Head, T>::serialize(const C &com, char *buf, char *end) const
 400 {
 401         buf = Head::serialize(com, buf, end);
 402         return ser.serialize(com.*ptr, buf, end);
 403 }
 404
 405 template<typename C, typename Head, typename T>
 406 const char *Protocol::FieldSerializer<C, Head, T>::deserialize(C &com, const char *buf, const char *end) const
 407 {
 408         buf = Head::deserialize(com, buf, end);
 409         return ser.deserialize(com.*ptr, buf, end);
 410 }
 411
 412
 413 template<typename P>
 414 Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
 415         PacketDefBase(i),
 416         serializer(new Serializer<P>)
 417 { }
 418
 419 template<typename P>
 420 Protocol::PacketTypeDef<P>::~PacketTypeDef()
 421 {
 422         delete serializer;
 423 }
 424
 425 template<typename P>
 426 template<typename S>
 427 void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
 428 {
 429         delete serializer;
 430         serializer = new S(ser);
 431 }
 432
 433 template<typename P>
 434 char *Protocol::PacketTypeDef<P>::serialize(const P &pkt, char *buf, char *end) const
 435 {
 436         return serializer->serialize(pkt, buf, end);
 437 }
 438
 439 template<typename P>
 440 const char *Protocol::PacketTypeDef<P>::deserialize(P &pkt, const char *buf, const char *end) const
 441 {
 442         return serializer->deserialize(pkt, buf, end);
 443 }
 444
 445 template<typename P>
 446 const char *Protocol::PacketTypeDef<P>::dispatch(ReceiverBase &rcv, const char *buf, const char *end) const
 447 {
 448         PacketReceiver<P> *prcv = dynamic_cast<PacketReceiver<P> *>(&rcv);
 449         if(!prcv)
 450                 throw bad_packet("unsupported");
 451         P pkt;
 452         buf = deserialize(pkt, buf, end);
 453         prcv->receive(pkt);
 454         return buf;
 455 }
 456
 457
 458 template<typename P, typename S>
 459 Protocol::PacketDefBuilder<P, S>::PacketDefBuilder(const Protocol &p, PacketTypeDef<P> &k, const S &s):
 460         protocol(p),
 461         pktdef(k),
 462         serializer(s)
 463 { }
 464
 465 template<typename P, typename S>
 466 template<typename T>
 467 Protocol::PacketDefBuilder<P, typename S::template Next<T>> Protocol::PacketDefBuilder<P, S>::fields(T P::*ptr)
 468 {
 469         typename S::template Next<T> next_ser(serializer, ptr, protocol);
 470         pktdef.set_serializer(next_ser);
 471         return PacketDefBuilder<P, typename S::template Next<T>>(protocol, pktdef, next_ser);
 472 }
 473
 474 } // namespace Net
 475 } // namespace Msp
 476
 477 #endif