Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TMethodCall.h
Go to the documentation of this file.
1 // @(#)root/meta:$Id$
2 // Author: Fons Rademakers 13/06/96
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TMethodCall
13 #define ROOT_TMethodCall
14 
15 
16 //////////////////////////////////////////////////////////////////////////
17 // //
18 // TMethodCall //
19 // //
20 // Method or function calling interface. Objects of this class contain //
21 // the (CINT) environment to call a global function or a method for an //
22 // object of a specific class with the desired arguments. This class is //
23 // espicially useful when a method has to be called more times for //
24 // different objects and/or with different arguments. If a function or //
25 // method needs to be called only once one better uses //
26 // TInterpreter::Execute(). //
27 // //
28 //////////////////////////////////////////////////////////////////////////
29 
30 #include "TDictionary.h"
31 
32 #include "TInterpreter.h"
33 
34 class TClass;
35 class TFunction;
36 
37 class TMethodCall : public TObject {
38 
39 public:
40  using EReturnType = TInterpreter::EReturnType;
41 
42  // For backward compatibility:
43  static const EReturnType kLong = TInterpreter::EReturnType::kLong;
44  static const EReturnType kDouble = TInterpreter::EReturnType::kDouble;
45  static const EReturnType kString = TInterpreter::EReturnType::kString;
46  static const EReturnType kOther = TInterpreter::EReturnType::kOther;
47  static const EReturnType kNoReturnType = TInterpreter::EReturnType::kNoReturnType;
48  // Historical name.
49  static const EReturnType kNone = TInterpreter::EReturnType::kNoReturnType;
50 
51  // enum EReturnType { kLong, kDouble, kString, kOther, kNone };
52 
53 private:
54  CallFunc_t *fFunc; //CINT method invocation environment
55  Long_t fOffset; //offset added to object pointer before method invocation
56  TClass *fClass; //pointer to the class info
57  TFunction *fMetPtr; //pointer to the method or function info
58  TString fMethod; //method name
59  TString fParams; //argument string
60  TString fProto; //prototype string
61  Bool_t fDtorOnly; //call only dtor and not delete when calling ~xxx
62  EReturnType fRetType; //method return type
63 
64  void Execute(const char *, const char *, int * /*error*/ = 0) { } // versions of TObject
65  void Execute(TMethod *, TObjArray *, int * /*error*/ = 0) { }
66 
67  void InitImplementation(const char *methodname, const char *params, const char *proto, Bool_t objectIsConst, TClass *cl, const ClassInfo_t *cinfo, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
68 
69 public:
70  TMethodCall();
71  TMethodCall(TClass *cl, CallFunc_t *callfunc, Long_t offset = 0);
72  TMethodCall(TClass *cl, const char *method, const char *params);
73  TMethodCall(const char *function, const char *params);
74  TMethodCall(const TFunction *func);
75  TMethodCall(const TMethodCall &org);
76  TMethodCall& operator=(const TMethodCall &rhs);
77  ~TMethodCall();
78 
79  void Init(const TFunction *func);
80  void Init(TClass *cl, CallFunc_t *func, Long_t offset = 0);
81  void Init(TClass *cl, const char *method, const char *params, Bool_t objectIsConst = kFALSE);
82  void Init(const char *function, const char *params);
83  void InitWithPrototype(TClass *cl, const char *method, const char *proto, Bool_t objectIsConst = kFALSE, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
84  void InitWithPrototype(const char *function, const char *proto, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
85  Bool_t IsValid() const;
86  TObject *Clone(const char *newname="") const;
87  void CallDtorOnly(Bool_t set = kTRUE) { fDtorOnly = set; }
88 
89  TFunction *GetMethod();
90  const char *GetMethodName() const { return fMethod.Data(); }
91  const char *GetParams() const { return fParams.Data(); }
92  const char *GetProto() const { return fProto.Data(); }
93  CallFunc_t *GetCallFunc() const { return fFunc; }
94  EReturnType ReturnType();
95 
96  void SetParamPtrs(void *paramArr, Int_t nparam = -1);
97  void ResetParam();
98  void SetParam(Long_t l);
99  void SetParam(Float_t f);
100  void SetParam(Double_t d);
101  void SetParam(Long64_t ll);
102  void SetParam(ULong64_t ull);
103 
104  template <typename... T> void SetParams(const T&... params) {
105  if (!fFunc) return;
106  gInterpreter->CallFunc_SetArguments(fFunc,params...);
107  }
108 
109  void Execute(void *object);
110  void Execute(void *object, const char *params);
111  void Execute(void *object, Long_t &retLong);
112  void Execute(void *object, const char *params, Long_t &retLong);
113  void Execute(void *object, Double_t &retDouble);
114  void Execute(void *object, const char *params, Double_t &retDouble);
115 
116  void Execute(void *object, char **retText);
117  void Execute(void *object, const char *params, char **retText);
118 
119  void Execute();
120  void Execute(const char *params);
121  void Execute(Long_t &retLong);
122  void Execute(const char *params, Long_t &retLong);
123  void Execute(Double_t &retDouble);
124  void Execute(const char *params, Double_t &retDouble);
125 
126  void Execute(void *objAddress, const void* args[], int nargs, void *ret = 0);
127 
128  ClassDef(TMethodCall,0) //Method calling interface
129 };
130 
131 inline void TMethodCall::Execute()
132  { Execute((void *)0); }
133 inline void TMethodCall::Execute(const char *params)
134  { Execute((void *)0, params); }
135 inline void TMethodCall::Execute(Long_t &retLong)
136  { Execute((void *)0, retLong); }
137 inline void TMethodCall::Execute(const char *params, Long_t &retLong)
138  { Execute((void *)0, params, retLong); }
139 inline void TMethodCall::Execute(Double_t &retDouble)
140  { Execute((void *)0, retDouble); }
141 inline void TMethodCall::Execute(const char *params, Double_t &retDouble)
142  { Execute((void *)0, params, retDouble); }
143 
144 #endif