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

.agents/rules/micromamba_build.md

@@ -18,7 +18,7 @@ This rule provides instructions for building the uLib project using the micromam
    ```bash
    export MAMBA_EXE="/home/share/micromamba/bin/micromamba"
    export MAMBA_ROOT_PREFIX="/home/share/micromamba"
-   export PRESET="clang-make"
+   export PRESET="clang-debug"
    eval "$(${MAMBA_EXE} shell hook --shell bash)"
    micromamba activate uLib
    ```

app/gcompose/src/ContextModel.cpp

@@ -38,8 +38,8 @@ void ContextModel::setContext(uLib::ObjectsContext* context) {
         });
 
         // Connect existing objects
-        for (auto* obj : m_rootContext->GetObjects()) {
+        for (const auto& obj : m_rootContext->GetObjects()) {
-            uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
+            uLib::Object::connect(obj.get(), &uLib::Object::Updated, refresh);
         }
     }
     endResetModel();
@@ -229,8 +229,8 @@ bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, in
         [&findAndRemoveRecursive](uLib::Object* current, uLib::Object* target) {
         if (auto ctx = current->GetChildren()) {
             ctx->RemoveObject(target);
-            for (auto* obj : ctx->GetObjects()) {
+            for (const auto& obj : ctx->GetObjects()) {
-                findAndRemoveRecursive(obj, target);
+                findAndRemoveRecursive(obj.get(), target);
             }
         }
     };
@@ -244,12 +244,12 @@ bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, in
              // check if targetCtx is descendant of obj
              std::function<bool(uLib::Object*, uLib::Object*)> isDescendant = 
                 [&isDescendant](uLib::Object* root, uLib::Object* target) -> bool {
-                 if (auto ctx = root->GetChildren()) {
+                  if (auto ctx = root->GetChildren()) {
-                     for (auto* child : ctx->GetObjects()) {
+                      for (const auto& child : ctx->GetObjects()) {
-                         if (child == target) return true;
+                          if (child.get() == target) return true;
-                         if (isDescendant(child, target)) return true;
+                          if (isDescendant(child.get(), target)) return true;
-                     }
+                      }
-                 }
+                  }
                  return false;
              };
              if (isDescendant(obj, (uLib::Object*)targetCtx)) invalid = true;

app/gcompose/src/MainPanel.cpp

@@ -182,8 +182,8 @@ void MainPanel::setContext(uLib::ObjectsContext* context) {
 
             // Add any prop3ds that were created during m_mainVtkContext's construction to all panes
             auto panes = this->findChildren<ViewportPane*>();
-            for (auto* obj : context->GetObjects()) {
+            for (const auto& obj : context->GetObjects()) {
-                if (auto* p = m_mainVtkContext->GetProp3D(obj)) {
+                if (auto* p = m_mainVtkContext->GetProp3D(obj.get())) {
                     for (auto* pane : panes) {
                         if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
                             vp->AddProp3D(*p);

app/gcompose/src/PropertyWidgets.cpp

@@ -426,15 +426,15 @@ void ReferencePropertyWidget::refreshCombo() {
 
     if (m_Context) {
         const auto& objects = m_Context->GetObjects();
-        for (auto* obj : objects) {
+        for (const auto& obj : objects) {
-            if (m_RefProp->IsCompatible(obj)) {
+            if (m_RefProp->IsCompatible(obj.get())) {
                 QString label = QString::fromStdString(obj->GetInstanceName());
                 if (label.isEmpty()) {
                     label = QString::fromStdString(std::string(obj->GetClassName()));
                 }
                 // Add index suffix if name is empty to disambiguate
-                m_Combo->addItem(label, QVariant::fromValue((quintptr)obj));
+                m_Combo->addItem(label, QVariant::fromValue((quintptr)obj.get()));
-                if (obj == currentRef) {
+                if (obj.get() == currentRef) {
                     selectedIdx = m_Combo->count() - 1;
                 }
             }

docs/object_context.md

@@ -2,6 +2,16 @@
 
 In uLib the context is meant to hold a set of objects and their hierarchy. In addition ObjectFactory is used to create objects from a predefined registry. 
 
+Object context can be thouught as a collection of uLib::Object instances. And there exists nested collection of objects if a context is added to another context. A nested context is a Group of elements that appears like a single object in the parent context and a hierarchy of objects inside the tree structure. 
+
+## SmartPointer access
+
+SmartPointer is a class that is used to hold a reference to another object. It is a template class that can be used to hold a reference to any object that is derived from uLib::Object. It is a smart pointer because it will automatically delete the object when it is no longer needed. It is also a smart pointer because it will automatically update the object when it is no longer needed. 
+
+The ObjectContext is responsible to keep track of all the objects that are added to it and to provide a way to access them, but also it holds the SmartPointer instances that point to the objects that are added to it. In this way Objects added to a Context are disposed only when the context is destroyed.
+For this reason the access to a object context for a Object via Get/Set is done using the SmartPointer instances. 
+
+
 ## Geant Physical Volumes
 
 The Geant library add a further layer of complexity. The physical volumes are created from a what is called LogicalVolume (which holds information about the shape, material and daughter volumes) and represent the actual instances of the volumes in the detector. So in this sense they represent what could be the Prop3D in the uLib Vtk library. The PhysicalVolume is created from the LogicalVolume and is the one that is actually placed in the scene, with its own relative TRS: position and rotation (rotation here is a rotation matrix comprising the scaling). 

src/Core/ObjectsContext.cpp

@@ -8,28 +8,41 @@ ObjectsContext::ObjectsContext() : Object() {}
 ObjectsContext::~ObjectsContext() {}
 
 void ObjectsContext::AddObject(Object* obj) {
-    if (obj && std::find(m_objects.begin(), m_objects.end(), obj) == m_objects.end()) {
+    if (obj) {
-        m_objects.push_back(obj);
+        auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
-        // Connect child's update to context's update to trigger re-renders
+            return sp.get() == obj;
-        Object::connect(obj, &Object::Updated, this, &Object::Updated);
+        });
-        ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+        if (it == m_objects.end()) {
-        this->Updated(); // Signal that the context has been updated
+            m_objects.push_back(SmartPointer<Object>(obj));
+            // Connect child's update to context's update to trigger re-renders
+            Object::connect(obj, &Object::Updated, this, &Object::Updated);
+            ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+            this->Updated(); // Signal that the context has been updated
+        }
     }
 }
 
 void ObjectsContext::RemoveObject(Object* obj) {
-    auto it = std::find(m_objects.begin(), m_objects.end(), obj);
+    auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
+        return sp.get() == obj;
+    });
     if (it != m_objects.end()) {
-        Object* removedObj = *it;
+        Object* removedObj = it->get();
-        m_objects.erase(it);
+        // Since we are about to erase it from the vector, if it was the last reference
+        // it would be deleted. We might want to emit the signal BEFORE erasing.
         ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, removedObj);
+        m_objects.erase(it);
         this->Updated(); // Signal that the context has been updated
     }
 }
 
 void ObjectsContext::Clear() {
     if (!m_objects.empty()) {
-        for (auto obj : m_objects) {
+        // Create a copy of the pointers to emit signals since m_objects might be modified or cleared
+        std::vector<Object*> toRemove;
+        for (const auto& sp : m_objects) toRemove.push_back(sp.get());
+
+        for (auto obj : toRemove) {
             ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
         }
         m_objects.clear();
@@ -37,7 +50,7 @@ void ObjectsContext::Clear() {
     }
 }
 
-const std::vector<Object*>& ObjectsContext::GetObjects() const {
+const std::vector<SmartPointer<Object>>& ObjectsContext::GetObjects() const {
     return m_objects;
 }
 
@@ -47,7 +60,7 @@ size_t ObjectsContext::GetCount() const {
 
 Object* ObjectsContext::GetObject(size_t index) const {
     if (index < m_objects.size()) {
-        return m_objects[index];
+        return m_objects[index].get();
     }
     return nullptr;
 }

src/Core/ObjectsContext.h

@@ -2,6 +2,7 @@
 #define U_CORE_OBJECTS_CONTEXT_H
 
 #include "Core/Object.h"
+#include "Core/SmartPointer.h"
 #include <vector>
 
 namespace uLib {
@@ -36,9 +37,9 @@ public:
 
     /**
      * @brief Returns the collection of objects.
-     * @return Const reference to the vector of object pointers.
+     * @return Const reference to the vector of SmartPointer<Object>.
      */
-    const std::vector<Object*>& GetObjects() const;
+    const std::vector<SmartPointer<Object>>& GetObjects() const;
     
     signals:
     /** @brief Signal emitted when an object is added. */
@@ -60,7 +61,7 @@ public:
     Object* GetObject(size_t index) const;
 
 private:
-    std::vector<Object*> m_objects;
+    std::vector<SmartPointer<Object>> m_objects;
 };
 
 } // namespace uLib

src/Core/SmartPointer.h

@@ -3,7 +3,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
   Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
+  All Padua preserved
 
   Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
 
@@ -30,11 +30,6 @@
 #include <functional>
 #include <type_traits>
 #include <utility>
-#include <boost/serialization/access.hpp>
-#include <boost/serialization/nvp.hpp>
-#include <boost/serialization/split_member.hpp>
-#include <boost/serialization/vector.hpp>
-#include <boost/serialization/string.hpp>
 
 #include <boost/serialization/access.hpp>
 #include <boost/serialization/nvp.hpp>
@@ -42,279 +37,265 @@
 namespace uLib {
 
 /**
- * @brief A smart pointer implementation inspired by std::shared_ptr.
+ * @brief Internal control block for shared ownership across polymorphic
- * 
+ * SmartPointers.
- * Features modernized C++11/14/17 syntax, thread-safe reference counting,
- * move semantics, and support for custom deleters.
- * 
- * NOTE: Default constructor allocates a new T following legacy behavior.
  */
-template <typename T>
+struct ControlBlock {
-class SmartPointer {
+  std::atomic<uint32_t> count;
-public:
+  std::function<void()> deleter;
-    using element_type = T;
 
-    /**
+  explicit ControlBlock(uint32_t initial_count = 1) : count(initial_count) {}
-     * @brief Default constructor.
-     * Allocates a new T following legacy behavior.
-     */
-    SmartPointer() : m_counter(nullptr) {
-        if constexpr (std::is_default_constructible_v<T>) {
-            m_counter = new ReferenceCounter(new T());
-        }
-    }
-
-    /**
-     * @brief Constructor from nullptr.
-     */
-    SmartPointer(std::nullptr_t) noexcept : m_counter(nullptr) {}
-
-    /**
-     * @brief Constructor from raw pointer.
-     */
-    explicit SmartPointer(T* ptr) : m_counter(nullptr) {
-        if (ptr) m_counter = new ReferenceCounter(ptr);
-    }
-
-    /**
-     * @brief Constructor with custom deleter.
-     */
-    template <typename D>
-    SmartPointer(T* ptr, D deleter) : m_counter(nullptr) {
-        if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
-    }
-
-    /**
-     * @brief Non-owning constructor from reference.
-     * Uses a no-op deleter to ensure the referenced object is not destroyed.
-     */
-    SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T*){}, 1)) { }
-
-    /**
-     * @brief Copy constructor.
-     */
-    SmartPointer(const SmartPointer& other) noexcept : m_counter(nullptr) {
-        acquire(other.m_counter);
-    }
-
-    /**
-     * @brief Copy constructor from a pointer to SmartPointer (Legacy support).
-     */
-    SmartPointer(const SmartPointer* other) noexcept : m_counter(nullptr) {
-        if (other) acquire(other->m_counter);
-    }
-
-    /**
-     * @brief Move constructor.
-     */
-    SmartPointer(SmartPointer&& other) noexcept : m_counter(other.m_counter) {
-        other.m_counter = nullptr;
-    }
-
-    /**
-     * @brief Virtual destructor.
-     */
-    virtual ~SmartPointer() { release(); }
-
-    /**
-     * @brief Copy assignment.
-     */
-    SmartPointer& operator=(const SmartPointer& other) noexcept {
-        if (this != &other) {
-            release();
-            acquire(other.m_counter);
-        }
-        return *this;
-    }
-
-    SmartPointer& operator=(T* ptr) noexcept {
-        reset(ptr);
-        return *this;
-    }
-
-    /**
-     * @brief Move assignment.
-     */
-    SmartPointer& operator=(SmartPointer&& other) noexcept {
-        if (this != &other) {
-            release();
-            m_counter = other.m_counter;
-            other.m_counter = nullptr;
-        }
-        return *this;
-    }
-
-    /**
-     * @brief Resets the smart pointer to hold a new raw pointer.
-     */
-    void reset(T* ptr = nullptr) {
-        release();
-        if (ptr) m_counter = new ReferenceCounter(ptr);
-    }
-
-    /**
-     * @brief Resets the smart pointer with a custom deleter.
-     */
-    template <typename D>
-    void reset(T* ptr, D deleter) {
-        release();
-        if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
-    }
-
-    /**
-     * @brief Swaps contents with another SmartPointer.
-     */
-    void swap(SmartPointer& other) noexcept {
-        std::swap(m_counter, other.m_counter);
-    }
-
-    /**
-     * @brief Dereference operator.
-     */
-    T& operator*() const noexcept { return *m_counter->ptr; }
-
-    /**
-     * @brief Member access operator.
-     */
-    T* operator->() const noexcept { return m_counter->ptr; }
-
-    /**
-     * @brief Returns the raw pointer.
-     */
-    T* get() const noexcept { return m_counter ? m_counter->ptr : nullptr; }
-    T* Get() const noexcept { return get(); }
-
-    /**
-     * @brief Implicit conversion to raw pointer (legacy compatibility).
-     */
-    operator T*() const noexcept { return get(); }
-
-    /**
-     * @brief Returns the number of SmartPointers sharing ownership.
-     */
-    uint32_t use_count() const noexcept {
-        return m_counter ? m_counter->count.load(std::memory_order_relaxed) : 0;
-    }
-
-    /**
-     * @brief Returns true if this is the only SmartPointer owning the resource.
-     */
-    bool unique() const noexcept { return use_count() == 1; }
-
-    /**
-     * @brief Boolean conversion operator.
-     */
-    explicit operator bool() const noexcept { return get() != nullptr; }
-
-    BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-    template <class Archive>
-    void save(Archive& ar, const unsigned int /*version*/) const {
-        ar & boost::serialization::make_nvp("counter", m_counter);
-    }
-
-    template <class Archive>
-    void load(Archive& ar, const unsigned int /*version*/) {
-        release();
-        ar & boost::serialization::make_nvp("counter", m_counter);
-        if (m_counter) {
-            m_counter->count.fetch_add(1, std::memory_order_relaxed);
-        }
-    }
 
 private:
-    friend class boost::serialization::access;
+  friend class boost::serialization::access;
-
+  template <class Archive>
-    struct ReferenceCounter {
+  void serialize(Archive &ar, const unsigned int /*version*/) {
-        T* ptr;
+    // ControlBlock identity is tracked by Boost via the cb pointer in
-        std::atomic<uint32_t> count;
+    // ReferenceCounter. We only save the count value.
-        std::function<void(T*)> deleter;
+    uint32_t c = count.load();
-
+    ar &boost::serialization::make_nvp("count", c);
-        ReferenceCounter(T* p, uint32_t initial_count = 1)
+    if constexpr (Archive::is_loading::value)
-            : ptr(p), count(initial_count), deleter([](T* ptr_to_del) { delete ptr_to_del; }) {}
+      count.store(c);
-
+  }
-        template <typename D>
-        ReferenceCounter(T* p, D d, uint32_t initial_count = 1)
-            : ptr(p), count(initial_count), deleter(d) {}
-
-        ReferenceCounter() 
-            : ptr(nullptr), count(0), deleter([](T* p) { delete p; }) {}
-
-    private:
-        friend class boost::serialization::access;
-        template <class Archive>
-        void serialize(Archive& ar, const unsigned int /*version*/) {
-            ar & boost::serialization::make_nvp("ptr", ptr);
-        }
-    };
-
-    ReferenceCounter* m_counter;
-
-    void acquire(ReferenceCounter* c) noexcept {
-        m_counter = c;
-        if (c) {
-            c->count.fetch_add(1, std::memory_order_relaxed);
-        }
-    }
-
-    void release() noexcept {
-        if (m_counter) {
-            if (m_counter->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
-                if (m_counter->ptr) {
-                    m_counter->deleter(m_counter->ptr);
-                }
-                delete m_counter;
-            }
-            m_counter = nullptr;
-        }
-    }
 };
 
 /**
- * @brief Global swap for SmartPointer.
+ * @brief A smart pointer implementation inspired by std::shared_ptr.
  */
-template <typename T>
+template <typename T> class SmartPointer {
-void swap(SmartPointer<T>& a, SmartPointer<T>& b) noexcept {
+public:
-    a.swap(b);
+  using element_type = T;
-}
+
+  /**
+   * @brief Nested reference counter structure.
+   * Preserved as a nested template for Boost serialization compatibility.
+   */
+  struct ReferenceCounter {
+    T *ptr;
+    ControlBlock *cb;
+
+    ReferenceCounter() : ptr(nullptr), cb(nullptr) {}
+    explicit ReferenceCounter(T *p) : ptr(p), cb(new ControlBlock(1)) {
+      cb->deleter = [p]() { delete p; };
+    }
+    template <typename D>
+    ReferenceCounter(T *p, D d) : ptr(p), cb(new ControlBlock(1)) {
+      cb->deleter = [p, d]() { d(p); };
+    }
+
+  private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive &ar, const unsigned int /*version*/) {
+      ar &boost::serialization::make_nvp("ptr", ptr);
+      ar &boost::serialization::make_nvp("cb", cb);
+    }
+  };
+
+  SmartPointer() : m_counter(nullptr) {
+    if constexpr (std::is_default_constructible_v<T>) {
+      m_counter = new ReferenceCounter(new T());
+    }
+  }
+
+  SmartPointer(std::nullptr_t) noexcept : m_counter(nullptr) {}
+
+  /**
+   * @brief Constructor from raw pointer (Implicit conversion allowed for legacy
+   * compatibility).
+   */
+  SmartPointer(T *ptr) : m_counter(nullptr) {
+    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);
+  }
+
+  SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T *) {})) {}
+
+  SmartPointer(const SmartPointer &other) noexcept : m_counter(nullptr) {
+    acquire(other.m_counter);
+  }
+
+  SmartPointer(const SmartPointer *other) noexcept : m_counter(nullptr) {
+    if (other)
+      acquire(other->m_counter);
+  }
+
+  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);
+    }
+  }
+
+  template <typename U>
+  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);
+    }
+  }
+
+  SmartPointer(SmartPointer &&other) noexcept : m_counter(other.m_counter) {
+    other.m_counter = nullptr;
+  }
+
+  ~SmartPointer() { release(); }
+
+  SmartPointer &operator=(const SmartPointer &other) noexcept {
+    if (this != &other) {
+      release();
+      acquire(other.m_counter);
+    }
+    return *this;
+  }
+
+  SmartPointer &operator=(T *ptr) noexcept {
+    reset(ptr);
+    return *this;
+  }
+
+  SmartPointer &operator=(SmartPointer &&other) noexcept {
+    if (this != &other) {
+      release();
+      m_counter = other.m_counter;
+      other.m_counter = nullptr;
+    }
+    return *this;
+  }
+
+  void reset(T *ptr = nullptr) {
+    release();
+    if (ptr)
+      m_counter = new ReferenceCounter(ptr);
+  }
+
+  void swap(SmartPointer &other) noexcept {
+    std::swap(m_counter, other.m_counter);
+  }
+
+  T &operator*() const noexcept { return *(m_counter->ptr); }
+  T *operator->() const noexcept { return m_counter->ptr; }
+  T *get() const noexcept { return m_counter ? m_counter->ptr : nullptr; }
+  T *Get() const noexcept { return get(); }
+  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;
+  }
+
+  bool unique() const noexcept { return use_count() == 1; }
+  explicit operator bool() const noexcept { return get() != nullptr; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archive>
+  void save(Archive &ar, const unsigned int /*version*/) const {
+    ar &boost::serialization::make_nvp("counter", m_counter);
+  }
+
+  template <class Archive>
+  void load(Archive &ar, const unsigned int /*version*/) {
+    release();
+    ar &boost::serialization::make_nvp("counter", m_counter);
+    if (m_counter && m_counter->cb) {
+      m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
+    }
+  }
+
+private:
+  friend class boost::serialization::access;
+
+  template <class Archive>
+  void serialize(Archive &ar, const unsigned int /*version*/) {
+    if (Archive::is_loading::value) {
+      release();
+    }
+    ar &boost::serialization::make_nvp("counter", m_counter);
+    if (Archive::is_loading::value && m_counter) {
+      m_counter->count.fetch_add(1, std::memory_order_relaxed);
+    }
+  }
+
+  struct ReferenceCounter {
+    T *ptr;
+    std::atomic<uint32_t> count;
+    std::function<void(T *)> deleter;
+
+    ReferenceCounter(T *p, uint32_t initial_count = 1)
+        : ptr(p), count(initial_count),
+          deleter([](T *ptr_to_del) { delete ptr_to_del; }) {}
+
+    template <typename D>
+    ReferenceCounter(T *p, D d, uint32_t initial_count = 1)
+        : ptr(p), count(initial_count), deleter(d) {}
+
+    ReferenceCounter()
+        : ptr(nullptr), count(0), deleter([](T *p) { delete p; }) {}
+
+  private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive &ar, const unsigned int /*version*/) {
+      ar &boost::serialization::make_nvp("ptr", ptr);
+    }
+  };
+
+  ReferenceCounter *m_counter;
+
+  void acquire(ReferenceCounter *c) noexcept {
+    m_counter = c;
+    if (c) {
+      c->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();
+        delete m_counter->cb;
+      }
+      delete m_counter;
+      m_counter = nullptr;
+    }
+  }
+};
 
