vtkMRMLNode.h

Go to the documentation of this file.

/*=auto=========================================================================
 
  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Program:   3D Slicer
  Module:    $RCSfile: vtkMRMLNode.h,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.18 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLNode_h
#define __vtkMRMLNode_h
 
// MRML includes
#include "vtkMRML.h"
#include "vtkObserverManager.h"
#include "vtkIdTypeArray.h"
#include "vtkIntArray.h"
#include "vtkMRMLI18N.h"
 
class vtkMRMLScene;
class vtkStringArray;
 
// VTK includes
#include <vtkObject.h>
#include <vtkSmartPointer.h>
#include <vtkWeakPointer.h>
class vtkCallbackCommand;
 
// Slicer VTK add-on includes
#include <vtkLoggingMacros.h>
 
// Helper macros for simplifying reading, writing, copying, and printing node properties.
#include "vtkMRMLNodePropertyMacros.h"
 
// STD includes
#include <map>
#include <set>
#include <string>
#include <vector>
 
#ifndef vtkSetMRMLObjectMacro
# define vtkSetMRMLObjectMacro(node, value)                                    \
   {                                                                           \
     this->MRMLObserverManager->SetObject(vtkObjectPointer(&(node)), (value)); \
   };
#endif

#ifndef vtkSetAndObserveMRMLObjectMacro
# define vtkSetAndObserveMRMLObjectMacro(node, value)                                    \
   {                                                                                     \
     this->MRMLObserverManager->SetAndObserveObject(vtkObjectPointer(&(node)), (value)); \
   };
#endif
 
#ifndef vtkSetAndObserveMRMLObjectMacroNoWarning
# define vtkSetAndObserveMRMLObjectMacroNoWarning(node, value)                                                        \
   {                                                                                                                  \
     this->MRMLObserverManager->SetAndObserveObject(vtkObjectPointer(&(node)), (value), 0.0, false /* no warning */); \
   };
#endif
 
#ifndef vtkSetAndObserveMRMLObjectEventsMacro
# define vtkSetAndObserveMRMLObjectEventsMacro(node, value, events)                                      \
   {                                                                                                     \
     this->MRMLObserverManager->SetAndObserveObjectEvents(vtkObjectPointer(&(node)), (value), (events)); \
   };
#endif
 
#ifndef vtkSetAndObserveMRMLObjectEventsMacroNoWarning
# define vtkSetAndObserveMRMLObjectEventsMacroNoWarning(node, value, events)                                                                               \
   {                                                                                                                                                       \
     this->MRMLObserverManager->SetAndObserveObjectEvents(vtkObjectPointer(&(node)), (value), (events), nullptr /* priorities */, false /* no warning */); \
   };
#endif
 
#ifndef vtkObserveMRMLObjectMacro
# define vtkObserveMRMLObjectMacro(node)               \
   {                                                   \
     this->MRMLObserverManager->ObserveObject((node)); \
   };
#endif
 
#ifndef vtkObserveMRMLObjectEventMacro
# define vtkObserveMRMLObjectEventMacro(node, event)             \
   {                                                             \
     this->MRMLObserverManager->AddObjectEvent((node), (event)); \
   };
#endif
 
#ifndef vtkObserveMRMLObjectEventMacroNoWarning
# define vtkObserveMRMLObjectEventMacroNoWarning(node, event)                \
   {                                                                         \
     this->MRMLObserverManager->AddObjectEvent((node), (event), 0.0, false); \
   };
#endif
 
#ifndef vtkObserveMRMLObjectEventsMacro
# define vtkObserveMRMLObjectEventsMacro(node, events)             \
   {                                                               \
     this->MRMLObserverManager->AddObjectEvents((node), (events)); \
   };
#endif
 
#ifndef vtkUnObserveMRMLObjectMacro
# define vtkUnObserveMRMLObjectMacro(node)                  \
   {                                                        \
     this->MRMLObserverManager->RemoveObjectEvents((node)); \
   };
#endif
 
