struct FOO : BASE
{
//... some code
  REFL_F(int, x)      // field
  REFL_A(float, y, 3) // array 
  REFL_P(BAR*, ptr)   // pointer to class hierarchy object
//... some code
};

struct FOO : BASE
XC>{
XC>//... some code
XC>  REFL_F(int, x)      // field
XC>  REFL_A(float, y, 3) // array 
XC>  REFL_P(BAR*, ptr)   // pointer to class hierarchy object
XC>//... some code
XC>};

struct FOO : BASE
{
    DEFINE_FIELDS
    (
        FOO, BASE,
        (int, x)
        ((array<float, 3>), y) 
        (BAR*, ptr)
    )
};

#include "reflect.h"
#include "typedecl.h"

class A { 
  public:
    int    i;
    char*  pc;
    double d;
  protected:
    long   larr[10];
    A**    ppa;    
    A*     pa;
  public:
    RTTI_DESCRIBE_STRUCT((RTTI_FIELD(i, RTTI_FLD_PUBLIC),
                          RTTI_PTR(pc, RTTI_FLD_PUBLIC),
                          RTTI_FIELD(d, RTTI_FLD_PUBLIC),
                          RTTI_ARRAY(larr, RTTI_FLD_PROTECTED),
                          RTTI_PTR_TO_PTR(ppa, RTTI_FLD_PROTECTED),
                          RTTI_PTR(pa, RTTI_FLD_PROTECTED)));
};

#include <stdio.h>
#include <iosfwd>
#include <string>
#include <iostream>
#include <typeinfo>

#include "boost/array.hpp"
#include "boost/type_traits.hpp"
#include "boost/mpl/has_xxx.hpp"
#include "boost/preprocessor/library.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/fusion/support.hpp"
#include "boost/fusion/include/iteration.hpp"
#include "boost/fusion/include/pair.hpp"
#include "boost/fusion/include/map.hpp"
#include "boost/fusion/include/intrinsic.hpp"
#include "boost/fusion/include/functional.hpp"
#include "boost/fusion/include/mpl.hpp"
namespace fusion = boost::fusion;

namespace Utils
{
    //////////////////////////////////////////////////////////////////////////
    template< class TagT, class ValT >
    struct PropertyTraits 
    {
        typedef TagT Tag;
        typedef ValT Value;
        typedef boost::fusion::pair< Tag, Value > Pair;
    };

    //////////////////////////////////////////////////////////////////////////
    struct PropertiesAccessImplBase
    {
        template< class PropT, class SourceT > 
        static typename PropT::Value const & AtVal(SourceT const & from)
        {
            return boost::fusion::at_key< typename PropT::Tag >(from);
        }

        template< class PropT, class SourceT > 
        static typename PropT::Value & AtRef(SourceT & from)
        {
            return boost::fusion::at_key< typename PropT::Tag >(from);
        }
    };

    template< class DerivedT >
    struct PropertiesAccessImpl : PropertiesAccessImplBase
    {
        typedef typename boost::remove_cv< DerivedT >::type DerivedT;

        template< class PropT > 
        typename PropT::Value const & AtVal() const
        {
            return PropertiesAccessImplBase::AtVal< PropT >( static_cast< DerivedT const & >(*this) );
        }
        
        template< class PropT >
        typename PropT::Value & AtRef()
        {
            return PropertiesAccessImplBase::AtRef< PropT >( static_cast< DerivedT & >(*this) );
        }

        template< class PropT > 
        typename PropT::Value const & At() const
        {
            return this->AtVal< PropT >();
        }

        template< class PropT >
        typename PropT::Value & At()
        {
            return this->AtRef< PropT >();
        }

        template< class PropT > 
        typename PropT::Pair AtP() const
        {
            return typename PropT::Pair( this->At< PropT >() );
        }
    };

} //namespace Utils {    


//////////////////////////////////////////////////////////////////////////
/* 
    Упрощенное объявление PropertyTraits, обертки над boost::fusion::pair, 
    которая в месте объявления типа тэга привязывает его к типу значения
*/
#define MY_DEFINE_PROPERTY_TRAITS(TagType, ValType) \
    struct TagType : Utils::PropertyTraits< TagType, ValType > \
    { \
        static char const * Name() { return BOOST_PP_STRINGIZE( TagType ); } \
        static char const * TypeName() { return BOOST_PP_STRINGIZE( ValType ); } \
    } \
    /**/

//    MY_DEFINE_PROPERTY_TRAITS( TagType0, ValueType0 );
//    MY_DEFINE_PROPERTY_TRAITS( TagType1, ValueType1 );
//    ...
#define MY_DEFINE_PROPERTIES_TUPLED_TRAITS(r, data, tag_value) \
    MY_DEFINE_PROPERTY_TRAITS( BOOST_PP_TUPLE_ELEM(2, 0, tag_value), BOOST_PP_TUPLE_ELEM(2, 1, tag_value) ); \
    /**/

//  TagType0::Pair, TagType1::Pair,...
#define MY_DEFINE_PROPERTIES_TYPES_I(r, data, i, tag_value_tuple) \
    BOOST_PP_COMMA_IF(i) BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(2, 0, tag_value_tuple), ::Pair ) \
    /**/

//    TagType0::Value const & v0, TagType1::Value const & v1,...
#define MY_DEFINE_PROPERTIES_CTOR_PARAMS_I(r, data, i, tag_value_tuple) \
    BOOST_PP_COMMA_IF(i) BOOST_PP_CAT( BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(2, 0, tag_value_tuple), ::Value const & v ), i ) \
    /**/

//    v0, v1,...
#define MY_DEFINE_PROPERTIES_CAT(z, i, data) \
    BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(data, i) \
    /**/

