corosio

Directory: ../corosio_lcov_PR-139/
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 100.0% 5 / 0 / 5
Functions: 100.0% 8 / 0 / 8
Branches: -% 0 / 0 / 0
include/boost/corosio/detail/thread_local_ptr.hpp
Line Branch Exec Source
1 //
2 // Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)
3 //
4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // Official repository: https://github.com/cppalliance/corosio
8 //
9
10 #ifndef BOOST_COROSIO_DETAIL_THREAD_LOCAL_PTR_HPP
11 #define BOOST_COROSIO_DETAIL_THREAD_LOCAL_PTR_HPP
12
13 #include <boost/corosio/detail/config.hpp>
14
15 #include <type_traits>
16
17 // Detect thread-local storage mechanism
18 #if !defined(BOOST_COROSIO_TLS_KEYWORD)
19 # if defined(_MSC_VER)
20 # define BOOST_COROSIO_TLS_KEYWORD __declspec(thread)
21 # elif defined(__GNUC__) || defined(__clang__)
22 # define BOOST_COROSIO_TLS_KEYWORD __thread
23 # endif
24 #endif
25
26 namespace boost::corosio::detail {
27
28 /** A thread-local pointer.
29
30 This class provides thread-local storage for a pointer to T.
31 Each thread has its own independent pointer value, initially
32 nullptr. The user is responsible for managing the lifetime
33 of the pointed-to objects.
34
35 The storage is static per type T. All instances of
36 `thread_local_ptr<T>` share the same underlying slot.
37
38 The implementation uses the most efficient available mechanism:
39 1. Compiler keyword (__declspec(thread) or __thread) - enforces POD
40 2. C++11 thread_local (fallback)
41
42 @tparam T The pointed-to type.
43
44 @par Declaration
45
46 Typically declared at namespace or class scope. The object
47 is stateless, so local variables work but are redundant.
48
49 @code
50 // Recommended: namespace scope
51 namespace {
52 thread_local_ptr<session> current_session;
53 }
54
55 // Also works: static class member
56 class server {
57 static thread_local_ptr<request> current_request_;
58 };
59
60 // Works but unusual: local variable (still accesses static storage)
61 void foo() {
62 thread_local_ptr<context> ctx; // same slot on every call
63 ctx = new context();
64 }
65 @endcode
66
67 @note The user is responsible for deleting pointed-to objects
68 before threads exit to avoid memory leaks.
69 */
70 template<class T>
71 class thread_local_ptr;
72
73 //------------------------------------------------------------------------------
74
75 #if defined(BOOST_COROSIO_TLS_KEYWORD)
76
77 // Use compiler-specific keyword (__declspec(thread) or __thread)
78 // Most efficient: static linkage, no dynamic init, enforces POD
79
80 template<class T>
81 class thread_local_ptr
82 {
83 static BOOST_COROSIO_TLS_KEYWORD T* ptr_;
84
85 public:
86 thread_local_ptr() = default;
87 ~thread_local_ptr() = default;
88
89 thread_local_ptr(thread_local_ptr const&) = delete;
90 thread_local_ptr& operator=(thread_local_ptr const&) = delete;
91
92 /** Return the pointer for this thread.
93
94 @return The stored pointer, or nullptr if not set.
95 */
96 T*
97 637145 get() const noexcept
98 {
99 637145 return ptr_;
100 }
101
102 /** Set the pointer for this thread.
103
104 @param p The pointer to store. The user manages its lifetime.
105 */
106 void
107 33119 set(T* p) noexcept
108 {
109 33119 ptr_ = p;
110 33119 }
111
112 /** Dereference the stored pointer.
113
114 @pre get() != nullptr
115 */
116 T&
117 operator*() const noexcept
118 {
119 return *ptr_;
120 }
121
122 /** Member access through the stored pointer.
123
124 @pre get() != nullptr
125 */
126 T*
127 operator->() const noexcept
128 requires std::is_class_v<T>
129 {
130 return ptr_;
131 }
132
133 /** Assign a pointer value.
134
135 @param p The pointer to store.
136 @return The stored pointer.
137 */
138 T*
139 operator=(T* p) noexcept
140 {
141 ptr_ = p;
142 return p;
143 }
144 };
145
146 template<class T>
147 BOOST_COROSIO_TLS_KEYWORD T* thread_local_ptr<T>::ptr_ = nullptr;
148
149 //------------------------------------------------------------------------------
150
151 #else
152
153 // Use C++11 thread_local keyword (fallback)
154
155 template<class T>
156 class thread_local_ptr
157 {
158 static thread_local T* ptr_;
159
160 public:
161 thread_local_ptr() = default;
162 ~thread_local_ptr() = default;
163
164 thread_local_ptr(thread_local_ptr const&) = delete;
165 thread_local_ptr& operator=(thread_local_ptr const&) = delete;
166
167 T*
168 get() const noexcept
169 {
170 return ptr_;
171 }
172
173 void
174 set(T* p) noexcept
175 {
176 ptr_ = p;
177 }
178
179 T&
180 operator*() const noexcept
181 {
182 return *ptr_;
183 }
184
185 T*
186 operator->() const noexcept
187 requires std::is_class_v<T>
188 {
189 return ptr_;
190 }
191
192 T*
193 operator=(T* p) noexcept
194 {
195 ptr_ = p;
196 return p;
197 }
198 };
199
200 template<class T>
201 thread_local T* thread_local_ptr<T>::ptr_ = nullptr;
202
203 #endif
204
205 } // namespace boost::corosio::detail
206
207 #endif
208