#ifndef vtkSetReferenceStringBodyMacro
# define vtkSetReferenceStringBodyMacro(name)                                                                           \
   vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting " << #name " to " << (_arg ? _arg : "(null)")); \
   if (this->name == nullptr && _arg == nullptr)                                                                        \
   {                                                                                                                    \
     return;                                                                                                            \
   }                                                                                                                    \
   if (this->name && _arg && (!strcmp(this->name, _arg)))                                                               \
   {                                                                                                                    \
     return;                                                                                                            \
   }                                                                                                                    \
   std::string oldValue;                                                                                                \
   if (this->name)                                                                                                      \
   {                                                                                                                    \
     oldValue = this->name;                                                                                             \
     delete[] this->name;                                                                                               \
   }                                                                                                                    \
   if (_arg)                                                                                                            \
   {                                                                                                                    \
     size_t n = strlen(_arg) + 1;                                                                                       \
     char* cp1 = new char[n];                                                                                           \
     const char* cp2 = (_arg);                                                                                          \
     this->name = cp1;                                                                                                  \
     do                                                                                                                 \
     {                                                                                                                  \
       *cp1++ = *cp2++;                                                                                                 \
     } while (--n);                                                                                                     \
   }                                                                                                                    \
   else                                                                                                                 \
   {                                                                                                                    \
     this->name = nullptr;                                                                                              \
   }                                                                                                                    \
   this->Modified();                                                                                                    \
   if (this->Scene && this->name)                                                                                       \
   {                                                                                                                    \
     if (oldValue.size() > 0)                                                                                           \
     {                                                                                                                  \
       this->Scene->RemoveReferencedNodeID(oldValue.c_str(), this);                                                     \
     }                                                                                                                  \
     this->Scene->AddReferencedNodeID(this->name, this);                                                                \
   }
#endif
 
#ifndef vtkSetReferenceStringMacro
# define vtkSetReferenceStringMacro(name)   \
   virtual void Set##name(const char* _arg) \
   {                                        \
     vtkSetReferenceStringBodyMacro(name)   \
   }
#endif
 
#ifndef vtkCxxSetReferenceStringMacro
# define vtkCxxSetReferenceStringMacro(class, name) \
   void class ::Set##name(const char* _arg)         \
   {                                                \
     vtkSetReferenceStringBodyMacro(name);          \
   }
#endif
 
#ifndef vtkMRMLNodeNewMacro
# define vtkMRMLNodeNewMacro(newClass)         \
   vtkStandardNewMacro(newClass);              \
   vtkMRMLNode* newClass::CreateNodeInstance() \
   {                                           \
     return newClass::New();                   \
   }
#endif
 
