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();

  bool InitializeExtensionModuleHandlers(
    const std::vector<vtkSessionObjectManagerRegistrarFunc>& registrars);
  bool InitializeExtensionModuleHandlers(
    const vtkSessionObjectManagerRegistrarFunc* registrars, std::size_t count);

  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 = true) 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);


  bool UpdateObjectFromState(const std::string& state);
  bool 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);

  vtkSmartPointer<vtkUnsignedCharArray> ExportToBytes();

  std::vector<vtkSmartPointer<vtkObjectBase>> ImportFromBytes(
    vtkSmartPointer<vtkUnsignedCharArray> byteArray);

  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;

  std::vector<vtkTypeUInt32> ImportFromJSON(const nlohmann::json& json);

  static const char* KEPT_ALIVE_KEY() { return "vtk-object-manager-kept-alive"; }

  bool IsKeptAlive(vtkObjectBase* object);

  void MarkKeptAlive(vtkObjectBase* object, vtkTypeUInt32 identifier);
};
VTK_ABI_NAMESPACE_END
#endif