classbuilder.h

cint...昨天看到有个c++解释器,叫CINT,down下来一用,很爽,推荐大家也去看一看。 相信不少朋友们早就知道这个东西了

         template < typename E >
            ClassBuilderT & AddEnum( const char * values,
                                     unsigned int modifiers = 0 );
         ClassBuilderT & AddEnum( const char * nam,
                                  const char * values,
                                  const std::type_info * ti = 0,
                                  unsigned int modifiers = 0 );
      
         //ClassBuilderT & addUnion( const char * nam,
         //                          const char * values,
         //                          unsigned int modifiers );


         /** AddProperty will add a PropertyNth to the last defined
          * data MemberAt, method or class.
          * @param  key the PropertyNth key
          * @param  value the value of the PropertyNth
          * @return a reference to the building class
          */
         template < typename P >
            ClassBuilderT & AddProperty( const char * key, 
                                         P value );

         private:
      
         ClassBuilderImpl fClassBuilderImpl;

      }; // class ClassBuilderT

   } // namespace Reflex
} // namespace ROOT


//-------------------------------------------------------------------------------
template< class C, class B > 
inline ROOT::Reflex::ClassBuilder & 
ROOT::Reflex::ClassBuilder::AddBase( unsigned int modifiers ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddBase( GetType<B>(), 
                              BaseOffset<C,B>::Get(),
                              modifiers );
   return * this;
}


//-------------------------------------------------------------------------------
template< class T > 
inline ROOT::Reflex::ClassBuilder & 
ROOT::Reflex::ClassBuilder::AddDataMember( const char *  nam,
                                           size_t        offs,
                                           unsigned int  modifiers ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddDataMember( nam,
                                    TypeDistiller<T>::Get(),
                                    offs,
                                    modifiers );
   return * this;
}


//-------------------------------------------------------------------------------
template < class F >
inline ROOT::Reflex::ClassBuilder & 
ROOT::Reflex::ClassBuilder::AddFunctionMember( const char * nam,
                                               StubFunction stubFP,
                                               void * stubCtx,
                                               const char * params, 
                                               unsigned int modifiers ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddFunctionMember( nam,
                                        FunctionDistiller<F>::Get(),
                                        stubFP,
                                        stubCtx,
                                        params,
                                        modifiers );
   return * this;
}
    

//-------------------------------------------------------------------------------
template < typename TD > 
inline ROOT::Reflex::ClassBuilder &
ROOT::Reflex::ClassBuilder::AddTypedef( const char * def ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddTypedef( TypeDistiller<TD>::Get(),
                                 def );
   return * this;
}


//-------------------------------------------------------------------------------
template < typename E >
inline ROOT::Reflex::ClassBuilder &
ROOT::Reflex::ClassBuilder::AddEnum( const char * values,
                                     unsigned int modifiers ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddEnum( Tools::Demangle(typeid(E)).c_str(),
                              values,
                              & typeid(E),
                              modifiers );
   return * this;
}


//-------------------------------------------------------------------------------
template < class P >
inline ROOT::Reflex::ClassBuilder & 
ROOT::Reflex::ClassBuilder::AddProperty( const char * key, 
                                         P value ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddProperty(key , value);
   return * this;
}


//-------------------------------------------------------------------------------
template <class C>
inline ROOT::Reflex::ClassBuilderT<C>::ClassBuilderT( unsigned int modifiers,
                                                      TYPE typ ) 
//-------------------------------------------------------------------------------
   : fClassBuilderImpl( Tools::Demangle(typeid(C)).c_str(),
                        typeid(C),
                        sizeof(C),
                        modifiers,
                        typ ) { }
    

//-------------------------------------------------------------------------------
template <class C>
inline ROOT::Reflex::ClassBuilderT<C>::ClassBuilderT( const char * nam, 
                                                      unsigned int modifiers,
                                                      TYPE typ )
//-------------------------------------------------------------------------------
   : fClassBuilderImpl( nam, typeid(C), sizeof(C), modifiers, typ ) { }

    
//-------------------------------------------------------------------------------
template <class C> template< class B > 
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddBase( unsigned int modifiers ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddBase( GetType<B>(), 
                              BaseOffset<C,B>::Get(),
                              modifiers );
   return * this;
}