// Use this macro to declare that this node supports
// CopyContent.It also declares CopyContent and
// HasCopyContent methods.
//
// The use of HasCopyContent() may be needed to determine if
// a specific node class has implemented CopyContent (if only
// a parent class implemented it that may not be enough).
//
#ifndef vtkMRMLCopyContentMacro
# define vtkMRMLCopyContentMacro(thisClassName)                        \
   void CopyContent(vtkMRMLNode* node, bool deepCopy = true) override; \
   bool HasCopyContent() const override                                \
   {                                                                   \
     return strcmp(#thisClassName, this->GetClassNameInternal()) == 0; \
   }
#endif
 
// Use this macro to declare that this node supports
// CopyContent by only declaring HasCopyContent without
// implementing CopyContent method
// (this is the case when parent classes copy all content).
#ifndef vtkMRMLCopyContentDefaultMacro
# define vtkMRMLCopyContentDefaultMacro(thisClassName)                 \
   bool HasCopyContent() const override                                \
   {                                                                   \
     return strcmp(#thisClassName, this->GetClassNameInternal()) == 0; \
   }
#endif
 
// This can be used for writing code that is backward-compatible with older Slicer versions
// where GetDefaultNodeNamePrefix() returned const char* (instead of std::string).
#define DEFAULT_NODE_NAME_PREFIX_IS_STD_STRING 1

class VTK_MRML_EXPORT vtkMRMLNode : public vtkObject
{
  friend class vtkMRMLScene;
  friend class vtkMRMLSceneViewNode;
 
public:
  vtkTypeMacro(vtkMRMLNode, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum ContentModifiedObserveType
  {
    ContentModifiedObserveUndefined = -1, 
    ContentModifiedObserveDisabled = 0,   
    ContentModifiedObserveEnabled = 1     
  };

  virtual vtkMRMLNode* CreateNodeInstance() = 0;

  virtual bool HasCopyContent() const;

  virtual void ReadXMLAttributes(const char** atts);

  virtual void UpdateReferences();

  virtual void ProcessChildNode(vtkMRMLNode*) {};

  virtual void UpdateScene(vtkMRMLScene*) { this->UpdateNodeReferences(); };

  virtual void OnNodeAddedToScene() { this->UpdateNodeReferences(); };

  virtual void WriteXML(ostream& of, int indent);

  virtual void WriteNodeBodyXML(ostream& of, int indent);

  virtual void Copy(vtkMRMLNode* node);

  virtual void CopyContent(vtkMRMLNode* node, bool deepCopy = true);

  virtual void CopyReferences(vtkMRMLNode* node);

  void CopyWithScene(vtkMRMLNode* node);

  virtual void Reset(vtkMRMLNode* defaultNode);

  virtual int StartModify()
  {
    int disabledModify = this->GetDisableModifiedEvent();
    this->DisableModifiedEventOn();
    return disabledModify;
  };

  virtual int EndModify(int previousDisableModifiedEventState)
  {
    this->SetDisableModifiedEvent(previousDisableModifiedEventState);
    if (!previousDisableModifiedEventState)
    {
      return this->InvokePendingModifiedEvent();
    }
    return this->ModifiedEventPending;
  };

  virtual const char* GetNodeTagName() = 0;

  virtual std::string GetTypeDisplayName();

  virtual void SetTypeDisplayName(const std::string& name);

  virtual std::string GetDefaultNodeNamePrefix();

  virtual void SetDefaultNodeNamePrefix(const std::string& prefix);

  void SetAttribute(const char* name, const char* value);

  void RemoveAttribute(const char* name);

  const char* GetAttribute(const char* name);

  std::vector<std::string> GetAttributeNames();

  void GetAttributeNames(vtkStringArray* attributeNames);

  vtkGetMacro(HideFromEditors, int);
  vtkSetMacro(HideFromEditors, int);
  vtkBooleanMacro(HideFromEditors, int);

  vtkGetMacro(Selectable, int);
  vtkSetMacro(Selectable, int);
  vtkBooleanMacro(Selectable, int);

  vtkGetMacro(UndoEnabled, bool);
  vtkSetMacro(UndoEnabled, bool);
  vtkBooleanMacro(UndoEnabled, bool);

  virtual void ProcessMRMLEvents(vtkObject* caller, unsigned long event, void* callData);

  vtkGetMacro(InMRMLCallbackFlag, int);
  void SetInMRMLCallbackFlag(int flag) { this->InMRMLCallbackFlag = flag; }

  vtkSetStringMacro(Description);
  vtkGetStringMacro(Description);

  vtkSetStringMacro(Name);
  vtkGetStringMacro(Name);

  // vtkSetStringMacro(ID);
  vtkGetStringMacro(ID);

  vtkSetStringMacro(SingletonTag);
  vtkGetStringMacro(SingletonTag);
  void SetSingletonOn() { this->SetSingletonTag("Singleton"); }
  void SetSingletonOff() { this->SetSingletonTag(nullptr); }
  bool IsSingleton() { return (this->GetSingletonTag() != nullptr); }

  vtkGetMacro(SaveWithScene, int);
  vtkSetMacro(SaveWithScene, int);
  vtkBooleanMacro(SaveWithScene, int);

  vtkGetMacro(AddToScene, int);
  vtkSetMacro(AddToScene, int);
  vtkBooleanMacro(AddToScene, int);
  void SetAddToSceneNoModify(int value);

  vtkGetMacro(DisableModifiedEvent, int);
  void SetDisableModifiedEvent(int onOff) { this->DisableModifiedEvent = onOff; }
  void DisableModifiedEventOn() { this->SetDisableModifiedEvent(1); }
  void DisableModifiedEventOff() { this->SetDisableModifiedEvent(0); }

  vtkGetMacro(ModifiedEventPending, int);

  int GetCustomModifiedEventPending(int eventId)
  {
    std::map<int, int>::iterator it = this->CustomModifiedEventPending.find(eventId);
    if (it == this->CustomModifiedEventPending.end())
    {
      return 0;
    }
    else
    {
      return it->second;
    }
  }

  void Modified() override
  {
    if (!this->GetDisableModifiedEvent())
    {
      Superclass::Modified();
    }
    else
    {
      ++this->ModifiedEventPending;
    }
  }

  virtual int InvokePendingModifiedEvent()
  {
    int oldModifiedEventPending = 0;
    // Invoke pending standard Modified event
    if (this->ModifiedEventPending)
    {
      oldModifiedEventPending += this->ModifiedEventPending;
      this->ModifiedEventPending = 0;
      Superclass::Modified();
    }
    // Invoke pending custom modified events
    if (!this->CustomModifiedEventPending.empty())
    {
      // Need to make a copy of the event IDs stored in this->CustomModifiedEventPending,
      // because event invocation may add more events to this->CustomModifiedEventPending,
      // which would then make the iterator invalid.
      std::vector<int> customEventsToInvoke;
      for (std::map<int, int>::iterator it = this->CustomModifiedEventPending.begin(); it != this->CustomModifiedEventPending.end(); ++it)
      {
        oldModifiedEventPending += it->second;
        customEventsToInvoke.push_back(it->first);
      }
      this->CustomModifiedEventPending.clear();
      for (std::vector<int>::iterator it = customEventsToInvoke.begin(); it != customEventsToInvoke.end(); ++it)
      {
        this->InvokeEvent(*it);
      }
    }
    return oldModifiedEventPending;
  }

  virtual void InvokeCustomModifiedEvent(int eventId, void* callData = nullptr)
  {
    if (!this->GetDisableModifiedEvent())
    {
      // DisableModify is inactive, we immediately invoke the event
      this->InvokeEvent(eventId, callData);
    }
    else
    {
      // just remember the custom modified event and invoke it once,
      // when DisableModify is deactivated
      ++this->CustomModifiedEventPending[eventId];
    }
  }

  virtual vtkMRMLScene* GetScene();

  virtual void SetScene(vtkMRMLScene* scene);

  virtual void SetSceneReferences();

  virtual void UpdateReferenceID(const char* oldID, const char* newID);

  vtkGetObjectMacro(ContentModifiedEvents, vtkIntArray);

  const char* URLEncodeString(const char* inString);

  const char* URLDecodeString(const char* inString);

  std::string XMLAttributeEncodeString(const std::string& inString);

  std::string XMLAttributeDecodeString(const std::string& inString);

  vtkGetMacro(Selected, int);
  vtkSetMacro(Selected, int);
  vtkBooleanMacro(Selected, int);

  void AddNodeReferenceRole(const char* referenceRole, const char* mrmlAttributeName = nullptr, vtkIntArray* events = nullptr, bool observeContentModifiedEvents = false);

  vtkMRMLNode* SetNodeReferenceID(const char* referenceRole, const char* referencedNodeID);

  vtkMRMLNode* AddNodeReferenceID(const char* referenceRole, const char* referencedNodeID);

  vtkMRMLNode* SetNthNodeReferenceID(const char* referenceRole, int n, const char* referencedNodeID);

  vtkMRMLNode* SetAndObserveNodeReferenceID(const char* referenceRole,
                                            const char* referencedNodeID,
                                            vtkIntArray* events = nullptr,
                                            ContentModifiedObserveType observeContentModifiedEvents = ContentModifiedObserveUndefined);

  vtkMRMLNode* AddAndObserveNodeReferenceID(const char* referenceRole,
                                            const char* referencedNodeID,
                                            vtkIntArray* events = nullptr,
                                            ContentModifiedObserveType observeContentModifiedEvents = ContentModifiedObserveUndefined);

  vtkMRMLNode* SetAndObserveNthNodeReferenceID(const char* referenceRole,
                                               int n,
                                               const char* referencedNodeID,
                                               vtkIntArray* events = nullptr,
                                               ContentModifiedObserveType observeContentModifiedEvents = ContentModifiedObserveUndefined);

  void RemoveNthNodeReferenceID(const char* referenceRole, int n);

  void RemoveNodeReferenceIDs(const char* referenceRole);

  bool HasNodeReferenceID(const char* referenceRole, const char* referencedNodeID);

  int GetNumberOfNodeReferences(const char* referenceRole);

  const char* GetNthNodeReferenceID(const char* referenceRole, int n);

  const char* GetNodeReferenceID(const char* referenceRole);

  vtkMRMLNode* GetNthNodeReference(const char* referenceRole, int n);

  vtkMRMLNode* GetNodeReference(const char* referenceRole);

  void GetNodeReferences(const char* referenceRole, std::vector<vtkMRMLNode*>& nodes);

  void GetNodeReferenceIDs(const char* referenceRole, std::vector<const char*>& referencedNodeIDs);

  void GetNodeReferenceRoles(std::vector<std::string>& roles);

  int GetNumberOfNodeReferenceRoles();

  const char* GetNthNodeReferenceRole(int n);

  enum
  {
    HierarchyModifiedEvent = 16000,
    IDChangedEvent = 16001,
    ReferenceAddedEvent,
    ReferenceModifiedEvent,
    ReferenceRemovedEvent,
    ReferencedNodeModifiedEvent
  };


  typedef std::map<std::string, std::string> ReferencePropertiesType;
  const ReferencePropertiesType* GetNthNodeReferenceProperties(const char* referenceRole, int n);
  const ReferencePropertiesType* GetNodeReferenceProperties(const char* referenceRole);


  void SetNodeReferenceProperty(const std::string& referenceRole, const std::string& propertyName, const std::string& value);
  void SetNthNodeReferenceProperty(const std::string& referenceRole, int n, const std::string& propertyName, const std::string& value);
  void SetNthNodeReferenceProperties(const std::string& referenceRole, int n, const std::map<std::string, std::string>& properties);


  std::string GetNodeReferenceProperty(const std::string& referenceRole, const std::string& propertyName);
  std::string GetNthNodeReferenceProperty(const std::string& referenceRole, int n, const std::string& propertyName);


  void RemoveNodeReferenceProperty(const std::string& referenceRole, const std::string& propertyName);
  void RemoveNthNodeReferenceProperty(const std::string& referenceRole, int n, const std::string& propertyName);


  int GetNumberOfNodeReferenceProperties(const std::string& referenceRole);
  int GetNumberOfNthNodeReferenceProperties(const std::string& referenceRole, int n);


  std::string GetNodeReferencePropertyName(const std::string& referenceRole, int propertyIndex);
  std::string GetNthNodeReferencePropertyName(const std::string& referenceRole, int referenceIndex, int propertyIndex);


  std::vector<std::string> GetNodeReferencePropertyNames(const std::string& referenceRole);
  std::vector<std::string> GetNthNodeReferencePropertyNames(const std::string& referenceRole, int n);


  void ClearNodeReferenceProperties(const std::string& referenceRole);
  void ClearNthNodeReferenceProperties(const std::string& referenceRole, int n);
 
protected:
  class VTK_MRML_EXPORT vtkMRMLNodeReference : public vtkObject
  {
  public:
    vtkTypeMacro(vtkMRMLNodeReference, vtkObject);
    static vtkMRMLNodeReference* New();
    void PrintSelf(ostream& vtkNotUsed(os), vtkIndent vtkNotUsed(indent)) override {};
 
  public:
    vtkSetStringMacro(ReferenceRole);
    vtkGetStringMacro(ReferenceRole);
 
    vtkSetStringMacro(ReferencedNodeID);
    vtkGetStringMacro(ReferencedNodeID);

    void SetStaticEvents(vtkIntArray* events);
    vtkIntArray* GetStaticEvents() const;

    vtkSetMacro(ObserveContentModifiedEvents, ContentModifiedObserveType);
    vtkGetMacro(ObserveContentModifiedEvents, ContentModifiedObserveType);
 
    void SetReferencingNode(vtkMRMLNode* node);
    vtkMRMLNode* GetReferencingNode() const;
 
    void SetReferencedNode(vtkMRMLNode* node);
    vtkMRMLNode* GetReferencedNode() const;

    bool SetProperty(const std::string& key, const std::string& value);

    std::string GetProperty(const std::string& key) const;

    bool RemoveProperty(const std::string& key);

    bool ClearProperties();
 
    const ReferencePropertiesType* GetProperties() const { return &this->Properties; }
    void SetProperties(const ReferencePropertiesType& properties) { this->Properties = properties; }
 
  protected:
    vtkMRMLNodeReference();
    ~vtkMRMLNodeReference() override;
 
    vtkMRMLNodeReference(const vtkMRMLNodeReference&);
    void operator=(const vtkMRMLNodeReference&);

    char* ReferenceRole;

    vtkWeakPointer<vtkMRMLNode> ReferencingNode;
    vtkSmartPointer<vtkMRMLNode> ReferencedNode;

    char* ReferencedNodeID;
    vtkSmartPointer<vtkIntArray> StaticEvents;
    ContentModifiedObserveType ObserveContentModifiedEvents{ vtkMRMLNode::ContentModifiedObserveUndefined };
 
    ReferencePropertiesType Properties;
  };
 
  vtkMRMLNode();
  ~vtkMRMLNode() override;
  vtkMRMLNode(const vtkMRMLNode&);
  void operator=(const vtkMRMLNode&);

  static void MRMLCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);

  vtkSetStringMacro(TempURLString);
  vtkGetStringMacro(TempURLString);

  virtual const char* GetReferenceRoleFromMRMLAttributeName(const char* attName);

  virtual const char* GetMRMLAttributeNameFromReferenceRole(const char* refRole);

  virtual bool IsReferenceRoleGeneric(const char* refRole);

  virtual void UpdateNodeReferences(const char* referenceRole = nullptr);

  void RemoveInvalidReferences(const std::set<std::string>& validNodeIDs);

  virtual void UpdateNthNodeReference(const char* referenceRole, int n);

  vtkMRMLNode* UpdateNodeReferenceEventObserver(vtkMRMLNode* oldReferencedNode,
                                                vtkMRMLNode* newReferencedNode,
                                                vtkIntArray* newEvents,
                                                bool newObserveContentModifiedEvents,
                                                vtkMRMLNodeReference* referenceToIgnore);

  void GetUpdatedReferencedNodeEventList(int& oldReferencedNodeUseCount,
                                         int& newReferencedNodeUseCount,
                                         vtkIntArray* oldConsolidatedEventList,
                                         vtkIntArray* newConsolidatedEventList,
                                         vtkMRMLNode* oldReferencedNode,
                                         vtkMRMLNode* newReferencedNode,
                                         vtkMRMLNodeReference* referenceToIgnore,
                                         vtkIntArray* newEvents,
                                         bool newObserveContentModifiedEvents);

  virtual void InvalidateNodeReferences();

  virtual void OnNodeReferenceAdded(vtkMRMLNodeReference* reference) { this->InvokeEvent(vtkMRMLNode::ReferenceAddedEvent, reference); }

  virtual void OnNodeReferenceModified(vtkMRMLNodeReference* reference) { this->InvokeEvent(vtkMRMLNode::ReferenceModifiedEvent, reference); }

  virtual void OnNodeReferenceRemoved(vtkMRMLNodeReference* reference) { this->InvokeEvent(vtkMRMLNode::ReferenceRemovedEvent, reference); }

  void ParseReferencesAttribute(const char* attValue, std::set<std::string>& references);

  std::string NodeReferencePropertyEncodeString(const std::string& inString);

  std::string NodeReferencePropertyDecodeString(const std::string& inString);

  vtkCallbackCommand* MRMLCallbackCommand;
 
  char* ID{ nullptr };
  char* Name{ nullptr };
  char* Description{ nullptr };
  int HideFromEditors{ 0 };
  int Selectable{ 1 };
  int Selected{ 0 };
  int AddToScene{ 1 };
  bool UndoEnabled{ false };
 
  std::string TypeDisplayName;
  std::string DefaultNodeNamePrefix;
 
  int SaveWithScene{ true };

  int InMRMLCallbackFlag{ 0 };
 
  // We don't increase the reference count of Scene when store its pointer
  // therefore we must use a weak pointer to prevent pointer dangling when
  // the scene is deleted.
  vtkWeakPointer<vtkMRMLScene> Scene;
 
  typedef std::map<std::string, std::string> AttributesType;
  AttributesType Attributes;
 
  vtkIntArray* ContentModifiedEvents;
 
  vtkObserverManager* MRMLObserverManager;

  typedef std::vector<vtkSmartPointer<vtkMRMLNodeReference>> NodeReferenceListType;
  typedef std::map<std::string, NodeReferenceListType> NodeReferencesType;
  NodeReferencesType NodeReferences;
 
  std::map<std::string, std::string> NodeReferenceMRMLAttributeNames;
 
  struct NodeReferenceEventList
  {
    vtkSmartPointer<vtkIntArray> StaticEvents;
    ContentModifiedObserveType ObserveContentModifiedEvents{ ContentModifiedObserveUndefined };
  };
  typedef std::map<std::string, NodeReferenceEventList> NodeReferenceEventsType;
  NodeReferenceEventsType NodeReferenceEvents; // for each role it specifies which referenced node emitted events this node should observe
 
private:
  void SetID(const char* newID);

  char* TempURLString{ nullptr };
 
  char* SingletonTag{ nullptr };
 
  int DisableModifiedEvent{ 0 };
  int ModifiedEventPending{ 0 };
  std::map<int, int> CustomModifiedEventPending; // event id, pending value (number of events grouped together)
};

class VTK_MRML_EXPORT MRMLNodeModifyBlocker
{
public:
  explicit MRMLNodeModifyBlocker(vtkMRMLNode* node)
  {
    this->Node = node;
    this->WasModifying = 0;
    if (this->Node)
    {
      this->WasModifying = this->Node->StartModify();
    }
  };
 
  ~MRMLNodeModifyBlocker()
  {
    if (this->Node)
    {
      this->Node->EndModify(this->WasModifying);
    }
  }
 
  // Non-copyable
  MRMLNodeModifyBlocker(const MRMLNodeModifyBlocker&) = delete;
  MRMLNodeModifyBlocker& operator=(const MRMLNodeModifyBlocker&) = delete;
 
  // Move constructor
  MRMLNodeModifyBlocker(MRMLNodeModifyBlocker&& other) noexcept
  {
    this->Node = other.Node;
    this->WasModifying = other.WasModifying;
    other.Node = nullptr;
    other.WasModifying = 0;
  }
 
  // Move assignment
  MRMLNodeModifyBlocker& operator=(MRMLNodeModifyBlocker&& other) noexcept
  {
    if (this != &other)
    {
      if (this->Node)
      {
        this->Node->EndModify(this->WasModifying);
      }
      this->Node = other.Node;
      this->WasModifying = other.WasModifying;
      other.Node = nullptr;
      other.WasModifying = 0;
    }
    return *this;
  }
 
protected:
  vtkWeakPointer<vtkMRMLNode> Node;
  int WasModifying;
};
 
#endif