2 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
4 * This is the base for StormByte Suite libraries.
6 * StormByte original source is dual-licensed:
8 * 1. GNU Lesser General Public License v3.0 (or later)
9 * You may redistribute and/or modify this file under the terms of the
10 * GNU Lesser General Public License as published by the Free Software
11 * Foundation, either version 3 of the License, or (at your option)
14 * 2. Commercial license
15 * Alternatively, this file may be used under the terms of a commercial
16 * license agreement with the copyright holder
17 * (David C. Manuelda <StormByte@gmail.com>).
19 * Both licenses apply only to original StormByte source in this repository.
20 * They do not cover other StormByte modules or any third-party material
21 * shipped with this repository (including everything under thirdparty/),
22 * which remains under its own license.
24 * Neither license grants any patent rights. Any patent licenses required
25 * to use this software or third-party components must be obtained separately
26 * from the patent holders.
28 * StormByte is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31 * GNU Lesser General Public License for more details.
33 * You should have received a copy of the GNU Lesser General Public License
34 * version 3 along with StormByte. If not, see
35 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
37 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
52 * @brief Allocate a control block and a @p T in one Base block.
53 * @tparam T Object type.
54 * @tparam Args Constructor argument types.
55 * @param args Arguments forwarded to @p T.
56 * @return Control block. The object address is @ref Control::Object.
57 * @throws AllocationError The block could not be allocated.
59 template<class T, class... Args>
60 Control* Create(Args&&... args) {
61 constexpr std::size_t align = alignof(T) > alignof(Control) ? alignof(T) : alignof(Control);
62 const std::size_t controlSize = (sizeof(Control) + align - 1) & ~(align - 1);
63 void* block = Heap::Allocate(controlSize + sizeof(T));
64 Control* control = static_cast<Control*>(block);
65 T* object = reinterpret_cast<T*>(static_cast<unsigned char*>(block) + controlSize);
66 control->Strong.store(1, std::memory_order_relaxed);
67 control->Weak.store(1, std::memory_order_relaxed);
68 control->Object = object;
69 control->Destroy = [](Control* dying) noexcept {
70 static_cast<T*>(dying->Object)->~T();
73 new (object) T(std::forward<Args>(args)...);
82 * @brief Drop one strong reference and destroy the object when it was the last.
83 * @param control Control block.
85 inline void ReleaseStrong(Control* control) noexcept {
86 if (control == nullptr)
88 if (control->Strong.fetch_sub(1, std::memory_order_acq_rel) == 1) {
89 control->Destroy(control);
90 if (control->Weak.fetch_sub(1, std::memory_order_acq_rel) == 1)
96 * @brief Drop one weak reference and free the block when it was the last.
97 * @param control Control block.
99 inline void ReleaseWeak(Control* control) noexcept {
100 if (control == nullptr)
102 if (control->Weak.fetch_sub(1, std::memory_order_acq_rel) == 1)
108 Shared<T>::Shared() noexcept: m_control(nullptr), m_object(nullptr) {}
111 Shared<T>::Shared(std::nullptr_t) noexcept: m_control(nullptr), m_object(nullptr) {}
115 requires Type::ConvertibleTo<U*, T*>
116 Shared<T>::Shared(const Shared<U>& other) noexcept: m_control(other.m_control), m_object(other.m_object) {
117 if (m_control != nullptr)
118 m_control->Strong.fetch_add(1, std::memory_order_relaxed);
123 requires Type::ConvertibleTo<U*, T*>
124 Shared<T>::Shared(Shared<U>&& other) noexcept: m_control(other.m_control), m_object(other.m_object) {
125 other.m_control = nullptr;
126 other.m_object = nullptr;
130 Shared<T>::Shared(const Shared& other) noexcept: m_control(other.m_control), m_object(other.m_object) {
131 if (m_control != nullptr)
132 m_control->Strong.fetch_add(1, std::memory_order_relaxed);
136 Shared<T>::Shared(Shared&& other) noexcept: m_control(other.m_control), m_object(other.m_object) {
137 other.m_control = nullptr;
138 other.m_object = nullptr;
142 Shared<T>::Shared(const Weak<T>& weak): m_control(nullptr), m_object(nullptr) {
143 Shared locked = weak.lock();
145 Heap::ThrowExpiredWeakPointer();
146 m_control = locked.m_control;
147 m_object = locked.m_object;
148 locked.m_control = nullptr;
149 locked.m_object = nullptr;
153 Shared<T>& Shared<T>::operator=(const Shared& other) noexcept {
162 Shared<T>& Shared<T>::operator=(Shared&& other) noexcept {
165 Shared taken(std::move(other));
171 Shared<T>::~Shared() {
176 T* Shared<T>::get() const noexcept {
181 std::add_lvalue_reference_t<T> Shared<T>::operator*() const noexcept {
182 if constexpr (!std::is_void_v<T>)
187 T* Shared<T>::operator->() const noexcept {
192 Shared<T>::operator bool() const noexcept {
193 return m_object != nullptr;
197 long Shared<T>::use_count() const noexcept {
198 return m_control == nullptr ? 0 : m_control->Strong.load(std::memory_order_relaxed);
202 void Shared<T>::reset() noexcept {
209 void Shared<T>::swap(Shared& other) noexcept {
211 swap(m_control, other.m_control);
212 swap(m_object, other.m_object);
217 bool Shared<T>::owner_before(const Shared<U>& other) const noexcept {
218 return m_control < other.m_control;
223 bool Shared<T>::owner_before(const Weak<U>& other) const noexcept {
224 return m_control < other.m_control;
228 template<class Target, class... Args>
229 requires Type::SameAs<Target, T> || Type::DerivedFrom<Target, T>
230 Shared<T> Shared<T>::MakePointer(Args&&... args) {
231 return MakeShared<Target>(std::forward<Args>(args)...);
235 Shared<T>::Shared(Detail::Control* control, T* object) noexcept: m_control(control), m_object(object) {}
238 void Shared<T>::Release() noexcept {
239 Detail::ReleaseStrong(m_control);
243 Unique<T>::Unique() noexcept: m_object(nullptr), m_destroy(nullptr) {}
246 Unique<T>::Unique(std::nullptr_t) noexcept: m_object(nullptr), m_destroy(nullptr) {}
250 requires Type::ConvertibleTo<U*, T*>
251 Unique<T>::Unique(Unique<U>&& other) noexcept: m_object(other.m_object), m_destroy(other.m_destroy) {
252 other.m_object = nullptr;
253 other.m_destroy = nullptr;
257 Unique<T>::Unique(Unique&& other) noexcept: m_object(other.m_object), m_destroy(other.m_destroy) {
258 other.m_object = nullptr;
259 other.m_destroy = nullptr;
263 Unique<T>& Unique<T>::operator=(Unique&& other) noexcept {
267 m_object = other.m_object;
268 m_destroy = other.m_destroy;
269 other.m_object = nullptr;
270 other.m_destroy = nullptr;
275 Unique<T>::~Unique() {
280 T* Unique<T>::get() const noexcept {
285 std::add_lvalue_reference_t<T> Unique<T>::operator*() const noexcept {
286 if constexpr (!std::is_void_v<T>)
291 T* Unique<T>::operator->() const noexcept {
296 Unique<T>::operator bool() const noexcept {
297 return m_object != nullptr;
301 void Unique<T>::reset() noexcept {
302 if (m_destroy != nullptr)
309 void Unique<T>::swap(Unique& other) noexcept {
311 swap(m_object, other.m_object);
312 swap(m_destroy, other.m_destroy);
316 template<class Target, class... Args>
317 requires Type::SameAs<Target, T> || Type::DerivedFrom<Target, T>
318 Unique<T> Unique<T>::MakePointer(Args&&... args) {
319 return MakeUnique<Target>(std::forward<Args>(args)...);
323 Unique<T>::Unique(T* object, void (*destroy)(void*) noexcept) noexcept: m_object(object), m_destroy(destroy) {}
326 Weak<T>::Weak() noexcept: m_control(nullptr), m_object(nullptr) {}
329 Weak<T>::Weak(std::nullptr_t) noexcept: m_control(nullptr), m_object(nullptr) {}
333 requires Type::ConvertibleTo<U*, T*>
334 Weak<T>::Weak(const Shared<U>& owner) noexcept: m_control(owner.m_control), m_object(owner.m_object) {
335 if (m_control != nullptr)
336 m_control->Weak.fetch_add(1, std::memory_order_relaxed);
340 Weak<T>::Weak(const Weak& other) noexcept: m_control(other.m_control), m_object(other.m_object) {
341 if (m_control != nullptr)
342 m_control->Weak.fetch_add(1, std::memory_order_relaxed);
346 Weak<T>::Weak(Weak&& other) noexcept: m_control(other.m_control), m_object(other.m_object) {
347 other.m_control = nullptr;
348 other.m_object = nullptr;
352 Weak<T>& Weak<T>::operator=(const Weak& other) noexcept {
361 Weak<T>& Weak<T>::operator=(Weak&& other) noexcept {
364 Weak taken(std::move(other));
375 Shared<T> Weak<T>::lock() const noexcept {
376 if (m_control == nullptr)
378 long count = m_control->Strong.load(std::memory_order_relaxed);
380 if (m_control->Strong.compare_exchange_weak(count, count + 1, std::memory_order_acquire, std::memory_order_relaxed))
381 return Shared<T>(m_control, m_object);
387 bool Weak<T>::expired() const noexcept {
388 return m_control == nullptr || m_control->Strong.load(std::memory_order_relaxed) == 0;
392 long Weak<T>::use_count() const noexcept {
393 return m_control == nullptr ? 0 : m_control->Strong.load(std::memory_order_relaxed);
397 void Weak<T>::reset() noexcept {
404 void Weak<T>::swap(Weak& other) noexcept {
406 swap(m_control, other.m_control);
407 swap(m_object, other.m_object);
412 bool Weak<T>::owner_before(const Weak<U>& other) const noexcept {
413 return m_control < other.m_control;
418 bool Weak<T>::owner_before(const Shared<U>& other) const noexcept {
419 return m_control < other.m_control;
423 void Weak<T>::Release() noexcept {
424 Detail::ReleaseWeak(m_control);
428 EnableSharedFromThis<T>::EnableSharedFromThis(const EnableSharedFromThis&) noexcept {}
431 EnableSharedFromThis<T>::EnableSharedFromThis(EnableSharedFromThis&&) noexcept {}
434 EnableSharedFromThis<T>& EnableSharedFromThis<T>::operator=(const EnableSharedFromThis&) noexcept {
439 EnableSharedFromThis<T>& EnableSharedFromThis<T>::operator=(EnableSharedFromThis&&) noexcept {
444 Shared<T> EnableSharedFromThis<T>::SharedFromThis() const {
445 return Shared<T>(m_weak);
449 AtomicShared<T>::AtomicShared() noexcept: m_lock(), m_control(nullptr), m_object(nullptr) {}
452 AtomicShared<T>::AtomicShared(Shared<T> owner) noexcept: m_lock(), m_control(owner.m_control), m_object(owner.m_object) {
453 owner.m_control = nullptr;
454 owner.m_object = nullptr;
458 AtomicShared<T>::~AtomicShared() {
459 Detail::ReleaseStrong(m_control);
463 AtomicShared<T>& AtomicShared<T>::operator=(Shared<T> owner) noexcept {
464 store(std::move(owner));
469 AtomicShared<T>::operator bool() const noexcept {
470 return static_cast<bool>(load());
474 Shared<T> AtomicShared<T>::load() const noexcept {
476 Shared<T> loaded(m_control, m_object);
477 if (m_control != nullptr)
478 m_control->Strong.fetch_add(1, std::memory_order_relaxed);
484 void AtomicShared<T>::store(Shared<T> owner) noexcept {
485 exchange(std::move(owner));
489 Shared<T> AtomicShared<T>::exchange(Shared<T> owner) noexcept {
491 Shared<T> previous(m_control, m_object);
492 m_control = owner.m_control;
493 m_object = owner.m_object;
494 owner.m_control = nullptr;
495 owner.m_object = nullptr;
501 bool AtomicShared<T>::compare_exchange_strong(Shared<T>& expected, Shared<T> desired) noexcept {
503 if (m_object == expected.get()) {
504 Detail::ReleaseStrong(expected.m_control);
505 expected.m_control = nullptr;
506 expected.m_object = nullptr;
507 expected = Shared<T>(m_control, m_object);
508 if (m_control != nullptr)
509 m_control->Strong.fetch_add(1, std::memory_order_relaxed);
510 Detail::ReleaseStrong(m_control);
511 m_control = desired.m_control;
512 m_object = desired.m_object;
513 desired.m_control = nullptr;
514 desired.m_object = nullptr;
518 Detail::ReleaseStrong(expected.m_control);
519 expected.m_control = m_control;
520 expected.m_object = m_object;
521 if (m_control != nullptr)
522 m_control->Strong.fetch_add(1, std::memory_order_relaxed);
528 bool AtomicShared<T>::compare_exchange_weak(Shared<T>& expected, Shared<T> desired) noexcept {
529 return compare_exchange_strong(expected, std::move(desired));
533 void AtomicShared<T>::Lock() const noexcept {
534 while (m_lock.test_and_set(std::memory_order_acquire))
539 void AtomicShared<T>::Unlock() const noexcept {
540 m_lock.clear(std::memory_order_release);
543 template<class T, class... Args>
544 Shared<T> MakeShared(Args&&... args) {
546 Detail::Control* control = Detail::Create<T>(std::forward<Args>(args)...);
547 Shared<T> owner(control, static_cast<T*>(control->Object));
548 if constexpr (std::is_base_of_v<EnableSharedFromThis<T>, T>)
549 static_cast<EnableSharedFromThis<T>*>(owner.get())->m_weak = owner;
552 Heap::RethrowException();
556 template<class T, class... Args>
557 Unique<T> MakeUnique(Args&&... args) {
558 void* block = Heap::Allocate(sizeof(T));
560 T* object = new (block) T(std::forward<Args>(args)...);
561 return Unique<T>(object, [](void* pointer) noexcept {
562 static_cast<T*>(pointer)->~T();
567 Heap::RethrowException();
571 template<class T, class U>
572 Shared<T> StaticPointerCast(const Shared<U>& from) noexcept {
575 Shared<T> casted(from.m_control, static_cast<T*>(from.get()));
576 casted.m_control->Strong.fetch_add(1, std::memory_order_relaxed);
580 template<class T, class U>
581 Shared<T> DynamicPointerCast(const Shared<U>& from) noexcept {
584 T* object = dynamic_cast<T*>(from.get());
585 if (object == nullptr)
587 Shared<T> casted(from.m_control, object);
588 casted.m_control->Strong.fetch_add(1, std::memory_order_relaxed);
592 template<class T, class U>
593 Shared<T> ConstPointerCast(const Shared<U>& from) noexcept {
596 Shared<T> casted(from.m_control, const_cast<T*>(from.get()));
597 casted.m_control->Strong.fetch_add(1, std::memory_order_relaxed);
601 template<class T, class U>
602 Shared<T> ReinterpretPointerCast(const Shared<U>& from) noexcept {
605 Shared<T> casted(from.m_control, reinterpret_cast<T*>(from.get()));
606 casted.m_control->Strong.fetch_add(1, std::memory_order_relaxed);
611 void swap(Shared<T>& left, Shared<T>& right) noexcept {
616 void swap(Unique<T>& left, Unique<T>& right) noexcept {
621 void swap(Weak<T>& left, Weak<T>& right) noexcept {