RakNet : Please Explain

// mystruct.gh -- feed to a code generation toolstruct SomeStruct {  int(0-1023) someValue;  float(0.01,10000) x, y, z;}// runs through a custom tool that you write, which spits out mystruct.h and mystruct.cpp:struct SomeStruct {  unsigned short someValue;  float x, y, z;};bool marshal(SomeStruct const * input, char ** outBytes, size_t * size) {  if (!put_bits_ushort(input->someValue, 12, outBytes, size)) return false;  if (!put_bits_float(input->x, 0.1, 10000, outBytes, size)) return false;  if (!put_bits_float(input->y, 0.1, 10000, outBytes, size)) return false;  if (!put_bits_float(input->z, 0.1, 10000, outBytes, size)) return false;  return true;}

// Macros; mystruct.hSTRUCT_BEGIN(MyStruct)STRUCT_INT_MEMBER(MyStruct, unsigned short, 12, someValue)STRUCT_FLOAT_MEMBER(MyStruct, 0.01, 10000, x)STRUCT_FLOAT_MEMBER(MyStruct, 0.01, 10000, y)STRUCT_FLOAT_MEMBER(MyStruct, 0.01, 10000, z)STRUCT_END(MyStruct)// Marshalling; mystruct.cpp// marshallingdefs.h arranges so that StructBegin() and STRUCT_INT_MEMBER() defines the appropriate code#include "marshallingdefs.h"#include "mystruct.h"// Usage; other files// usedefs.h arrange so that the struct is defined and the functions forward declared#include "usedefs.h"#include "mystruct.h"

// Some headertemplate<typename T> struct MarshalInfo;#define USHORT_BITS(bits,name)   struct name;   template<> struct MarshalInfo<name> {     typedef unsigned short Type;     enum { Bits = bits };   }struct MarshalTerminate {  template<typename typ> void get<typ>();};template<typename typ, typename base>struct MarshalBase : base {  template<> bool get<typ>(typename MarshalInfo<typ>::Type * out) {    *out = _myval; return true;  }  bool marshal(char ** out, size_t * data) {    return put_data(_myval, out, data) && base::marshal(out, data);  }  private: typename MarshalInfo<typ>::Type _myval;};// Declaring the structUSHORT_BITS(someValue,12);FLOAT_VALUES(x,0.01,10000);FLOAT_VALUES(y,0.01,10000);FLOAT_VALUES(z,0.01,10000);struct MyStruct : public MarshalBase<someValue,   MarshalBase<x, MarshalBase<y, MarshalBase<z, MarshalTerminate> > > >{};// To access members:MyStruct s;  unsigned short v = s.get<someValue>();  float x = s.get<x>();

#pragma warning(push)#pragma warning(disable:4996)//! \internal base declarationtemplate <typename T> struct StructInfo;//! USHORT_BITS(name,bits) declares a structure field that will //! store unsigned integer values up to 'bits' bits in size, as //! an unsigned short within the struct. You reference the given //! 'name' in your structure declaration (Struct<name, ...>).//! \param name The name to give the field; must be a valid C //! identifier name.//! \param bits The number of bits to use for storage (only used //! by some marshalling visitors).#define USHORT_BITS(name,bits) &92;  struct name; &92;  template<> struct StructInfo<name> { &92;    typedef name Name; &92;    typedef unsigned short Type; &92;    static inline int getBits() { return bits; } &92;    static inline Type init() { return 0; } &92;  }//! FLOAT_RES_LIMIT(name,res,limit) declares a structure field that will //! store float values with a given resolution ('res') extending out to //! a positive and negative limit from the origin ('limit').//!  You reference the given //! 'name' in your structure declaration (Struct<name, ...>).//! \param name The name to give the field; must be a valid C //! identifier name.//! \param res The minimum step size to represent.//! \param limit The maximum magnitude to represent.//! \note Res and limit may be used by some marshalling visitors to //! encode the float as a fixed-resolution number.#define FLOAT_RES_LIMIT(name,rez,limit) &92;  struct name; &92;  template<> struct StructInfo<name> { &92;    typedef name Name; &92;    typedef float Type; &92;    static inline float getRez() { return rez; } &92;    static inline float getLimit() { return limit; } &92;    static inline Type init() { return 0; } &92;  }#pragma warning(push)#pragma warning(disable:4584) // already a base// Declare helpers in the system//! Operations for inputting into a structstruct in;//! Operations for outputting from a structstruct out;//! \internal An actual struct member (used to disambiguate access)template<typename N> struct StructMember {  typename StructInfo<N>::Type _memb;  StructMember() { _memb = StructInfo<N>::init(); }};//! You implement a partial specialization on StructOp::visit() //! to perform visitation (such as serializing or validating data).template<typename operation, typename type, typename container> struct StructOp {};//! You implement a partial specialization on StructInitialize::initialize() //! to start out visitation.template<typename operation, typename type, typename container> struct StructInitialize {};//! You implement a partial specialization on StructTerminate::terminate() //! to finalize visitation.template<typename operation, typename type, typename container> struct StructTerminate {};//! \internal Base is used to terminate the declaration of a user compound type.struct Base {  template<typename operation, typename topmost, typename data> bool visit_internal(data & o) {    return StructTerminate<operation, topmost, data>().terminate(o);  }};//! You use template struct to construct structures out of data types //! that you have defined with USHORT_BITS, FLOAT_RES_LIMIT and other //! such macros that define "struct member" names/types.//! The first parameter is a name/type; the second is another Struct //! (for what comes after the first member), or empty (default) to //! finish the struct.template<typename N, typename B = Base>struct Struct : StructMember<N>, B {  //! Call get<name>() to read the value of the member 'name'.  template<typename T> typename StructInfo<T>::Type const & get() const {    return StructMember<T>::_memb;  }  //! Call set<name>() to set the value of the member 'name'.  template<typename T> void set(typename StructInfo<T>::Type const & t) {    StructMember<T>::_memb = t;  }  //! Call visit() to visit all the members of the struct in order,   //! based on your StructInitialize, StructOp and StructTerminate   //! visitor class implementations.  template<typename operation, typename data> bool visit(data & o) {    return StructInitialize<operation, Struct, data>().initialize(o, *this)        && visit_internal<operation, Struct, data>(o);  }protected:  //! \internal get the visitation in the right order  template<typename operation, typename topmost, typename data> bool visit_internal(data & o) {    return StructOp<operation, topmost, data>().visit(o, StructMember<N>::_memb)        && B::visit_internal<operation, topmost, data>(o) ;  }};#pragma warning(pop)//! \internal marshal to strings (do not use resolution information)template<typename T>struct StructInitialize<out, T, std::string> {  bool initialize(std::string & out, T const & t) {    return true;  }};//! \internal marshal to strings (do not use resolution information)template<typename T>struct StructTerminate<out, T, std::string> {  bool terminate(std::string & out) {    out += "\n";    return true;  }};//! \internal marshal to strings (do not use resolution information)template<typename T>struct StructOp<out, T, std::string> {  //! \internal Put floats into the string  bool visit(std::string & out, float f) {    char buf[30];    sprintf(buf, ":%g", f);    out += buf;    return true;  }  //! \internal Put ushorts into the string  bool visit(std::string & out, unsigned short us) {    char buf[30];    sprintf(buf, ":%d", us);    out += buf;    return true;  }};#pragma warning(pop)