Re: Second draft (was Re: Framework for iterating over product types?)

[..]
There are many classes for which swap() can be defined like this:

    swap(this->a, other.a);
    swap(this->b, other.b);
    swap(this->c, other.c);
    // ...

and serialize() can be defined like this:

    ar & a;
    ar & b;
    ar & c;
    // ...

and operator==() can be defined like this:

    if (!(this->a == other.a)) return false;
    if (!(this->b == other.b)) return false;
    if (!(this->c == other.c)) return false;
    // ...

and operator<() can be defined like this:

    if (this->a < other.a) return true;
    if (other.a < this->a) return false;
    if (this->b < other.b) return true;
    if (other.b < this->b) return false;
    if (this->c < other.c) return true;
    if (other.c < this->c) return false;
    // ...

and so on. It's a hassle to write this boilerplate for a large number
of user-defined classes. All of the above boilerplate functions can be
auto-generated from a single per-class boilerplate method looking
something like this:

    template<class Visitor>
    static void enum_children(Visitor& has) {
        has (&Foo::a) (&Foo::b) (&Foo::c) /* ... */ ;
    }

for example, here's how to do it for swap():

    template<class T>
    class swap_member {
    public:
        swap_member(T& a, T& b) : a(a), b(b) {}

        template<class X>
        void operator()(X T::* p) {
            swap(a.*p, b.*p);
        }

    private:
        T& a; T& b;
    };

    template<class T>
    void generic_swap(T& a, T& b) {
        T::enum_children(swap_member(a,b));
    }

For a system with a lot of boilerplate methods of this kind, this
technique looks like it could save a lot of time and avoid a lot of
bugs. I was surprised not to find support for it in Boost. I can
write my own implementation, but I'd rather use someone else's, or at
least use a standardized name for the method (instead of
"enum_children") for future compatibility. So, has anyone implemented
this before or chosen a naming convention for it?