Auto dispose disposable in case of destruction if needed

src/rpp/rpp/disposables/callback_disposable.hpp

@@ -36,7 +36,7 @@ class callback_disposable final : public details::base_disposable
     }
 
 private:
-    void dispose_impl() noexcept override { std::move(m_fn)(); } // NOLINT(bugprone-exception-escape)
+    void base_dispose_impl(interface_disposable::Mode) noexcept override { std::move(m_fn)(); } // NOLINT(bugprone-exception-escape)
 
 private:
     Fn m_fn;

src/rpp/rpp/disposables/composite_disposable.hpp

@@ -39,15 +39,15 @@ class composite_disposable_impl : public interface_composite_disposable
         return m_current_state.load(std::memory_order::seq_cst) == State::Disposed;
     }
 
-    void dispose() noexcept final
+    void dispose_impl(interface_disposable::Mode mode) noexcept final
     {
         while (true)
         {
             State expected{State::None};
             // need to acquire possible state changing from `add`
             if (m_current_state.compare_exchange_strong(expected, State::Disposed, std::memory_order::seq_cst))
             {
-                dispose_impl();
+                composite_dispose_impl(mode);
 
                 m_disposables.dispose();
                 m_disposables.clear();
@@ -150,7 +150,7 @@ class composite_disposable_impl : public interface_composite_disposable
     }
 
 protected:
-    virtual void dispose_impl() noexcept {}
+    virtual void composite_dispose_impl(interface_disposable::Mode) noexcept {}
 
 private:
     enum class State : uint8_t

src/rpp/rpp/disposables/details/base_disposable.hpp

@@ -31,15 +31,16 @@ class base_disposable_impl : public BaseInterface
         return m_disposed.load(std::memory_order::seq_cst);
     }
 
-    void dispose() noexcept final
+private:
+    void dispose_impl(interface_disposable::Mode mode) noexcept final
     {
         // just need atomicity, not guarding anything
         if (m_disposed.exchange(true, std::memory_order::seq_cst) == false)
-            dispose_impl();
+            base_dispose_impl(mode);
     }
 
 protected:
-    virtual void dispose_impl() noexcept = 0;
+    virtual void base_dispose_impl(interface_disposable::Mode mode) noexcept = 0;
 
 private:
     std::atomic_bool m_disposed{};

src/rpp/rpp/disposables/disposable_wrapper.hpp

@@ -41,7 +41,7 @@ class auto_dispose_wrapper final
 
     ~auto_dispose_wrapper() noexcept
     {
-        // static_cast<interface_disposable&>(m_data).dispose_impl(rpp::interface_disposable::Mode::Destroying);
+        static_cast<interface_disposable&>(m_data).dispose_impl(rpp::interface_disposable::Mode::Destroying);
     }
 
     TDisposable* get() { return &m_data; }

src/rpp/rpp/disposables/fwd.hpp

@@ -12,6 +12,12 @@
 
 #include <rpp/utils/constraints.hpp>
 
+namespace rpp::details
+{
+template<rpp::constraint::decayed_type TDisposable>
+class auto_dispose_wrapper;
+}
+
 namespace rpp
 {
 struct interface_disposable;

src/rpp/rpp/disposables/interface_disposable.hpp

@@ -33,6 +33,18 @@ struct interface_disposable
      * @brief Dispose disposable and free any underlying resources and etc.
      * @warning This function must be thread-safe
      */
-    virtual void dispose() noexcept = 0;
+    void dispose() noexcept { dispose_impl(Mode::Disposing); }
+
+    template<rpp::constraint::decayed_type TStrategy>
+    friend class rpp::details::auto_dispose_wrapper;
+
+protected:
+    enum class Mode : bool
+    {
+        Disposing  = 0, // someone called "dispose" method manually
+        Destroying = 1  // called during destruction -> not needed to clear self in other disposables and etc + not allowed to call `shared_from_this`
+    };
+
+    virtual void dispose_impl(Mode mode) noexcept = 0;
 };
 }

src/rpp/rpp/disposables/refcount_disposable.hpp

@@ -45,7 +45,7 @@ class refcount_disposable : public rpp::details::enable_wrapper_from_this<refcou
         }
     }
 
