fix dynamic observer/observable

src/rpp/rpp/observables/dynamic_observable.hpp

@@ -10,7 +10,7 @@
 #pragma once
 
 #include <rpp/observables/fwd.hpp>
-
+#include <rpp/observables/observable.hpp>
 #include <rpp/observers/dynamic_observer.hpp>
 
 #include <memory>
@@ -87,7 +87,16 @@ namespace rpp
  */
 template<constraint::decayed_type Type>
 class dynamic_observable : public observable<Type, details::observables::dynamic_strategy<Type>> {
+    using base = observable<Type, details::observables::dynamic_strategy<Type>>;
 public:
-    using observable<Type, details::observables::dynamic_strategy<Type>>::observable;
+    using base::base;
+
+    dynamic_observable(base&& b)
+        : base{std::move(b)}
+    {}
+
+    dynamic_observable(const base& b)
+        : base{b}
+    {}
 };
 }

src/rpp/rpp/observables/fwd.hpp

@@ -19,7 +19,7 @@
 namespace rpp::constraint
 {
 template<typename S, typename T>
-concept observable_strategy = requires(const S& strategy, details::fake_observer<T>&& observer)
+concept observable_strategy = requires(const S& strategy, rpp::details::observers::fake_observer<T>&& observer)
 {
     {strategy.subscribe(std::move(observer))} -> std::same_as<void>;
     typename S::value_type;
@@ -33,6 +33,14 @@ class dynamic_strategy;
 
 template<rpp::constraint::decayed_type Type, rpp::constraint::observable_strategy<Type> Strategy>
 class blocking_strategy;
+
+template<rpp::constraint::decayed_type Type>
+struct fake_strategy
+{
+    using value_type = Type;
+
+    static void subscribe(const auto&) {}
+};
 }
 
 namespace rpp
@@ -85,23 +93,23 @@ concept operator_observable_transform = requires(const Op& op, TObs obs)
 template<typename Op, typename Type>
 concept operator_base = requires(const Op& op) {
     typename std::decay_t<Op>::template result_value<Type>;
-    requires details::observables::constraint::disposable_strategy<details::observables::deduce_updated_disposable_strategy<std::decay_t<Op>, typename observable_chain_strategy<details::observables::dynamic_strategy<Type>>::expected_disposable_strategy>>;
+    requires details::observables::constraint::disposable_strategy<details::observables::deduce_updated_disposable_strategy<std::decay_t<Op>, typename observable_chain_strategy<details::observables::fake_strategy<Type>>::expected_disposable_strategy>>;
 };
 
 template<typename Op, typename Type>
-concept operator_subscribe = operator_base<Op, Type> && requires(const Op& op, dynamic_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer, const observable_chain_strategy<details::observables::dynamic_strategy<Type>>& chain)
+concept operator_subscribe = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer, const observable_chain_strategy<details::observables::fake_strategy<Type>>& chain)
 {
     {op.subscribe(std::move(observer), chain)};
 };
 
 template<typename Op, typename Type>
-concept operator_lift = operator_base<Op, Type> && requires(const Op& op, dynamic_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer)
+concept operator_lift = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer)
 {
     {op.template lift<Type>(std::move(observer))} -> rpp::constraint::observer_of_type<Type>;
 };
 
 template<typename Op, typename Type, typename DisposableStrategy>
-concept operator_lift_with_disposable_strategy = operator_base<Op, Type> && requires(const Op& op, dynamic_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer)
+concept operator_lift_with_disposable_strategy = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer)
 {
     {op.template lift_with_disposable_strategy<Type, DisposableStrategy>(std::move(observer))} -> rpp::constraint::observer_of_type<Type>;
 };

src/rpp/rpp/observables/observable.hpp

@@ -15,8 +15,6 @@
 #include <rpp/disposables/composite_disposable.hpp>
 #include <rpp/disposables/disposable_wrapper.hpp>
 #include <rpp/observables/details/chain_strategy.hpp>
-#include <rpp/observables/dynamic_observable.hpp>
-#include <rpp/observers/dynamic_observer.hpp>
 #include <rpp/observers/lambda_observer.hpp>
 #include <rpp/operators/subscribe.hpp>
 