-/**
- * @brief Equality comparison.
- */
 template <typename T, typename U>
-bool operator==(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
+SmartPointer<T> static_pointer_cast(const SmartPointer<U> &r) noexcept {
-    return a.get() == b.get();
+  return SmartPointer<T>(r, static_cast<T *>(r.get()));
 }
-
-/**
- * @brief Inequality comparison.
- */
 template <typename T, typename U>
-bool operator!=(const SmartPointer<T>& a, const SmartPointer<U>& b) noexcept {
+SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U> &r) noexcept {
-    return a.get() != b.get();
+  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 {
- * @brief Comparison with nullptr.
+  return SmartPointer<T>(r, const_cast<T *>(r.get()));
- */
-template <typename T>
-bool operator==(const SmartPointer<T>& a, std::nullptr_t) noexcept {
-    return a.get() == nullptr;
 }
-
+template <typename T, typename U>
-template <typename T>
+SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U> &r) noexcept {
-bool operator==(std::nullptr_t, const SmartPointer<T>& a) noexcept {
+  return SmartPointer<T>(r, reinterpret_cast<T *>(r.get()));
-    return a.get() == nullptr;
-}
-
-template <typename T>
-bool operator!=(const SmartPointer<T>& a, std::nullptr_t) noexcept {
-    return a.get() != nullptr;
-}
-
-template <typename T>
-bool operator!=(std::nullptr_t, const SmartPointer<T>& a) noexcept {
-    return a.get() != nullptr;
 }
 
 } // namespace uLib

src/Core/testing/AffinityTest.cpp

@@ -10,17 +10,52 @@
 
 using namespace uLib;
 
+std::vector<int> GetAvailableCpus() {
+    std::vector<int> available;
+#ifdef __linux__
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    if (sched_getaffinity(0, sizeof(cpu_set_t), &cpuset) == 0) {
+        for (int i = 0; i < CPU_SETSIZE; ++i) {
+            if (CPU_ISSET(i, &cpuset)) {
+                available.push_back(i);
+            }
+        }
+    }
+#endif
+    return available;
+}
+
+class TestThread : public Thread {
+public:
+    void Run() override {
+        Thread::Sleep(200);
+    }
+};
+
 void TestThreadAffinity() {
     std::cout << "Testing Thread Affinity..." << std::endl;
 #ifdef __linux__
-    Thread t;
+    auto available = GetAvailableCpus();
+    if (available.empty()) {
+        std::cout << "  No CPUs available for affinity test, skipping." << std::endl;
+        return;
+    }
+    int target_cpu = available[0];
+    std::cout << "  Using CPU " << target_cpu << std::endl;
+
+    TestThread t;
     t.Start();
-    t.SetAffinity(0); // Bind to CPU 0
+    t.SetAffinity(target_cpu); 
     
     cpu_set_t cpuset;
     CPU_ZERO(&cpuset);
-    pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
+    int s = pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
-    assert(CPU_ISSET(0, &cpuset));
+    if (s != 0) {
+        std::cerr << "Error: pthread_getaffinity_np failed with code " << s << std::endl;
+        assert(false);
+    }
+    assert(CPU_ISSET(target_cpu, &cpuset));
     
     t.Join();
     std::cout << "  Passed (Thread bound to CPU 0)." << std::endl;
@@ -32,9 +67,15 @@ void TestThreadAffinity() {
 void TestTeamAffinity() {
     std::cout << "Testing Team Affinity..." << std::endl;
 #ifdef __linux__
-#ifdef _OPENMP
+    auto available = GetAvailableCpus();
+    if (available.size() < 2) {
+        std::cout << "  Not enough CPUs available for Team affinity test, skipping." << std::endl;
+        return;
+    }
+    std::vector<int> cpus = {available[0], available[1]};
+    std::cout << "  Using CPUs " << cpus[0] << ", " << cpus[1] << std::endl;
+
     Team team(2);
-    std::vector<int> cpus = {0, 1};
     team.SetAffinity(cpus);
     
     // We check affinity inside a parallel region
@@ -48,7 +89,6 @@ void TestTeamAffinity() {
         assert(CPU_ISSET(expected_cpu, &cpuset));
     }
     std::cout << "  Passed (Team threads bound correctly)." << std::endl;
-#endif
 #else
     std::cout << "  Affinity not supported on this OS, skipping." << std::endl;
 #endif

src/Core/testing/SmartPointerTest.cpp

@@ -27,6 +27,7 @@
 
 
 #include <iostream>
+#include "Core/Object.h"
 #include "Core/SmartPointer.h"
 #include "testing-prototype.h"
 
@@ -34,12 +35,12 @@ using namespace uLib;
 
 namespace Test {
 
-struct ObjectMockInterface {
+struct ObjectMockInterface : public Object {
     virtual void PrintValue()=0;
     virtual int& Value()=0;
 };
 
-class ObjectMock : ObjectMockInterface {
+class ObjectMock : public ObjectMockInterface {
     int value;
 public:
     int& Value() { return value; }
@@ -72,12 +73,15 @@ int main () {
         SmartPointer<Test::ObjectMock> spt(new Test::ObjectMock);
         TEST1(test_smpt(spt));
     }
+
     {
         SmartPointer<Test::ObjectMock> spt;
         TEST1(test_smpt(spt));
     }
+
     {
-        SmartPointer<Test::ObjectMock> spt = new SmartPointer<Test::ObjectMock>;
+        SmartPointer<Test::ObjectMock> base_spt;
+        SmartPointer<Test::ObjectMock> spt = &base_spt;
         TEST1(test_smpt(spt));
     }
 
@@ -88,7 +92,28 @@ int main () {
         TEST1(test_smpt(spt));
     }
 
+    {
+        Test::ObjectMock obj;
+        SmartPointer<Object> spt1 = obj;
+        SmartPointer<Test::ObjectMock> spt2 = obj;
+        SmartPointer<Test::ObjectMockInterface> spt = obj;
+    }
 
+    { 
+      Test::ObjectMock *obj = new Test::ObjectMock; 
+      SmartPointer<Test::ObjectMock> spt(obj); 
+      SmartPointer<Test::ObjectMock> spt2(spt); 
+      SmartPointer<Test::ObjectMock> spt3(spt); 
+      SmartPointer<Test::ObjectMock> spt4(spt2); 
+      spt->Value() = 123;
+      spt2->Value() = 456;
+      spt3->Value() = 789;
+      spt4->Value() = 101112;
+      TEST1(spt->Value() == 101112);
+      TEST1(spt2->Value() == 101112);
+      TEST1(spt3->Value() == 101112);
+      TEST1(spt4->Value() == 101112);
+    }
 
     END_TESTING;
 }

src/HEP/Geant/Solid.cpp

@@ -170,14 +170,6 @@ BoxSolid::BoxSolid(const char *name) :
     m_Solid(new G4Box(name, 1, 1, 1))
   {}
 
-BoxSolid::BoxSolid(const char *name, ContainerBox *box) : 
-    Solid(name),
-    m_ContainerBox(box),
-    m_Solid(new G4Box(name, 1, 1, 1)) {
-  if (box) Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
-  Update();
-}
-
 BoxSolid::BoxSolid(const char *name, SmartPointer<ContainerBox> box) : 
     Solid(name),
     m_ContainerBox(box),

src/HEP/Geant/Solid.h

@@ -96,9 +96,7 @@ public:
     return m_Logical ? m_Logical->GetName().c_str() : m_Name.c_str();
   }
 
-  void SetSolid(Solid *solid) { m_Solid = solid; }
   void SetSolid(SmartPointer<Solid> solid) { m_Solid = solid; }
-  void SetMaterial(Material *material) { m_Material = material; }
   void SetMaterial(SmartPointer<Material> material) { m_Material = material; }
   
   G4LogicalVolume* GetG4LogicalVolume() const { return m_Logical; }
@@ -210,7 +208,6 @@ public:
 
   BoxSolid();
   BoxSolid(const char *name);
-  BoxSolid(const char *name, ContainerBox *box);
   BoxSolid(const char *name, SmartPointer<ContainerBox> box);
   
   virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }

src/Math/Assembly.cpp

@@ -89,8 +89,8 @@ void Assembly::ComputeBoundingBox() {
     m_BBoxMin = Vector3f(inf, inf, inf);
     m_BBoxMax = Vector3f(-inf, -inf, -inf);
 
-    for (Object *obj : objects) {
+    for (const auto& obj : objects) {
-        if (auto *box = dynamic_cast<ContainerBox *>(obj)) {
+        if (auto *box = dynamic_cast<ContainerBox *>(obj.get())) {
             // ContainerBox: wm is matrix from unit cube [0,1] to local space
             // Since it is parented to 'this', GetMatrix() is sufficient.
             Matrix4f m = box->GetMatrix();
@@ -104,7 +104,7 @@ void Assembly::ComputeBoundingBox() {
                     m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
                 }
             }
-        } else if (auto *cyl = dynamic_cast<Cylinder *>(obj)) {
+        } else if (auto *cyl = dynamic_cast<Cylinder *>(obj.get())) {
             // Cylinder: centered [-1, 1] radial, [-0.5, 0.5] height
             Matrix4f m = cyl->GetMatrix();
             for (int i = 0; i < 8; ++i) {
@@ -117,7 +117,7 @@ void Assembly::ComputeBoundingBox() {
                     m_BBoxMax(a) = std::max(m_BBoxMax(a), corner(a));
                 }
             }
-        } else if (auto *subAsm = dynamic_cast<Assembly *>(obj)) {
+        } else if (auto *subAsm = dynamic_cast<Assembly *>(obj.get())) {
             // Recursive AABB for nested assemblies
             subAsm->ComputeBoundingBox();
             Vector3f subMin, subMax;

src/Vtk/vtkObjectsContext.cpp

@@ -49,8 +49,8 @@ void ObjectsContext::Synchronize() {
   // 1. Identify objects to add and remove
   const auto &objects = m_Context->GetObjects();
   std::map<uLib::Object *, bool> currentObjects;
-  for (auto obj : objects)
+  for (const auto& obj : objects)
-    currentObjects[obj] = true;
+    currentObjects[obj.get()] = true;
 
   // Remove Prop3Ds for objects no longer in context
   for (auto it = m_Prop3Ds.begin(); it != m_Prop3Ds.end();) {
@@ -71,11 +71,11 @@ void ObjectsContext::Synchronize() {
   }
 
   // Add Prop3Ds for new objects
-  for (auto obj : objects) {
+  for (const auto& obj : objects) {
-    if (m_Prop3Ds.find(obj) == m_Prop3Ds.end()) {
+    if (m_Prop3Ds.find(obj.get()) == m_Prop3Ds.end()) {
-      Prop3D *prop3d = this->CreateProp3D(obj);
+      Prop3D *prop3d = this->CreateProp3D(obj.get());
       if (prop3d) {
-        m_Prop3Ds[obj] = prop3d;
+        m_Prop3Ds[obj.get()] = prop3d;
         if (auto *p3d = vtkProp3D::SafeDownCast(prop3d->GetProp()))
           m_Assembly->AddPart(p3d);
         this->Prop3DAdded(prop3d);