Macro for automatic generation serialization function for a class - c++

Question

I often describing the existing structures, and I need whatever method to automatically generate structure map...
As example, I have small structure:
struct SExampleBox
{
int x; //0x0000
int y; //0x0004
float size; //0x0008
}; Size=0x000C
My idea is to describe it as: (using macro or maybe boost.preprocessor)
STRUCT_BEGIN(SExampleBox)
MEMBER(int, x);
MEMBER(int, y);
MEMBER(float size);
STRUCT_END
To expand it automatically to:
struct SExampleBox
{
int x;
int y;
float size;
};
void DUMP__SExampleBox(SExampleBox *obj)
{
printf("%p > SExampleObj:\n", obj);
printf(" 0x%04x - int x = %d\n", offsetof(SExampleObj, x), obj->x);
printf(" 0x%04x - int y = %d\n", offsetof(SExampleObj, y), obj->y);
printf(" 0x%04x - float size = %f\n", offsetof(SExampleObj, size), obj->size);
}
To call DUMP__SExampleBox(test); and get an example output:
0x00402000 > SExampleObj:
0x0000 - int x = 100
0x0004 - int y = 50
0x0008 - float size = 200.000f
Is there's any possible way to do it?
Thank you!

Answer 1

Not quite satisfied with the value formatting juggle, but that's tweakable.
The syntax looks like this:
DECLARE_STRUCT(SExampleBox,
(int, x)
(int, y)
(float, size)
)
int main(int, char**) {
SExampleBox o{1, 2, 3.14f};
dump(&o);
}
Now, the implementation. First, we'll need a utility function to add parentheses to a Boost.PP sequence, turning (a)(b) into ((a))((b)):
#define glk_pp_detail_doubleSeqParens_0(...)\
((__VA_ARGS__)) glk_pp_detail_doubleSeqParens_1
#define glk_pp_detail_doubleSeqParens_1(...)\
((__VA_ARGS__)) glk_pp_detail_doubleSeqParens_0
#define glk_pp_detail_doubleSeqParens_0_end
#define glk_pp_detail_doubleSeqParens_1_end
#define glk_pp_doubleSeqParens(seq)\
BOOST_PP_CAT(glk_pp_detail_doubleSeqParens_0 seq, _end)
Then we'll build the skeleton of the struct declaration and the corresponding function:
#define DECLARE_STRUCT(name_, fields_) \
struct name_ { \
BOOST_PP_SEQ_FOR_EACH(DETAIL_DECLARE_FIELD, name_, glk_pp_doubleSeqParens(fields_)) \
}; \
void dump(name_ *obj_) { \
::std::printf("%p > " BOOST_PP_STRINGIZE(name_) ":\n", static_cast<void*>(obj_)); \
BOOST_PP_SEQ_FOR_EACH(DETAIL_PRINT_FIELD, name_, glk_pp_doubleSeqParens(fields_)) \
}
The double-parentheses from glk_pp_doubleSeqParens enable passing the sequence of tuples (type, name)(type, name) to BOOST_PP_SEQ_FOR_EACH, which would otherwise choke on it because of the commas.
Now it's just a matter of forming valid member declarations and print statements for each struct member:
#define DETAIL_DECLARE_FIELD(r, structName_, typeAndName_) \
BOOST_PP_TUPLE_ELEM(0, typeAndName_) BOOST_PP_TUPLE_ELEM(1, typeAndName_);
#define DETAIL_PRINT_FIELD_1(structName_, type_, name_) \
::std::printf(" 0x%04zx - " BOOST_PP_STRINGIZE(type_) " " BOOST_PP_STRINGIZE(name_) " = ", offsetof(structName_, name_)); \
::detail_printValue(obj_->name_);
#define DETAIL_PRINT_FIELD(r, structName_, typeAndName_) \
DETAIL_PRINT_FIELD_1(structName_, BOOST_PP_TUPLE_ELEM(0, typeAndName_), BOOST_PP_TUPLE_ELEM(1, typeAndName_))
Choosing the appropriate format parameter for each value is a bit clunky. I've elected to defer that to an overload set that only prints the value and the newline, but you could also construct the format string on-the-fly and use a single printf.
void detail_printValue(float const &v) { std::printf("%f\n", v); }
void detail_printValue(int const &v) { std::printf("%d\n", v); }
Voilà! See it live on Coliru