Hello,
 
Here's a question for the preprocessor metaprogramming experts out there.
 
I have some classes that need to have write() methods that look like this:
 
template <typename output>
bool write(output& out) const
{
    return utils::write(out, member_1) &&
           utils::write(out, member_2) &&
           ...
           utils::write(out, member_n);
}
 
where member_1, member_2, ..., member_n are the member variables of the class.
 
(These write() methods are used as part of a serialization framework).
 
Since I have quite a few classes that need write() methods that look like this,
and the structure of each write() method is uniform (the only thing that varies
is the names of the class members), I figured that it would be neat to somehow
generate the code for these write() methods.
 
What I came up with is macros that look like this:
 
#define MEMBERS1(m1)                            \
    template <typename output>                  \
    bool write(output& out) const                \
    {                                           \
        return utils::write(out, m1);    \
    }

#define MEMBERS2(m1, m2)                        \
    template <typename output>                  \
    bool write(output& out) const                \
    {                                           \
        return utils::write(out, m1) &&  \
               utils::write(out, m2);    \
    }
 
// and so on for MEMBERS3, MEMBERS4, etc.
 
Then, instead of declaring and defining the write() methods explicilty,
I would just call the appropriate MEMBERS# macro in the class definition,
e.g. for a class with 3 members named a, b, and c, I'd write
MEMBERS3(a, b, c) in the class definition.
 
While this is definitely an improvement over writing the write() methods
explicitly for each class, there are two issues with it:
 
1) The number of lines of code needed to write the macro definitions
is quadratic in the maximum number of parameters supported.
It would be nice if it could be constant instead.
 
2) The user of the macros needs to match the macro name to the number
of member variables in the class, and to change the macro name whenever
the number of member variables changes.
 
I'm wondering if there is a way to improve on this generation scheme
that solves one or both of these issues.
 
If I were allowed to use C++0x, I could have a variadic macro MEMBERS(...)
and inside it pass the parameters to a variadic template function which
unpacks its parameters and calls utils::write() on each. This would solve
both issues. Unfortunately, however, I am not allowed to use C++0x features,
since our code needs to be able to compile on our servers, which run Ubuntu 8.04,
which runs g++ 4.2, which does not support C++0x features.
 
So I thought I'd turn to some more preprocessor magic to solve these issues.
I looked at examples in Boost.Preprocessor that generated repetitive code
using preprocessor metaprogramming. However, all the examples there
generated repetitive *code*, whereas what I seem to need is to be able
to generate repetitive *macro definitions*. Is there a way to do that?
If not, can anyone recommend other ways of improving the way I generate
the code for the write() functions?
 
Thanks in advance,
Nate.

---

Enter for a chance to get your town photo on Bing.ca! Submit a Photo Now!