GCC Code Coverage Report


Directory: cvmfs/
File: cvmfs/util/shared_ptr.h
Date: 2026-11-08 02:41:18
Exec Total Coverage
Lines: 50 55 90.9%
Branches: 19 26 73.1%

Line Branch Exec Source
1 /**
2 * This file is part of the CernVM File System.
3 */
4
5 #ifndef CVMFS_UTIL_SHARED_PTR_H_
6 #define CVMFS_UTIL_SHARED_PTR_H_
7
8 #include <atomic>
9 #include <cstdint>
10 #include <cstdlib>
11
12 #ifdef CVMFS_NAMESPACE_GUARD
13 namespace CVMFS_NAMESPACE_GUARD {
14 #endif // CVMFS_NAMESPACE_GUARD
15
16 template<typename T>
17 class SharedPtr {
18 public:
19 typedef T element_type;
20
21 9863 SharedPtr() { // never throws
22 9863 value_ = NULL;
23 9863 count_ = NULL;
24 9863 }
25
26 template<class Y>
27 144 explicit SharedPtr(Y *p) {
28 144 value_ = static_cast<element_type *>(p);
29 144 count_ = new std::atomic<int64_t>;
30 144 count_->store(1);
31 144 }
32
33 10138 ~SharedPtr() { // never throws
34
2/2
✓ Branch 0 taken 184 times.
✓ Branch 1 taken 4926 times.
10138 if (count_) {
35 286 count_->fetch_sub(1);
36
2/2
✓ Branch 1 taken 89 times.
✓ Branch 2 taken 95 times.
572 if (count_->load() == 0) {
37
1/2
✓ Branch 0 taken 89 times.
✗ Branch 1 not taken.
157 delete value_;
38
1/2
✓ Branch 0 taken 89 times.
✗ Branch 1 not taken.
157 delete count_;
39 }
40 }
41 10138 }
42
43 154 SharedPtr(SharedPtr const &r)
44 154 : value_(r.value_), count_(r.count_) { // never throws
45
1/2
✓ Branch 0 taken 103 times.
✗ Branch 1 not taken.
154 if (count_) {
46 154 count_->fetch_add(1);
47 }
48 154 }
49
50 template<class Y>
51 explicit SharedPtr(SharedPtr<Y> const &r)
52 : value_(r.value_), count_(r.count_) { // never throws
53 if (count_) {
54 count_->fetch_add(1);
55 }
56 }
57
58 2222 SharedPtr &operator=(SharedPtr const &r) { // never throws
59
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1124 times.
2222 if (this == &r)
60 ✗ return *this;
61
62 2222 Reset();
63 2222 value_ = r.value_;
64 2222 count_ = r.count_;
65
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 1098 times.
2222 if (count_) {
66 26 count_->fetch_add(1);
67 }
68 2222 return *this;
69 }
70
71 template<class Y>
72 SharedPtr &operator=(SharedPtr<Y> const &r) { // never throws
73 Reset();
74 value_ = r.Get();
75 count_ = r.GetCountPtr();
76 if (count_) {
77 count_->fetch_add(1);
78 }
79 return *this;
80 }
81
82 2256 void Reset() { // never throws
83
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 1122 times.
2256 if (count_) {
84 36 count_->fetch_sub(1);
85
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 34 times.
72 if (count_->load() == 0) {
86
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 delete value_;
87
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 delete count_;
88 }
89 36 value_ = NULL;
90 36 count_ = NULL;
91 }
92 2256 }
93
94 template<class Y>
95 17 void Reset(Y *p) {
96 17 Reset();
97 17 value_ = static_cast<element_type *>(p);
98 17 count_ = new std::atomic<int64_t>;
99 17 count_->store(1);
100 17 }
101
102 ✗ T &operator*() const { // never throws
103 ✗ return *value_;
104 }
105
106 99 T *operator->() const { // never throws
107 99 return value_;
108 }
109
110 ✗ element_type *Get() const { // never throws
111 ✗ return value_;
112 }
113
114 std::atomic<int64_t> *GetCountPtr() const { return count_; }
115
116 153 bool Unique() const { // never throws
117
3/4
✓ Branch 0 taken 153 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 102 times.
✓ Branch 4 taken 51 times.
306 return count_ && (count_->load() == 1);
118 }
119
120 8341 int64_t UseCount() const { // never throws
121 8494 return count_ ? count_->load() : -1;
122 }
123
124 private:
125 element_type *value_;
126 std::atomic<int64_t> *count_;
127 };
128
129 template<class T, class U>
130 bool operator==(SharedPtr<T> const &a,
131 SharedPtr<U> const &b) { // never throws
132 return a.value_ == b.value_;
133 }
134
135 template<class T, class U>
136 bool operator!=(SharedPtr<T> const &a,
137 SharedPtr<U> const &b) { // never throws
138 return a.value_ != b.value_;
139 }
140
141 template<class T, class U>
142 bool operator<(SharedPtr<T> const &a, SharedPtr<U> const &b) { // never throws
143 return a.value_ < b.value_;
144 }
145
146 template<class T>
147 typename SharedPtr<T>::element_type *GetPointer(
148 SharedPtr<T> const &p) { // never throws
149 return p.value_;
150 }
151
152 template<class T, class U>
153 SharedPtr<T> StaticPointerCast(SharedPtr<U> const &r) { // never throws
154 return SharedPtr<T>(static_cast<T *>(r.value_));
155 }
156
157 template<class T, class U>
158 SharedPtr<T> ConstPointerCast(SharedPtr<U> const &r) { // never throws
159 return SharedPtr<T>(const_cast<T *>(r.value_));
160 }
161
162 template<class T, class U>
163 SharedPtr<T> DynamicPointerCast(SharedPtr<U> const &r) { // never throws
164 return SharedPtr<T>(dynamic_cast<T *>(r.value_));
165 }
166
167 template<class T, class U>
168 SharedPtr<T> ReinterpretPointerCast(SharedPtr<U> const &r) { // never throws
169 return SharedPtr<T>(reinterpret_cast<T *>(r.value_));
170 }
171
172 #ifdef CVMFS_NAMESPACE_GUARD
173 } // namespace CVMFS_NAMESPACE_GUARD
174 #endif
175
176 #endif // CVMFS_UTIL_SHARED_PTR_H_
177
178