1 #ifndef MSP_NET_PROTOCOL_H_
2 #define MSP_NET_PROTOCOL_H_
8 #include <msp/core/hash.h>
14 class bad_packet: public std::runtime_error
17 bad_packet(const std::string &w): std::runtime_error(w) { }
21 class buffer_error: public std::runtime_error
24 buffer_error(const std::string &w): std::runtime_error(w) { }
31 template<typename T, std::uint8_t K>
46 BasicSerializer(const Protocol &) { }
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;
53 class StringSerializer
56 typedef std::string ValueType;
59 BasicSerializer<std::uint16_t> length_serializer;
62 StringSerializer(const Protocol &);
64 std::uint64_t get_hash() const;
65 char *serialize(const std::string &, char *, char *) const;
66 const char *deserialize(std::string &, const char *, const char *) const;
76 BasicSerializer<std::uint16_t> length_serializer;
77 typename Traits<typename A::value_type>::Serializer element_serializer;
80 ArraySerializer(const Protocol &);
82 std::uint64_t get_hash() const;
83 char *serialize(const A &, char *, char *) const;
84 const char *deserialize(A &, const char *, const char *) const;
88 class CompoundSerializer
94 const Serializer<C> &serializer;
97 CompoundSerializer(const Protocol &);
99 std::uint64_t get_hash() const;
100 char *serialize(const C &, char *, char *) const;
101 const char *deserialize(C &, const char *, const char *) const;
104 template<typename C, typename Head, typename S>
105 class FieldSerializer: public Head
111 typedef FieldSerializer<C, FieldSerializer<C, Head, S>, typename Traits<N>::Serializer> Type;
115 typedef typename S::ValueType C::*Pointer;
121 FieldSerializer(const Head &, Pointer, const Protocol &);
123 std::uint64_t get_hash() const;
124 char *serialize(const C &, char *, char *) const;
125 const char *deserialize(C &, const char *, const char *) const;
135 typedef FieldSerializer<C, Serializer<C>, typename Traits<N>::Serializer> Type;
138 virtual ~Serializer() = default;
140 virtual std::uint64_t get_hash() const { return 0; }
141 virtual char *serialize(const C &, char *b, char *) const { return b; }
142 virtual const char *deserialize(C &, const char *b, const char *) const { return b; }
150 PacketDefBase(unsigned);
152 virtual ~PacketDefBase() = default;
154 virtual unsigned get_class_id() const = 0;
155 unsigned get_id() const { return id; }
156 virtual std::uint64_t get_hash() const = 0;
157 virtual const char *dispatch(ReceiverBase &, const char *, const char *) const = 0;
161 class PacketTypeDef: public PacketDefBase
164 Serializer<P> *serializer;
167 PacketTypeDef(unsigned);
170 unsigned get_class_id() const override { return get_packet_class_id<P>(); }
173 void set_serializer(const S &);
175 const Serializer<P> &get_serializer() const { return *serializer; }
177 std::uint64_t get_hash() const override { return serializer->get_hash(); }
178 char *serialize(const P &, char *, char *) const;
179 const char *deserialize(P &, const char *, const char *) const;
180 const char *dispatch(ReceiverBase &, const char *, const char *) const override;
183 template<typename P, typename S>
184 class PacketDefBuilder
187 const Protocol &protocol;
188 PacketTypeDef<P> &pktdef;
192 PacketDefBuilder(const Protocol &, PacketTypeDef<P> &, const S &);
195 PacketDefBuilder<P, typename S::template Next<T>::Type> operator()(T P::*);
200 std::uint16_t type = 0;
201 std::uint16_t length = 0;
203 PacketHeader() = default;
204 PacketHeader(std::uint16_t, std::uint16_t);
207 typedef std::map<unsigned, PacketDefBase *> PacketMap;
209 PacketTypeDef<PacketHeader> header_def;
210 unsigned next_packet_id;
211 PacketMap packet_class_defs;
212 PacketMap packet_id_defs;
215 Protocol(unsigned = 1);
220 static unsigned get_next_packet_class_id();
223 static unsigned get_packet_class_id();
225 void add_packet(PacketDefBase *);
229 PacketDefBuilder<P, Serializer<P>> add(unsigned);
232 PacketDefBuilder<P, Serializer<P>> add();
234 const PacketDefBase &get_packet_by_class_id(unsigned) const;
235 const PacketDefBase &get_packet_by_id(unsigned) const;
238 const PacketTypeDef<P> &get_packet_by_class() const;
242 std::size_t serialize(const P &, char *, std::size_t) const;
244 std::size_t get_packet_size(const char *, std::size_t) const;
245 std::size_t dispatch(ReceiverBase &, const char *, std::size_t) const;
247 std::uint64_t get_hash() const;
252 unsigned Protocol::get_packet_class_id()
254 static unsigned id = get_next_packet_class_id();
259 Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add(unsigned id)
261 PacketTypeDef<P> *pdef = new PacketTypeDef<P>(id);
263 return PacketDefBuilder<P, Serializer<P>>(*this, *pdef, Serializer<P>());
267 Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add()
269 return add<P>(next_packet_id++);
273 const Protocol::PacketTypeDef<P> &Protocol::get_packet_by_class() const
275 const PacketDefBase &pdef = get_packet_by_class_id(get_packet_class_id<P>());
276 return static_cast<const PacketTypeDef<P> &>(pdef);
280 std::size_t Protocol::serialize(const P &pkt, char *buf, std::size_t size) const
282 const PacketTypeDef<P> &pdef = get_packet_by_class<P>();
284 throw std::invalid_argument("no packet id");
285 char *ptr = pdef.serialize(pkt, buf+4, buf+size);
287 header_def.serialize(PacketHeader(pdef.get_id(), size), buf, buf+4);
292 template<typename T, std::uint8_t K>
293 struct Protocol::BasicTraits
295 static const std::uint16_t signature = K | (sizeof(T)<<8);
296 typedef BasicSerializer<T> Serializer;
300 struct Protocol::Traits
302 static const std::uint16_t signature = 'C';
303 typedef CompoundSerializer<T> Serializer;
306 template<> struct Protocol::Traits<bool>: BasicTraits<bool, 'B'> { };
307 template<> struct Protocol::Traits<std::int8_t>: BasicTraits<std::int8_t, 'I'> { };
308 template<> struct Protocol::Traits<std::uint8_t>: BasicTraits<std::uint8_t, 'U'> { };
309 template<> struct Protocol::Traits<std::int16_t>: BasicTraits<std::int16_t, 'I'> { };
310 template<> struct Protocol::Traits<std::uint16_t>: BasicTraits<std::uint16_t, 'U'> { };
311 template<> struct Protocol::Traits<std::int32_t>: BasicTraits<std::int32_t, 'I'> { };
312 template<> struct Protocol::Traits<std::uint32_t>: BasicTraits<std::uint32_t, 'U'> { };
313 template<> struct Protocol::Traits<std::int64_t>: BasicTraits<std::int64_t, 'I'> { };
314 template<> struct Protocol::Traits<std::uint64_t>: BasicTraits<std::uint64_t, 'U'> { };
315 template<> struct Protocol::Traits<float>: BasicTraits<float, 'F'> { };
316 template<> struct Protocol::Traits<double>: BasicTraits<double, 'F'> { };
318 template<> struct Protocol::Traits<std::string>
320 static const std::uint16_t signature = 'S';
321 typedef StringSerializer Serializer;
325 struct Protocol::Traits<std::vector<T>>
327 static const std::uint16_t signature = 'A';
328 typedef ArraySerializer<std::vector<T>> Serializer;
332 inline std::uint64_t Protocol::StringSerializer::get_hash() const
334 return Traits<std::string>::signature;
339 Protocol::ArraySerializer<A>::ArraySerializer(const Protocol &proto):
340 length_serializer(proto),
341 element_serializer(proto)
345 std::uint64_t Protocol::ArraySerializer<A>::get_hash() const
347 return hash_round<64>(element_serializer.get_hash(), 'A');
351 char *Protocol::ArraySerializer<A>::serialize(const A &array, char *buf, char *end) const
353 buf = length_serializer.serialize(array.size(), buf, end);
354 for(const auto &e: array)
355 buf = element_serializer.serialize(e, buf, end);
360 const char *Protocol::ArraySerializer<A>::deserialize(A &array, const char *buf, const char *end) const
362 std::uint16_t length;
363 buf = length_serializer.deserialize(length, buf, end);
364 array.resize(length);
365 for(unsigned i=0; i<length; ++i)
366 buf = element_serializer.deserialize(array[i], buf, end);
372 Protocol::CompoundSerializer<C>::CompoundSerializer(const Protocol &proto):
373 serializer(proto.get_packet_by_class<C>().get_serializer())
377 std::uint64_t Protocol::CompoundSerializer<C>::get_hash() const
379 return hash_round<64>(serializer.get_hash(), 'C');
383 char *Protocol::CompoundSerializer<C>::serialize(const C &com, char *buf, char *end) const
385 return serializer.serialize(com, buf, end);
389 const char *Protocol::CompoundSerializer<C>::deserialize(C &com, const char *buf, const char *end) const
391 return serializer.deserialize(com, buf, end);
395 template<typename P, typename Head, typename S>
396 Protocol::FieldSerializer<P, Head, S>::FieldSerializer(const Head &h, Pointer p, const Protocol &proto):
402 template<typename P, typename Head, typename S>
403 std::uint64_t Protocol::FieldSerializer<P, Head, S>::get_hash() const
405 return hash_update<64>(Head::get_hash(), ser.get_hash());
408 template<typename P, typename Head, typename S>
409 char *Protocol::FieldSerializer<P, Head, S>::serialize(const P &pkt, char *buf, char *end) const
411 buf = Head::serialize(pkt, buf, end);
412 return ser.serialize(pkt.*ptr, buf, end);
415 template<typename P, typename Head, typename S>
416 const char *Protocol::FieldSerializer<P, Head, S>::deserialize(P &pkt, const char *buf, const char *end) const
418 buf = Head::deserialize(pkt, buf, end);
419 return ser.deserialize(pkt.*ptr, buf, end);
424 Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
426 serializer(new Serializer<P>)
430 Protocol::PacketTypeDef<P>::~PacketTypeDef()
437 void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
440 serializer = new S(ser);
444 char *Protocol::PacketTypeDef<P>::serialize(const P &pkt, char *buf, char *end) const
446 return serializer->serialize(pkt, buf, end);
450 const char *Protocol::PacketTypeDef<P>::deserialize(P &pkt, const char *buf, const char *end) const
452 return serializer->deserialize(pkt, buf, end);
456 const char *Protocol::PacketTypeDef<P>::dispatch(ReceiverBase &rcv, const char *buf, const char *end) const
458 PacketReceiver<P> *prcv = dynamic_cast<PacketReceiver<P> *>(&rcv);
460 throw bad_packet("unsupported");
462 buf = deserialize(pkt, buf, end);
468 template<typename P, typename S>
469 Protocol::PacketDefBuilder<P, S>::PacketDefBuilder(const Protocol &p, PacketTypeDef<P> &k, const S &s):
475 template<typename P, typename S>
477 Protocol::PacketDefBuilder<P, typename S::template Next<T>::Type> Protocol::PacketDefBuilder<P, S>::operator()(T P::*ptr)
479 typename S::template Next<T>::Type next_ser(serializer, ptr, protocol);
480 pktdef.set_serializer(next_ser);
481 return PacketDefBuilder<P, typename S::template Next<T>::Type>(protocol, pktdef, next_ser);