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 
50 class vtkCollection;
51 
52 class VTKCOMMONCORE_EXPORT vtkObjectFactory : public vtkObject
53 {
54 public:
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();
102  static void UnRegisterAllFactories();
103 
109 
114  static int HasOverrideAny(const char* className);
115 
120  static void GetOverrideInformation(const char* name,
122 
127  static void SetAllEnableFlags(vtkTypeBool flag,
128  const char* className);
133  static void SetAllEnableFlags(vtkTypeBool flag,
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 
224 protected:
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  {
247  char* Description;
250  CreateFunction CreateCallback;
251  };
252 
257 
258 private:
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;
288 private:
289  vtkObjectFactory(const vtkObjectFactory&) VTK_DELETE_FUNCTION;
290  void operator=(const vtkObjectFactory&) VTK_DELETE_FUNCTION;
291 };
292 
293 // Implementation detail for Schwartz counter idiom.
294 class VTKCOMMONCORE_EXPORT vtkObjectFactoryRegistryCleanup
295 {
296 public:
299 
300 private:
301  vtkObjectFactoryRegistryCleanup(const vtkObjectFactoryRegistryCleanup& other) VTK_DELETE_FUNCTION;
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) \
311 static 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) \
324 extern "C" \
325 VTK_FACTORY_INTERFACE_EXPORT \
326 const char* vtkGetFactoryCompilerUsed() \
327 { \
328  return VTK_CXX_COMPILER; \
329 } \
330 extern "C" \
331 VTK_FACTORY_INTERFACE_EXPORT \
332 const char* vtkGetFactoryVersion() \
333 { \
334  return VTK_SOURCE_VERSION; \
335 } \
336 extern "C" \
337 VTK_FACTORY_INTERFACE_EXPORT \
338 vtkObjectFactory* 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  }
vtkOverrideInformationCollection
maintain a list of override information objects
Definition: vtkOverrideInformationCollection.h:37
vtkObjectFactory::CreateObject
virtual vtkObject * CreateObject(const char *vtkclassname)
This method is provided by sub-classes of vtkObjectFactory.
vtkObjectFactory::CreateAllInstance
static void CreateAllInstance(const char *vtkclassname, vtkCollection *retList)
Create all possible instances of the named vtk object.
vtkObjectFactory::RegisterFactory
static void RegisterFactory(vtkObjectFactory *)
Register a factory so it can be used to create vtk objects.
vtkObjectFactory::vtkObjectFactory
vtkObjectFactory()
vtkObjectFactory::GetOverrideDescription
virtual const char * GetOverrideDescription(int index)
Return the description for a the class override at the given index.
vtkObjectFactory::SizeOverrideArray
int SizeOverrideArray
Definition: vtkObjectFactory.h:255
vtkObjectFactoryRegistryCleanupInstance
static vtkObjectFactoryRegistryCleanup vtkObjectFactoryRegistryCleanupInstance
Definition: vtkObjectFactory.h:304
vtkObjectFactory::GetOverrideInformation
static void GetOverrideInformation(const char *name, vtkOverrideInformationCollection *)
Fill the given collection with all the overrides for the class with the given name.
vtkObjectFactory::OverrideInformation::CreateCallback
CreateFunction CreateCallback
Definition: vtkObjectFactory.h:250
vtkObjectFactory::SetEnableFlag
virtual void SetEnableFlag(vtkTypeBool flag, const char *className, const char *subclassName)
Set and Get the Enable flag for the specific override of className.
vtkObjectFactory::HasOverride
virtual int HasOverride(const char *className)
Return 1 if this factory overrides the given class name, 0 otherwise.
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:60
vtkObjectFactoryRegistryCleanup
Definition: vtkObjectFactory.h:295
vtkObjectFactory::GetEnableFlag
virtual vtkTypeBool GetEnableFlag(int index)
Return the enable flag for the class at the given index.
vtkObjectFactory::ReHash
static void ReHash()
Re-check the VTK_AUTOLOAD_PATH for new factory libraries.
vtkObjectFactory::Disable
virtual void Disable(const char *className)
Set all enable flags for the given class to 0.
vtkObjectFactory::GetClassOverrideName
virtual const char * GetClassOverrideName(int index)
Return the name of a class override at the given index.
vtkObjectFactory::GetNumberOfOverrides
virtual int GetNumberOfOverrides()
Return number of overrides this factory can create.
vtkObjectFactory::UnRegisterFactory
static void UnRegisterFactory(vtkObjectFactory *)
Remove a factory from the list of registered factories.
vtkObjectFactory::RegisterOverride
void RegisterOverride(const char *classOverride, const char *overrideClassName, const char *description, int enableFlag, CreateFunction createFunction)
Register object creation information with the factory.
vtkObjectFactory::OverrideClassNames
char ** OverrideClassNames
Definition: vtkObjectFactory.h:254
vtkObjectFactory::OverrideArrayLength
int OverrideArrayLength
Definition: vtkObjectFactory.h:256
vtkObjectFactoryRegistryCleanup::vtkObjectFactoryRegistryCleanup
vtkObjectFactoryRegistryCleanup()
vtkObjectFactoryRegistryCleanup::~vtkObjectFactoryRegistryCleanup
~vtkObjectFactoryRegistryCleanup()
vtkObjectFactory::OverrideInformation::Description
char * Description
Definition: vtkObjectFactory.h:247
vtkDebugLeaksManager.h
vtkCollection
create and manipulate unsorted lists of objects
Definition: vtkCollection.h:52
vtkObjectFactory
abstract base class for vtkObjectFactories
Definition: vtkObjectFactory.h:53
vtkObjectFactory::HasOverrideAny
static int HasOverrideAny(const char *className)
return 1 if one of the registered factories overrides the given class name
vtkObjectFactory::GetRegisteredFactories
static vtkObjectFactoryCollection * GetRegisteredFactories()
Return the list of all registered factories.
vtkObjectFactory::OverrideInformation::OverrideWithName
char * OverrideWithName
Definition: vtkObjectFactory.h:248
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:40
vtkObjectFactory::UnRegisterAllFactories
static void UnRegisterAllFactories()
Unregister all factories.
vtkObjectFactory::HasOverride
virtual int HasOverride(const char *className, const char *subclassName)
Return 1 if this factory overrides the given class name, 0 otherwise.
vtkObjectFactory::OverrideInformation::EnabledFlag
vtkTypeBool EnabledFlag
Definition: vtkObjectFactory.h:249
vtkObjectFactory::SetAllEnableFlags
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::ConstructInstance
static void ConstructInstance(const char *vtkclassname)
No longer used.
vtkObjectFactory::CreateInstance
static VTK_NEWINSTANCE vtkObject * CreateInstance(const char *vtkclassname, bool isAbstract=false)
Create and return an instance of the named vtk object.
vtkGetStringMacro
vtkGetStringMacro(ExtensionsString)
Returns a string listing all available extensions.
vtkObjectFactoryCollection
maintain a list of object factories
Definition: vtkObjectFactoryCollection.h:35
vtkX3D::name
@ name
Definition: vtkX3D.h:219
vtkObject.h
vtkObjectFactory::SetAllEnableFlags
static void SetAllEnableFlags(vtkTypeBool flag, const char *className)
Set the enable flag for a given named class for all registered factories.
vtkObjectFactory::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Print ObjectFactory to stream.
vtkX3D::description
@ description
Definition: vtkX3D.h:322
vtkObjectFactory::OverrideInformation
Definition: vtkObjectFactory.h:246
vtkObjectFactory::~vtkObjectFactory
~vtkObjectFactory() override
vtkObjectFactory::OverrideArray
OverrideInformation * OverrideArray
Definition: vtkObjectFactory.h:253
VTK_NEWINSTANCE
#define VTK_NEWINSTANCE
Definition: vtkWrappingHints.h:30
vtkObjectFactory::GetDescription
virtual const char * GetDescription()=0
Return a descriptive string describing the factory.
vtkX3D::index
@ index
Definition: vtkX3D.h:246
vtkObjectFactory::GetClassOverrideWithName
virtual const char * GetClassOverrideWithName(int index)
Return the name of the class that will override the class at the given index.
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkObjectFactory::GetVTKSourceVersion
virtual const char * GetVTKSourceVersion()=0
All sub-classes of vtkObjectFactory should must return the version of VTK they were built with.
vtkObjectFactory::GetEnableFlag
virtual vtkTypeBool GetEnableFlag(const char *className, const char *subclassName)