1 #ifndef MSP_NET_PROTOCOL_H_
2 #define MSP_NET_PROTOCOL_H_
9 #include <msp/core/hash.h>
10 #include "mspnet_api.h"
16 class MSPNET_API bad_packet: public std::runtime_error
19 bad_packet(const std::string &w): std::runtime_error(w) { }
23 class MSPNET_API buffer_error: public std::runtime_error
26 buffer_error(const std::string &w): std::runtime_error(w) { }
30 class MSPNET_API Protocol
35 std::uint16_t type = 0;
36 std::uint16_t length = 0;
38 PacketHeader() = default;
39 PacketHeader(std::uint16_t, std::uint16_t);
43 template<typename T, std::uint8_t K>
56 BasicSerializer(const Protocol &) { }
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;
63 class StringSerializer
66 BasicSerializer<std::uint16_t> length_serializer;
69 StringSerializer(const Protocol &);
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;
80 BasicSerializer<std::uint16_t> length_serializer;
81 typename Traits<typename A::value_type>::Serializer element_serializer;
84 ArraySerializer(const Protocol &);
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;
92 class CompoundSerializer
95 const Serializer<C> &serializer;
98 CompoundSerializer(const Protocol &);
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;
105 template<typename C, typename Head, typename T>
106 class FieldSerializer: public Head
110 using Next = FieldSerializer<C, FieldSerializer<C, Head, T>, N>;
114 typename Traits<T>::Serializer ser;
117 FieldSerializer(const Head &, T C::*, const Protocol &);
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;
129 using Next = FieldSerializer<C, Serializer<C>, N>;
131 virtual ~Serializer() = default;
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; }
143 PacketDefBase(unsigned);
145 virtual ~PacketDefBase() = default;
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 *deserialize(Variant &, const char *, const char *) const = 0;
151 virtual const char *dispatch(ReceiverBase &, const char *, const char *) const = 0;
155 class PacketTypeDef: public PacketDefBase
158 std::unique_ptr<Serializer<P>> serializer;
161 PacketTypeDef(unsigned);
163 unsigned get_class_id() const override { return get_packet_class_id<P>(); }
166 void set_serializer(const S &);
168 const Serializer<P> &get_serializer() const { return *serializer; }
170 std::uint64_t get_hash() const override { return serializer->get_hash(); }
171 char *serialize(const P &, char *, char *) const;
172 const char *deserialize(P &, const char *, const char *) const;
173 const char *deserialize(Variant &, const char *, const char *) const override;
174 const char *dispatch(ReceiverBase &, const char *, const char *) const override;
177 template<typename P, typename S>
178 class PacketDefBuilder
181 const Protocol &protocol;
182 PacketTypeDef<P> &pktdef;
186 PacketDefBuilder(const Protocol &, PacketTypeDef<P> &, const S &);
189 PacketDefBuilder<P, typename S::template Next<T>> fields(T P::*);
191 template<typename T1, typename T2, typename... Rest>
192 auto fields(T1 P::*first, T2 P::*second, Rest P::*...rest) { return fields(first).fields(second, rest...); }
195 PacketTypeDef<PacketHeader> header_def;
196 unsigned next_packet_id = 1;
197 std::map<unsigned, std::unique_ptr<PacketDefBase>> packet_class_defs;
198 std::map<unsigned, PacketDefBase *> packet_id_defs;
204 static unsigned get_next_packet_class_id();
207 static unsigned get_packet_class_id();
209 void add_packet(std::unique_ptr<PacketDefBase>);
213 PacketDefBuilder<P, Serializer<P>> add();
215 template<typename P, typename T, typename... Rest>
216 auto add(T P::*field, Rest P::*...rest) { return add<P>().fields(field, rest...); }
218 const PacketDefBase &get_packet_by_class_id(unsigned) const;
219 const PacketDefBase &get_packet_by_id(unsigned) const;
222 const PacketTypeDef<P> &get_packet_by_class() const;
226 bool has_packet() const { return packet_class_defs.count(get_packet_class_id<P>()); }
229 unsigned get_packet_id() const { return get_item(packet_class_defs, get_packet_class_id<P>())->get_id(); }
231 unsigned get_max_packet_id() const;
234 std::size_t serialize(const P &, char *, std::size_t, unsigned = 0) const;
236 bool get_packet_header(PacketHeader &, const char *, std::size_t) const;
237 std::size_t get_packet_size(const char *, std::size_t) const;
238 std::size_t dispatch(ReceiverBase &, const char *, std::size_t, unsigned = 0) const;
240 std::uint64_t get_hash() const;
245 unsigned Protocol::get_packet_class_id()
247 static unsigned id = get_next_packet_class_id();
252 Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add()
254 std::unique_ptr<PacketTypeDef<P>> pdef = std::make_unique<PacketTypeDef<P>>(next_packet_id++);
255 PacketDefBuilder<P, Serializer<P>> next(*this, *pdef, Serializer<P>());
256 add_packet(move(pdef));
261 const Protocol::PacketTypeDef<P> &Protocol::get_packet_by_class() const
263 const PacketDefBase &pdef = get_packet_by_class_id(get_packet_class_id<P>());
264 return static_cast<const PacketTypeDef<P> &>(pdef);
268 std::size_t Protocol::serialize(const P &pkt, char *buf, std::size_t size, unsigned base_id) const
270 const PacketTypeDef<P> &pdef = get_packet_by_class<P>();
272 throw std::invalid_argument("no packet id");
273 char *ptr = pdef.serialize(pkt, buf+4, buf+size);
275 header_def.serialize(PacketHeader(base_id+pdef.get_id(), size), buf, buf+4);
280 template<typename T, std::uint8_t K>
281 struct Protocol::BasicTraits
283 static const std::uint16_t signature = K | (sizeof(T)<<8);
284 typedef BasicSerializer<T> Serializer;
288 struct Protocol::Traits
290 static const std::uint16_t signature = 'C';
291 typedef CompoundSerializer<T> Serializer;
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'> { };
306 template<> struct Protocol::Traits<std::string>
308 static const std::uint16_t signature = 'S';
309 typedef StringSerializer Serializer;
313 struct Protocol::Traits<std::vector<T>>
315 static const std::uint16_t signature = 'A';
316 typedef ArraySerializer<std::vector<T>> Serializer;
320 inline std::uint64_t Protocol::StringSerializer::get_hash() const
322 return Traits<std::string>::signature;
327 Protocol::ArraySerializer<A>::ArraySerializer(const Protocol &proto):
328 length_serializer(proto),
329 element_serializer(proto)
333 std::uint64_t Protocol::ArraySerializer<A>::get_hash() const
335 return hash_round<64>(element_serializer.get_hash(), 'A');
339 char *Protocol::ArraySerializer<A>::serialize(const A &array, char *buf, char *end) const
341 buf = length_serializer.serialize(array.size(), buf, end);
342 for(const auto &e: array)
343 buf = element_serializer.serialize(e, buf, end);
348 const char *Protocol::ArraySerializer<A>::deserialize(A &array, const char *buf, const char *end) const
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);
360 Protocol::CompoundSerializer<C>::CompoundSerializer(const Protocol &proto):
361 serializer(proto.get_packet_by_class<C>().get_serializer())
365 std::uint64_t Protocol::CompoundSerializer<C>::get_hash() const
367 return hash_round<64>(serializer.get_hash(), 'C');
371 char *Protocol::CompoundSerializer<C>::serialize(const C &com, char *buf, char *end) const
373 return serializer.serialize(com, buf, end);
377 const char *Protocol::CompoundSerializer<C>::deserialize(C &com, const char *buf, const char *end) const
379 return serializer.deserialize(com, buf, end);
383 template<typename C, typename Head, typename T>
384 Protocol::FieldSerializer<C, Head, T>::FieldSerializer(const Head &h, T C::*p, const Protocol &proto):
390 template<typename C, typename Head, typename T>
391 std::uint64_t Protocol::FieldSerializer<C, Head, T>::get_hash() const
393 return hash_update<64>(Head::get_hash(), ser.get_hash());
396 template<typename C, typename Head, typename T>
397 char *Protocol::FieldSerializer<C, Head, T>::serialize(const C &com, char *buf, char *end) const
399 buf = Head::serialize(com, buf, end);
400 return ser.serialize(com.*ptr, buf, end);
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
406 buf = Head::deserialize(com, buf, end);
407 return ser.deserialize(com.*ptr, buf, end);
412 Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
414 serializer(std::make_unique<Serializer<P>>())
419 void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
421 serializer = std::make_unique<S>(ser);
425 char *Protocol::PacketTypeDef<P>::serialize(const P &pkt, char *buf, char *end) const
427 return serializer->serialize(pkt, buf, end);
431 const char *Protocol::PacketTypeDef<P>::deserialize(P &pkt, const char *buf, const char *end) const
433 return serializer->deserialize(pkt, buf, end);
437 const char *Protocol::PacketTypeDef<P>::deserialize(Variant &var_pkt, const char *buf, const char *end) const
440 const char *ptr = serializer->deserialize(pkt, buf, end);
441 var_pkt = std::move(pkt);
446 const char *Protocol::PacketTypeDef<P>::dispatch(ReceiverBase &rcv, const char *buf, const char *end) const
448 PacketReceiver<P> *prcv = dynamic_cast<PacketReceiver<P> *>(&rcv);
450 throw bad_packet("unsupported");
452 buf = deserialize(pkt, buf, end);
458 template<typename P, typename S>
459 Protocol::PacketDefBuilder<P, S>::PacketDefBuilder(const Protocol &p, PacketTypeDef<P> &k, const S &s):
465 template<typename P, typename S>
467 Protocol::PacketDefBuilder<P, typename S::template Next<T>> Protocol::PacketDefBuilder<P, S>::fields(T P::*ptr)
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);