src/rpp/rpp/observers/dynamic_observer.hpp

@@ -9,8 +9,9 @@
 
 #pragma once
 
-#include <rpp/disposables/fwd.hpp>
 #include <rpp/observers/fwd.hpp>
+#include <rpp/observers/observer.hpp>
+#include <rpp/disposables/fwd.hpp>
 
 #include <memory>
 #include <utility>
@@ -94,3 +95,31 @@ class dynamic_strategy final
     const vtable*         m_vtable;
 };
 }
+
+
+namespace rpp
+{
+/**
+ * @brief Type-erased version of the `rpp::observer`. Any observer can be converted to dynamic_observer via `rpp::observer::as_dynamic` member function.
+ * @details To provide type-erasure it uses `std::shared_ptr`. As a result it has worse performance, but it is **ONLY** way to copy observer.
+ *
+ * @tparam Type of value this observer can handle
+ *
+ * @ingroup observers
+ */
+template<constraint::decayed_type Type>
+class dynamic_observer final : public observer<Type, details::observers::dynamic_strategy<Type>>
+{
+    using base = observer<Type, details::observers::dynamic_strategy<Type>>;
+public:
+    using base::base;
+
+    dynamic_observer(base&& b)
+        : base{std::move(b)}
+    {}
+
+    dynamic_observer(const base& b)
+        : base{b}
+    {}
+};
+}

src/rpp/rpp/observers/fwd.hpp

@@ -90,16 +90,8 @@ namespace rpp
 template<constraint::decayed_type Type, constraint::observer_strategy<Type> Strategy>
 class observer;
 
-/**
- * @brief Type-erased version of the `rpp::observer`. Any observer can be converted to dynamic_observer via `rpp::observer::as_dynamic` member function.
- * @details To provide type-erasure it uses `std::shared_ptr`. As a result it has worse performance, but it is **ONLY** way to copy observer.
- *
- * @tparam Type of value this observer can handle
- *
- * @ingroup observers
- */
 template<constraint::decayed_type Type>
