vtkObjectBase.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 vtkObjectBase_h
#define vtkObjectBase_h
 
// Semantics around vtkDebugLeaks usage has changed. Now just call
// vtkObjectBase::InitializeObjectBase() after creating an object with New().
// The object factory methods take care of this automatically.
#define VTK_HAS_INITIALIZE_OBJECT_BASE
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkDeprecation.h"
#include "vtkFeatures.h" // for VTK_USE_MEMKIND
#include "vtkIndent.h"
#include "vtkSystemIncludes.h"
#include "vtkType.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
#include <atomic> // For std::atomic
#include <memory> // for std::weak_ptr
#include <mutex>  // for std::mutex
#include <string>
 
VTK_ABI_NAMESPACE_BEGIN
class vtkGarbageCollector;
class vtkGarbageCollectorToObjectBaseFriendship;
class vtkWeakPointerBase;
class vtkWeakPointerBaseToObjectBaseFriendship;
template <typename T>
class vtkWeakPtr;
 
// typedefs for malloc and free compatible replacement functions
typedef void* (*vtkMallocingFunction)(size_t);
typedef void* (*vtkReallocingFunction)(void*, size_t);
typedef void (*vtkFreeingFunction)(void*);
 
class VTKCOMMONCORE_EXPORT VTK_MARSHALAUTO vtkObjectBase
{
  virtual const char* GetClassNameInternal() const { return "vtkObjectBase"; }
 
public:
#ifdef VTK_WORKAROUND_WINDOWS_MANGLE
// Avoid windows name mangling.
#define GetClassNameA GetClassName
#define GetClassNameW GetClassName
#endif

  VTK_MARSHALGETTER(ClassName)
  const char* GetClassName() const;

  virtual std::string GetObjectDescription() const;
 
#ifdef VTK_WORKAROUND_WINDOWS_MANGLE
#undef GetClassNameW
#undef GetClassNameA
 
  // Define possible mangled names.
  const char* GetClassNameA() const;
  const char* GetClassNameW() const;
 
#endif

  static vtkTypeBool IsTypeOf(const char* name);

  virtual vtkTypeBool IsA(const char* name);

  static vtkIdType GetNumberOfGenerationsFromBaseType(const char* name);

  virtual vtkIdType GetNumberOfGenerationsFromBase(const char* name);

  virtual void Delete();

  virtual void FastDelete();

  static vtkObjectBase* New()
  {
    vtkObjectBase* o = new vtkObjectBase;
    o->InitializeObjectBase();
    return o;
  }
 
  // Called by implementations of vtkObject::New(). Centralized location for
  // vtkDebugLeaks registration.
  void InitializeObjectBase();
 
#if defined(_WIN32) || defined(VTK_USE_MEMKIND)
  // Take control of allocation to avoid dll boundary problems or to use memkind.
  void* operator new(size_t tSize);
  void operator delete(void* p);
#endif

  void Print(ostream& os);


  virtual void PrintSelf(ostream& os, vtkIndent indent);
  virtual void PrintHeader(ostream& os, vtkIndent indent);
  virtual void PrintTrailer(ostream& os, vtkIndent indent);

  void Register(vtkObjectBase* o);

  // XXX(virtual): VTK_DEPRECATED_IN_9_7_0("Override `UsesGarbageCollector()` instead")
  virtual void UnRegister(vtkObjectBase* o);


  virtual bool UsesGarbageCollector() const { return false; }

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  int GetReferenceCount() { return this->ReferenceCount; }

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void SetReferenceCount(int);

  static void SetMemkindDirectory(const char* directoryname);


  static bool GetUsingMemkind();

  class VTKCOMMONCORE_EXPORT vtkMemkindRAII
  {
#ifdef VTK_USE_MEMKIND
    bool OriginalValue;
#endif
 
  public:
    vtkMemkindRAII(bool newValue);
    ~vtkMemkindRAII();
    vtkMemkindRAII(vtkMemkindRAII const&) = default;
 
  private:
    void Save(bool newValue);
    void Restore();
  };

  bool GetIsInMemkind() const;
 
protected:
  vtkObjectBase();
  virtual ~vtkObjectBase();
 
  std::atomic<int32_t> ReferenceCount;
  vtkWeakPointerBase** WeakPointers;
 
  // Internal Register/UnRegister implementation that accounts for
  // possible garbage collection participation.  The second argument
  // indicates whether to participate in garbage collection.
  virtual void RegisterInternal(vtkObjectBase*, vtkTypeBool check);
  virtual void UnRegisterInternal(vtkObjectBase*, vtkTypeBool check);
 
  // See vtkGarbageCollector.h:
  virtual void ReportReferences(vtkGarbageCollector*);
 
  // Call this to call from either malloc or memkind_malloc depending on current UsingMemkind
  static vtkMallocingFunction GetCurrentMallocFunction();
  // Call this to call from either realloc or memkind_realloc depending on current UsingMemkind
  static vtkReallocingFunction GetCurrentReallocFunction();
  // Call this to call from either free or memkind_free depending on instance's IsInMemkind
  static vtkFreeingFunction GetCurrentFreeFunction();
  // Call this to unconditionally call memkind_free
  static vtkFreeingFunction GetAlternateFreeFunction();
 
  virtual void ObjectFinalize();
 
private:
  friend VTKCOMMONCORE_EXPORT ostream& operator<<(ostream& os, vtkObjectBase& o);
  friend class vtkGarbageCollectorToObjectBaseFriendship;
  friend class vtkWeakPointerBaseToObjectBaseFriendship;
 
  friend class vtkMemkindRAII;
  friend class vtkTDSCMemkindRAII;
  static void SetUsingMemkind(bool);
  bool IsInMemkind;
  void SetIsInMemkind(bool);

  template <typename T>
  friend class vtkWeakPtr;
  struct WeakControlBlock
  {
    WeakControlBlock(vtkObjectBase* obj)
      : Object(obj)
    {
    }
 
    vtkObjectBase* Object;
    std::mutex Mutex;
  };
  bool TryUpgradeRegister(vtkObjectBase* o);
  std::shared_ptr<WeakControlBlock> GetWeakControlBlock();
  std::mutex WeakBlockMutex;
  std::weak_ptr<WeakControlBlock> WeakBlock;


  friend class vtkInformationKey;
  friend class vtkGarbageCollector;
  void ClearReferenceCounts();
 
  friend class vtkDebugLeaks;
  virtual const char* GetDebugClassName() const;
 
protected:
  vtkObjectBase(const vtkObjectBase&) {}
  void operator=(const vtkObjectBase&) {}
};
VTK_ABI_NAMESPACE_END
#endif
 
// VTK-HeaderTest-Exclude: vtkObjectBase.h