/usr/include/root/TPluginManager.h is in libroot-core-dev 5.34.00-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 | // @(#)root/base:$Id: TPluginManager.h 37497 2010-12-10 12:22:54Z rdm $
// Author: Fons Rademakers 26/1/2002
/*************************************************************************
* Copyright (C) 1995-2002, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#ifndef ROOT_TPluginManager
#define ROOT_TPluginManager
//////////////////////////////////////////////////////////////////////////
// //
// TPluginManager //
// //
// This class implements a plugin library manager. It keeps track of //
// a list of plugin handlers. A plugin handler knows which plugin //
// library to load to get a specific class that is used to extend the //
// functionality of a specific base class and how to create an object //
// of this class. For example, to extend the base class TFile to be //
// able to read RFIO files one needs to load the plugin library //
// libRFIO.so which defines the TRFIOFile class. This loading should //
// be triggered when a given URI contains a regular expression defined //
// by the handler. //
// Plugin handlers can be defined via macros in a list of plugin //
// directories. With $ROOTSYS/etc/plugins the default top plugin //
// directory specified in $ROOTSYS/etc/system.rootrc. Additional //
// directories can be specified by adding them to the end of the list. //
// Macros for identical plugin handlers in later directories will //
// override previous ones (the inverse of normal search path behavior). //
// The macros must have names like <BaseClass>/PX0_<PluginClass>.C, //
// e.g.: //
// TFile/P10_TRFIOFile.C, TSQLServer/P20_TMySQLServer.C, etc. //
// to allow easy sorting and grouping. If the BaseClass is in a //
// namespace the directory must have the name NameSpace@@BaseClass as //
// : is a reserved pathname character on some operating systems. //
// Macros not beginning with 'P' and ending with ".C" are ignored. //
// These macros typically look like: //
// //
// void P10_TDCacheFile() //
// { //
// gPluginMgr->AddHandler("TFile", "^dcache", "TDCacheFile", //
// "DCache", "TDCacheFile(const char*,Option_t*)"); //
// } //
// //
// Plugin handlers can also be defined via resources in the .rootrc //
// file. Although now deprecated this method still works for backward //
// compatibility, e.g.: //
// //
// Plugin.TFile: ^rfio: TRFIOFile RFIO "<constructor>" //
// Plugin.TSQLServer: ^mysql: TMySQLServer MySQL "<constructor>" //
// +Plugin.TSQLServer: ^pgsql: TPgSQLServer PgSQL "<constructor>" //
// Plugin.TVirtualFitter: * TFitter Minuit "TFitter(Int_t)" //
// //
// Where the + in front of Plugin.TSQLServer says that it extends the //
// existing definition of TSQLServer, useful when there is more than //
// one plugin that can extend the same base class. The "<constructor>" //
// should be the constructor or a static method that generates an //
// instance of the specified class. Global methods should start with //
// "::" in their name, like "::CreateFitter()". //
// Instead of being a shared library a plugin can also be a CINT //
// script, so instead of libDialog.so one can have Dialog.C. //
// The * is a placeholder in case there is no need for a URI to //
// differentiate between different plugins for the same base class. //
// For the default plugins see $ROOTSYS/etc/system.rootrc. //
// //
// Plugin handlers can also be registered at run time, e.g.: //
// //
// gPluginMgr->AddHandler("TSQLServer", "^sapdb:", //
// "TSapDBServer", "SapDB", //
// "TSapDBServer(const char*,const char*, const char*)"); //
// //
// A list of currently defined handlers can be printed using: //
// //
// gPluginMgr->Print(); // use option="a" to see ctors //
// //
// The use of the plugin library manager removes all textual references //
// to hard-coded class and library names and the resulting dependencies //
// in the base classes. The plugin manager is used to extend a.o. //
// TFile, TSQLServer, TGrid, etc. functionality. //
// //
//////////////////////////////////////////////////////////////////////////
#ifndef ROOT_TObject
#include "TObject.h"
#endif
#ifndef ROOT_TString
#include "TString.h"
#endif
class TEnv;
class TList;
class THashTable;
class TFunction;
class TMethodCall;
class TPluginManager;
class TPluginHandler : public TObject {
friend class TPluginManager;
private:
TString fBase; // base class which will be extended by plugin
TString fRegexp; // regular expression which must be matched in URI
TString fClass; // class to be loaded from plugin library
TString fPlugin; // plugin library which should contain fClass
TString fCtor; // ctor used to instantiate object of fClass
TString fOrigin; // origin of plugin handler definition
TMethodCall *fCallEnv; //!ctor method call environment
TFunction *fMethod; //!ctor method or global function
Int_t fCanCall; //!if 1 fCallEnv is ok, -1 fCallEnv is not ok
Bool_t fIsMacro; // plugin is a macro and not a library
Bool_t fIsGlobal; // plugin ctor is a global function
TPluginHandler() :
fBase(), fRegexp(), fClass(), fPlugin(), fCtor(), fOrigin(),
fCallEnv(0), fMethod(0), fCanCall(0), fIsMacro(kTRUE), fIsGlobal(kTRUE) { }
TPluginHandler(const char *base, const char *regexp,
const char *className, const char *pluginName,
const char *ctor, const char *origin);
TPluginHandler(const TPluginHandler&); // not implemented
TPluginHandler& operator=(const TPluginHandler&); // not implemented
~TPluginHandler();
const char *GetBase() const { return fBase; }
const char *GetRegexp() const { return fRegexp; }
const char *GetPlugin() const { return fPlugin; }
const char *GetCtor() const { return fCtor; }
const char *GetOrigin() const { return fOrigin; }
Bool_t CanHandle(const char *base, const char *uri);
void SetupCallEnv();
public:
const char *GetClass() const { return fClass; }
Int_t CheckPlugin() const;
Int_t LoadPlugin();
Long_t ExecPlugin(Int_t nargs, ...);
void Print(Option_t *opt = "") const;
ClassDef(TPluginHandler,3) // Handler for plugin libraries
};
class TPluginManager : public TObject {
private:
TList *fHandlers; // list of plugin handlers
THashTable *fBasesLoaded; //! table of base classes already checked or loaded
Bool_t fReadingDirs; //! true if we are running LoadHandlersFromPluginDirs
TPluginManager(const TPluginManager& pm); // not implemented
TPluginManager& operator=(const TPluginManager& pm); // not implemented
void LoadHandlerMacros(const char *path);
public:
TPluginManager() : fHandlers(0), fBasesLoaded(0), fReadingDirs(kFALSE) { }
~TPluginManager();
void LoadHandlersFromEnv(TEnv *env);
void LoadHandlersFromPluginDirs(const char *base = 0);
void AddHandler(const char *base, const char *regexp,
const char *className, const char *pluginName,
const char *ctor = 0, const char *origin = 0);
void RemoveHandler(const char *base, const char *regexp = 0);
TPluginHandler *FindHandler(const char *base, const char *uri = 0);
void Print(Option_t *opt = "") const;
Int_t WritePluginMacros(const char *dir, const char *plugin = 0) const;
Int_t WritePluginRecords(const char *envFile, const char *plugin = 0) const;
ClassDef(TPluginManager,1) // Manager for plugin handlers
};
R__EXTERN TPluginManager *gPluginMgr;
#endif
|