vtkObjectManager.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 vtkObjectManager_h
#define vtkObjectManager_h
 
#include "vtkObject.h"
 
#include "vtkSerializationManagerModule.h" // for export macro
 
#include "vtkDeserializer.h"    // for vtkDeserializer
#include "vtkInvoker.h"         // for vtkInvoker
#include "vtkLogger.h"          // for vtkLogger::Verbosity enum
#include "vtkNew.h"             // for vtkNew
#include "vtkSerializer.h"      // for vtkSerializer
#include "vtkSession.h"         // for vtkSessionObjectManagerRegistrarFunc
#include "vtkSmartPointer.h"    // for vtkSmartPointer
#include "vtkTypeUInt32Array.h" // for vtkTypeUInt32Array
 
#include <string> // for string
#include <vector> // for vector
 
VTK_ABI_NAMESPACE_BEGIN
class vtkMarshalContext;
class vtkTypeUInt8Array;
 
class VTKSERIALIZATIONMANAGER_EXPORT vtkObjectManager : public vtkObject
{
public:
  static vtkObjectManager* New();
  vtkTypeMacro(vtkObjectManager, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  virtual bool Initialize();
  bool InitializeDefaultHandlers();
 
#if !defined(__VTK_WRAP__)
  bool InitializeExtensionModuleHandlers(
    const std::vector<vtkSessionObjectManagerRegistrarFunc>& registrars);
  bool InitializeExtensionModuleHandlers(
    const vtkSessionObjectManagerRegistrarFunc* registrars, std::size_t count);
#endif
 
  bool InitializeExtensionModuleHandler(void* registrar);
 
  vtkTypeUInt32 RegisterObject(vtkSmartPointer<vtkObjectBase> objectBase);
 
  bool UnRegisterObject(vtkTypeUInt32 identifier);
 
 
  bool RegisterState(const std::string& state);
  bool RegisterState(const nlohmann::json& state);
 
  bool UnRegisterState(vtkTypeUInt32 identifier);
 
  vtkTypeUInt32 GetId(vtkSmartPointer<vtkObjectBase> objectBase);
 
  std::string GetState(vtkTypeUInt32 id);
 
  vtkSmartPointer<vtkObjectBase> GetObjectAtId(vtkTypeUInt32 id);
 
 
  std::vector<vtkTypeUInt32> GetAllDependencies(vtkTypeUInt32 identifier);
  vtkSmartPointer<vtkTypeUInt32Array> GetAllDependenciesAsVTKDataArray(vtkTypeUInt32 identifier);
 
  std::vector<std::string> GetBlobHashes(const std::vector<vtkTypeUInt32>& ids);
 
  vtkSmartPointer<vtkTypeUInt8Array> GetBlob(const std::string& hash, bool copy = false) const;
 
  bool RegisterBlob(const std::string& hash, vtkSmartPointer<vtkTypeUInt8Array> blob);
 
  bool UnRegisterBlob(const std::string& hash);
 
  void PruneUnusedBlobs();
 
  void UpdateObjectsFromStates();
 
  void UpdateStatesFromObjects();
 
  void UpdateStatesFromObjects(const std::vector<vtkTypeUInt32>& identifiers);
 
 
  void UpdateObjectFromState(const std::string& state);
  void UpdateObjectFromState(const nlohmann::json& state);
 
  void UpdateStateFromObject(vtkTypeUInt32 identifier);
 
  void Clear();
 
  std::string Invoke(
    vtkTypeUInt32 identifier, const std::string& methodName, const std::string& args);
  nlohmann::json Invoke(
    vtkTypeUInt32 identifier, const std::string& methodName, const nlohmann::json& args);
 
  std::size_t GetTotalBlobMemoryUsage();
  std::size_t GetTotalVTKDataObjectMemoryUsage();
 
  void Export(const std::string& filename, int indentLevel = -1, char indentChar = ' ');
 
  void Import(const std::string& stateFileName, const std::string& blobFileName);
 
  void PruneUnusedStates();
 
  void PruneUnusedObjects();
 
  static vtkTypeUInt32 ROOT() { return 0; }
 
  vtkGetSmartPointerMacro(Serializer, vtkSerializer);
  vtkGetSmartPointerMacro(Deserializer, vtkDeserializer);
  vtkGetSmartPointerMacro(Invoker, vtkInvoker);
 
 
  void SetObjectManagerLogVerbosity(vtkLogger::Verbosity verbosity);
  vtkLogger::Verbosity GetObjectManagerLogVerbosity();
 
protected:
  vtkObjectManager();
  ~vtkObjectManager() override;
 
  vtkSmartPointer<vtkMarshalContext> Context;
  vtkNew<vtkDeserializer> Deserializer;
  vtkNew<vtkSerializer> Serializer;
  vtkNew<vtkInvoker> Invoker;
  vtkLogger::Verbosity ObjectManagerLogVerbosity = vtkLogger::VERBOSITY_INVALID;
 
  static const char* OWNERSHIP_KEY() { return "manager"; }
 
private:
  vtkObjectManager(const vtkObjectManager&) = delete;
  void operator=(const vtkObjectManager&) = delete;
};
VTK_ABI_NAMESPACE_END
#endif