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