//-------------------------------------------------------------------------------
template <class C> 
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddBase( const Type & bas,
                                         OffsetFunction offsFP,
                                         unsigned int modifiers ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddBase( bas, 
                              offsFP,
                              modifiers );
   return * this;
}


//-------------------------------------------------------------------------------
template <class C> template< class T > 
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddDataMember( const char *  nam,
                                               size_t        offs,
                                               unsigned int  modifiers )
//-------------------------------------------------------------------------------
{
   fClassBuilderImpl.AddDataMember( nam,
                                    TypeDistiller<T>::Get(),
                                    offs,
                                    modifiers );
   return * this;
}


//-------------------------------------------------------------------------------
template <class C>
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddDataMember( const Type &  typ,
                                               const char *  nam,
                                               size_t        offs,
                                               unsigned int  modifiers )
//-------------------------------------------------------------------------------
{
   fClassBuilderImpl.AddDataMember( nam,
                                    typ,
                                    offs,
                                    modifiers );
   return * this;
}
    
    
//-------------------------------------------------------------------------------
template < class C > template < class F >
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddFunctionMember( const char * nam,
                                                   StubFunction stubFP,
                                                   void * stubCtx,
                                                   const char * params, 
                                                   unsigned int modifiers )
//-------------------------------------------------------------------------------
{
   fClassBuilderImpl.AddFunctionMember( nam,
                                        FunctionDistiller<F>::Get(),
                                        stubFP,
                                        stubCtx,
                                        params,
                                        modifiers );
   return * this;
}
    

//-------------------------------------------------------------------------------
template < class C >
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddFunctionMember( const Type & typ,
                                                   const char * nam,
                                                   StubFunction stubFP,
                                                   void * stubCtx,
                                                   const char * params, 
                                                   unsigned int modifiers ) 
//-------------------------------------------------------------------------------
{
   fClassBuilderImpl.AddFunctionMember( nam,
                                        typ,
                                        stubFP,
                                        stubCtx,
                                        params,
                                        modifiers );
   return * this;
}


//-------------------------------------------------------------------------------
template < class C > template < typename TD > 
inline ROOT::Reflex::ClassBuilderT<C> &
ROOT::Reflex::ClassBuilderT<C>::AddTypedef( const char * def ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddTypedef( TypeDistiller<TD>::Get(),
                                 def );
   return * this;
}


//-------------------------------------------------------------------------------
template < class C > 
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddTypedef( const char * typ,
                                            const char * def ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddTypedef( TypeBuilder( typ ),
                                 def );
   return * this;
}


//-------------------------------------------------------------------------------
template < class C > 
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddTypedef( const Type & typ,
                                            const char * def ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddTypedef( typ,
                                 def );
   return * this;
}


//-------------------------------------------------------------------------------
template < class C > template < typename E >
inline ROOT::Reflex::ClassBuilderT<C> &
ROOT::Reflex::ClassBuilderT<C>::AddEnum( const char * values,
                                         unsigned int modifiers ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddEnum( Tools::Demangle(typeid(E)).c_str(),
                              values,
                              & typeid(E),
                              modifiers );
   return * this;
}


//-------------------------------------------------------------------------------
template < class C > 
inline ROOT::Reflex::ClassBuilderT<C> &
ROOT::Reflex::ClassBuilderT<C>::AddEnum( const char * nam,
                                         const char * values,
                                         const std::type_info * ti,
                                         unsigned int modifiers ) {
//-------------------------------------------------------------------------------
   fClassBuilderImpl.AddEnum( nam, 
                              values, 
                              ti,
                              modifiers );
   return * this;
}


/*/-------------------------------------------------------------------------------
  template < class C > 
  inline ROOT::Reflex::ClassBuilderT<C> &
  ROOT::Reflex::ClassBuilderT<C>::addUnion( const char * nam,
  const char * values,
  unsigned int modifiers ) {
//-------------------------------------------------------------------------------
  fClassBuilderImpl.addUnion( nam, values, modifiers );
  return * this;
  }
*/


//-------------------------------------------------------------------------------
template < class C > template < class P >
inline ROOT::Reflex::ClassBuilderT<C> & 
ROOT::Reflex::ClassBuilderT<C>::AddProperty( const char * key, 
                                             P value )
//-------------------------------------------------------------------------------
{
   fClassBuilderImpl.AddProperty(key , value);
   return * this;
}

#endif // ROOT_Reflex_ClassBuilder