#include <cstdint>
#include <map>
+#include <memory>
#include <stdexcept>
#include <vector>
#include <msp/core/hash.h>
class BasicSerializer
{
public:
- typedef T ValueType;
-
BasicSerializer(const Protocol &) { }
std::uint64_t get_hash() const { return Traits<T>::signature; }
class StringSerializer
{
- public:
- typedef std::string ValueType;
-
private:
BasicSerializer<std::uint16_t> length_serializer;
template<typename A>
class ArraySerializer
{
- public:
- typedef A ValueType;
-
private:
BasicSerializer<std::uint16_t> length_serializer;
typename Traits<typename A::value_type>::Serializer element_serializer;
template<typename C>
class CompoundSerializer
{
- public:
- typedef C ValueType;
-
private:
const Serializer<C> &serializer;
const char *deserialize(C &, const char *, const char *) const;
};
- template<typename C, typename Head, typename S>
+ template<typename C, typename Head, typename T>
class FieldSerializer: public Head
{
public:
template<typename N>
- struct Next
- {
- typedef FieldSerializer<C, FieldSerializer<C, Head, S>, typename Traits<N>::Serializer> Type;
- };
+ using Next = FieldSerializer<C, FieldSerializer<C, Head, T>, N>;
private:
- typedef typename S::ValueType C::*Pointer;
-
- Pointer ptr;
- S ser;
+ T C::*ptr;
+ typename Traits<T>::Serializer ser;
public:
- FieldSerializer(const Head &, Pointer, const Protocol &);
+ FieldSerializer(const Head &, T C::*, const Protocol &);
std::uint64_t get_hash() const;
char *serialize(const C &, char *, char *) const;
{
public:
template<typename N>
- struct Next
- {
- typedef FieldSerializer<C, Serializer<C>, typename Traits<N>::Serializer> Type;
- };
+ using Next = FieldSerializer<C, Serializer<C>, N>;
virtual ~Serializer() = default;
class PacketTypeDef: public PacketDefBase
{
private:
- Serializer<P> *serializer;
+ std::unique_ptr<Serializer<P>> serializer;
public:
PacketTypeDef(unsigned);
- ~PacketTypeDef();
unsigned get_class_id() const override { return get_packet_class_id<P>(); }
public:
PacketDefBuilder(const Protocol &, PacketTypeDef<P> &, const S &);
-
+
template<typename T>
- PacketDefBuilder<P, typename S::template Next<T>::Type> operator()(T P::*);
+ PacketDefBuilder<P, typename S::template Next<T>> fields(T P::*);
+
+ template<typename T1, typename T2, typename... Rest>
+ auto fields(T1 P::*first, T2 P::*second, Rest P::*...rest) { return fields(first).fields(second, rest...); }
};
struct PacketHeader
PacketHeader(std::uint16_t, std::uint16_t);
};
- typedef std::map<unsigned, PacketDefBase *> PacketMap;
-
PacketTypeDef<PacketHeader> header_def;
unsigned next_packet_id;
- PacketMap packet_class_defs;
- PacketMap packet_id_defs;
+ std::map<unsigned, std::unique_ptr<PacketDefBase>> packet_class_defs;
+ std::map<unsigned, PacketDefBase *> packet_id_defs;
protected:
Protocol(unsigned = 1);
-public:
- ~Protocol();
private:
static unsigned get_next_packet_class_id();
template<typename P>
static unsigned get_packet_class_id();
- void add_packet(PacketDefBase *);
+ void add_packet(std::unique_ptr<PacketDefBase>);
protected:
template<typename P>
PacketDefBuilder<P, Serializer<P>> add(unsigned);
+ template<typename P, typename T, typename... Rest>
+ auto add(unsigned id, T P::*field, Rest P::*...rest) { return add<P>(id).fields(field, rest...); }
+
template<typename P>
PacketDefBuilder<P, Serializer<P>> add();
+ template<typename P, typename T, typename... Rest>
+ auto add(T P::*field, Rest P::*...rest) { return add<P>().fields(field, rest...); }
+
const PacketDefBase &get_packet_by_class_id(unsigned) const;
const PacketDefBase &get_packet_by_id(unsigned) const;
template<typename P>
Protocol::PacketDefBuilder<P, Protocol::Serializer<P>> Protocol::add(unsigned id)
{
- PacketTypeDef<P> *pdef = new PacketTypeDef<P>(id);
- add_packet(pdef);
- return PacketDefBuilder<P, Serializer<P>>(*this, *pdef, Serializer<P>());
+ std::unique_ptr<PacketTypeDef<P>> pdef = std::make_unique<PacketTypeDef<P>>(id);
+ PacketDefBuilder<P, Serializer<P>> next(*this, *pdef, Serializer<P>());
+ add_packet(move(pdef));
+ return next;
}
template<typename P>
}
-template<typename P, typename Head, typename S>
-Protocol::FieldSerializer<P, Head, S>::FieldSerializer(const Head &h, Pointer p, const Protocol &proto):
+template<typename C, typename Head, typename T>
+Protocol::FieldSerializer<C, Head, T>::FieldSerializer(const Head &h, T C::*p, const Protocol &proto):
Head(h),
ptr(p),
ser(proto)
{ }
-template<typename P, typename Head, typename S>
-std::uint64_t Protocol::FieldSerializer<P, Head, S>::get_hash() const
+template<typename C, typename Head, typename T>
+std::uint64_t Protocol::FieldSerializer<C, Head, T>::get_hash() const
{
return hash_update<64>(Head::get_hash(), ser.get_hash());
}
-template<typename P, typename Head, typename S>
-char *Protocol::FieldSerializer<P, Head, S>::serialize(const P &pkt, char *buf, char *end) const
+template<typename C, typename Head, typename T>
+char *Protocol::FieldSerializer<C, Head, T>::serialize(const C &com, char *buf, char *end) const
{
- buf = Head::serialize(pkt, buf, end);
- return ser.serialize(pkt.*ptr, buf, end);
+ buf = Head::serialize(com, buf, end);
+ return ser.serialize(com.*ptr, buf, end);
}
-template<typename P, typename Head, typename S>
-const char *Protocol::FieldSerializer<P, Head, S>::deserialize(P &pkt, const char *buf, const char *end) const
+template<typename C, typename Head, typename T>
+const char *Protocol::FieldSerializer<C, Head, T>::deserialize(C &com, const char *buf, const char *end) const
{
- buf = Head::deserialize(pkt, buf, end);
- return ser.deserialize(pkt.*ptr, buf, end);
+ buf = Head::deserialize(com, buf, end);
+ return ser.deserialize(com.*ptr, buf, end);
}
template<typename P>
Protocol::PacketTypeDef<P>::PacketTypeDef(unsigned i):
PacketDefBase(i),
- serializer(new Serializer<P>)
+ serializer(std::make_unique<Serializer<P>>())
{ }
-template<typename P>
-Protocol::PacketTypeDef<P>::~PacketTypeDef()
-{
- delete serializer;
-}
-
template<typename P>
template<typename S>
void Protocol::PacketTypeDef<P>::set_serializer(const S &ser)
{
- delete serializer;
- serializer = new S(ser);
+ serializer = std::make_unique<S>(ser);
}
template<typename P>
template<typename P, typename S>
template<typename T>
-Protocol::PacketDefBuilder<P, typename S::template Next<T>::Type> Protocol::PacketDefBuilder<P, S>::operator()(T P::*ptr)
+Protocol::PacketDefBuilder<P, typename S::template Next<T>> Protocol::PacketDefBuilder<P, S>::fields(T P::*ptr)
{
- typename S::template Next<T>::Type next_ser(serializer, ptr, protocol);
+ typename S::template Next<T> next_ser(serializer, ptr, protocol);
pktdef.set_serializer(next_ser);
- return PacketDefBuilder<P, typename S::template Next<T>::Type>(protocol, pktdef, next_ser);
+ return PacketDefBuilder<P, typename S::template Next<T>>(protocol, pktdef, next_ser);
}
} // namespace Net