CsPointer  2.0.0
cs_shared_pointer.h
1 
19 #ifndef LIB_CS_SHARED_POINTER_H
20 #define LIB_CS_SHARED_POINTER_H
21 
22 #include <compare>
23 #include <memory>
24 
25 namespace CsPointer {
26 
27 template <typename T, typename Deleter>
29 
30 template <typename T>
32 
33 template <typename T>
35 {
36  public:
37  using element_type = typename std::shared_ptr<T>::element_type;
39  using pointer = element_type *;
40 
43  using Pointer = pointer;
44 
45  constexpr CsSharedPointer() noexcept
46  {
47  }
48 
49  constexpr CsSharedPointer(std::nullptr_t) noexcept
50  {
51  }
52 
53  template <typename U>
54  explicit CsSharedPointer(U *p)
55  : m_ptr(p)
56  {
57  }
58 
59  template <typename U, typename Deleter>
60  CsSharedPointer(U *p, Deleter d)
61  : m_ptr(p, std::move(d))
62  {
63  }
64 
65  template <typename Deleter>
66  CsSharedPointer(std::nullptr_t, Deleter d)
67  : m_ptr(nullptr, std::move(d))
68  {
69  }
70 
71  template <typename U, typename Deleter, typename Alloc>
72  CsSharedPointer(U *p, Deleter d, Alloc a)
73  : m_ptr(p, std::move(d), std::move(a))
74  {
75  }
76 
77  template <typename Deleter, typename Alloc>
78  CsSharedPointer(std::nullptr_t, Deleter d, Alloc a)
79  : m_ptr(nullptr, std::move(d), std::move(a))
80  {
81  }
82 
83  template <typename U, typename Deleter>
85  : m_ptr(std::unique_ptr<U, Deleter>(std::move(p)))
86  {
87  }
88 
89  template <typename U>
90  CsSharedPointer(const std::shared_ptr<U> &p) noexcept
91  : m_ptr(p)
92  {
93  }
94 
95  template <typename U>
96  CsSharedPointer(std::shared_ptr<U> &&p) noexcept
97  : m_ptr(std::move(p))
98  {
99  }
100 
101  template <typename U>
103  : m_ptr(p1.m_ptr, p2)
104  {
105  }
106 
107  template <typename U>
109  : m_ptr(std::move(p1.m_ptr), p2)
110  {
111  p1.m_ptr.reset();
112  }
113 
114  ~CsSharedPointer() = default;
115 
116  CsSharedPointer(const CsSharedPointer &other) = default;
117  CsSharedPointer &operator=(const CsSharedPointer &other) = default;
118 
119  CsSharedPointer(CsSharedPointer &&other) = default;
120  CsSharedPointer &operator=(CsSharedPointer && other) = default;
121 
122  template <typename U>
124  : m_ptr(p.m_ptr)
125  {
126  }
127 
128  template <typename U>
130  m_ptr = p.m_ptr;
131  return *this;
132  }
133 
134  template <typename U>
136  : m_ptr(std::move(p.m_ptr))
137  {
138  }
139 
140  template <typename U>
142  m_ptr = std::move(p.m_ptr);
143  return *this;
144  }
145 
146  template <typename U>
148  : m_ptr(p.m_ptr.lock())
149  {
150  if (is_null()) {
151  throw std::bad_weak_ptr();
152  }
153  }
154 
155  template <typename U>
157  m_ptr = p.m_ptr.lock();
158  return *this;
159  }
160 
161  element_type &operator*() const noexcept {
162  return *m_ptr;
163  }
164 
165  pointer operator->() const noexcept {
166  return m_ptr.get();
167  }
168 
169  bool operator !() const noexcept {
170  return m_ptr == nullptr;
171  }
172 
173  explicit operator bool() const noexcept {
174  return m_ptr != nullptr;
175  }
176 
177  template <typename U>
178  operator std::shared_ptr<U>() const & noexcept
179  {
180  return m_ptr;
181  }
182 
183  template <typename U>
184  operator std::shared_ptr<U>() && noexcept
185  {
186  return std::move(m_ptr);
187  }
188 
189  //
190  void clear() noexcept {
191  reset();
192  }
193 
194  template <typename... Args>
195  static CsSharedPointer<T> create(Args &&... args) {
196  return std::make_shared<T>(std::forward<Args>(args)...);
197  }
198 
199  pointer data() const noexcept {
200  return m_ptr.get();
201  }
202 
203  pointer get() const noexcept {
204  return m_ptr.get();
205  }
206 
207  bool is_null() const noexcept {
208  return m_ptr == nullptr;
209  }
210 
211  template <typename U>
212  bool owner_before(const CsSharedPointer<U> &p) const noexcept {
213  return m_ptr.owner_before(p.m_ptr);
214  }
215 
216  template <typename U>
217  bool owner_before(const CsWeakPointer<U> &p) const noexcept {
218  return m_ptr.owner_before(p.m_ptr);
219  }
220 
221  void reset() noexcept {
222  m_ptr.reset();
223  }
224 
225  template <typename U>
226  void reset(U *p) {
227  if (m_ptr.get() == p) {
228  return;
229  }
230 
231  m_ptr.reset(p);
232  }
233 
234  template <typename U, typename Deleter>
235  void reset(U *p, Deleter d) {
236  if (m_ptr.get() == p) {
237  return;
238  }
239 
240  m_ptr.reset(p, std::move(d));
241  }
242 
243  template <typename U, typename Deleter, typename Alloc>
244  void reset(U *p, Deleter d, Alloc a) {
245  if (m_ptr.get() == p) {
246  return;
247  }
248 
249  m_ptr.reset(p, std::move(d), std::move(a));
250  }
251 
252  void swap(CsSharedPointer &other) noexcept {
253  std::swap(m_ptr, other.m_ptr);
254  }
255 
257  return CsWeakPointer<T>(*this);
258  }
259 
260  bool unique() const noexcept {
261  return m_ptr.use_count() == 1;
262  }
263 
264  long use_count() const noexcept {
265  return m_ptr.use_count();
266  }
267 
268  template <typename U>
269  auto operator<=>(const CsSharedPointer<U> &ptr) const noexcept {
270  return this->m_ptr <=> ptr.m_ptr;
271  }
272 
273  template <typename U>
274  bool operator==(const CsSharedPointer<U> &ptr) const noexcept {
275  return this->m_ptr == ptr.m_ptr;
276  }
277 
278  template <typename U>
279  auto operator<=>(const U *ptr) const noexcept {
280  return this->get() <=> ptr;
281  }
282 
283  template <typename U>
284  bool operator==(const U *ptr) const noexcept {
285  return this->get() == ptr;
286  }
287 
288  auto operator<=>(std::nullptr_t) const noexcept {
289  return this->m_ptr <=> nullptr;
290  }
291 
292  bool operator==(std::nullptr_t) const noexcept {
293  return this->m_ptr == nullptr;
294  }
295 
296  private:
297  std::shared_ptr<T> m_ptr;
298 
299  template <typename U>
300  friend class CsSharedArrayPointer;
301 
302  template <typename U>
303  friend class CsSharedPointer;
304 
305  template <typename U>
306  friend class CsWeakPointer;
307 };
308 
309 template <typename T, typename... Args, typename = typename std::enable_if_t<! std::is_array_v<T>>>
311 {
312  return std::make_shared<T>(std::forward<Args>(args)...);
313 }
314 
315 template <typename T>
316 void swap(CsSharedPointer<T> &ptr1, CsSharedPointer<T> &ptr2) noexcept
317 {
318  ptr1.swap(ptr2);
319 }
320 
321 // cast functions
322 template <typename T, typename U>
324 {
325  return std::static_pointer_cast<T> (std::shared_ptr<U>(ptr));
326 }
327 
328 template <typename T, typename U>
330 {
331  return std::dynamic_pointer_cast<T> (std::shared_ptr<U>(ptr));
332 }
333 
334 template <typename T, typename U>
336 {
337  return std::const_pointer_cast<T> (std::shared_ptr<U>(ptr));
338 }
339 
340 template <typename T, typename U>
342 {
343  return std::static_pointer_cast<T> (std::shared_ptr<U>(std::move(ptr)));
344 }
345 
346 template <typename T, typename U>
348 {
349  return std::dynamic_pointer_cast<T> (std::shared_ptr<U>(std::move(ptr)));
350 }
351 
352 template <typename T, typename U>
354 {
355  return std::const_pointer_cast<T> (std::shared_ptr<U>(std::move(ptr)));
356 }
357 
358 } // end namespace
359 
360 #endif
CsSharedPointer< T > static_pointer_cast(const CsSharedPointer< U > &ptr)
Definition: cs_shared_pointer.h:323
bool unique() const noexcept
Definition: cs_shared_pointer.h:260
void swap(CsSharedPointer &other) noexcept
Definition: cs_shared_pointer.h:252
CsSharedPointer< T > dynamic_pointer_cast(const CsSharedPointer< U > &ptr)
Definition: cs_shared_pointer.h:329
bool owner_before(const CsWeakPointer< U > &p) const noexcept
Definition: cs_shared_pointer.h:217
CsWeakPointer< T > toWeakRef() const
Definition: cs_shared_pointer.h:256
pointer get() const noexcept
Definition: cs_shared_pointer.h:203
CsSharedPointer< T > const_pointer_cast(const CsSharedPointer< U > &ptr)
Definition: cs_shared_pointer.h:335
pointer data() const noexcept
Definition: cs_shared_pointer.h:199
static CsSharedPointer< T > create(Args &&...args)
Definition: cs_shared_pointer.h:195
void clear() noexcept
Definition: cs_shared_pointer.h:190
void reset(U *p, Deleter d, Alloc a)
Definition: cs_shared_pointer.h:244
void reset() noexcept
Definition: cs_shared_pointer.h:221
pointer operator->() const noexcept
Definition: cs_shared_pointer.h:165
element_type & operator*() const noexcept
Definition: cs_shared_pointer.h:161
CsSharedPointer & operator=(const CsWeakPointer< U > &p)
Definition: cs_shared_pointer.h:156
bool is_null() const noexcept
Definition: cs_shared_pointer.h:207
CsSharedPointer(const CsWeakPointer< U > &p)
Definition: cs_shared_pointer.h:147
long use_count() const noexcept
Definition: cs_shared_pointer.h:264
CsSharedPointer(const CsSharedPointer< U > &p) noexcept
Definition: cs_shared_pointer.h:123
void reset(U *p, Deleter d)
Definition: cs_shared_pointer.h:235
CsSharedPointer(CsSharedPointer< U > &&p1, element_type *p2) noexcept
Definition: cs_shared_pointer.h:108
CsSharedPointer(const CsSharedPointer< U > &p1, element_type *p2) noexcept
Definition: cs_shared_pointer.h:102
CsSharedPointer(std::shared_ptr< U > &&p) noexcept
Definition: cs_shared_pointer.h:96
CsSharedPointer(std::nullptr_t, Deleter d, Alloc a)
Definition: cs_shared_pointer.h:78
bool operator==(const CsSharedPointer< T1 > &ptr1, const CsSharedPointer< T2 > &ptr2)
CsSharedPointer(U *p, Deleter d, Alloc a)
Definition: cs_shared_pointer.h:72
CsSharedPointer(std::nullptr_t, Deleter d)
Definition: cs_shared_pointer.h:66
CsSharedPointer(U *p, Deleter d)
Definition: cs_shared_pointer.h:60
bool owner_before(const CsSharedPointer< U > &p) const noexcept
Definition: cs_shared_pointer.h:212
CsSharedPointer(U *p)
Definition: cs_shared_pointer.h:54
CsSharedPointer(const std::shared_ptr< U > &p) noexcept
Definition: cs_shared_pointer.h:90
constexpr CsSharedPointer(std::nullptr_t) noexcept
Definition: cs_shared_pointer.h:49
CsSharedPointer & operator=(const CsSharedPointer< U > &p) noexcept
Definition: cs_shared_pointer.h:129
constexpr CsSharedPointer() noexcept
Definition: cs_shared_pointer.h:45
bool operator!() const noexcept
Definition: cs_shared_pointer.h:169
pointer Pointer
Definition: cs_shared_pointer.h:43
CsSharedPointer< T > make_shared(Args &&...args)
Definition: cs_shared_pointer.h:310
void reset(U *p)
Definition: cs_shared_pointer.h:226
CsSharedPointer & operator=(CsSharedPointer< U > &&p) noexcept
Definition: cs_shared_pointer.h:141
CsWeakPointer< T > weak_type
Definition: cs_shared_pointer.h:38
CsSharedPointer & operator=(const CsSharedPointer &other) = default
element_type ElementType
Definition: cs_shared_pointer.h:41
CsSharedPointer(CsUniquePointer< U, Deleter > &&p)
Definition: cs_shared_pointer.h:84
element_type * pointer
Definition: cs_shared_pointer.h:39
typename std::shared_ptr< cs_add_missing_extent_t< T > >::element_type element_type
Definition: cs_shared_pointer.h:37
Stores a pointer to a potentially shared object.
Definition: cs_shared_pointer.h:34
Stores a weak pointer to a potentially shared object.
Definition: cs_shared_pointer.h:31
CsSharedPointer(CsSharedPointer< U > &&p) noexcept
Definition: cs_shared_pointer.h:135
Contains a pointer to an object and takes exclusive ownership.
Definition: cs_shared_pointer.h:28
Namespace for the CsPointer library.