fix docu / add more

git-svn-id: http://root.cern.ch/svn/root/trunk@15698 27541ba8-7e3a-0410-8455-c3a389f83636

reflex/src/FuncHandler.cxx

-// @(#)root/reflex:$Name: HEAD $:$Id: FuncHandler.cxx,v 1.7 2006/03/20 09:46:18 roiser Exp $
+// @(#)root/reflex:$Name:  $:$Id: FuncHandler.cxx,v 1.8 2006/07/05 07:09:09 roiser Exp $
 // Author: Stefan Roiser 2004
 
 // Copyright CERN, CH-1211 Geneva 23, 2004-2006, All rights reserved.
@@ -24,6 +24,7 @@
 template < class R, class C >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)()) {
 //-------------------------------------------------------------------------------
+// Demangle return type of  a member function with 0 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -32,6 +33,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)()) {
 template < class R, class C, class T0>
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of  a member function with 1 argument.
    return Tools::Demangle(typeid(R));
 }
 
@@ -40,6 +42,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0)) {
 template < class R, class C, class T0, class T1 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0,T1)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of  a member function with 2 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -48,6 +51,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0,T1))
 template < class R, class C, class T0, class T1, class T2 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0,T1,T2)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of  a member function with 3 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -56,6 +60,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0,T1,T2
 template < class R, class C, class T0, class T1, class T2, class T3 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0,T1,T2,T3)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of  a member function with 4 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -64,6 +69,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0,T1,T2
 template < class R, class C, class T0, class T1, class T2, class T3, class T4 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0,T1,T2,T3,T4)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of  a member function with 5 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -72,6 +78,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(C::*)(T0,T1,T2
 template < class R, class C >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)()) {
 //-------------------------------------------------------------------------------
+// Demangle parameters of a member function with 0 arguments.
    return "void";
 }
 
@@ -80,6 +87,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)()) {
 template < class R, class C, class T0>
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0)) {
 //-------------------------------------------------------------------------------
+// Demangle parameters of a member function with 1 argument.
    return Tools::Demangle(typeid(T0));
 }
 
@@ -88,6 +96,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0)) {
 template < class R, class C, class T0, class T1 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0,T1)) {
 //-------------------------------------------------------------------------------
+// Demangle parameters of a member function with 2 arguments.
    std::string s = 
       Tools::Demangle(typeid(T0)) + ";" +
       Tools::Demangle(typeid(T1));
@@ -99,6 +108,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0,T1))
 template < class R, class C, class T0, class T1, class T2 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0,T1,T2)) {
 //-------------------------------------------------------------------------------
+// Demangle parameters of a member function with 3 arguments.
    std::string s =
       Tools::Demangle(typeid(T0)) + ";" +
       Tools::Demangle(typeid(T1)) + ";" +
@@ -111,6 +121,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0,T1,T
 template < class R, class C, class T0, class T1, class T2, class T3 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0,T1,T2,T3)) {
 //-------------------------------------------------------------------------------
+// Demangle parameters of a member function with 4 arguments.
    std::string s = 
       Tools::Demangle(typeid(T0)) + ";" +
       Tools::Demangle(typeid(T1)) + ";" +
@@ -124,6 +135,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0,T1,T
 template < class R, class C, class T0, class T1, class T2, class T3, class T4 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0,T1,T2,T3,T4)) {
 //-------------------------------------------------------------------------------
+// Demangle parameters of a member function with 5 arguments.
    std::string s = 
       Tools::Demangle(typeid(T0)) + ";" +
       Tools::Demangle(typeid(T1)) + ";" +
@@ -138,6 +150,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(C::*)(T0,T1,T
 template < class R >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)()) {
 //-------------------------------------------------------------------------------
+// Demangle return type of a free function with 0 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -146,6 +159,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)()) {
 template < class R, class T0>
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of a free function with 0 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -154,6 +168,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0)) {
 template < class R, class T0, class T1 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0,T1)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of a free function with 0 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -162,6 +177,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0,T1)) {
 template < class R, class T0, class T1, class T2 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0,T1,T2)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of a free function with 0 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -170,6 +186,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0,T1,T2))
 template < class R, class T0, class T1, class T2, class T3 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0,T1,T2,T3)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of a free function with 0 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -178,6 +195,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0,T1,T2,T3
 template < class R, class T0, class T1, class T2, class T3, class T4 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0,T1,T2,T3,T4)) {
 //-------------------------------------------------------------------------------
+// Demangle return type of a free function with 0 arguments.
    return Tools::Demangle(typeid(R));
 }
 
@@ -186,6 +204,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunRetType(R(*)(T0,T1,T2,T3
 template < class R >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)()) {
 //-------------------------------------------------------------------------------
+// Demangle parameter types of a free function with 0 arguments.
    return "void";
 }
 
