1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#include "vtkSmartPointerBase.h"
#include "vtkGarbageCollector.h"
//------------------------------------------------------------------------------
VTK_ABI_NAMESPACE_BEGIN
vtkSmartPointerBase::vtkSmartPointerBase() noexcept
: Object(nullptr)
{
}
//------------------------------------------------------------------------------
vtkSmartPointerBase::vtkSmartPointerBase(vtkObjectBase* r)
: Object(r)
{
// Add a reference to the object.
this->Register();
}
//------------------------------------------------------------------------------
vtkSmartPointerBase::vtkSmartPointerBase(vtkObjectBase* r, const NoReference&)
: Object(r)
{
// Do not add a reference to the object because we received the
// NoReference argument.
}
//------------------------------------------------------------------------------
vtkSmartPointerBase::vtkSmartPointerBase(const vtkSmartPointerBase& r)
: Object(r.Object)
{
// Add a reference to the object.
this->Register();
}
//------------------------------------------------------------------------------
vtkSmartPointerBase::~vtkSmartPointerBase()
{
// The main pointer must be set to nullptr before calling UnRegister,
// so use a local variable to save the pointer. This is because the
// garbage collection reference graph traversal may make it back to
// this smart pointer, and we do not want to include this reference.
vtkObjectBase* object = this->Object;
if (object)
{
this->Object = nullptr;
object->UnRegister(nullptr);
}
}
//------------------------------------------------------------------------------
vtkSmartPointerBase& vtkSmartPointerBase::operator=(vtkObjectBase* r)
{
if (r != this->Object)
{
// This is an exception-safe assignment idiom that also gives the
// correct order of register/unregister calls to all objects
// involved. A temporary is constructed that references the new
// object. Then the main pointer and temporary are swapped and the
// temporary's destructor unreferences the old object.
vtkSmartPointerBase(r).Swap(*this);
}
return *this;
}
//------------------------------------------------------------------------------
vtkSmartPointerBase& vtkSmartPointerBase::operator=(const vtkSmartPointerBase& r)
{
if (&r != this && r.Object != this->Object)
{
// This is an exception-safe assignment idiom that also gives the
// correct order of register/unregister calls to all objects
// involved. A temporary is constructed that references the new
// object. Then the main pointer and temporary are swapped and the
// temporary's destructor unreferences the old object.
vtkSmartPointerBase(r).Swap(*this);
}
return *this;
}
//------------------------------------------------------------------------------
void vtkSmartPointerBase::Report(vtkGarbageCollector* collector, const char* desc)
{
vtkGarbageCollectorReport(collector, this->Object, desc);
}
//------------------------------------------------------------------------------
void vtkSmartPointerBase::Swap(vtkSmartPointerBase& r) noexcept
{
// Just swap the pointers. This is used internally by the
// assignment operator.
vtkObjectBase* temp = r.Object;
r.Object = this->Object;
this->Object = temp;
}
//------------------------------------------------------------------------------
void vtkSmartPointerBase::Register()
{
// Add a reference only if the object is not nullptr.
if (this->Object)
{
this->Object->Register(nullptr);
}
}
//------------------------------------------------------------------------------
ostream& operator<<(ostream& os, const vtkSmartPointerBase& p)
{
// Just print the pointer value into the stream.
return os << static_cast<void*>(p.GetPointer());
}
VTK_ABI_NAMESPACE_END
|
