VTK
vtkObjectFactory.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkObjectFactory.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
41#ifndef vtkObjectFactory_h
42#define vtkObjectFactory_h
43
44#include "vtkDebugLeaksManager.h" // Must be included before singletons
45#include "vtkCommonCoreModule.h" // For export macro
46#include "vtkObject.h"
47
50class vtkCollection;
51
52class VTKCOMMONCORE_EXPORT vtkObjectFactory : public vtkObject
53{
54public:
55 // Class Methods used to interface with the registered factories
56
67 static vtkObject* CreateInstance(const char* vtkclassname,
68 bool isAbstract = false);
69
76 VTK_LEGACY(static void ConstructInstance(const char* vtkclassname));
77
84 static void CreateAllInstance(const char* vtkclassname,
85 vtkCollection* retList);
90 static void ReHash();
103
109
114 static int HasOverrideAny(const char* className);
115
120 static void GetOverrideInformation(const char* name,
122
128 const char* className);
134 const char* className,
135 const char* subclassName);
136
137 // Instance methods to be used on individual instances of vtkObjectFactory
138
139 // Methods from vtkObject
144 void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
145
153 virtual const char* GetVTKSourceVersion() = 0;
154
158 virtual const char* GetDescription() = 0;
159
163 virtual int GetNumberOfOverrides();
164
168 virtual const char* GetClassOverrideName(int index);
169
174 virtual const char* GetClassOverrideWithName(int index);
175
180
185 virtual const char* GetOverrideDescription(int index);
186
188
192 virtual void SetEnableFlag(vtkTypeBool flag,
193 const char* className,
194 const char* subclassName);
195 virtual vtkTypeBool GetEnableFlag(const char* className,
196 const char* subclassName);
198
202 virtual int HasOverride(const char* className);
206 virtual int HasOverride(const char* className, const char* subclassName);
207
213 virtual void Disable(const char* className);
214
216
219 vtkGetStringMacro(LibraryPath);
221
222 typedef vtkObject* (*CreateFunction)();
223
224protected:
225
229 void RegisterOverride(const char* classOverride,
230 const char* overrideClassName,
231 const char* description,
232 int enableFlag,
233 CreateFunction createFunction);
234
240 virtual vtkObject* CreateObject(const char* vtkclassname );
241
243 ~vtkObjectFactory() VTK_OVERRIDE;
244
246 {
250 CreateFunction CreateCallback;
251 };
252
257
258private:
259 void GrowOverrideArray();
260
265 static void Init();
269 static void RegisterDefaults();
273 static void LoadDynamicFactories();
277 static void LoadLibrariesInPath( const char*);
278
279 // list of registered factories
280 static vtkObjectFactoryCollection* RegisteredFactories;
281
282 // member variables for a factory set by the base class
283 // at load or register time
284 void* LibraryHandle;
285 char* LibraryVTKVersion;
286 char* LibraryCompilerUsed;
287 char* LibraryPath;
288private:
289 vtkObjectFactory(const vtkObjectFactory&) VTK_DELETE_FUNCTION;
290 void operator=(const vtkObjectFactory&) VTK_DELETE_FUNCTION;
291};
292
293// Implementation detail for Schwartz counter idiom.
294class VTKCOMMONCORE_EXPORT vtkObjectFactoryRegistryCleanup
295{
296public:
299
300private:
302 vtkObjectFactoryRegistryCleanup& operator=(const vtkObjectFactoryRegistryCleanup& rhs) VTK_DELETE_FUNCTION;
303};
305
306
307// Macro to create an object creation function.
308// The name of the function will by vtkObjectFactoryCreateclassname
309// where classname is the name of the class being created
310#define VTK_CREATE_CREATE_FUNCTION(classname) \
311static vtkObject* vtkObjectFactoryCreate##classname() \
312{ return classname::New(); }
313
314#endif
315
316#define VTK_FACTORY_INTERFACE_EXPORT VTKCOMMONCORE_EXPORT
317
318// Macro to create the interface "C" functions used in
319// a dll or shared library that contains a VTK object factory.
320// Put this function in the .cxx file of your object factory,
321// and pass in the name of the factory sub-class that you want
322// the dll to create.
323#define VTK_FACTORY_INTERFACE_IMPLEMENT(factoryName) \
324extern "C" \
325VTK_FACTORY_INTERFACE_EXPORT \
326const char* vtkGetFactoryCompilerUsed() \
327{ \
328 return VTK_CXX_COMPILER; \
329} \
330extern "C" \
331VTK_FACTORY_INTERFACE_EXPORT \
332const char* vtkGetFactoryVersion() \
333{ \
334 return VTK_SOURCE_VERSION; \
335} \
336extern "C" \
337VTK_FACTORY_INTERFACE_EXPORT \
338vtkObjectFactory* vtkLoad() \
339{ \
340 return factoryName ::New(); \
341}
342
343// Macro to implement the body of the object factory form of the New() method.
344#define VTK_OBJECT_FACTORY_NEW_BODY(thisClass) \
345 vtkObject* ret = vtkObjectFactory::CreateInstance(#thisClass, false); \
346 if(ret) \
347 { \
348 return static_cast<thisClass*>(ret); \
349 } \
350 thisClass *result = new thisClass; \
351 result->InitializeObjectBase(); \
352 return result;
353
354// Macro to implement the body of the abstract object factory form of the New()
355// method, i.e. an abstract base class that can only be instantiated if the
356// object factory overrides it.
357#define VTK_ABSTRACT_OBJECT_FACTORY_NEW_BODY(thisClass) \
358 vtkObject* ret = vtkObjectFactory::CreateInstance(#thisClass, true); \
359 if(ret) \
360 { \
361 return static_cast<thisClass*>(ret); \
362 } \
363 vtkGenericWarningMacro("Error: no override found for '" #thisClass "'."); \
364 return NULL;
365
366// Macro to implement the body of the standard form of the New() method.
367#if defined(VTK_ALL_NEW_OBJECT_FACTORY)
368# define VTK_STANDARD_NEW_BODY(thisClass) \
369 VTK_OBJECT_FACTORY_NEW_BODY(thisClass)
370#else
371# define VTK_STANDARD_NEW_BODY(thisClass) \
372 thisClass *result = new thisClass; \
373 result->InitializeObjectBase(); \
374 return result;
375#endif
376
377// Macro to implement the standard form of the New() method.
378#define vtkStandardNewMacro(thisClass) \
379 thisClass* thisClass::New() \
380 { \
381 VTK_STANDARD_NEW_BODY(thisClass) \
382 }
383
384// Macro to implement the object factory form of the New() method.
385#define vtkObjectFactoryNewMacro(thisClass) \
386 thisClass* thisClass::New() \
387 { \
388 VTK_OBJECT_FACTORY_NEW_BODY(thisClass) \
389 }
390
391// Macro to implement the abstract object factory form of the New() method.
392// That is an abstract base class that can only be instantiated if the
393// object factory overrides it.
394#define vtkAbstractObjectFactoryNewMacro(thisClass) \
395 thisClass* thisClass::New() \
396 { \
397 VTK_ABSTRACT_OBJECT_FACTORY_NEW_BODY(thisClass) \
398 }
create and manipulate unsorted lists of objects
Definition: vtkCollection.h:52
a simple class to control print indentation
Definition: vtkIndent.h:40
maintain a list of object factories
abstract base class for vtkObjectFactories
virtual const char * GetClassOverrideWithName(int index)
Return the name of the class that will override the class at the given index.
virtual const char * GetDescription()=0
Return a descriptive string describing the factory.
virtual void Disable(const char *className)
Set all enable flags for the given class to 0.
void PrintSelf(ostream &os, vtkIndent indent) override
Print ObjectFactory to stream.
static void SetAllEnableFlags(vtkTypeBool flag, const char *className)
Set the enable flag for a given named class for all registered factories.
static void ConstructInstance(const char *vtkclassname)
No longer used.
virtual vtkTypeBool GetEnableFlag(int index)
Return the enable flag for the class at the given index.
virtual const char * GetVTKSourceVersion()=0
All sub-classes of vtkObjectFactory should must return the version of VTK they were built with.
virtual const char * GetClassOverrideName(int index)
Return the name of a class override at the given index.
static vtkObjectFactoryCollection * GetRegisteredFactories()
Return the list of all registered factories.
virtual int GetNumberOfOverrides()
Return number of overrides this factory can create.
static void GetOverrideInformation(const char *name, vtkOverrideInformationCollection *)
Fill the given collection with all the overrides for the class with the given name.
virtual void SetEnableFlag(vtkTypeBool flag, const char *className, const char *subclassName)
Set and Get the Enable flag for the specific override of className.
virtual const char * GetOverrideDescription(int index)
Return the description for a the class override at the given index.
static void CreateAllInstance(const char *vtkclassname, vtkCollection *retList)
Create all possible instances of the named vtk object.
OverrideInformation * OverrideArray
static void UnRegisterFactory(vtkObjectFactory *)
Remove a factory from the list of registered factories.
void RegisterOverride(const char *classOverride, const char *overrideClassName, const char *description, int enableFlag, CreateFunction createFunction)
Register object creation information with the factory.
virtual vtkTypeBool GetEnableFlag(const char *className, const char *subclassName)
static int HasOverrideAny(const char *className)
return 1 if one of the registered factories overrides the given class name
virtual vtkObject * CreateObject(const char *vtkclassname)
This method is provided by sub-classes of vtkObjectFactory.
virtual int HasOverride(const char *className)
Return 1 if this factory overrides the given class name, 0 otherwise.
static void ReHash()
Re-check the VTK_AUTOLOAD_PATH for new factory libraries.
static void UnRegisterAllFactories()
Unregister all factories.
static void SetAllEnableFlags(vtkTypeBool flag, const char *className, const char *subclassName)
Set the enable flag for a given named class subclass pair for all registered factories.
~vtkObjectFactory() override
static void RegisterFactory(vtkObjectFactory *)
Register a factory so it can be used to create vtk objects.
virtual int HasOverride(const char *className, const char *subclassName)
Return 1 if this factory overrides the given class name, 0 otherwise.
static VTK_NEWINSTANCE vtkObject * CreateInstance(const char *vtkclassname, bool isAbstract=false)
Create and return an instance of the named vtk object.
abstract base class for most VTK objects
Definition: vtkObject.h:60
maintain a list of override information objects
@ description
Definition: vtkX3D.h:322
@ name
Definition: vtkX3D.h:219
@ index
Definition: vtkX3D.h:246
int vtkTypeBool
Definition: vtkABI.h:69
static vtkObjectFactoryRegistryCleanup vtkObjectFactoryRegistryCleanupInstance
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.
#define VTK_NEWINSTANCE