vtkMarshalContext.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 vtkMarshalContext_h
#define vtkMarshalContext_h
 
#include "vtkObject.h"
 
#include "vtkCommonCoreModule.h" // for export macro
#include "vtkSmartPointer.h"     // for vtkSmartPointer
#include "vtkTypeUInt8Array.h"   // for vtkTypeUInt8Array
#include "vtkWeakPointer.h"      // for vtkWeakPointer
 
// clang-format off
#include "vtk_nlohmannjson.h"        // for json
#include VTK_NLOHMANN_JSON(json.hpp) // for json
// clang-format on
 
#include <memory> // for unique_ptr
#include <set>    // for set
 
typedef int (*vtkMarshalContextRegistrarFunc)(
  void* ser, void* deser, void* invoker, const char** error);
 
VTK_ABI_NAMESPACE_BEGIN
class VTKCOMMONCORE_EXPORT vtkMarshalContext : public vtkObject
{
public:
  vtkTypeMacro(vtkMarshalContext, vtkObject);
  static vtkMarshalContext* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  using WeakObjectStore = std::map<vtkTypeUInt32, vtkWeakPointer<vtkObjectBase>>;
  using StrongObjectStore = std::map<std::string, std::set<vtkSmartPointer<vtkObjectBase>>>;

  static void AddRegistrar(vtkMarshalContextRegistrarFunc registrar);

  static bool CallRegistrars(void* ser, void* deser, void* invoker, const char** error);

  const nlohmann::json& Blobs() const;

  const nlohmann::json& States() const;

  const WeakObjectStore& WeakObjects() const;

  const StrongObjectStore& StrongObjects() const;

  void KeepAlive(const std::string& owner, vtkObjectBase* objectBase);

  void Retire(const std::string& owner, vtkObjectBase* objectBase);

  bool RegisterState(nlohmann::json state);

  bool UnRegisterState(vtkTypeUInt32 identifier);

  nlohmann::json& GetState(vtkTypeUInt32 identifier) const;

  bool RegisterObject(vtkObjectBase* objectBase, vtkTypeUInt32& identifier);

  bool UnRegisterObject(vtkTypeUInt32 identifier);

  vtkSmartPointer<vtkObjectBase> GetObjectAtId(vtkTypeUInt32 identifier) const;

  vtkTypeUInt32 GetId(vtkObjectBase* objectBase) const;

  bool RegisterBlob(vtkSmartPointer<vtkTypeUInt8Array> blob, std::string& hash);

  bool UnRegisterBlob(const std::string& hash);

  vtkSmartPointer<vtkTypeUInt8Array> GetBlob(const std::string& hash, bool copy = true);

  std::vector<vtkTypeUInt32> GetDirectDependencies(vtkTypeUInt32 identifier) const;

  void ResetDirectDependencies();

  void ResetDirectDependenciesForNode(vtkTypeUInt32 identifier);

  vtkTypeUInt32 MakeId();


  void SetAllocateIdsDescending(bool allocateIdsDescending);
  bool GetAllocateIdsDescending() const;

  class ScopedParentTracker
  {
    vtkMarshalContext* Context = nullptr;
 
  public:
    explicit ScopedParentTracker(vtkMarshalContext* context, vtkTypeUInt32 identifier)
      : Context(context)
    {
      if (this->Context)
      {
        this->Context->PushParent(identifier);
      }
    }
 
    ~ScopedParentTracker()
    {
      if (this->Context)
      {
        this->Context->PopParent();
      }
    }
 
    ScopedParentTracker(const ScopedParentTracker&) = delete;
    void operator=(const ScopedParentTracker&) = delete;
    ScopedParentTracker(ScopedParentTracker&&) = delete;
    void operator=(ScopedParentTracker&&) = delete;
  };

  void PushParent(vtkTypeUInt32 identifier);

  void PopParent();
 
protected:
  vtkMarshalContext();
  ~vtkMarshalContext() override;

  bool HasId(vtkObjectBase* objectBase, vtkTypeUInt32& identifier);

  bool IsProcessing(vtkTypeUInt32 identifier);

  bool IsProcessed(vtkTypeUInt32 identifier);

  void AddChild(vtkTypeUInt32 identifier);
 
private:
  vtkMarshalContext(const vtkMarshalContext&) = delete;
  void operator=(const vtkMarshalContext&) = delete;
 
  friend class vtkDeserializer;
  friend class vtkSerializer;
 
  class vtkInternals;
  std::unique_ptr<vtkInternals> Internals;
 
  static std::vector<vtkMarshalContextRegistrarFunc>& GetSerDesRegistrars();
};
 
VTK_ABI_NAMESPACE_END
#endif