Library Proposal: Reflection for C++

29 Jan 2006

      Hi,

We would like to propose a library and tools which enhance C++ with  
reflection capabilities. The package, "Reflex", provides a library  
for runtime introspection and interaction with C++ "constructs" such  
as objects, types, scopes, members, templated types, ... The library  
has no external dependencies and was developed with the ISO/IEC  
standard for C++ as guideline.

Production of dictionary information of arbitrary C++ definitions is  
done via a Python script (genreflex), in a non-intrusive way, using  
an external tool (gccxml - www.gccxml.org). The generated dictionary  
source code can be compiled into a shared library, dynamically loaded  
and accessed via an API providing the introspection information.

You can find more information at

http://cern.ch/reflex

Below you may find an example code snippet which exposes a subset of  
the functionality. The four different parts show
1 - the definition of the example classes
2 - how to generate the dictionary information
3 - example on introspection (re-generate classes from the dictionary  
information)
4 - examples on interaction (get/set data members, invoke functions,  
con/destruct objects)

Cheers

     Stefan

//
// 1. original class Foo.h
//

namespace zot {

   struct foo_base {
   public:
     foo_base() : fBar(4711) {}
     ~foo_base() {}
   protected:
     int fBar;
   };

   class foo : public foo_base {
   public:
     int bar();
     void set_bar(int i);
     void set_bar(float f);
     void operator ++ ();
   };

   inline int foo::bar()             { return fBar; }
   inline void foo::set_bar(float f) { fBar = int(f); }
   inline void foo::set_bar(int i)   { fBar = i; }
   inline void foo::operator ++ ()   { ++fBar; }

} // namespace zot

//
// 2. Run python script on Foo.h generating dictionary source code
//    (Foo_rflx.cpp) and produce a shared library libFooRflx.so
//

genreflex Foo.h --gccxmlpath=/dir/to/gccxml/bin
(e.g.) g++ -shared -o libFooRflx.so Foo_rflx.cpp -I${REFLEXROOT}/ 
include -L${REFLEXROOT}/lib -lReflex

//
// 3. + 4. example code for introspection and interaction
//

#include "Reflex/Reflex.h"

using namespace std;
using namespace ROOT::Reflex;
enum Visibility { Public, Protected, Private };

void generate_class_decl( const Type & cl,
                           const string & indent ) {

   // ... base class declarations
   if ( cl.BaseSize()) {
     for ( Base_Iterator b = cl.Base_Begin(); b != cl.Base_End(); ++b)
       generate_class_decl((*b).ToType(), indent);
   }

   cout << indent << "class " << cl.Name();

   // ... bases
   if ( cl.BaseSize()) {

     cout << " : " ;

     for ( Base_Iterator b = cl.Base_Begin(); b != cl.Base_End(); + 
+b ) {

       if ( (*b).IsVirtual() )   cout << "virtual ";
       if ( (*b).IsPublic() )    cout << "public ";
       if ( (*b).IsProtected() ) cout << "protected ";
       if ( (*b).IsPrivate() )   cout << "private ";

       cout << (*b).ToType().Name(SCOPED);

       if ( b != cl.Base_End()-1 ) cout << ", ";
     }
   }

   cout << " {" << endl;

   Visibility vis = Private;

   // ... function members
   for ( Member_Iterator f = cl.FunctionMember_Begin(); f !=  
cl.FunctionMember_End(); ++f ) {

     if ( ! (*f).IsArtificial()) {

       if ( (*f).IsPublic() && vis != Public ) {
         cout << indent << "public:" << endl;
         vis = Public;
       }
       else if ( (*f).IsProtected() && vis != Protected ) {
         cout << indent << "protected:" << endl;
         vis = Protected;
       }
       else if ( (*f).IsPrivate()   && vis != Private ) {
         cout << indent << "private:" << endl;
         vis = Private;
       }

       Type ft = (*f).TypeOf();

       cout << indent + "  ";

       if ( ! (*f).IsConstructor() && !(*f).IsDestructor() )
         cout << ft.ReturnType().Name(SCOPED) << " ";

       if (  (*f).IsOperator() ) cout << "operator ";
       cout << (*f).Name() << " (";

       if ( ft.FunctionParameterSize() ) {
         for ( size_t p = 0 ; p < ft.FunctionParameterSize(); p++ ) {
           cout << ft.FunctionParameterAt(p).Name(SCOPED|QUALIFIED);

           if ( (*f).FunctionParameterNameAt(p).length() )
             cout << " " << (*f).FunctionParameterNameAt(p);

           if ( (*f).FunctionParameterDefaultAt(p).length() )
             cout << " = " << (*f).FunctionParameterDefaultAt(p);

           if ( p != ft.FunctionParameterSize()-1 ) cout << ", ";
         }
       }
       cout << ");" << endl;
     }
   }

   // ... data members
   for ( Member_Iterator d = cl.DataMember_Begin(); d !=  
cl.DataMember_End(); ++d ) {

     if ( (*d).IsPublic() && vis != Public ) {
       cout << indent << "public:" << endl;
       vis = Public;
     }
     else if ( (*d).IsProtected() && vis != Protected ) {
       cout << indent << "protected:" << endl;
       vis = Protected;
     }
     else if ( (*d).IsPrivate()   && vis != Private ) {
       cout << indent << "private:" << endl;
       vis = Private;
     }
     cout << indent + "  " << (*d).TypeOf().Name(SCOPED)
          << " " << (*d).Name() << ";"  << endl;
   }
   cout << indent << "};" << endl;
}

