Changeset 44690


Ignore:
Timestamp:
Apr 21, 2008, 9:36:51 AM (10 years ago)
Author:
matus.chochlik
Message:

Added support for querying the types of all class members including the inherited ones.
Updated the example 'registering/virtual_base.cpp' showing the registering of virtual base classes and the access to all memebr atributes.

Location:
sandbox/mirror
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • sandbox/mirror/boost/mirror/meta_attribs_base.hpp

    r44548 r44690  
    5555                typedef mpl::int_<attrib_index> position;
    5656                typedef mpl::int_<position::value+1> next;
     57                typedef typename meta_class::attributes::type_list type_list;
    5758                // get the type of the attribute
    58                 typedef mpl::at<meta_class::attributes::type_list, position>::type attrib_type;
     59                typedef typename mpl::at<
     60                                type_list,
     61                                position
     62                        >::type attrib_type;
    5963                //
    6064                // execute the operation
     
    6468                        meta_attributes,
    6569                        is_same<
    66                                 mpl::int_<mpl::size<meta_class::attributes::type_list>::value>,
     70                                mpl::int_<mpl::size<type_list>::value>,
    6771                                next
    6872                        >::value
     
    8185        typedef the_class base_class;
    8286        typedef BOOST_MIRROR_REFLECT_CLASS_VT(the_class, variant_tag) meta_class;
    83         typedef typename meta_class_attributes<the_class, variant_tag > meta_attributes;
     87        typedef meta_class_attributes<the_class, variant_tag > meta_attributes;
    8488        /**
    8589         */
     
    8791        static meta_attrib_op for_each(meta_attrib_op op)
    8892        {
     93                typedef typename meta_class::attributes::type_list type_list;
    8994                meta_class_attrib_for_each_impl<
    9095                        meta_attributes,
    9196                        is_same<
    92                                 mpl::int_<mpl::size<meta_class::attributes::type_list>::value>,
     97                                mpl::int_<mpl::size<type_list>::value>,
    9398                                mpl::int_<0>
    9499                        >::value
    95100                >::apply(op, (meta_class*)0, mpl::int_<0>());
    96101                return op;
    97         };
     102        }
    98103};
    99104
  • sandbox/mirror/boost/mirror/meta_class.hpp

    r44548 r44690  
    1212
    1313#include <boost/mpl/if.hpp>
     14#include <boost/mpl/and.hpp>
     15#include <boost/mpl/plus.hpp>
     16#include <boost/mpl/minus.hpp>
     17#include <boost/mpl/comparison.hpp>
     18#include <boost/mpl/fold.hpp>
     19#include <boost/mpl/transform.hpp>
    1420#include <boost/mpl/accumulate.hpp>
    1521#include <boost/mpl/remove_if.hpp>
     22#include <boost/mpl/contains.hpp>
    1623#include <boost/mpl/insert_range.hpp>
    1724#include <boost/mpl/joint_view.hpp>
     
    7178                {
    7279                        /** The list of non-virtual base classes in the same
    73                          *  order as registered.
     80                         *  order as they were registered.
     81                         */
     82                        typedef typename mpl::remove_if<
     83                                typename base_classes::list,
     84                                mpl::lambda<
     85                                        reflects_virtual_inheritance<mpl::_1>
     86                                >::type
     87                        >::type list_of_regular_base_classes;
     88
     89                        /** The list of directly inhertied virtual base classes.
    7490                         */
    7591                        typedef typename mpl::remove_if<
     
    7894                                        mpl::not_<reflects_virtual_inheritance<mpl::_1> >
    7995                                >::type
    80                         >::type list_of_regular_base_classes;
    81 
    82                         /** The list of all virtual base classes with duplicates.
    83                          */
    84                         typedef typename mpl::remove_if<
    85                                 typename base_classes::list,
    86                                 mpl::lambda<
    87                                         reflects_virtual_inheritance<mpl::_1>
    88                                 >::type
    89                         >::type list_of_all_virtual_base_classes;
    90 
    91                         /** The list of virtual base classes with duplicates
    92                          *  removed.
    93                          * TODO:
    94                          */
    95                         typedef typename list_of_all_virtual_base_classes
    96                                 list_of_virtual_base_classes;
    97                        
    98                         /** This tells whether the virtual base classes
    99                          *  go first or last into the list of base classes.
    100                          */
    101                         typedef true_type virtual_first;
    102 
    103                         /** The list of base classes of the reflected_class.
    104                          */
    105                         typedef typename mpl::joint_view<
    106                                 typename mpl::if_<
    107                                         virtual_first,
    108                                         list_of_virtual_base_classes,
    109                                         list_of_regular_base_classes
    110                                 >::type,
    111                                 typename mpl::if_<
    112                                         virtual_first,
    113                                         list_of_regular_base_classes,
    114                                         list_of_virtual_base_classes
    115                                 >::type
    116                         >::type list_of_base_classes;
    117 
    118                         /** This template gets the list of attributes types
    119                          *  when given a meta_inheritance specialization.
     96                        >::type list_of_virtual_base_classes;
     97
     98                        /** This template gets the regular_base_class_layout
     99                         *  of a base class when given a meta_inheritance
     100                         *  specialization for this base class.
    120101                         */
    121102                        template <class meta_inheritance>
    122                         struct get_bc_all_attrib_tl
    123                         {
    124                                 typedef typename meta_inheritance::meta_class::all_attributes::type_list type;
     103                        struct get_base_class_regular_layout
     104                        {
     105                                typedef typename
     106                                        meta_inheritance::
     107                                        meta_class::
     108                                        all_attributes::
     109                                        detail::
     110                                        regular_base_class_layout type;
    125111                        };
    126112                       
    127                         /** Definition of a list containing the lists
    128                          *  of all_attributes from the base classes.
     113                        /** The layout of non-virtual base classes
     114                         *  of this class, stored as a mpl::vector
     115                         *  of meta_inheritances.
    129116                         */
    130117                        typedef typename mpl::accumulate<
    131                                 typename list_of_base_classes,
     118                                list_of_regular_base_classes,
    132119                                mpl::vector<>,
    133120                                mpl::push_back<
    134                                         mpl::_1,
    135                                         mpl::lambda<get_bc_all_attrib_tl<mpl::_2> >
    136                                 >
    137                         >::type att_type_lists_of_base_classes;
     121                                        mpl::insert_range<
     122                                                mpl::_1,
     123                                                mpl::end<mpl::_1>,
     124                                                get_base_class_regular_layout<
     125                                                        mpl::_2
     126                                                >
     127                                        >,
     128                                        mpl::_2
     129                                >
     130                        >::type regular_base_class_layout;
    138131                       
    139                         /** Defintion of a mpl::vector containing the member
    140                          *  attributes inherited from the base classes.
     132                        /** This template gets the virtual_base_class_layout
     133                         *  of a base class when given a meta_inheritance
     134                         *  specialization for this base class.
     135                         */
     136                        template <class meta_inheritance>
     137                        struct get_base_class_virtual_layout
     138                        {
     139                                typedef typename
     140                                        meta_inheritance::
     141                                        meta_class::
     142                                        all_attributes::
     143                                        detail::
     144                                        virtual_base_class_layout type;
     145                        };
     146       
     147                        /** This template gets the base_class_layout
     148                         *  of a base class when given a meta_inheritance
     149                         *  specialization for this base class.
     150                         */
     151                        template <class meta_inheritance>
     152                        struct get_base_class_layout
     153                        {
     154                                typedef typename
     155                                        meta_inheritance::
     156                                        meta_class::
     157                                        all_attributes::
     158                                        detail::
     159                                        base_class_layout type;
     160                        };
     161       
     162                        /** The list of vitual base classes of this class.
     163                         *  This list still contains dupplicates, that are
     164                         *  removed to form virtual_base_class_layout
    141165                         */
    142166                        typedef typename mpl::accumulate<
    143                                 att_type_lists_of_base_classes,
     167                                typename base_classes::list,
    144168                                mpl::vector<>,
     169                                mpl::if_<
     170                                        reflects_virtual_inheritance<
     171                                                mpl::_2
     172                                        >,
     173                                        mpl::push_back<
     174                                                mpl::insert_range<
     175                                                        mpl::_1,
     176                                                        mpl::end<mpl::_1>,
     177                                                        get_base_class_layout<
     178                                                                mpl::_2
     179                                                        >
     180                                                >,
     181                                                mpl::_2
     182                                        >,
     183                                        mpl::insert_range<
     184                                                mpl::_1,
     185                                                mpl::end<mpl::_1>,
     186                                                get_base_class_virtual_layout<
     187                                                        mpl::_2
     188                                                >
     189                                        >
     190                                >
     191                        >::type virtual_base_class_layout_w_dups;
     192                       
     193                        /** The layout of virtual base classes
     194                         *  of this class, stored as a mpl::vector
     195                         *  of meta_inheritances.
     196                         */
     197                        typedef typename mpl::fold<
     198                                virtual_base_class_layout_w_dups,
     199                                mpl::vector0<>,
     200                                mpl::if_<
     201                                        mpl::contains<
     202                                                mpl::_1,
     203                                                mpl::_2
     204                                        >,
     205                                        mpl::_1,
     206                                        mpl::push_back<
     207                                                mpl::_1,
     208                                                mpl::_2
     209                                        >
     210                                >
     211                        >::type virtual_base_class_layout;
     212                       
     213                        /** This template gets the list of member
     214                         *  attrbute types of a base class when
     215                         *  given a meta_inheritance<> specialization
     216                         */
     217                        template <class meta_inheritance>
     218                        struct get_base_class_attrib_type_list
     219                        {
     220                                typedef typename
     221                                        meta_inheritance::
     222                                        meta_class::
     223                                        attributes::
     224                                        type_list type;
     225       
     226                        };
     227
     228                        typedef typename mpl::joint_view<
     229                                virtual_base_class_layout,
     230                                regular_base_class_layout
     231                        >::type base_class_layout;
     232
     233                        /** The list of inherited member attributes
     234                         *  of the reflected class.
     235                         *  NOTE: this implementation puts the
     236                         *  members of the virtual bases before
     237                         *  the other members
     238                         */
     239                        typedef typename mpl::accumulate<
     240                                base_class_layout,
     241                                mpl::vector0<>,
    145242                                mpl::insert_range<
    146243                                        mpl::_1,
    147244                                        mpl::end<mpl::_1>,
    148                                         mpl::_2
    149                                 >
    150                         >::type inherited_attrib_type_list;
     245                                        get_base_class_attrib_type_list<
     246                                                mpl::_2
     247                                        >
     248                                >
     249                        >::type inherited_member_attrib_type_list;
     250
     251                        /** The list of types of all attributes including
     252                        *  the inherited ones.
     253                        */
     254                        typedef typename mpl::joint_view<
     255                                typename detail::inherited_member_attrib_type_list,
     256                                typename meta_class<reflected_class, variant_tag>::attributes::type_list
     257                        >::type member_attrib_type_list;
     258
     259                        /** The count of virtually inherited attributes
     260                         */
     261                        typedef typename mpl::accumulate<
     262                                typename mpl::transform<
     263                                        virtual_base_class_layout,
     264                                        get_base_class_attrib_type_list<
     265                                                mpl::_1
     266                                        >
     267                                >::type,
     268                                mpl::int_<0>,
     269                                mpl::plus<
     270                                        mpl::_1,
     271                                        mpl::size< mpl::_2 >
     272                                >
     273                        >::type virtual_attrib_count;
     274               
     275
     276                        /** Is a true type if the I-th member attribute is
     277                         *  virtually inherited.
     278                         */
     279                        template <int I>
     280                        struct is_virtually_inherited
     281                        : mpl::less<
     282                                mpl::int_<I>,
     283                                virtual_attrib_count
     284                        >::type { };
     285               
     286                        /** This template is used to query the return value
     287                         *  type of the getter for the I-th member attribute
     288                         */
     289                        template <int I>
     290                        struct result_of_get
     291                        {
     292                                typedef typename mpl::at<
     293                                                member_attrib_type_list,
     294                                                mpl::int_<I>
     295                                        >::type type;
     296                        };             
     297       
     298                        /** This function is used to get the members of virtual
     299                         *  base classes.
     300                         */
     301                        template <class a_class, int I>
     302                        static typename result_of_get<I>::type
     303                        get(a_class context, mpl::int_<I> pos, mpl::bool_<true>)
     304                        {
     305                                typedef meta_class<a_class, variant_tag> meta_class;
     306                               
     307                                return meta_class::attributes::get(context, pos);
     308                        }
     309               
     310                        /** This function is used to get the members of regular
     311                         *  base classes.
     312                         */
     313                        template <class a_class, int I>
     314                        static typename result_of_get<I>::type
     315                        get(a_class context, mpl::int_<I> pos, mpl::bool_<false>)
     316                        {
     317                                typedef meta_class<a_class, variant_tag> meta_class;
     318
     319                                return meta_class::attributes::get(context, pos);
     320
     321                        }
    151322                }; // struct detail
    152323               
     324                /** The list of inherited attribute types
     325                 */
     326                typedef typename detail::inherited_member_attrib_type_list inherited_type_list;
     327
     328                /** The size of the type_list, i.e. the count of inherited attributes
     329                 */
     330                struct inherited_size : public mpl::size<inherited_type_list> { };
     331
    153332                /** The list of types of all attributes including
    154333                 *  the inherited ones.
    155334                 */
    156                 typedef typename mpl::joint_view<
    157                         typename detail::inherited_attrib_type_list,
    158                         typename meta_class<reflected_class, variant_tag>::attributes::type_list
    159                 >::type type_list;
     335                typedef typename detail::member_attrib_type_list type_list;
    160336               
    161337                /** The size of the type_list, i.e. the count of all attributes
    162338                 */
    163339                struct size : public mpl::size<type_list> { };
    164         };
     340               
     341                /**
     342                template <class a_class, int I>
     343                static typename detail::result_of_get<I>::type
     344                get(a_class context, mpl::int_<I> pos)
     345                {
     346                        // is the attrib virtually inherited
     347                        typedef typename detail::
     348                                is_virtually_inherited<I> is_virtual;           
     349                        //
     350                        // the index of the attribute
     351                        typedef typename mpl::if<
     352                                        is_virtual,
     353                                        pos,
     354                                        mpl::minus<
     355                                                pos
     356                                        >
     357                                >::type att_pos;
     358                        //
     359                        return detail::get(
     360                                context,
     361                                att_pos,
     362                                is_virtual
     363                        );
     364                }
     365                 */
     366        }; // all_attrbutes
    165367
    166368};
  • sandbox/mirror/boost/mirror/meta_inheritance.hpp

    r44548 r44690  
    119119template <
    120120        class the_base_class,
    121         typename access_spec = class_kind_default_access<
    122                 meta_class_kind<the_base_class>::result
    123         >::specifier,
     121        typename access_spec,
    124122        typename inheritance_spec = nonvirtual_base_
    125123>
     
    159157 */
    160158#define BOOST_MIRROR_REG_BASE_CLASS_SIMPLE(NUMBER, A_BASE_CLASS) \
    161         BOOST_PP_COMMA_IF(NUMBER) meta_inheritance<A_BASE_CLASS>
     159        BOOST_PP_COMMA_IF(NUMBER) \
     160        meta_inheritance<\
     161                A_BASE_CLASS, \
     162                class_kind_default_access<\
     163                        meta_class_kind< A_BASE_CLASS >::result \
     164                >::specifier \
     165        >
    162166
    163167/** This macro declares that the A_BASE_CLASS class is the i-th
  • sandbox/mirror/boost/mirror/meta_namespace.hpp

    r44508 r44690  
    4040};
    4141
     42
    4243/** Helper macro for registering new general namespaces (top level or nested)
    4344 */
    44 #define BOOST_MIRROR_REG_META_NAMESPACE_HELPER(PARENT_NS_ALIAS, PREFIX, NAMESPACE_NAME) \
    45 namespace namespaces {struct PREFIX##_##NAMESPACE_NAME { }; }\
    46 template<> struct meta_namespace< namespaces :: PREFIX##_##NAMESPACE_NAME >      \
     45#define BOOST_MIRROR_REG_META_NAMESPACE_HELPER(PARENT_NS_ALIAS, NAMESPACE_NAME) \
    4746{                                                                                         \
    4847        typedef meta_namespace< namespaces :: PARENT_NS_ALIAS > parent;                                                        \
    49         typedef mpl::push_back<typedef parent::scope, parent>::type scope;    \
     48        typedef mpl::push_back<parent::scope, parent>::type scope;    \
    5049        static const bchar*   base_name  (void) {return BOOST_STR_LIT(#NAMESPACE_NAME);}           \
    5150};                                                                                        \
     
    5554 */
    5655#define BOOST_MIRROR_REG_META_NAMESPACE(PARENT_NS_ALIAS, NAMESPACE_NAME) \
    57         BOOST_MIRROR_REG_META_NAMESPACE_HELPER(PARENT_NS_ALIAS, PARENT_NS_ALIAS, NAMESPACE_NAME)
     56        namespace namespaces {struct PARENT_NS_ALIAS##_##NAMESPACE_NAME { }; }\
     57        template<> struct meta_namespace< namespaces :: PARENT_NS_ALIAS##_##NAMESPACE_NAME >      \
     58        BOOST_MIRROR_REG_META_NAMESPACE_HELPER(PARENT_NS_ALIAS, NAMESPACE_NAME)
    5859
    5960/** Macro for registering of top-level namespaces
    6061 */
    6162#define BOOST_MIRROR_REG_META_NAMESPACE_TOP_LEVEL(NAMESPACE_NAME)    \
    62         BOOST_MIRROR_REG_META_NAMESPACE_HELPER(\
    63                 _, \
    64                 BOOST_PP_EMPTY(), \
    65                 NAMESPACE_NAME \
    66         )
     63        namespace namespaces {struct _##NAMESPACE_NAME { }; }\
     64        template<> struct meta_namespace< namespaces :: _##NAMESPACE_NAME >      \
     65        BOOST_MIRROR_REG_META_NAMESPACE_HELPER(_, NAMESPACE_NAME)
    6766
    6867// Registration of the ::std namespace
  • sandbox/mirror/boost/mirror/utils/name_to_stream/namespace.hpp

    r44494 r44690  
    4141        static out_stream& put(out_stream& s, bool ldng_dbl_cln)
    4242        {
     43                typedef typename meta_ns::parent parent_ns;
    4344                // let the printer print out the  base name of the parent namespace
    44                 name_to_stream<meta_ns::parent>::put(s, ldng_dbl_cln);
     45                name_to_stream<parent_ns>::put(s, ldng_dbl_cln);
    4546                // if the parent is not the global scope
    46                 if(!reflects_global_scope<meta_ns::parent>::value)
     47                if(!reflects_global_scope<parent_ns>::value)
    4748                        s << BOOST_STR_LIT("::");
    4849                // let the printer print out the  base name of the parent namespace
  • sandbox/mirror/boost/mirror/utils/name_to_stream/type.hpp

    r44508 r44690  
    2828        {
    2929                if(!reflects_global_scope<typename meta_type<base_type>::scope>::value)
    30                         name_to_stream<meta_type<base_type>::scope>::put(s, ldng_dbl_cln) << BOOST_STR_LIT("::");
     30                        name_to_stream<
     31                                typename meta_type<base_type>::scope
     32                        >::put(s, ldng_dbl_cln) << BOOST_STR_LIT("::");
    3133                else if(ldng_dbl_cln) s << BOOST_STR_LIT("::");
    3234                return s << meta_type<base_type>::base_name();
     
    4648};
    4749
    48 /** Specialization for meta-types for arrays
     50/** Specialization for meta-types for non-cv element arrays
     51 */
     52template <typename element_type, size_t size>
     53struct name_to_stream_helper<meta_type<element_type[size]> >
     54{
     55        template <class out_stream>
     56        static out_stream& put(out_stream& s, bool ldng_dbl_cln)
     57        {
     58                return name_to_stream_helper<meta_type<element_type> >::put(s,ldng_dbl_cln) <<
     59                        BOOST_STR_LIT("[") <<
     60                        size <<
     61                        BOOST_STR_LIT("]");
     62        }
     63};
     64
     65/** Specialization for meta-types for const element arrays
    4966 */
    5067template <typename element_type, size_t size>
     
    5471        static out_stream& put(out_stream& s, bool ldng_dbl_cln)
    5572        {
     73               
    5674                s << BOOST_STR_LIT("const ");
    57                 return name_to_stream_helper<meta_type<element_type> >::put(s,ldng_dbl_cln) <<
    58                         BOOST_STR_LIT("[") <<
    59                         size <<
    60                         BOOST_STR_LIT("]");
     75                return name_to_stream_helper<
     76                        meta_type<element_type[size]>
     77                >::put(s, ldng_dbl_cln);
    6178        }
    6279};
  • sandbox/mirror/libs/examples/registering/classes.cpp

    r44548 r44690  
    185185 *  a stream.
    186186 */
    187 template <class meta_object>
     187template <class a_meta_object>
    188188struct pretty_printer
    189189{
    190         typedef meta_object meta_object;
     190        typedef a_meta_object meta_object;
    191191        //
    192192        // prints some info about the meta-object t
     
    196196        {
    197197                typedef pretty_printer<meta_object> prn_type;
    198                 typedef prn_type::meta_object meta_object;
     198                typedef typename prn_type::meta_object meta_object;
    199199                //
    200200                using namespace ::std;
     
    211211                s << name_to_stream<meta_object>() << "' " << endl;
    212212                //
     213                //
     214                typedef typename meta_object::scope meta_scope;
    213215                // print info about the scope where the meta-object
    214216                // is defined
    215217                s << "is defined ";
    216218                // if the scope is the global scope
    217                 if(reflects_global_scope<meta_object::scope>::value)
     219                if(reflects_global_scope<meta_scope>::value)
    218220                        s << "on the global scope";
    219221                // if it's a class
    220                 else if(reflects_class<meta_object::scope>::value)
    221                         s << "inside of the '" << name_to_stream<meta_object::scope>() << "' class";
     222                else if(reflects_class<meta_scope>::value)
     223                        s << "inside of the '" << name_to_stream<meta_scope>() << "' class";
    222224                // otherwise
    223                 else s << "in the '" << name_to_stream<meta_object::scope>() << "' namespace";
     225                else s << "in the '" << name_to_stream<meta_scope>() << "' namespace";
    224226                s << "."  << endl;
    225227                //
     
    253255                        // of the base class
    254256                        using namespace ::std;
    255                         s << endl << " - " <<
    256                                 name_to_stream<BOOST_MIRROR_REFLECT_CLASS(meta_inheritance::base_class)>();
     257                        typedef typename meta_inheritance::meta_class meta_class;
     258                        s << endl << " - " << name_to_stream<meta_class>();
    257259                }
    258260        };
     
    266268                // print out the count of (registered) base classes that
    267269                // the inspected class has
     270                //
     271                typedef typename meta_object::base_classes::list base_class_list;
     272                //
    268273                s << "It has ";
    269                 if(mpl::size<meta_object::base_classes::list>::value == 1)
     274                if(mpl::size<base_class_list>::value == 1)
    270275                        s << "this one base class:";
    271                 else if(mpl::size<meta_object::base_classes::list>::value > 1)
    272                         s << "these " << mpl::size<meta_object::base_classes::list>::value << " base classes:";
     276                else if(mpl::size<base_class_list>::value > 1)
     277                        s << "these " << mpl::size<base_class_list>::value << " base classes:";
    273278                else s << "no base classes.";
    274279                //
    275280                // execute the printer on the list of base classes
    276                 mpl::for_each<meta_object::base_classes::list>(base_class_printer<out_stream>(s));
     281                mpl::for_each<base_class_list>(base_class_printer<out_stream>(s));
    277282                //
    278283                return s << endl;
     
    324329                //
    325330                // print the number of the registered attributes
     331                //
     332                typedef typename meta_object::attributes::type_list attrib_type_list;
     333                //
    326334                s << "It has ";
    327                 if(mpl::size<meta_object::attributes::type_list>::value == 1)
     335                if(mpl::size<attrib_type_list>::value == 1)
    328336                        s << "this one member attribute:";
    329                 else if(mpl::size<meta_object::attributes::type_list>::value > 1)
    330                         s << "these " << mpl::size<meta_object::attributes::type_list>::value << " member attributes:";
     337                else if(mpl::size<attrib_type_list>::value > 1)
     338                        s << "these " << mpl::size<attrib_type_list>::value << " member attributes:";
    331339                else s << "no member attributes.";
    332340                //
  • sandbox/mirror/libs/examples/registering/virtual_bases.cpp

    r44548 r44690  
    2222#include <boost/mpl/at.hpp>
    2323
     24#include <boost/static_assert.hpp>
     25
    2426#include <boost/char_type_switch/iostream.hpp>
    2527
     
    6062                float f;
    6163        };
     64
     65        struct F : virtual E
     66        {
     67                bool b;
     68        };
     69
     70        struct G : virtual E
     71        {
     72                char c;
     73        };
     74
     75        struct H : F, G
     76        {
     77                wchar_t w;
     78        };
     79
    6280
    6381} // namespace Test
     
    7997BOOST_MIRROR_REG_META_TYPE(_Test, ::Test, D)
    8098BOOST_MIRROR_REG_META_TYPE(_Test, ::Test, E)
     99BOOST_MIRROR_REG_META_TYPE(_Test, ::Test, F)
     100BOOST_MIRROR_REG_META_TYPE(_Test, ::Test, G)
     101BOOST_MIRROR_REG_META_TYPE(_Test, ::Test, H)
    81102
    82103
     
    99120BOOST_MIRROR_REG_BASE_CLASSES_END
    100121
     122BOOST_MIRROR_REG_BASE_CLASSES_BEGIN(::Test::F)
     123BOOST_MIRROR_REG_BASE_CLASS_VIRTUAL(0,  public, ::Test::E)
     124BOOST_MIRROR_REG_BASE_CLASSES_END
     125
     126BOOST_MIRROR_REG_BASE_CLASSES_BEGIN(::Test::G)
     127BOOST_MIRROR_REG_BASE_CLASS_VIRTUAL(0,  public, ::Test::E)
     128BOOST_MIRROR_REG_BASE_CLASSES_END
     129
     130BOOST_MIRROR_REG_BASE_CLASSES_BEGIN(::Test::H)
     131BOOST_MIRROR_REG_BASE_CLASS_SIMPLE(0,  ::Test::F)
     132BOOST_MIRROR_REG_BASE_CLASS_SIMPLE(1,  ::Test::G)
     133BOOST_MIRROR_REG_BASE_CLASSES_END
     134
    101135
    102136/** Class attributes
     
    122156BOOST_MIRROR_REG_CLASS_ATTRIBS_END
    123157
     158BOOST_MIRROR_REG_CLASS_ATTRIBS_BEGIN(::Test::F)
     159        BOOST_MIRROR_REG_CLASS_ATTRIB(0, bool, b)
     160BOOST_MIRROR_REG_CLASS_ATTRIBS_END
     161
     162BOOST_MIRROR_REG_CLASS_ATTRIBS_BEGIN(::Test::G)
     163        BOOST_MIRROR_REG_CLASS_ATTRIB(0, char, c)
     164BOOST_MIRROR_REG_CLASS_ATTRIBS_END
     165
     166BOOST_MIRROR_REG_CLASS_ATTRIBS_BEGIN(::Test::H)
     167        BOOST_MIRROR_REG_CLASS_ATTRIB(0, wchar_t, w)
     168BOOST_MIRROR_REG_CLASS_ATTRIBS_END
     169
    124170
    125171
    126172} // namespace mirror
    127173} // namespace boost
     174
    128175
    129176int main(void)
     
    135182        using namespace ::Test;
    136183        //
    137         typedef BOOST_MIRROR_REFLECT_CLASS(::Test::E) meta_E;
    138         //
    139         bcout << sizeof(E().l) << endl;
    140         //
    141         bcout << "The class ::Test::E has " << endl;
    142         //
    143         bcout << meta_E::base_classes::size::value << " base classes" << endl;
    144         bcout << meta_E::attributes::size::value << " own member attribs" << endl;
    145         // NOTE: this isn't working as expected yet
    146         bcout << meta_E::all_attributes::size::value << " member attribs" << endl;
    147         //
    148         //
    149         bcout << "Finished" << endl;
     184        typedef ::Test::H T;
     185        //
     186        typedef BOOST_MIRROR_REFLECT_CLASS(T) meta_T;
     187        //
     188        // Print some basic info about the reflected class
     189        //
     190        bcout << "The reflected class has " << endl;
     191        //
     192        bcout << meta_T::base_classes::size::value << " base class(es)" << endl;
     193        bcout << meta_T::attributes::size::value << " own member attrib(s)" << endl;
     194        bcout << meta_T::all_attributes::inherited_size::value << " inherited member attrib(s)" << endl;
     195        bcout << meta_T::all_attributes::size::value << " member attrib(s)" << endl;
     196        //
     197        // The attrbs of H are reflected in the following order
     198        // A::l (long)
     199        // B::i (int)
     200        // C::d (double)
     201        // D::s (short)
     202        // E::f (float)
     203        // F::b (bool)
     204        // G::c (char)
     205        // H::w (wchar_t)
     206        //
     207        BOOST_STATIC_ASSERT((is_same<
     208                mpl::at<meta_T::all_attributes::type_list, mpl::int_<0> >::type,
     209                BOOST_TYPEOF(T().l)
     210        >::value));
     211        BOOST_STATIC_ASSERT((is_same<
     212                mpl::at<meta_T::all_attributes::type_list, mpl::int_<1> >::type,
     213                BOOST_TYPEOF(T().i)
     214        >::value));
     215        BOOST_STATIC_ASSERT((is_same<
     216                mpl::at<meta_T::all_attributes::type_list, mpl::int_<2> >::type,
     217                BOOST_TYPEOF(T().d)
     218        >::value));
     219        BOOST_STATIC_ASSERT((is_same<
     220                mpl::at<meta_T::all_attributes::type_list, mpl::int_<3> >::type,
     221                BOOST_TYPEOF(T().s)
     222        >::value));
     223        BOOST_STATIC_ASSERT((is_same<
     224                mpl::at<meta_T::all_attributes::type_list, mpl::int_<4> >::type,
     225                BOOST_TYPEOF(T().f)
     226        >::value));
     227        BOOST_STATIC_ASSERT((is_same<
     228                mpl::at<meta_T::all_attributes::type_list, mpl::int_<5> >::type,
     229                BOOST_TYPEOF(T().b)
     230        >::value));
     231        BOOST_STATIC_ASSERT((is_same<
     232                mpl::at<meta_T::all_attributes::type_list, mpl::int_<6> >::type,
     233                BOOST_TYPEOF(T().c)
     234        >::value));
     235        BOOST_STATIC_ASSERT((is_same<
     236                mpl::at<meta_T::all_attributes::type_list, mpl::int_<7> >::type,
     237                BOOST_TYPEOF(T().w)
     238        >::value));
     239        //
     240        BOOST_STATIC_ASSERT((is_same<
     241                mpl::at<meta_T::attributes::type_list, mpl::int_<0> >::type,
     242                BOOST_TYPEOF(T().w)
     243        >::value));
     244        //
     245        //
     246        //
     247        T t;
     248        // init the members of t
     249        t.l = 123L;
     250        t.i = 234;
     251        t.d = 345.6;
     252        t.s = 567;
     253        t.f = 678.9f;
     254        t.b = true;
     255        t.c = '9';
     256        t.w = L'0';
     257        //
     258        //
     259        bcout << "--------------------------------------------" << endl;
     260        //
     261        bcout << meta_T::all_attributes::detail::is_virtually_inherited<4>::value << endl;
     262        bcout << meta_T::all_attributes::detail::is_virtually_inherited<5>::value << endl;
    150263        //
    151264        return 0;
  • sandbox/mirror/libs/examples/serialization/cube.cpp

    r44548 r44690  
    3636
    3737        // coordinates
    38         template <typename float_type>
     38        template <typename a_float_type>
    3939        class CoordsTempl
    4040        {
    4141        public:
    42                 typedef float_type float_type;
     42                typedef a_float_type float_type;
    4343                CoordsTempl(
    4444                        float_type _x = 0.0,
     
    156156        bcout << meta_Vector::base_classes::size::value << endl;
    157157        bcout << meta_Vector::attributes::size::value << endl;
    158         bcout << meta_Vector::all_attributes::size::value << endl;
     158        //bcout << meta_Vector::all_attributes::size::value << endl;
    159159        //
    160160        //
Note: See TracChangeset for help on using the changeset viewer.