You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
232 lines
10 KiB
C++
232 lines
10 KiB
C++
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkInformationKey.h
|
|
|
|
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
|
|
All rights reserved.
|
|
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
/**
|
|
* @class vtkInformationKey
|
|
* @brief Superclass for vtkInformation keys.
|
|
*
|
|
* vtkInformationKey is the superclass for all keys used to access the
|
|
* map represented by vtkInformation. The vtkInformation::Set and
|
|
* vtkInformation::Get methods of vtkInformation are accessed by
|
|
* information keys. A key is a pointer to an instance of a subclass
|
|
* of vtkInformationKey. The type of the subclass determines the
|
|
* overload of Set/Get that is selected. This ensures that the type
|
|
* of value stored in a vtkInformation instance corresponding to a
|
|
* given key matches the type expected for that key.
|
|
*/
|
|
|
|
#ifndef vtkInformationKey_h
|
|
#define vtkInformationKey_h
|
|
|
|
#include "vtkCommonCoreModule.h" // For export macro
|
|
#include "vtkObject.h" // Need vtkTypeMacro
|
|
#include "vtkObjectBase.h"
|
|
|
|
class vtkInformation;
|
|
|
|
class VTKCOMMONCORE_EXPORT vtkInformationKey : public vtkObjectBase
|
|
{
|
|
public:
|
|
vtkBaseTypeMacro(vtkInformationKey, vtkObjectBase);
|
|
void PrintSelf(ostream& os, vtkIndent indent) override;
|
|
|
|
/**
|
|
* Prevent normal vtkObject reference counting behavior.
|
|
*/
|
|
void Register(vtkObjectBase*) override;
|
|
|
|
/**
|
|
* Prevent normal vtkObject reference counting behavior.
|
|
*/
|
|
void UnRegister(vtkObjectBase*) override;
|
|
|
|
/**
|
|
* Get the name of the key. This is not the type of the key, but
|
|
* the name of the key instance.
|
|
*/
|
|
const char* GetName();
|
|
|
|
/**
|
|
* Get the location of the key. This is the name of the class in
|
|
* which the key is defined.
|
|
*/
|
|
const char* GetLocation();
|
|
|
|
//@{
|
|
/**
|
|
* Key instances are static data that need to be created and
|
|
* destroyed. The constructor and destructor must be public. The
|
|
* name of the static instance and the class in which it is defined
|
|
* should be passed to the constructor. They must be string
|
|
* literals because the strings are not copied.
|
|
*/
|
|
vtkInformationKey(const char* name, const char* location);
|
|
~vtkInformationKey() override;
|
|
//@}
|
|
|
|
/**
|
|
* Copy the entry associated with this key from one information
|
|
* object to another. If there is no entry in the first information
|
|
* object for this key, the value is removed from the second.
|
|
*/
|
|
virtual void ShallowCopy(vtkInformation* from, vtkInformation* to) = 0;
|
|
|
|
/**
|
|
* Duplicate (new instance created) the entry associated with this key from
|
|
* one information object to another (new instances of any contained
|
|
* vtkInformation and vtkInformationVector objects are created).
|
|
* Default implementation simply calls ShallowCopy().
|
|
*/
|
|
virtual void DeepCopy(vtkInformation* from, vtkInformation* to) { this->ShallowCopy(from, to); }
|
|
|
|
/**
|
|
* Check whether this key appears in the given information object.
|
|
*/
|
|
virtual int Has(vtkInformation* info);
|
|
|
|
/**
|
|
* Remove this key from the given information object.
|
|
*/
|
|
virtual void Remove(vtkInformation* info);
|
|
|
|
/**
|
|
* Report a reference this key has in the given information object.
|
|
*/
|
|
virtual void Report(vtkInformation* info, vtkGarbageCollector* collector);
|
|
|
|
//@{
|
|
/**
|
|
* Print the key's value in an information object to a stream.
|
|
*/
|
|
void Print(vtkInformation* info);
|
|
virtual void Print(ostream& os, vtkInformation* info);
|
|
//@}
|
|
|
|
/**
|
|
* This function is only relevant when the pertaining key
|
|
* is used in a VTK pipeline. Specific keys that handle
|
|
* pipeline data requests (for example, UPDATE_PIECE_NUMBER)
|
|
* can overwrite this method to notify the pipeline that a
|
|
* a filter should be (re-)executed because what is in
|
|
* the current output is different that what is being requested
|
|
* by the key. For example, DATA_PIECE_NUMBER != UPDATE_PIECE_NUMBER.
|
|
*/
|
|
virtual bool NeedToExecute(
|
|
vtkInformation* vtkNotUsed(pipelineInfo), vtkInformation* vtkNotUsed(dobjInfo))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* This function is only relevant when the pertaining key
|
|
* is used in a VTK pipeline. Specific keys that handle
|
|
* pipeline data requests (for example, UPDATE_PIECE_NUMBER)
|
|
* can overwrite this method to store in the data information
|
|
* meta-data about the request that led to the current filter
|
|
* execution. This meta-data can later be used to compare what
|
|
* is being requested to decide whether the filter needs to
|
|
* re-execute. For example, a filter may store the current
|
|
* UPDATE_PIECE_NUMBER in the data object's information as
|
|
* the DATA_PIECE_NUMBER. DATA_PIECE_NUMBER can later be compared
|
|
* to a new UPDATA_PIECE_NUMBER to decide whether a filter should
|
|
* re-execute.
|
|
*/
|
|
virtual void StoreMetaData(vtkInformation* vtkNotUsed(request),
|
|
vtkInformation* vtkNotUsed(pipelineInfo), vtkInformation* vtkNotUsed(dobjInfo))
|
|
{
|
|
}
|
|
|
|
/**
|
|
* This function is only relevant when the pertaining key
|
|
* is used in a VTK pipeline. By overwriting this method, a
|
|
* key can decide if/how to copy itself downstream or upstream
|
|
* during a particular pipeline pass. For example, meta-data keys
|
|
* can copy themselves during REQUEST_INFORMATION whereas request
|
|
* keys can copy themselves during REQUEST_UPDATE_EXTENT.
|
|
*/
|
|
virtual void CopyDefaultInformation(vtkInformation* vtkNotUsed(request),
|
|
vtkInformation* vtkNotUsed(fromInfo), vtkInformation* vtkNotUsed(toInfo))
|
|
{
|
|
}
|
|
|
|
protected:
|
|
char* Name;
|
|
char* Location;
|
|
|
|
#define vtkInformationKeySetStringMacro(name) \
|
|
virtual void Set##name(const char* _arg) \
|
|
{ \
|
|
if (this->name == nullptr && _arg == nullptr) \
|
|
{ \
|
|
return; \
|
|
} \
|
|
if (this->name && _arg && (!strcmp(this->name, _arg))) \
|
|
{ \
|
|
return; \
|
|
} \
|
|
delete[] this->name; \
|
|
if (_arg) \
|
|
{ \
|
|
size_t n = strlen(_arg) + 1; \
|
|
char* cp1 = new char[n]; \
|
|
const char* cp2 = (_arg); \
|
|
this->name = cp1; \
|
|
do \
|
|
{ \
|
|
*cp1++ = *cp2++; \
|
|
} while (--n); \
|
|
} \
|
|
else \
|
|
{ \
|
|
this->name = nullptr; \
|
|
} \
|
|
}
|
|
|
|
vtkInformationKeySetStringMacro(Name);
|
|
vtkInformationKeySetStringMacro(Location);
|
|
|
|
// Set/Get the value associated with this key instance in the given
|
|
// information object.
|
|
void SetAsObjectBase(vtkInformation* info, vtkObjectBase* value);
|
|
const vtkObjectBase* GetAsObjectBase(vtkInformation* info) const;
|
|
vtkObjectBase* GetAsObjectBase(vtkInformation* info);
|
|
|
|
// Report the object associated with this key instance in the given
|
|
// information object to the collector.
|
|
void ReportAsObjectBase(vtkInformation* info, vtkGarbageCollector* collector);
|
|
|
|
// Helper for debug leaks support.
|
|
void ConstructClass(const char*);
|
|
|
|
private:
|
|
vtkInformationKey(const vtkInformationKey&) = delete;
|
|
void operator=(const vtkInformationKey&) = delete;
|
|
};
|
|
|
|
// Macros to define an information key instance in a C++ source file.
|
|
// The corresponding method declaration must appear in the class
|
|
// definition in the header file.
|
|
#define vtkInformationKeyMacro(CLASS, NAME, type) \
|
|
static vtkInformation##type##Key* CLASS##_##NAME = new vtkInformation##type##Key(#NAME, #CLASS); \
|
|
vtkInformation##type##Key* CLASS::NAME() { return CLASS##_##NAME; }
|
|
#define vtkInformationKeySubclassMacro(CLASS, NAME, type, super) \
|
|
static vtkInformation##type##Key* CLASS##_##NAME = new vtkInformation##type##Key(#NAME, #CLASS); \
|
|
vtkInformation##super##Key* CLASS::NAME() { return CLASS##_##NAME; }
|
|
#define vtkInformationKeyRestrictedMacro(CLASS, NAME, type, required) \
|
|
static vtkInformation##type##Key* CLASS##_##NAME = \
|
|
new vtkInformation##type##Key(#NAME, #CLASS, required); \
|
|
vtkInformation##type##Key* CLASS::NAME() { return CLASS##_##NAME; }
|
|
|
|
#endif
|