OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add Boost serialization support for SmartPointer and include standard smart pointer headers

Browse Source
This commit is contained in:
AndreaRigoni
2026-04-16 11:30:50 +00:00
parent a3d0a1c28c
commit 8c8aa2358e
1 changed files with 198 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
src/Core/SmartPointer.h
View File

@@ -37,7 +37,8 @@
namespace uLib {
/**
* @brief Internal control block for shared ownership across polymorphic SmartPointers.
* @brief Internal control block for shared ownership across polymorphic
* SmartPointers.
*/
struct ControlBlock {
std::atomic<uint32_t> count;
@@ -49,19 +50,19 @@ private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive &ar, const unsigned int /*version*/) {
// ControlBlock identity is tracked by Boost via the cb pointer in ReferenceCounter.
// We only save the count value.
// ControlBlock identity is tracked by Boost via the cb pointer in
// ReferenceCounter. We only save the count value.
uint32_t c = count.load();
ar &boost::serialization::make_nvp("count", c);
if constexpr (Archive::is_loading::value) count.store(c);
if constexpr (Archive::is_loading::value)
count.store(c);
}
};
/**
* @brief A smart pointer implementation inspired by std::shared_ptr.
*/
template <typename T>
class SmartPointer {
template <typename T> class SmartPointer {
public:
using element_type = T;
@@ -100,15 +101,17 @@ public:
SmartPointer(std::nullptr_t) noexcept : m_counter(nullptr) {}
/**
* @brief Constructor from raw pointer (Implicit conversion allowed for legacy compatibility).
* @brief Constructor from raw pointer (Implicit conversion allowed for legacy
* compatibility).
*/
SmartPointer(T *ptr) : m_counter(nullptr) {
if (ptr) m_counter = new ReferenceCounter(ptr);
if (ptr)
m_counter = new ReferenceCounter(ptr);
}
template <typename D>
SmartPointer(T* ptr, D deleter) : m_counter(nullptr) {
if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
template <typename D> SmartPointer(T *ptr, D deleter) : m_counter(nullptr) {
if (ptr)
m_counter = new ReferenceCounter(ptr, deleter);
}
SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T *) {})) {}
@@ -118,26 +121,31 @@ public:
}
SmartPointer(const SmartPointer *other) noexcept : m_counter(nullptr) {
if (other) acquire(other->m_counter);
if (other)
acquire(other->m_counter);
}
template <typename U, typename = std::enable_if_t<std::is_convertible_v<U*, T*>>>
template <typename U,
typename = std::enable_if_t<std::is_convertible_v<U *, T *>>>
SmartPointer(const SmartPointer<U> &other) noexcept : m_counter(nullptr) {
if (other.m_counter) {
m_counter = new ReferenceCounter();
m_counter->ptr = static_cast<T *>(other.m_counter->ptr);
m_counter->cb = other.m_counter->cb;
if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
if (m_counter->cb)
m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
}
}
template <typename U>
SmartPointer(const SmartPointer<U>& other, T* ptr) noexcept : m_counter(nullptr) {
SmartPointer(const SmartPointer<U> &other, T *ptr) noexcept
: m_counter(nullptr) {
if (other.m_counter) {
m_counter = new ReferenceCounter();
m_counter->ptr = ptr;
m_counter->cb = other.m_counter->cb;
if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
if (m_counter->cb)
m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
}
}
@@ -171,7 +179,8 @@ public:
void reset(T *ptr = nullptr) {
release();
if (ptr) m_counter = new ReferenceCounter(ptr);
if (ptr)
m_counter = new ReferenceCounter(ptr);
}
void swap(SmartPointer &other) noexcept {
@@ -185,7 +194,9 @@ public:
operator T *() const noexcept { return get(); }
uint32_t use_count() const noexcept {
return (m_counter && m_counter->cb) ? m_counter->cb->count.load(std::memory_order_relaxed) : 0;
return (m_counter && m_counter->cb)
? m_counter->cb->count.load(std::memory_order_relaxed)
: 0;
}
bool unique() const noexcept { return use_count() == 1; }
@@ -218,14 +229,17 @@ private:
m_counter = new ReferenceCounter();
m_counter->ptr = c->ptr;
m_counter->cb = c->cb;
if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
if (m_counter->cb)
m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
}
}
void release() noexcept {
if (m_counter) {
if (m_counter->cb && m_counter->cb->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
if (m_counter->cb->deleter) m_counter->cb->deleter();
if (m_counter->cb &&
m_counter->cb->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
if (m_counter->cb->deleter)
m_counter->cb->deleter();
delete m_counter->cb;
}
delete m_counter;
@@ -234,13 +248,24 @@ private:
}
};
template <typename T, typename U> SmartPointer<T> static_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, static_cast<T*>(r.get())); }
template <typename T, typename U> SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U>& r) noexcept {
if (auto p = dynamic_cast<T*>(r.get())) return SmartPointer<T>(r, p);
template <typename T, typename U>
SmartPointer<T> static_pointer_cast(const SmartPointer<U> &r) noexcept {
return SmartPointer<T>(r, static_cast<T *>(r.get()));
}
template <typename T, typename U>
SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U> &r) noexcept {
if (auto p = dynamic_cast<T *>(r.get()))
return SmartPointer<T>(r, p);
return SmartPointer<T>(nullptr);
}
template <typename T, typename U> SmartPointer<T> const_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, const_cast<T*>(r.get())); }
template <typename T, typename U> SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, reinterpret_cast<T*>(r.get())); }
template <typename T, typename U>
SmartPointer<T> const_pointer_cast(const SmartPointer<U> &r) noexcept {
return SmartPointer<T>(r, const_cast<T *>(r.get()));
}
template <typename T, typename U>
SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U> &r) noexcept {
return SmartPointer<T>(r, reinterpret_cast<T *>(r.get()));
}
} // namespace uLib