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