-using dynamic_observer = observer<Type, details::observers::dynamic_strategy<Type>>;
+class dynamic_observer;
 
 /**
  * @brief Observer specialized with passed callbacks. Most easiesest way to construct observer "on the fly" via lambdas and etc.
@@ -209,7 +201,7 @@ auto make_lambda_observer(const rpp::composite_disposable_wrapper& d,
 }
 } // namespace rpp
 
-namespace rpp::details
+namespace rpp::details::observers
 {
 struct fake_strategy
 {

src/rpp/rpp/observers/observer.hpp

@@ -16,7 +16,6 @@
 #include <rpp/defs.hpp>
 #include <rpp/disposables/composite_disposable.hpp>
 #include <rpp/disposables/disposable_wrapper.hpp>
-#include <rpp/observers/dynamic_observer.hpp>
 #include <rpp/utils/exceptions.hpp>
 #include <rpp/utils/functors.hpp>
 #include <rpp/utils/utils.hpp>
@@ -225,7 +224,7 @@ class observer<Type, details::with_disposable_strategy<Strategy, DisposableStrat
 };
 
 template<constraint::decayed_type Type>
-class observer<Type, rpp::details::observers::dynamic_strategy<Type>> final
+class observer<Type, rpp::details::observers::dynamic_strategy<Type>>
     : public details::observer_impl<Type, rpp::details::observers::dynamic_strategy<Type>, details::observers::none_disposable_strategy>
 {
 public:
@@ -241,12 +240,12 @@ class observer<Type, rpp::details::observers::dynamic_strategy<Type>> final
 
     dynamic_observer<Type> as_dynamic() &&
     {
-        return std::move(*this);
+        return dynamic_observer<Type>{std::move(*this)};
     }
 
     const dynamic_observer<Type>& as_dynamic() &
     {
-        return *this;
+        return dynamic_observer<Type>{*this};
     }
 };
 

src/rpp/rpp/sources/fwd.hpp

@@ -24,7 +24,7 @@
 namespace rpp::constraint
 {
 template<typename S, typename T>
-concept on_subscribe = requires(const S& strategy, rpp::details::fake_observer<T>&& observer)
+concept on_subscribe = requires(const S& strategy, rpp::details::observers::fake_observer<T>&& observer)
 {
     {strategy(std::move(observer))} -> std::same_as<void>;
 };

src/rpp/rpp/subjects/fwd.hpp

@@ -21,7 +21,7 @@ namespace rpp::subjects::details
 namespace constraint
 {
 template<typename Strategy, typename T>
-concept subject_strategy = requires(Strategy t, rpp::details::fake_observer<T>&& obs)
+concept subject_strategy = requires(Strategy t, rpp::details::observers::fake_observer<T>&& obs)
 {
     {t.get_observer()} -> rpp::constraint::observer;
     t.on_subscribe(std::move(obs));

src/tests/rpp/test_buffer.cpp

@@ -14,6 +14,7 @@
 #include <rpp/sources/error.hpp>
 #include <rpp/operators/buffer.hpp>
 #include <rpp/operators/merge.hpp>
+#include <rpp/observables/dynamic_observable.hpp>
 
 #include "mock_observer.hpp"
 #include "disposable_observable.hpp"

src/tests/rpp/test_concat.cpp

@@ -15,6 +15,7 @@
 #include <rpp/sources/just.hpp>
 #include <rpp/schedulers/immediate.hpp>
 #include <rpp/subjects/publish_subject.hpp>
+#include <rpp/observables/dynamic_observable.hpp>
 
 #include <rpp/operators/concat.hpp>
 #include <snitch/snitch_macros_check.hpp>

src/tests/rpp/test_flat_map.cpp

@@ -18,6 +18,7 @@
 #include <rpp/sources/error.hpp>
 #include <rpp/sources/never.hpp>
 #include <rpp/schedulers/immediate.hpp>
+#include <rpp/observables/dynamic_observable.hpp>
 
 #include "copy_count_tracker.hpp"
 #include "mock_observer.hpp"

src/tests/rpp/test_group_by.cpp

@@ -16,6 +16,7 @@
 #include <rpp/sources/create.hpp>
 #include <rpp/sources/just.hpp>
 #include <rpp/schedulers/immediate.hpp>
+#include <rpp/observables/dynamic_observable.hpp>
 
 #include "mock_observer.hpp"
 #include "disposable_observable.hpp"

src/tests/rpp/test_merge.cpp

@@ -10,6 +10,7 @@
 
 #include <snitch/snitch.hpp>
 
+#include <rpp/observables/dynamic_observable.hpp>
 #include <rpp/operators/as_blocking.hpp>
 #include <rpp/operators/merge.hpp>
 #include <rpp/sources/create.hpp>

src/tests/rpp/test_scheduler.cpp

@@ -15,6 +15,8 @@
 #include <snitch/snitch.hpp>
 #include <rpp/schedulers.hpp>
 #include <rpp/observers/lambda_observer.hpp>
+#include <rpp/observers/dynamic_observer.hpp>
+
 #include <rpp/sources/just.hpp>
 #include <rpp/operators/as_blocking.hpp>
 #include <rpp/operators/subscribe_on.hpp>

src/tests/rpp/test_subscribe.cpp

@@ -10,6 +10,8 @@
 
 #include <snitch/snitch.hpp>
 #include <rpp/sources/just.hpp>
+#include <rpp/observers/dynamic_observer.hpp>
+
 #include <exception>
 #include "mock_observer.hpp"
 

src/tests/rpp/test_switch_on_next.cpp

@@ -15,6 +15,7 @@
 #include <rpp/sources/empty.hpp>
 #include <rpp/sources/never.hpp>
 
+#include <rpp/observables/dynamic_observable.hpp>
 #include <rpp/operators/switch_on_next.hpp>
 
 #include <rpp/subjects/publish_subject.hpp>

src/tests/rppqt/test_main_thread_scheduler.cpp

@@ -12,6 +12,7 @@
 #include <snitch/snitch.hpp>
 
 #include <rppqt/schedulers/main_thread.hpp>
+#include <rpp/observers/dynamic_observer.hpp>
 
 #include <future>