// MY_DEFINE_PROPERTIES + наличие дефолтного конструктора (0 - нет, 1 - есть) + макрос объявления класса-наследника для Utils::PropertyTraits
#define MY_DEFINE_PROPERTIES_IMPL(TupleName, HasDefaultCtor, HasVirtualDtor, TagDefMacro, TagValueSeq) \
    BOOST_PP_SEQ_FOR_EACH( TagDefMacro, ~, TagValueSeq ) \
    struct TupleName \
        : boost::fusion::map< BOOST_PP_SEQ_FOR_EACH_I( MY_DEFINE_PROPERTIES_TYPES_I, ~, TagValueSeq ) > \
        , public Utils::PropertiesAccessImpl< TupleName > \
    { \
        typedef boost::fusion::map< BOOST_PP_SEQ_FOR_EACH_I( MY_DEFINE_PROPERTIES_TYPES_I, ~, TagValueSeq ) > BaseT; \
        TupleName( BOOST_PP_SEQ_FOR_EACH_I( MY_DEFINE_PROPERTIES_CTOR_PARAMS_I, ~, TagValueSeq ) ) \
            : BaseT( BOOST_PP_REPEAT( BOOST_PP_SEQ_SIZE(TagValueSeq), MY_DEFINE_PROPERTIES_CAT, v ) ) \
        { \
        } \
        BOOST_PP_IF( HasDefaultCtor, TupleName BOOST_PP_LPAREN() BOOST_PP_RPAREN() {}, BOOST_PP_EMPTY() ) \
        BOOST_PP_IF( HasVirtualDtor, BOOST_PP_CAT(~, TupleName) BOOST_PP_LPAREN() BOOST_PP_RPAREN() {}, BOOST_PP_EMPTY() ) \
    } \
    /**/

// MY_DEFINE_PROPERTIES + наличие дефолтного конструктора (0 - нет, 1 - есть)
#define MY_DEFINE_PROPERTIES_EX(TupleName, HasDefaultCtor, TagValueSeq) \
    MY_DEFINE_PROPERTIES_IMPL(TupleName, HasDefaultCtor, 0, MY_DEFINE_PROPERTIES_TUPLED_TRAITS, TagValueSeq) \
    /**/

/* 
    Объявление кортежа с "именованными" полями (на основе boost::fusion::map)
    MY_DEFINE_PROPERTIES( 
        TupleName, 
        ( (TagType0, ValueType0) )
        ( (TagType1, ValueType1) )
        ...
    );
    - разворачивается в совокупность объявлений классов-тэгов и класса на основе boost::fusion::map
    MY_DEFINE_PROPERTY_TRAITS( TagType0, ValueType0 );
    MY_DEFINE_PROPERTY_TRAITS( TagType1, ValueType1 );
    ...

    struct TupleName
        : boost::fusion::map< TagType0::Pair, TagType1::Pair,... >
        , public Utils::PropertiesAccessImpl< TupleName >
    {
        typedef boost::fusion::map< TagType0::Pair, TagType1::Pair,... > BaseT;
        TupleName(TagType0::Value const & v0, TagType1::Value const & v1,...)
            : BaseT(v0, v1,...)
        {
        }
    };
*/
#define MY_DEFINE_PROPERTIES(TupleName, TagValueSeq) \
    MY_DEFINE_PROPERTIES_EX( TupleName, 0, TagValueSeq) \
    /**/

struct Base
{
};

MY_DEFINE_PROPERTIES(
    WeNeed2GoDeeper,
    ( (Zzz, int) )
);

MY_DEFINE_PROPERTIES(
    Bar,
    ( (Aaa, int) )
    ( (Bbb, std::string) )
    ( (Ccc, WeNeed2GoDeeper *) )
);

typedef boost::array< int, 3 > Int3;

struct FooTraits : Base
{
    MY_DEFINE_PROPERTIES_EX(
        Storage, 1,
        ( (x, int) )
        ( (y, Int3) )
        ( (ptr, Bar *) )
    );
};

struct Foo
    : public FooTraits
    , public FooTraits::Storage
{
    Foo()
    {
        this->At< ptr >() = new Bar(12, std::string("qwe"), new WeNeed2GoDeeper(34));
    }

    struct Printer
    {
        Printer(int indent) 
            : m_indent(indent)
        {
        }
        template< class PairT >
        void operator ()(PairT & data) const;

    private:
        int const m_indent;
    };

    void PrintHierarchy()
    {
        fusion::for_each(*this, Printer(0));
    }
};

//////////////////////////////////////////////////////////////////////////
BOOST_MPL_HAS_XXX_TRAIT_DEF( first_type )
BOOST_MPL_HAS_XXX_TRAIT_DEF( second_type )
template< 
    class PairT
    , bool Expand = has_first_type< PairT >::value && has_second_type< PairT >::value && boost::is_pointer< typename PairT::second_type >::value  
>
struct FooPrinterImpl
{
    static void Do(PairT & data, int const indent)
    {
        std::string const prfx(indent, '*');
        ::printf("%s[%s] of '%s'\n", prfx.c_str(), typename PairT::first_type::Name(), typename PairT::first_type::TypeName());
    }
};

template< class PairT >
struct FooPrinterImpl< PairT, true >
{
    static void Do(PairT & data, int const indent)
    {
        if (! data.second)
            return;
        ::printf("----\n");
        fusion::for_each(*data.second, Foo::Printer(indent + 1));
    }
};

template< class PairT >
void Foo::Printer::operator ()(PairT & data) const
{
    FooPrinterImpl< PairT >::Do(data, m_indent);
}

//////////////////////////////////////////////////////////////////////////
int main()
{
    Foo().PrintHierarchy();
}