void generate_class(const Type & ty) {

   string indent = "";
   Scope sc = ty.DeclaringScope();

   // ... declaring scope
   if ( ! sc.IsTopScope() ) {
     if (sc.IsNamespace())  cout << "namespace ";
     else if (sc.IsClass()) cout << "class ";

     cout << sc.Name() << " {" << endl;
     indent += "  ";
   }

   generate_class_decl(ty, indent);

   if ( ! sc.IsTopScope() ) {
     cout << "}" << endl;
     if (sc.IsClass()) cout << ";";
   }
}

int main() {

   // load the dictionary information
   void * v = dlopen("libFooRflx.so", RTLD_LAZY);

   // get meta information of type Foo
   Type fooType = Type::ByName("zot::foo");

   // check if the type is valid
   if (fooType) {

     //
     // 3. Introspection
     //

     // generate declarations for foo
     generate_class(fooType);

     //
     // 4. Interaction
     //

     // update the information for inherited members of class foo
     // this will be automatic in the future
     fooType.UpdateMembers();

     // construct an object of type Foo
     Object fooObj = fooType.Construct();

     // get the value of the data member (i.e. 4711)
     int val = Object_Cast<int>(fooObj.Get("fBar"));

     // set the data member to 4712
     fooObj.Set("fBar",++val);
     // get the data member again (i.e. 4712)
     val = Object_Cast<int>(fooObj.Get("fBar"));

     // call function setBar with value 4713
     fooObj.Invoke("set_bar",Type::ByName("void (int)"), ++val);
     // call operator ++ to increase fBar by one
     fooObj.Invoke("operator++");
     // call bar getter and cast the output to int (i.e. 4714)
     val = Object_Cast<int>(fooObj.Invoke("bar"));

     // delete the Foo object
     fooObj.Destruct();
   }

   return 0;

}

/*
//
// the output of the introspection part is
//

namespace zot {
   class foo_base {
   public:
     foo_base ();
     ~foo_base ();
   protected:
     int fBar;
   };
   class foo : public zot::foo_base {
   public:
     int bar ();
     void set_bar (int i);
     void set_bar (float f);
     void operator operator++ ();
   };
}

//
//
//
*/

-- 
Stefan Roiser
CERN, PH Department
CH - 1211 Geneva 23
Mob:+41 76 487 5334
Tel:+41 22 767 4838
Fax:+41 22 767 9425

Stefan Roiser

Edward Diener

Stefan Roiser

Edward Diener

Stefan Roiser

Edward Diener

David Abrahams

Stefan Roiser

pongba

Stefan Roiser

Stefan Seefeld

Stefan Roiser

Stefan Seefeld

Stefan Roiser

Stefan Seefeld

Stefan Roiser

pongba

Stefan Roiser

David Abrahams

Stefan Roiser

Ion Gaztañaga

Stefan Roiser

David Abrahams

Edward Diener

David Abrahams

Edward Diener

Stefan Roiser

Edward Diener

David Abrahams

Sebastian Redl

Stefan Seefeld

Sebastian Redl

Stefan Seefeld

David Abrahams

Sebastian Redl

Stefan Seefeld

Edward Diener

Stefan Seefeld

Stefan Roiser

David Abrahams

Sebastian Redl

David Abrahams

Edward Diener

Sebastian Redl

Edward Diener

Stefan Roiser

Edward Diener

tags

participants (7)