TMethodCall

class TMethodCall : public TObject

    private:

      virtual void Execute(Text_t*, Text_t*)
      virtual void Execute(TMethod*, TObjArray*)

    public:

          TMethodCall TMethodCall()
          TMethodCall TMethodCall(TClass* cl, char* method, char* params)
          TMethodCall TMethodCall(char* function, char* params)
          TMethodCall TMethodCall(TMethodCall&)
         virtual void ~TMethodCall()
                 void CallDtorOnly(Bool_t set = kTRUE)
              TClass* Class()
                 void Execute(void* object)
                 void Execute(void* object, char* params)
                 void Execute(void* object, Long_t& retLong)
                 void Execute(void* object, char* params, Long_t& retLong)
                 void Execute(void* object, Double_t& retDouble)
                 void Execute(void* object, char* params, Double_t& retDouble)
                 void Execute(void* object, Text_t** retText)
                 void Execute(void* object, char* params, Text_t** retText)
                 void Execute()
                 void Execute(char* params)
                 void Execute(Long_t& retLong)
                 void Execute(char* params, Long_t& retLong)
                 void Execute(Double_t& retDouble)
                 void Execute(char* params, Double_t& retDouble)
           TFunction* GetMethod()
        const Text_t* GetMethodName()
        const Text_t* GetParams()
        const Text_t* GetProto()
                 void Init(TClass* cl, char* method, char* params)
                 void Init(char* function, char* params)
                 void InitWithPrototype(TClass* cl, char* method, char* proto)
                 void InitWithPrototype(char* function, char* proto)
      virtual TClass* IsA()
          EReturnType ReturnType()
                 void SetParamPtrs(void* paramArr)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)

  Data Members
    private:

      G__CallFunc* fFunc      CINT method invocation environment
            Long_t fOffset    offset added to object pointer before method invocation
           TClass* fClass     pointer to the class info
        TFunction* fMetPtr    pointer to the method or function info
           TString fMethod    method name
           TString fParams    argument string
           TString fProto     prototype string
            Bool_t fDtorOnly  call only dtor and not delete when calling ~xxx
       EReturnType fRetType   method return type

Class Description

                                                                      
 TMethodCall                                                          
                                                                      
 Method or function calling interface. Objects of this class contain  
 the (CINT) environment to call a global function or a method for an  
 object of a specific class with the desired arguments. This class is 
 espicially useful when a method has to be called more times for      
 different objects and/or with different arguments. If a function or  
 method needs to be called only once one better uses                  
 TInterpreter::Execute().                                             
                                                                      

 Default TMethodCall ctor. Use Init() to initialize the method call
 environment.

 Create a method invocation environment for a specific class, method and
 parameters. The parameter string has the form: ""aap", 3, 4.35".
 To execute the method call TMethodCall::Execute(object,...).
 This two step method is much more efficient than calling for
 every invocation TInterpreter::Execute(...).

 Create a global function invocation environment. The parameter
 string has the form: ""aap", 3, 4,35". To execute the
 function call TMethodCall::Execute(...).
 This two step method is much more efficient than calling for
 every invocation TInterpreter::Execute(...).

 TMethodCall dtor.

 Initialize the method invocation environment. Necessary input
 information: the class, method name and the parameter string
 of the form ""aap", 3, 4.35".
 To execute the method call TMethodCall::Execute(object,...).
 This two step method is much more efficient than calling for
 every invocation TInterpreter::Execute(...).

 Initialize the function invocation environment. Necessary input
 information: the function name and the parameter string of
 the form ""aap", 3, 4.35".
 To execute the method call TMethodCall::Execute(...).
 This two step method is much more efficient than calling for
 every invocation TInterpreter::Execute(...).

 Initialize the method invocation environment. Necessary input
 information: the class, method name and the prototype string of
 the form: "char*,int,float".
 To execute the method call TMethodCall::Execute(object,...).
 This two step method is much more efficient than calling for
 every invocation TInterpreter::Execute(...).

 Initialize the function invocation environment. Necessary input
 information: the function name and the prototype string of
 the form: "char*,int,float".
 To execute the method call TMethodCall::Execute(...).
 This two step method is much more efficient than calling for
 every invocation TInterpreter::Execute(...).

 Returns the TMethod describing the method to be executed. This takes
 all overriding and overloading into account (call TClass::GetMethod()).
 Since finding the method is expensive the result is cached.

 Execute the method (with preset arguments) for the specified object.

 Execute the method for the specified object and argument values.

 Execute the method (with preset arguments) for the specified object.

 Execute the method for the specified object and argument values.

 Execute the method (with preset arguments) for the specified object.

 Execute the method for the specified object and argument values.

 Execute the method (with preset arguments) for the specified object.

 Execute the method for the specified object and argument values.

 Returns the return type of the method. Either (unsigned) long,
 int, short and char, or float and double or anything else.
 Since finding the return type is expensive the result is cached.

 ParamArr is an array containing the addresses where to take the
 function parameters. At least as many pointers should be present in
 the array as there are required arguments (all arguments - default args).

Inline Functions

                 void CallDtorOnly(Bool_t set = kTRUE)
        const Text_t* GetMethodName()
        const Text_t* GetParams()
        const Text_t* GetProto()
                 void Execute(void* object, Text_t** retText)
                 void Execute(void* object, char* params, Text_t** retText)
                 void Execute()
                 void Execute(char* params)
                 void Execute(Long_t& retLong)
                 void Execute(char* params, Long_t& retLong)
                 void Execute(Double_t& retDouble)
                 void Execute(char* params, Double_t& retDouble)
              TClass* Class()
              TClass* IsA()
                 void ShowMembers(TMemberInspector& insp, char* parent)
                 void Streamer(TBuffer& b)
          TMethodCall TMethodCall(TMethodCall&)