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