GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/util/shared_ptr.h
Date: 2025-06-22 02:36:02
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 <cstdlib>
9
10 #include "util/atomic.h"
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 25078 SharedPtr() { // never throws
22 25078 value_ = NULL;
23 25078 count_ = NULL;
24 25078 }
25
26 template<class Y>
27 538 explicit SharedPtr(Y *p) {
28 538 value_ = static_cast<element_type *>(p);
29 538 count_ = new atomic_int64;
30 538 atomic_write64(count_, 1);
31 538 }
32
33 25856 ~SharedPtr() { // never throws
34
2/2
✓ Branch 0 taken 874 times.
✓ Branch 1 taken 12488 times.
 25856 if (count_) {
35 880 atomic_dec64(count_);
36
2/2
✓ Branch 1 taken 242 times.
✓ Branch 2 taken 632 times.
 880 if (atomic_read64(count_) == 0) {
37
1/2
✓ Branch 0 taken 242 times.
✗ Branch 1 not taken.
 246 delete value_;
38
1/2
✓ Branch 0 taken 242 times.
✗ Branch 1 not taken.
 246 delete count_;
39 }
40 }
41 25856 }
42
43 510 SharedPtr(SharedPtr const &r)
44 510 : value_(r.value_), count_(r.count_) { // never throws
45
1/2
✓ Branch 0 taken 507 times.
✗ Branch 1 not taken.
 510 if (count_) {
46 510 atomic_inc64(count_);
47 }
48 510 }
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 atomic_inc64(count_);
55 }
56 }
57
58 6559 SharedPtr &operator=(SharedPtr const &r) { // never throws
59
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3343 times.
 6559 if (this == &r)
60 ✗ return *this;
61
62 6559 Reset();
63 6559 value_ = r.value_;
64 6559 count_ = r.count_;
65
2/2
✓ Branch 0 taken 127 times.
✓ Branch 1 taken 3216 times.
 6559 if (count_) {
66 127 atomic_inc64(count_);
67 }
68 6559 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 atomic_inc64(count_);
78 }
79 return *this;
80 }
81
82 6561 void Reset() { // never throws
83
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 3315 times.
 6561 if (count_) {
84 30 atomic_dec64(count_);
85
2/2
✓ Branch 1 taken 28 times.
✓ Branch 2 taken 2 times.
 30 if (atomic_read64(count_) == 0) {
86
1/2
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
 28 delete value_;
87
1/2
✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
 28 delete count_;
88 }
89 30 value_ = NULL;
90 30 count_ = NULL;
91 }
92 6561 }
93
94 template<class Y>
95 1 void Reset(Y *p) {
96 1 Reset();
97 1 value_ = static_cast<element_type *>(p);
98 1 count_ = new atomic_int64;
99 1 atomic_write64(count_, 1);
100 1 }
101
102 ✗ T &operator*() const { // never throws
103 ✗ return *value_;
104 }
105
106 1330 T *operator->() const { // never throws
107 1330 return value_;
108 }
109
110 ✗ element_type *Get() const { // never throws
111 ✗ return value_;
112 }
113
114 atomic_int64 *GetCountPtr() const { return count_; }
115
116 9 bool Unique() const { // never throws
117
3/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 3 times.
 9 return count_ && (atomic_read64(count_) == 1);
118 }
119
120 21523 int64_t UseCount() const { // never throws
121 21523 return count_ ? atomic_read64(count_) : -1;
122 }
123
124 private:
125 element_type *value_;
126 atomic_int64 *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