Medical Imaging Interaction Toolkit  2024.12.99-0483bf7c
Medical Imaging Interaction Toolkit
mitkDataStorage.h
Go to the documentation of this file.
1 /*============================================================================
2 
3 The Medical Imaging Interaction Toolkit (MITK)
4 
5 Copyright (c) German Cancer Research Center (DKFZ)
6 All rights reserved.
7 
8 Use of this source code is governed by a 3-clause BSD license that can be
9 found in the LICENSE file.
10 
11 ============================================================================*/
12 
13 #ifndef mitkDataStorage_h
14 #define mitkDataStorage_h
15 
16 #include "itkObject.h"
17 #include "itkVectorContainer.h"
18 #include "mitkDataNode.h"
19 #include "mitkGeometry3D.h"
20 #include "mitkMessage.h"
21 #include <MitkCoreExports.h>
22 #include <map>
23 #include <mutex>
24 
25 namespace mitk
26 {
27  class NodePredicateBase;
28  class DataNode;
29  class BaseRenderer;
30 
31  //##Documentation
32  //## @brief Data management class that handles 'was created by' relations
33  //##
34  //## The DataStorage provides data storage and management functionality.
35  //## It handles a 'was created by' relation by associating each data object with a
36  //## set of source objects, that this object was created from.
37  //## Thus, nodes are stored in a noncyclical directed graph data structure.
38  //## If a new node is added to the DataStorage, AddNodeEvent is emitted.
39  //## If a node is removed, RemoveNodeEvent is emitted.
40  //##
41  //##
42  //## \ingroup DataStorage
43  class MITKCORE_EXPORT DataStorage : public itk::Object
44  {
45  public:
47 
48  //##Documentation
49  //## @brief A Container of objects that is used as a result set of GetSubset() query operations (Set of
50  //SmartPointers
51  // to DataNodes).
52  typedef itk::VectorContainer<unsigned int, DataNode::Pointer> SetOfObjects;
53 
54  //##Documentation
55  //## @brief Adds a DataNode containing a data object to its internal storage
56  //##
57  //## This Method adds a new data object to the DataStorage. The new object is
58  //## passed in the first parameter. The second parameter is a set
59  //## of source objects, that were used to create this object. The new object will have
60  //## a 'was created from' relation to its source objects.
61  //## the addition of a new object will fire the notification mechanism.
62  //## If the node parameter is nullptr or if the DataNode has already been added,
63  //## an exception will be thrown.
64  virtual void Add(DataNode *node, const DataStorage::SetOfObjects *parents = nullptr) = 0;
65 
66  //##Documentation
67  //## @brief Convenience method to add a node that has one parent
68  //##
69  void Add(DataNode *node, DataNode *parent);
70 
71  //##Documentation
72  //## @brief Removes node from the DataStorage
73  //##
74  virtual void Remove(const DataNode *node) = 0;
75 
76  //##Documentation
77  //## @brief Checks if a node exists in the DataStorage
78  //##
79  virtual bool Exists(const DataNode *node) const = 0;
80 
81  //##Documentation
82  //## @brief Removes a set of nodes from the DataStorage
83  //##
84  void Remove(const DataStorage::SetOfObjects *nodes);
85 
86  //##Documentation
87  //## @brief returns a set of data objects that meet the given condition(s)
88  //##
89  //## GetSubset returns a set of objects with a specific data type that meet the condition(s)
90  //## specified in the condition parameter. Conditions can be
91  //## - data type of the data object
92  //## - is source object of specific object (e.g. all source objects of node x)
93  //## - has property with specific value (e.g. OrganType is Liver)
94  //## - negation of any condition
95  //## - conjunction of a set of conditions
96  //## - disjunction of a set of conditions
97  //## Conditions are implemented as predicates using the Composite Design Pattern
98  //## (see definition of NodePredicateBase for details).
99  //## The method returns a set of SmartPointers to the DataNodes that fulfill the
100  //## conditions. A set of all objects can be retrieved with the GetAll() method;
101  SetOfObjects::ConstPointer GetSubset(const NodePredicateBase *condition) const;
102 
103  //##Documentation
104  //## @brief returns a set of source objects for a given node that meet the given condition(s).
105  //##
106  virtual SetOfObjects::ConstPointer GetSources(const DataNode *node,
107  const NodePredicateBase *condition = nullptr,
108  bool onlyDirectSources = true) const = 0;
109 
110  //##Documentation
111  //## @brief returns a set of derived objects for a given node.
112  //##
113  //## GetDerivations() returns a set of objects that are derived from the DataNode node.
114  //## This means, that node was used to create the returned objects. If the parameter
115  //## onlyDirectDerivations is set to true (default value), only objects that directly have
116  //## node as one of their source objects will be returned. Otherwise, objects that are
117  //## derived from derivations of node are returned too.
118  //## The derived objects can be filtered with a predicate object as described in the GetSubset()
119  //## method by providing a predicate as the condition parameter.
120  virtual SetOfObjects::ConstPointer GetDerivations(const DataNode *node,
121  const NodePredicateBase *condition = nullptr,
122  bool onlyDirectDerivations = true) const = 0;
123 
124  //##Documentation
125  //## @brief returns a set of all data objects that are stored in the data storage
126  //##
127  virtual SetOfObjects::ConstPointer GetAll() const = 0;
128 
129  //##Documentation
130  //## @brief Convenience method to get the first node that matches the predicate condition
131  //##
132  DataNode *GetNode(const NodePredicateBase *condition = nullptr) const;
133 
134  //##Documentation
135  //## @brief Convenience method to get the first node with a given name
136  //##
137  DataNode *GetNamedNode(const char *name) const;
138 
139  //##Documentation
140  //## @brief Convenience method to get the first node with a given name
141  //##
142  DataNode *GetNamedNode(const std::string& name) const { return this->GetNamedNode(name.c_str()); }
143  //##Documentation
144  //## @brief Convenience method to get the first node with a given name that is derived from sourceNode
145  //##
146  DataNode *GetNamedDerivedNode(const char *name,
147  const DataNode *sourceNode,
148  bool onlyDirectDerivations = true) const;
149 
150  //##Documentation
151  //## @brief Convenience method to get the first data object of a given data type with a given name
152  //##
153  template <class DataType>
154  DataType *GetNamedObject(const char *name) const
155  {
156  if (name == nullptr)
157  return nullptr;
158  DataNode *n = this->GetNamedNode(name);
159  if (n == nullptr)
160  return nullptr;
161  else
162  return dynamic_cast<DataType *>(n->GetData());
163  }
164  //##Documentation
165  //## @brief Convenience method to get the first data object of a given data type with a given name
166  //##
167  template <class DataType>
168  DataType *GetNamedObject(const std::string& name) const
169  {
170  return this->GetNamedObject<DataType>(name.c_str());
171  }
172 
173  //##Documentation
174  //## @brief Convenience method to get the first data object of a given data type with a given name that is derived
175  // from a specific node
176  //##
177  template <class DataType>
178  DataType *GetNamedDerivedObject(const char *name,
179  const DataNode *sourceNode,
180  bool onlyDirectDerivations = true) const
181  {
182  if (name == nullptr)
183  return nullptr;
184  DataNode *n = this->GetNamedDerivedNode(name, sourceNode, onlyDirectDerivations);
185  if (n == nullptr)
186  return nullptr;
187  else
188  return dynamic_cast<DataType *>(n->GetData());
189  }
190 
191  //##Documentation
192  //## @brief Get a unique node name by potentially appending an increasing number, starting from 2.
193  //##
194  //## Fills gaps between existing numbers to maintain a compact sequence. If a source node
195  //## is provided, the uniqueness check is restricted to its derived nodes rather than
196  //## all nodes.
197  //##
198  //## @param name The base name to make unique
199  //## @param sourceNode The node whose derived nodes define the search space
200  //## @param onlyDirectDerivations Only consider direct derivations in search space
201  //## @return A unique name derived from the given base name
202  //##
203  std::string GetUniqueName(const std::string& name, const DataNode* sourceNode = nullptr, bool onlyDirectDerivations = true) const;
204 
205  //##Documentation
206  //## @brief Returns a list of used grouptags
207  //##
208  const DataNode::GroupTagList GetGroupTags() const;
209 
210  /*ITK Mutex */
211  mutable std::mutex m_MutexOne;
212 
213  /* Public Events */
215  //##Documentation
216  //## @brief AddEvent is emitted whenever a new node has been added to the DataStorage.
217  //##
218  //## Observers should register to this event by calling myDataStorage->AddNodeEvent.AddListener(myObject,
219  // MyObject::MyMethod).
220  //## After registering, myObject->MyMethod() will be called every time a new node has been added to the DataStorage.
221  //## Observers should unregister by calling myDataStorage->AddNodeEvent.RemoveListener(myObject,
222  //MyObject::MyMethod).
223  //## Note: AddEvents are _not_ emitted if a node is added to DataStorage by adding it to the the underlying
224  //DataTree!
225 
226  // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef
227  // for
228  // a Message1 object which is thread safe
230 
231  //##Documentation
232  //## @brief RemoveEvent is emitted directly before a node is removed from the DataStorage.
233  //##
234  //## Observers should register to this event by calling myDataStorage->RemoveNodeEvent.AddListener(myObject,
235  // MyObject::MyMethod).
236  //## After registering, myObject->MyMethod() will be called every time a new node has been added to the DataStorage.
237  //## Observers should unregister by calling myDataStorage->RemoveNodeEvent.RemoveListener(myObject,
238  // MyObject::MyMethod).
239  //## Note: RemoveEvents are also emitted if a node was removed from the DataStorage by deleting it from the
240  //underlying
241  // DataTree
242 
243  // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef
244  // for
245  // a Message1 object which is thread safe
247 
248  //##Documentation
249  //## @brief ChangedEvent is emitted directly after a node was changed.
250  //##
251  //## Observers should register to this event by calling myDataStorage->ChangedNodeEvent.AddListener(myObject,
252  // MyObject::MyMethod).
253  //## After registering, myObject->MyMethod() will be called every time a new node has been changed.
254  //## Observers should unregister by calling myDataStorage->ChangedNodeEvent.RemoveListener(myObject,
255  // MyObject::MyMethod).
256  //## Internally the DataStorage listens to itk::ModifiedEvents on the nodes and forwards them
257  //## to the listeners of this event.
258 
259  // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef
260  // for
261  // a Message1 object which is thread safe
263 
264  //##Documentation
265  //## @brief DeleteNodeEvent is emitted directly before a node is deleted.
266  //##
267  //## Observers should register to this event by calling myDataStorage->DeleteNodeEvent.AddListener(myObject,
268  // MyObject::MyMethod).
269  //## After registering, myObject->MyMethod() will be called when a node is deleted.
270  //## Observers should unregister by calling myDataStorage->DeleteNodeEvent.RemoveListener(myObject,
271  // MyObject::MyMethod).
272  //## Internally the DataStorage listens to itk::DeleteEvents on the nodes and forwards them
273  //## to the listeners of this event.
274 
275  // member variable is not needed to be locked in multi threaded scenarios since the DataStorageEvent is a typedef
276  // for
277  // a Message1 object which is thread safe
279 
281 
282  //##Documentation
283  //## @brief Compute the axis-parallel bounding geometry of the input objects
284  //##
285  //## Throws std::invalid_argument exception if input is nullptr
286  //## @param input set of objects of the DataStorage to be included in the bounding geometry
287  //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
288  //## and is set to @a false, the node is ignored for the bounding-box calculation.
289  //## @param renderer see @a boolPropertyKey
290  //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
291  TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const SetOfObjects *input,
292  const char *boolPropertyKey = nullptr,
293  const BaseRenderer *renderer = nullptr,
294  const char *boolPropertyKey2 = nullptr) const;
295 
296  //##Documentation
297  //## @brief Compute the axis-parallel bounding geometry of the data tree
298  //## (bounding box, minimal spacing of the considered nodes, live-span)
299  //##
300  //## it -> an iterator to a data tree structure
301  //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
302  //## and is set to @a false, the node is ignored for the bounding-box calculation.
303  //## @param renderer see @a boolPropertyKey
304  //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
305  TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const char *boolPropertyKey = nullptr,
306  const BaseRenderer *renderer = nullptr,
307  const char *boolPropertyKey2 = nullptr) const;
308 
309  //##Documentation
310  //## @brief Compute the axis-parallel bounding geometry of all visible parts of the
311  //## data tree bounding box, minimal spacing of the considered nodes, live-span)
312  //##
313  //## Simply calls ComputeBoundingGeometry3D(it, "visible", renderer, boolPropertyKey).
314  //## it -> an iterator of a data tree structure
315  //## @param renderer the reference to the renderer
316  //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
317  //## and is set to @a false, the node is ignored for the bounding-box calculation.
318  TimeGeometry::ConstPointer ComputeVisibleBoundingGeometry3D(const BaseRenderer *renderer = nullptr,
319  const char *boolPropertyKey = nullptr);
320 
321  //##Documentation
322  //## @brief Compute the bounding box of data tree structure
323  //## it -> an iterator to a data tree structure
324  //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
325  //## and is set to @a false, the node is ignored for the bounding-box calculation.
326  //## @param renderer see @a boolPropertyKey
327  //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
328  BoundingBox::Pointer ComputeBoundingBox(const char *boolPropertyKey = nullptr,
329  const BaseRenderer *renderer = nullptr,
330  const char *boolPropertyKey2 = nullptr);
331 
332  //##Documentation
333  //## \brief Compute the bounding box of all visible parts of the data tree structure, for general
334  //## rendering or renderer specific visibility property checking
335  //##
336  //## Simply calls ComputeBoundingBox(it, "visible", renderer, boolPropertyKey).
337  //## it -> an iterator of a data tree structure
338  //## @param renderer the reference to the renderer
339  //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
340  //## and is set to @a false, the node is ignored for the bounding-box calculation.
341  BoundingBox::Pointer ComputeVisibleBoundingBox(const BaseRenderer *renderer = nullptr,
342  const char *boolPropertyKey = nullptr)
343  {
344  return ComputeBoundingBox("visible", renderer, boolPropertyKey);
345  }
346 
347  //##Documentation
348  //## @brief Compute the time-bounds of the contents of a data tree structure
349  //##
350  //## The methods returns only [-infinity, +infinity], if all data-objects have an infinite live-span. Otherwise,
351  //## all data-objects with infinite live-span are ignored.
352  //## it -> an iterator to a data tree structure
353  //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
354  //## and is set to @a false, the node is ignored for the time-bounds calculation.
355  //## @param renderer see @a boolPropertyKey
356  //## @param boolPropertyKey2 a second condition that is applied additionally to @a boolPropertyKey
357  TimeBounds ComputeTimeBounds(const char *boolPropertyKey,
358  const BaseRenderer *renderer,
359  const char *boolPropertyKey2);
360 
361  //##Documentation
362  //## @brief Compute the time-bounds of all visible parts of the data tree structure, for general
363  //## rendering or renderer specific visibility property checking
364  //##
365  //## The methods returns only [-infinity, +infinity], if all data-objects have an infinite live-span. Otherwise,
366  //## all data-objects with infinite live-span are ignored.
367  //## Simply calls ComputeTimeBounds(it, "visible", renderer, boolPropertyKey).
368  //## @param boolPropertyKey if a BoolProperty with this boolPropertyKey exists for a node (for @a renderer)
369  //## and is set to @a false, the node is ignored for the time-bounds calculation.
370  //## @param renderer see @a boolPropertyKey
371  TimeBounds ComputeTimeBounds(const BaseRenderer *renderer, const char *boolPropertyKey)
372  {
373  return ComputeTimeBounds("visible", renderer, boolPropertyKey);
374  }
375 
376  //##Documentation
377  //## @brief Defines whether or not NodeChangedEvent is invoked .
378  //##
379  //## This method can be used to set m_BlockNodeModifiedEvents.
380  //##
381  //## If this flag is true, NodeChangedEvent is not invoked when a
382  //## DataNode is modified. This might be undesired when setting
383  //## many properties on a datanode and you do not want anyone to
384  //## react.
385  void BlockNodeModifiedEvents(bool block);
386 
387  protected:
388  //##Documentation
389  //## @brief EmitAddNodeEvent emits the AddNodeEvent
390  //##
391  //## This method should be called by subclasses to emit the AddNodeEvent
392  void EmitAddNodeEvent(const DataNode *node);
393 
394  //##Documentation
395  //## @brief EmitRemoveNodeEvent emits the RemoveNodeEvent
396  //##
397  //## This method should be called by subclasses to emit the RemoveNodeEvent
398  void EmitRemoveNodeEvent(const DataNode *node);
399 
400  void OnNodeInteractorChanged(itk::Object *caller, const itk::EventObject &event);
401 
402  //##Documentation
403  //## @brief OnNodeModified listens to modified events of DataNodes.
404  //##
405  //## The node is hidden behind the caller parameter, which has to be casted first.
406  //## If the cast succeeds the ChangedNodeEvent is emitted with this node.
407  void OnNodeModifiedOrDeleted(const itk::Object *caller, const itk::EventObject &event);
408 
409  //##Documentation
410  //## @brief Adds a Modified-Listener to the given Node.
411  void AddListeners(const DataNode *_Node);
412 
413  //##Documentation
414  //## @brief Removes a Modified-Listener from the given Node.
415  void RemoveListeners(const DataNode *_Node);
416 
417  //##Documentation
418  //## @brief Saves Modified-Observer Tags for each node in order to remove the event listeners again.
419  std::map<const DataNode *, unsigned long> m_NodeModifiedObserverTags;
420 
421  std::map<const DataNode *, unsigned long> m_NodeInteractorChangedObserverTags;
422 
423  //##Documentation
424  //## @brief Saves Delete-Observer Tags for each node in order to remove the event listeners again.
425  std::map<const DataNode *, unsigned long> m_NodeDeleteObserverTags;
426 
427  //##Documentation
428  //## @brief If this class changes nodes itself, set this to TRUE in order
429  //## to suppress NodeChangedEvent to be emitted.
431 
432  DataStorage();
433  ~DataStorage() override;
434 
435  //##Documentation
436  //## @brief Filters a SetOfObjects by the condition. If no condition is provided, the original set is returned
437  SetOfObjects::ConstPointer FilterSetOfObjects(const SetOfObjects *set, const NodePredicateBase *condition) const;
438 
439  //##Documentation
440  //## @brief Prints the contents of the DataStorage to os. Do not call directly, call ->Print() instead
441  void PrintSelf(std::ostream &os, itk::Indent indent) const override;
442  };
443 
444  //##Documentation
445  //## @brief returns the topmost visible node of a given list of nodes.
446  //## The function returns a node that is visible and has the highest layer of a set of given nodes.
447  //## The property list, which is used to find the visibility- and layer-property is specified by the
448  //## given base renderer.
449  //##
450  MITKCORE_EXPORT DataNode::Pointer FindTopmostVisibleNode(const DataStorage::SetOfObjects::ConstPointer nodes,
451  const Point3D worldPosition,
452  const TimePointType timePoint,
453  const BaseRenderer* baseRender);
454 } // namespace mitk
455 
456 #endif
mitk::DataStorage::AddNodeEvent
DataStorageEvent AddNodeEvent
AddEvent is emitted whenever a new node has been added to the DataStorage.
Definition: mitkDataStorage.h:229
mitk::DataStorage::m_NodeInteractorChangedObserverTags
std::map< const DataNode *, unsigned long > m_NodeInteractorChangedObserverTags
Definition: mitkDataStorage.h:421
mitk::Message1< const DataNode * >
mitk::DataStorage::SetOfObjects
itk::VectorContainer< unsigned int, DataNode::Pointer > SetOfObjects
A Container of objects that is used as a result set of GetSubset() query operations (Set of.
Definition: mitkDataStorage.h:46
mitk::DataStorage::m_BlockNodeModifiedEvents
bool m_BlockNodeModifiedEvents
If this class changes nodes itself, set this to TRUE in order to suppress NodeChangedEvent to be emit...
Definition: mitkDataStorage.h:430
mitk::DataStorage::GetNamedObject
DataType * GetNamedObject(const std::string &name) const
Convenience method to get the first data object of a given data type with a given name.
Definition: mitkDataStorage.h:168
mitk::DataStorage::m_MutexOne
std::mutex m_MutexOne
Definition: mitkDataStorage.h:211
itk::SmartPointer< const Self >
mitk::NodePredicateBase
Interface for evaluation conditions used in the DataStorage class GetSubset() method.
Definition: mitkNodePredicateBase.h:35
mitkGeometry3D.h
mitk::FindTopmostVisibleNode
MITKCORE_EXPORT DataNode::Pointer FindTopmostVisibleNode(const DataStorage::SetOfObjects::ConstPointer nodes, const Point3D worldPosition, const TimePointType timePoint, const BaseRenderer *baseRender)
returns the topmost visible node of a given list of nodes. The function returns a node that is visibl...
mitk::DataStorage::GetNamedObject
DataType * GetNamedObject(const char *name) const
Convenience method to get the first data object of a given data type with a given name.
Definition: mitkDataStorage.h:154
mitkClassMacroItkParent
#define mitkClassMacroItkParent(className, SuperClassName)
Definition: mitkCommon.h:45
mitk
Find image slices visible on a given plane.
Definition: RenderingTests.dox:1
mitk::DataStorage::InteractorChangedNodeEvent
DataStorageEvent InteractorChangedNodeEvent
Definition: mitkDataStorage.h:280
mitk::DataNode::GetData
BaseData * GetData() const
Get the data object (instance of BaseData, e.g., an Image) managed by this DataNode.
mitk::DataNode::GroupTagList
std::set< std::string > GroupTagList
Definition: mitkDataNode.h:70
mitk::DataStorage::DataStorageEvent
Message1< const DataNode * > DataStorageEvent
Definition: mitkDataStorage.h:214
mitk::DataStorage::ComputeVisibleBoundingBox
BoundingBox::Pointer ComputeVisibleBoundingBox(const BaseRenderer *renderer=nullptr, const char *boolPropertyKey=nullptr)
Compute the bounding box of all visible parts of the data tree structure, for general rendering or re...
Definition: mitkDataStorage.h:341
mitk::DataStorage::ComputeTimeBounds
TimeBounds ComputeTimeBounds(const BaseRenderer *renderer, const char *boolPropertyKey)
Compute the time-bounds of all visible parts of the data tree structure, for general rendering or ren...
Definition: mitkDataStorage.h:371
MitkCoreExports.h
mitkMessage.h
mitk::Point< ScalarType, 3 >
mitk::DataStorage::GetNamedDerivedObject
DataType * GetNamedDerivedObject(const char *name, const DataNode *sourceNode, bool onlyDirectDerivations=true) const
Convenience method to get the first data object of a given data type with a given name that is derive...
Definition: mitkDataStorage.h:178
mitk::DataStorage
Data management class that handles 'was created by' relations.
Definition: mitkDataStorage.h:43
mitkDataNode.h
mitk::DataStorage::m_NodeDeleteObserverTags
std::map< const DataNode *, unsigned long > m_NodeDeleteObserverTags
Saves Delete-Observer Tags for each node in order to remove the event listeners again.
Definition: mitkDataStorage.h:425
mitk::BaseRenderer
Definition: mitkBaseRenderer.h:56
mitk::TimePointType
mitk::ScalarType TimePointType
Definition: mitkTimeGeometry.h:26
mitk::DataStorage::ChangedNodeEvent
DataStorageEvent ChangedNodeEvent
ChangedEvent is emitted directly after a node was changed.
Definition: mitkDataStorage.h:262
mitk::TimeBounds
itk::FixedArray< ScalarType, 2 > TimeBounds
Standard typedef for time-bounds.
Definition: mitkBaseGeometry.h:44
mitk::DataStorage::m_NodeModifiedObserverTags
std::map< const DataNode *, unsigned long > m_NodeModifiedObserverTags
Saves Modified-Observer Tags for each node in order to remove the event listeners again.
Definition: mitkDataStorage.h:419
MITKCORE_EXPORT
#define MITKCORE_EXPORT
Definition: MitkCoreExports.h:15
mitk::DataStorage::DeleteNodeEvent
DataStorageEvent DeleteNodeEvent
DeleteNodeEvent is emitted directly before a node is deleted.
Definition: mitkDataStorage.h:278
mitk::DataNode
Class for nodes of the DataTree.
Definition: mitkDataNode.h:63
mitk::DataStorage::GetNamedNode
DataNode * GetNamedNode(const std::string &name) const
Convenience method to get the first node with a given name.
Definition: mitkDataStorage.h:142
mitk::DataStorage::RemoveNodeEvent
DataStorageEvent RemoveNodeEvent
RemoveEvent is emitted directly before a node is removed from the DataStorage.
Definition: mitkDataStorage.h:246