@@ -194,6 +213,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)()) {
 template < class R, class T0>
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0)) {
 //-------------------------------------------------------------------------------
+// Demangle parameter types of a free function with 1 argument.
    return Tools::Demangle(typeid(T0));
 }
 
@@ -202,6 +222,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0)) {
 template < class R, class T0, class T1 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0,T1)) {
 //-------------------------------------------------------------------------------
+// Demangle parameter types of a free function with 2 arguments.
    std::string s = 
       Tools::Demangle(typeid(T0)) + ";" +
       Tools::Demangle(typeid(T1));
@@ -213,6 +234,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0,T1)) {
 template < class R, class T0, class T1, class T2 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0,T1,T2)) {
 //-------------------------------------------------------------------------------
+// Demangle parameter types of a free function with 3 arguments.
    std::string s = 
       Tools::Demangle(typeid(T0)) + ";" +
       Tools::Demangle(typeid(T1)) + ";" +
@@ -225,6 +247,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0,T1,T2))
 template < class R, class T0, class T1, class T2, class T3 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0,T1,T2,T3)) {
 //-------------------------------------------------------------------------------
+// Demangle parameter types of a free function with 4 arguments.
    std::string s = 
       Tools::Demangle(typeid(T0)) + ";" +
       Tools::Demangle(typeid(T1)) + ";" +
@@ -238,6 +261,7 @@ const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0,T1,T2,T
 template < class R, class T0, class T1, class T2, class T3, class T4 >
 const std::string ROOT::Reflex::FuncHandler::DemangleFunParTypes(R(*)(T0,T1,T2,T3,T4)) {
 //-------------------------------------------------------------------------------
+// Demangle parameter types of a free function with 5 arguments.
    std::string s = 
       Tools::Demangle(typeid(T0)) + ";" +
       Tools::Demangle(typeid(T1)) + ";" +

reflex/src/Kernel.cxx

-// @(#)root/reflex:$Name: HEAD $:$Id: Kernel.cxx,v 1.12 2006/07/03 17:02:38 roiser Exp $
+// @(#)root/reflex:$Name:  $:$Id: Kernel.cxx,v 1.11 2006/07/05 07:09:09 roiser Exp $
 // Author: Stefan Roiser 2004
 
 // Copyright CERN, CH-1211 Geneva 23, 2004-2006, All rights reserved.
@@ -34,6 +34,7 @@
 //-------------------------------------------------------------------------------
 ROOT::Reflex::Reflex::Reflex() {
 //-------------------------------------------------------------------------------
+// Initialisation of Reflex.Setup of global scope, fundamental types.
 
    /** initialisation of the global namespace */
    Namespace::InitGlobalNamespace();
@@ -173,6 +174,7 @@ ROOT::Reflex::Reflex::Reflex() {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::StdString_Cont_Type_t & ROOT::Reflex::Dummy::StdStringCont() {
 //-------------------------------------------------------------------------------
+// static wrapper for an empty container of std strings.
    static StdString_Cont_Type_t c;
    return c;
 }
@@ -181,6 +183,7 @@ ROOT::Reflex::StdString_Cont_Type_t & ROOT::Reflex::Dummy::StdStringCont() {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::Type_Cont_Type_t & ROOT::Reflex::Dummy::TypeCont() {
 //-------------------------------------------------------------------------------
+// static wrapper for an empty container of Types.
    static Type_Cont_Type_t c;
    return c;
 }
@@ -189,6 +192,7 @@ ROOT::Reflex::Type_Cont_Type_t & ROOT::Reflex::Dummy::TypeCont() {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::Base_Cont_Type_t & ROOT::Reflex::Dummy::BaseCont() {
 //-------------------------------------------------------------------------------
+// static wrapper for an empty container of Bases.
    static Base_Cont_Type_t c;
    return c;
 }
@@ -197,6 +201,7 @@ ROOT::Reflex::Base_Cont_Type_t & ROOT::Reflex::Dummy::BaseCont() {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::Scope_Cont_Type_t & ROOT::Reflex::Dummy::ScopeCont() {
 //-------------------------------------------------------------------------------
+// static wrapper for an empty container of Scopes.
    static Scope_Cont_Type_t c;
    return c;
 }
@@ -205,6 +210,7 @@ ROOT::Reflex::Scope_Cont_Type_t & ROOT::Reflex::Dummy::ScopeCont() {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::Object_Cont_Type_t & ROOT::Reflex::Dummy::ObjectCont() {
 //-------------------------------------------------------------------------------
+// static wrapper for an empty container of Objects.
    static Object_Cont_Type_t c;
    return c;
 }
@@ -213,6 +219,7 @@ ROOT::Reflex::Object_Cont_Type_t & ROOT::Reflex::Dummy::ObjectCont() {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::Member_Cont_Type_t & ROOT::Reflex::Dummy::MemberCont() {
 //-------------------------------------------------------------------------------
+// static wrapper for an empty container of Members.
    static Member_Cont_Type_t c;
    return c;
 }
@@ -221,6 +228,7 @@ ROOT::Reflex::Member_Cont_Type_t & ROOT::Reflex::Dummy::MemberCont() {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::TypeTemplate_Cont_Type_t & ROOT::Reflex::Dummy::TypeTemplateCont() {
 //-------------------------------------------------------------------------------
+// static wrapper for an empty container of TypeTemplates.
    static TypeTemplate_Cont_Type_t c;
    return c;
 }
@@ -229,6 +237,7 @@ ROOT::Reflex::TypeTemplate_Cont_Type_t & ROOT::Reflex::Dummy::TypeTemplateCont()
 //-------------------------------------------------------------------------------
 ROOT::Reflex::MemberTemplate_Cont_Type_t & ROOT::Reflex::Dummy::MemberTemplateCont() {
 //-------------------------------------------------------------------------------
+// static wrapper for an empty container of MemberTemplates.
    static MemberTemplate_Cont_Type_t c;
    return c;
 }
@@ -237,6 +246,7 @@ ROOT::Reflex::MemberTemplate_Cont_Type_t & ROOT::Reflex::Dummy::MemberTemplateCo
 //-------------------------------------------------------------------------------
 const std::string & ROOT::Reflex::Reflex::Argv0() {
 //-------------------------------------------------------------------------------
+// Return the name of the package.
    static std::string str = "REFLEX";
    return str;
 }

reflex/src/MemberBase.cxx

-// @(#)root/reflex:$Name: HEAD $:$Id: MemberBase.cxx,v 1.9 2006/07/04 15:02:55 roiser Exp $
+// @(#)root/reflex:$Name:  $:$Id: MemberBase.cxx,v 1.9 2006/07/05 07:09:09 roiser Exp $
 // Author: Stefan Roiser 2004
 
 // Copyright CERN, CH-1211 Geneva 23, 2004-2006, All rights reserved.
@@ -31,20 +31,20 @@ ROOT::Reflex::MemberBase::MemberBase( const char *  name,
                                       TYPE          memberType,
                                       unsigned int  modifiers )
 //-------------------------------------------------------------------------------
+// Construct the dictionary info for a member
    : fType( type, modifiers & ( CONST | VOLATILE | REFERENCE ), true ),
      fModifiers( modifiers ),
      fName( name ),
      fScope( Scope() ),
      fMemberType( memberType ),
      fPropertyList( PropertyList( new PropertyListImpl())) {
-   // Construct the dictionary info for a member
 }
 
 
 //-------------------------------------------------------------------------------
 ROOT::Reflex::MemberBase::~MemberBase() {
 //-------------------------------------------------------------------------------
-   // destructor.
+// Destructor.
    fPropertyList.ClearProperties();
 }
 
@@ -52,7 +52,7 @@ ROOT::Reflex::MemberBase::~MemberBase() {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::MemberBase::operator ROOT::Reflex::Member () const {
 //-------------------------------------------------------------------------------
-   // Conversion operator to Member.
+// Conversion operator to Member.
    return Member( this );
 }
 
@@ -60,7 +60,7 @@ ROOT::Reflex::MemberBase::operator ROOT::Reflex::Member () const {
 //-------------------------------------------------------------------------------
 void * ROOT::Reflex::MemberBase::CalculateBaseObject( const Object & obj ) const {
 //-------------------------------------------------------------------------------
-   // Return the object address a member lives in.
+// Return the object address a member lives in.
    char * mem = (char*)obj.Address();
    // check if its a dummy object 
    Type cl = obj.TypeOf();
@@ -94,7 +94,7 @@ void * ROOT::Reflex::MemberBase::CalculateBaseObject( const Object & obj ) const
 //-------------------------------------------------------------------------------
 ROOT::Reflex::Scope ROOT::Reflex::MemberBase::DeclaringScope() const {
 //-------------------------------------------------------------------------------
-   // Return the scope the member lives in.
+// Return the scope the member lives in.
    return fScope;
 }
 
@@ -102,7 +102,7 @@ ROOT::Reflex::Scope ROOT::Reflex::MemberBase::DeclaringScope() const {
 //-------------------------------------------------------------------------------
 ROOT::Reflex::Type ROOT::Reflex::MemberBase::DeclaringType() const {
 //-------------------------------------------------------------------------------
-   // Return the type the member lives in.
+// Return the type the member lives in.
    return DeclaringScope();
 }