Re: [Boost-users] [Q] opinion on basic C++ reflection implementation

Subject: Re: [Boost-users] [Q] opinion on basic C++ reflection implementation
From: Jens Weller (JensWeller_at_[hidden])
Date: 2009-03-01 16:44:10

I'm thinking right now about such a thing too.
I decided to use soci, as it is a really good SQL Lib for C++:
soci.sourceforge.net

My current approach is from the DB side, I'm writing a programm which generates classes from CREATE TABLE statements.
I think by next weekend I got a prototype ready.

regards,

Jens Weller

-------- Original-Nachricht --------
> Datum: Sat, 28 Feb 2009 11:21:50 -0500
> Von: "V S P" <toreason_at_[hidden]>
> An: boost-users_at_[hidden]
> Betreff: [Boost-users] [Q] opinion on basic C++ reflection implementation

> Hello to be make it easy to read a table from a database
> and save the result with boost serialization (and to write back back to
> the database)
> 
> I have devised a scheme to achieve C++ reflections
> that allows me to  set a field value and get a field
> value using a string data member name.
> 
> I am using the fact that in C++ functions can take
> a reference to a class instance and operate on the
> class data members, where the functions have
> hardcoded the datamember names.
> Since those functions can be declared as static,
> I simply remember the pointer to my getters and setters
> in static maps associated with every class instance
> 
> So when a class instance gets created -- it updates
> the static maps of getters and setters.
> I do not like the fact that I have to use a mutex on the
> function maps.
> 
> ANd in general wanted to ask if such approach has been implemented
> in one of the boost libraries or if not ... why not
> 
> I am attaching a 'brief' of the mechanism.  Thank you in advance
> for any feedback.
> 
> Vlad
> -------------------------------------------------------------
> 
> 
> struct tField
> {
>   string name;
>   //other DB-related attributes
>   //order of declaration, isnullable, otltype
> }
> 
> 
> struct reflectable
> {
>    
>    
>    //returns a string name of the field
>    char* (*tF_get_field_name)(void),
>    
>    //assign a value to the field. The value is obtained from functor
>    //that's why we call it 'set'
>    typedef void (*tFset__field)(reflecatble& , CFFunctorAssignVal&)  ;
>    
>    //send the field value (const) to somewhere
>    //that's why we call it 'get'
>    typedef void (*tFget__field)(const reflectable&,CFFunctorReceiveVal&)
>     ;
>    
>    
>    
>    typedef map<string,tField> tName2Fields;
>    typedef map<string,tFset__field> tMFset__field;
>    typedef map<string,tFget__field> tMFget__field;
>    //derived classes must have the "static" version of the maps
>    //we inforce it by declaring abstract functions here 
>    //also each class will have to provide a static function
>    //that gets returns a pointer to each map
>    
> };
> 
> tempate <
> typename T, //cpp type
> tF_get_field_name fname,  //function ptr to get name
> tFset__field assing_functor, //functor pointer to assing val to field
> tFget__field get_functor, //functor to read val from field
> 
> tName2Fields* ptrFieldMap,
> tMFset__field* ptrSetterMap,
> tFget__field* ptrGetterMap
>  
> struct rffield
> {
>   //register a field name (obtained from fname()
>   //with ptrFieldMap
>   
>   //register pointer to getter with ptrGetterMap
>   //register pointer to setter with ptrSetMap
> 
> }
> 
> ---- separate header -----------------
> 
> struct myclass: public reflecatble
> {
>   static allTheMaps...;
> 
>   //to simplify I have a macro that takes in field name, cpp type
>   //and declares them and generates getter and setter functions
>   //that accept functors
>   
>   static void field1__getter ( const reflectable&th,CFFunctorReceiveVal&
>   f) 
>    {
>       f(th.field1);                                                
>    }
>   static void field1__setter ( const reflectable& th,CFFunctorAssignVal&
>   f)
>    {
>       f(th.field1);                                                
>    }
> 
>   static const char* field1__name (void)
>   {
>     const char* res="field1";
>     return res;
>   }
>   
>    //single declration causes all the registration to take place
>    //since I am passing parameteres to rffield constructor
>    //via template.  It is almost like ability to invoke constructor
>     // right in a header file.
>    rffield<int, all the static map pointers, funct pointers> field1;
> 
> 
> }
> 
> ------------ cpp for my class has the static maps -- -----------
> -- 
>   V S P
>   toreason_at_[hidden]
> 
> -- 
> http://www.fastmail.fm - Faster than the air-speed velocity of an
>                           unladen european swallow
> 
> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]
> http://lists.boost.org/mailman/listinfo.cgi/boost-users

-- 
Psssst! Schon vom neuen GMX MultiMessenger gehört? Der kann`s mit allen: http://www.gmx.net/de/go/multimessenger01