vtkDeserializer.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 vtkDeserializer_h
#define vtkDeserializer_h
 
#include "vtkObject.h"
 
#include "vtkCommonCoreModule.h" // for export macro
#include "vtkMarshalContext.h"   // for vtkMarshalContext
#include "vtkSmartPointer.h"     // for vktSmartPointer
 
// clang-format off
#include "vtk_nlohmannjson.h"            // for json
#include VTK_NLOHMANN_JSON(json_fwd.hpp) // for json
// clang-format on
 
#include <memory>   // for unique_ptr
#include <typeinfo> // for type_info
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKCOMMONCORE_EXPORT vtkDeserializer : public vtkObject
{
public:
  static vtkDeserializer* New();
  vtkTypeMacro(vtkDeserializer, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  using HandlerType = std::function<void(const nlohmann::json&, vtkObjectBase*, vtkDeserializer*)>;
  using ConstructorType = std::function<vtkObjectBase*()>;
 
  vtkObjectBase* ConstructObject(
    const std::string& className, const std::vector<std::string>& superClassNames);
 
  bool DeserializeJSON(const vtkTypeUInt32& identifier, vtkSmartPointer<vtkObjectBase>& objectBase);
 
 
  void RegisterConstructor(const std::string& className, ConstructorType constructor);
  ConstructorType GetConstructor(
    const std::string& className, const std::vector<std::string>& superClassNames);
  void UnRegisterConstructor(const std::string& className);
 
 
  void RegisterHandler(const std::type_info& type, HandlerType deserializer);
  HandlerType GetHandler(const std::type_info& type) const;
  bool UnRegisterHandler(const std::type_info& type);
 
 
  vtkSetSmartPointerMacro(Context, vtkMarshalContext);
  vtkGetSmartPointerMacro(Context, vtkMarshalContext);
protected:
  vtkDeserializer();
  ~vtkDeserializer() override;
 
  vtkSmartPointer<vtkMarshalContext> Context;
 
private:
  vtkDeserializer(const vtkDeserializer&) = delete;
  void operator=(const vtkDeserializer&) = delete;
  class vtkInternals;
  std::unique_ptr<vtkInternals> Internals;
};
 
#define VTK_DESERIALIZE_VALUE_FROM_STATE(name, type, state, object)                                \
  do                                                                                               \
  {                                                                                                \
    const auto iter = state.find(#name);                                                           \
    if ((iter != state.end()) && !iter->is_null())                                                 \
    {                                                                                              \
      object->Set##name(iter->get<type>());                                                        \
    }                                                                                              \
  } while (0)
 
#define VTK_DESERIALIZE_VTK_OBJECT_FROM_STATE_DIFFERENT_NAMES(                                     \
  stateKey, propertyName, cls, state, object, deserializer)                                        \
  do                                                                                               \
  {                                                                                                \
    const auto iter = state.find(#stateKey);                                                       \
    if ((iter != state.end()) && !iter->is_null())                                                 \
    {                                                                                              \
      const auto* context = deserializer->GetContext();                                            \
      const auto identifier = iter->at("Id").get<vtkTypeUInt32>();                                 \
      auto subObject = context->GetObjectAtId(identifier);                                         \
      deserializer->DeserializeJSON(identifier, subObject);                                        \
      if (auto* asVtkType = cls::SafeDownCast(subObject))                                          \
      {                                                                                            \
        object->Set##propertyName(asVtkType);                                                      \
      }                                                                                            \
    }                                                                                              \
  } while (0)
 
#define VTK_DESERIALIZE_VTK_OBJECT_FROM_STATE(name, cls, state, object, deserializer)              \
  VTK_DESERIALIZE_VTK_OBJECT_FROM_STATE_DIFFERENT_NAMES(                                           \
    name, name, cls, state, object, deserializer)
 
#define VTK_DESERIALIZE_VECTOR_FROM_STATE(name, type, state, object)                               \
  do                                                                                               \
  {                                                                                                \
    const auto iter = state.find(#name);                                                           \
    if ((iter != state.end()) && !iter->is_null())                                                 \
    {                                                                                              \
      using namespace std;                                                                         \
      const auto elements = iter->get<vector<type>>();                                             \
      object->Set##name(elements.data());                                                          \
    }                                                                                              \
  } while (0)
 
VTK_ABI_NAMESPACE_END
#endif