vtkInformationKey.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkInformationKey_h
#define vtkInformationKey_h
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkObject.h"           // Need vtkTypeMacro
#include "vtkObjectBase.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkInformation;
class vtkCommonInformationKeyManager;
class vtkFilteringInformationKeyManager;
 
class VTKCOMMONCORE_EXPORT vtkInformationKey : public vtkObjectBase
{
public:
  friend class vtkCommonInformationKeyManager;
  friend class vtkFilteringInformationKeyManager;
 
  vtkBaseTypeMacro(vtkInformationKey, vtkObjectBase);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  const char* GetName() VTK_FUTURE_CONST;

  const char* GetLocation() VTK_FUTURE_CONST;


  vtkInformationKey(const char* name, const char* location);
  ~vtkInformationKey() override;

  virtual void ShallowCopy(vtkInformation* from, vtkInformation* to) = 0;

  virtual void DeepCopy(vtkInformation* from, vtkInformation* to) { this->ShallowCopy(from, to); }

  virtual int Has(VTK_FUTURE_CONST vtkInformation* info) VTK_FUTURE_CONST;

  virtual void Remove(vtkInformation* info);

  virtual void Report(vtkInformation* info, vtkGarbageCollector* collector);


  void Print(vtkInformation* info);
  virtual void Print(ostream& os, vtkInformation* info);

  virtual bool NeedToExecute(
    vtkInformation* vtkNotUsed(pipelineInfo), vtkInformation* vtkNotUsed(dobjInfo))
  {
    return false;
  }

  virtual void StoreMetaData(vtkInformation* vtkNotUsed(request),
    vtkInformation* vtkNotUsed(pipelineInfo), vtkInformation* vtkNotUsed(dobjInfo))
  {
  }

  virtual void CopyDefaultInformation(vtkInformation* vtkNotUsed(request),
    vtkInformation* vtkNotUsed(fromInfo), vtkInformation* vtkNotUsed(toInfo))
  {
  }
 
protected:
  using ManagerUnregisterCallback = void (*)(vtkInformationKey*);

  void SetManagerUnregisterCallback(ManagerUnregisterCallback callback)
  {
    this->ManagerCallback = callback;
  }
 
  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(VTK_FUTURE_CONST 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;
 
  ManagerUnregisterCallback ManagerCallback = nullptr;
};
 
// 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;                                                                         \
  }
 
VTK_ABI_NAMESPACE_END
#endif