-    void dispose_impl() noexcept override
+    void composite_dispose_impl(interface_disposable::Mode) noexcept override
     {
         m_refcount.store(s_disposed, std::memory_order::seq_cst);
     }
@@ -70,9 +70,11 @@ class refocunt_disposable_inner final : public rpp::composite_disposable, public
     refocunt_disposable_inner(disposable_wrapper_impl<refcount_disposable> state)
         : m_state{std::move(state)} {}
 
-    void dispose_impl() noexcept override
+    void composite_dispose_impl(interface_disposable::Mode mode) noexcept override
     {
-        m_state.remove(this->wrapper_from_this());
+        if (mode != interface_disposable::Mode::Destroying)
+            m_state.remove(this->wrapper_from_this());
+
         if (const auto locked = m_state.lock())
             locked->release();
         m_state = disposable_wrapper_impl<refcount_disposable>::empty();

src/rpp/rpp/observables/blocking_observable.hpp

@@ -28,7 +28,7 @@ class blocking_disposble final : public base_disposable
         m_cv.wait(lock, [this] { return m_completed; });
     }
 
-    void dispose_impl() noexcept override
+    void base_dispose_impl(interface_disposable::Mode) noexcept override
     {
         {
             std::lock_guard lock{m_mutex};

src/rpp/rpp/schedulers/new_thread.hpp

@@ -64,7 +64,7 @@ class new_thread
         }
 
     private:
-        void dispose_impl() noexcept override
+        void base_dispose_impl(interface_disposable::Mode) noexcept override
         {
             if (!m_thread.joinable())
                 return;

src/rpp/rpp/schedulers/run_loop.hpp

@@ -89,7 +89,7 @@ class run_loop final
             return !m_queue.is_empty() && (m_queue.top()->is_disposed() || m_queue.top()->get_timepoint() <= now);
         }
 
-        void dispose_impl() noexcept override 
+        void base_dispose_impl(interface_disposable::Mode) noexcept override 
         {
             {
                 std::lock_guard lock{m_mutex};

src/rpp/rpp/subjects/details/subject_state.hpp

@@ -90,7 +90,7 @@ class subject_state : public std::enable_shared_from_this<subject_state<Type>>
     }
 
 private:
-    void dispose_impl() noexcept override
+    void composite_dispose_impl(interface_disposable::Mode) noexcept override
     {
         exchange_observers_under_lock_if_there(disposed{});
     }

src/tests/rpp/test_disposables.cpp

@@ -19,7 +19,7 @@ struct custom_disposable : public rpp::interface_disposable
 
     bool is_disposed() const noexcept final { return dispose_count > 1; }
 
-    void dispose() noexcept final { ++dispose_count; }
+    void dispose_impl(rpp::interface_disposable::Mode) noexcept final { ++dispose_count; }
 
     size_t dispose_count{};
 };
@@ -134,18 +134,18 @@ TEMPLATE_TEST_CASE("disposable keeps state", "", rpp::details::disposables::dyna
             CHECK(other.is_disposed());
         }
     }
-    // SECTION("disposable dispose on destruction")
-    // {
-    //     {
-    //         auto other = rpp::composite_disposable_wrapper::make();
-    //         CHECK(!other.is_disposed());
-    //         CHECK(!d.is_disposed());
-    //         other.add(d);
-    //         CHECK(!other.is_disposed());
-    //         CHECK(!d.is_disposed());
-    //     }
-    //     CHECK(d.is_disposed());
-    // }
+    SECTION("disposable dispose on destruction")
+    {
+        {
+            auto other = rpp::composite_disposable_wrapper::make();
+            CHECK(!other.is_disposed());
+            CHECK(!d.is_disposed());
+            other.add(d);
+            CHECK(!other.is_disposed());
+            CHECK(!d.is_disposed());
+        }
+        CHECK(d.is_disposed());
+    }
 
     SECTION("add callback_disposable")
     {

src/tests/utils/test_scheduler.hpp

@@ -56,7 +56,7 @@ class test_scheduler final
             }
         }
 
-        void dispose_impl() noexcept override {}
+        void base_dispose_impl(interface_disposable::Mode) noexcept override {}
 
         std::vector<rpp::schedulers::time_point>     schedulings{};
         std::vector<rpp::schedulers::time_point>     executions{};