Re: serialization

On 08/11/09 21:09, Joshua Maurice wrote:


Absolutely true.


In the company where I work we use a perl script to generate reflection
from annotated C++ header files. You may be pleased to know that the
main feature of the generated files is reflect() function template to
iterate over the base sub-objects and members of an object.

Here is what an annotated header looks like:

   struct /* @reflect_class */ A
   {
       int /* @reflect_member */ abc;
       double /* @reflect_member */ def;
   };

   struct /* @reflect_class */ B
       : /* @reflect_base */ A
   {
       A /* @reflect_member */ aaa;
   };

For every reflectable class it generates the following:

And here is what generated reflection looks like:

   #ifdef REFLECT_NAMESPACE_BEGIN
   REFLECT_NAMESPACE_BEGIN
   #endif

   // start of generated code for class A

   meta::Yes isReflectable(A const&);

The above function declaration (no implementation) allows for
IsReflectable<T> trait class which is used to tell reflectable classes
from non-reflectable at compile time (similar to boost type traits).

   template<class T> struct BaseIndexOf;
   template<> struct BaseIndexOf<A>
   {
       enum Type {
             ENUM_NIL = -1
           , ENUM_END
           , ENUM_BEGIN = 0
       };
   };

   template<class T> struct MemberIndexOf;
   template<> struct MemberIndexOf<A>
   {
       enum Type {
             ENUM_NIL = -1
           , abc
           , def
           , ENUM_END
           , ENUM_BEGIN = 0
       };
   };

Index of reflectable base classes and members accessible as
MemberIndexOf<A>::<member_name>. The enumeration is organized in such a
way that makes it easy to iterate over all members or base classes using
range [ENUM_BEGIN, ENUM_END).

   template<class Functor>
   void reflect(A& object, Functor& f)
   {
       f.onObjectBegin(object);
       f.onMember(object, object.abc, MemberIndexOf<A>::abc);
       f.onMember(object, object.def, MemberIndexOf<A>::def);
       f.onObjectEnd(object);
   }

   template<class Functor>
   bool reflect(A& object, Functor& f, MemberIndexOf<A>::Type member_index)
   {
       switch(member_index) {
       case 0: f.onMember(object, object.abc, MemberIndexOf<A>::abc);
return true;
       case 1: f.onMember(object, object.def, MemberIndexOf<A>::def);
return true;
       default: return false;
       }
   }

These are the fundamental reflect function templates which iterate over
all or particular members. This function templates accept a functor that
gets invoked for members (onMember() call), base sub-objects
(onBaseSubobject() call, see reflect for B below), and object begin/end
so that the functor can handle object nesting.

The functor passed in reflect() does the actual job of
serializing/deserializing object. The simple beauty of this approach is
that there is only one functor class for every particular serialization
format. This functor handles any reflectable classes using the rest of
generated C++ code.

   inline Sref toId(Type<A>)
   {
       return Sref("A", 1);
   }

   inline Sref toId(BaseIndexOf<A>::Type base_index)
   {
       switch(base_index) {
       default: return Sref();
       }
   }

   inline Sref toId(MemberIndexOf<A>::Type member_index)
   {
       switch(member_index) {
       case MemberIndexOf<A>::abc: return Sref("abc", 3);
       case MemberIndexOf<A>::def: return Sref("def", 3);
       default: return Sref();
       }
   }

This are the functions to get base class and member identifiers using
the generated indexes. A functor uses the base/member index (passed by
reflect() in its onBaseSubobject/onMember callback) to get any meta
information associated with that particular base/member. It relies on
the fact that indexes (enums) are stongly typed so that function
overloading picks up the correct function overload for a particular
index type).

On practice, we use more annotation to associate more meta information
with members. And we generate annotation for enums.

   // end of generated code for class A

   // start of generated code for class B

   meta::Yes isReflectable(B const&);

   template<class T> struct BaseIndexOf;
   template<> struct BaseIndexOf<B>
   {
       enum Type {
             ENUM_NIL = -1
           , A
           , ENUM_END
           , ENUM_BEGIN = 0
       };
   };

Here class B has a reflectable base class A.

   template<class T> struct MemberIndexOf;
   template<> struct MemberIndexOf<B>
   {
       enum Type {
             ENUM_NIL = -1
           , aaa
           , ENUM_END
           , ENUM_BEGIN = 0
       };
   };

And a reflectable member aaa.

   template<class Functor>
   void reflect(B& object, Functor& f)
   {
       f.onObjectBegin(object);
       f.onBaseSubobject(static_cast<A&>(object), BaseIndexOf<B>::A);
       f.onMember(object, object.aaa, MemberIndexOf<B>::aaa);
       f.onObjectEnd(object);
   }

   template<class Functor>
   bool reflect(B& object, Functor& f, MemberIndexOf<B>::Type member_index)
   {
       switch(member_index) {
       case 0: f.onMember(object, object.aaa, MemberIndexOf<B>::aaa);
return true;
       default: return false;
       }
   }

   inline Sref toId(Type<B>)
   {
       return Sref("B", 1);
   }

   inline Sref toId(BaseIndexOf<B>::Type base_index)
   {
       switch(base_index) {
       case BaseIndexOf<B>::A: return Sref("A", 1);
       default: return Sref();
       }
   }

   inline Sref toId(MemberIndexOf<B>::Type member_index)
   {
       switch(member_index) {
       case MemberIndexOf<B>::aaa: return Sref("aaa", 3);
       default: return Sref();
       }
   }

   // end of generated code for class B

   #ifdef REFLECT_NAMESPACE_END
   REFLECT_NAMESPACE_END
   #endif

The perl script to parse annotation and generate the reflect code is
under 700 lines.

--
Max