Re: [Boost-users] Preprocessor sequence of "pairs"

Subject: Re: [Boost-users] Preprocessor sequence of "pairs"
From: Viatcheslav.Sysoltsev_at_[hidden]
Date: 2012-09-26 04:01:18

On Wed, 26 Sep 2012 07:52:24 +0200, <driscoll_at_[hidden]> wrote:

> I have a question about the use of the preprocessor library. I'll  
> describe
> my ultimate goal in a moment, but I've simplified my first problem to the
> following. Also, I know what I'm doing looks a lot at first glance like
> Fusion's ADAPT_STRUCT, but I took a quick look at that documentation and  
> I
> don't think it matches. However, if you disagree with me and think it
> does, or can suggest a totally different solution, feel free to describe
> how.
>
> == My problem ==
>
> I don't like C's struct syntax, so I'm trying to define my own.
> (</sarcasm> Really for purposes of this section I'm just doing this to
> figure out all the steps I'll need.)
>
> What I want to do is something like the following:
>
>   #include <boost/preprocessor/seq/for_each.hpp>
>
>   #define DEFINE_FIELD(r, os, field_pair)  [....]
>
>   #define DEFINE_STRUCT(struct_name, fields)              \
>       struct struct_name {                                \
>           BOOST_PP_SEQ_FOR_EACH(DEFINE_FIELD, ~, fields)  \
>       }
>
>   DEFINE_STRUCT(mystruct, (int, x)(int, y)(double, z))
>
> but this doesn't work, because the sequence is made up of pairs instead  
> of
> single preprocessor arguments. (GCC complains about "macro
> "BOOST_PP_SEQ_SIZE_0" passed 2 arguments, but takes just 1" and same for
> PP_EXPR_IIF_0.)
>
> I can get it to work by double-parenthesizing the stuff in the sequence
> (saying "((int, x))((int, y))((double, z))") then defining DEFINE_FIELD  
> as
> follows:
>
>   #define DEFINE_FIELD_REAL(type, name)    type name;
>   #define DEFINE_FIELD(r, os, field_pair)  DEFINE_FIELD_REAL field_pair
>
> but this is less than optimal. Is there a way that I can do this easily,
> or would I effectively have to re-implement SEQ_FOR_EACH? (And how hard
> would that be if it's necessary?)
>
>
> == What I'm actually trying to do ==
>
> What I'm actually doing is trying to write a macro that will define a
> function like the following:
>
>     DEFINE_SERIALIZED_STRUCT(mystruct, (int, x)(int, y)(double, z))
>        |
>        V
>     struct mystruct {
>         int x;
>         int y;
>         double z;
>     };
>     void serialize(ostream & os, mystruct const & s) {
>         os << "x: " << s.x << "\n";
>         os << "y: " << s.y << "\n";
>         os << "z: " << s.z << "\n";
>     }
>
> (I didn't see a way to recover the field names from a Fusion-adapted
> struct -- from what I can tell, it more just seems to be a way to iterate
> over the fields.)

Hi,

the trick /I looked from fusion:)/ is to wrap every sequence member in an  
additional () before passing it to the main macro:

#define  
MY_SEQUENCE_CREATOR_0(...)                                                    
\
     ((__VA_ARGS__)) MY_SEQUENCE_CREATOR_1
#define  
MY_SEQUENCE_CREATOR_1(...)                                                    
\
     ((__VA_ARGS__)) MY_SEQUENCE_CREATOR_0
#define MY_SEQUENCE_CREATOR_0_END
#define MY_SEQUENCE_CREATOR_1_END

And then you wrap call to your DEFINE_STRUCT:

#define _DEFINE_STRUCT(struct_name, fields)             \
    struct struct_name {                                 \
       BOOST_PP_SEQ_FOR_EACH(DEFINE_FIELD, ~, fields)    \
    }
#define DEFINE_FIELD(r, data, field_tuple)			  \
        V_BOOST_PP_TUPLE_ELEM(0, field_tuple) V_BOOST_PP_TUPLE_ELEM(1,  
field_tuple);

#define DEFINE_STRUCT(struct_name, fields)                    \
     _DEFINE_STRUCT(struct_name,						       \
        BOOST_PP_CAT(MY_SEQUENCE_CREATOR_0 fields,_END))      \

If I dont mistake it basically transforms
DEFINE_STRUCT(mystruct, (int, x)(int, y)(double, z))
into
_DEFINE_STRUCT(mystruct, ((int, x))((int, y))((double, z)))
so you get a single *tuple* as a parameter to your DEFINE_FIELD.  
Eventually you can call another macro with this tuple, but I am not sure  
whether this will be preprocessed as expected. I had troubles with it, so  
I used V_BOOST_PP_TUPLE_ELEM (appeared first in boost 1.49) to extract  
tuple elements in-place and it worked for me.

// I've heard there are some nasty troubles with msvc and variadic macros,  
so you have an additional quest if you need to support msvc

-- Slava