From 36c9f32dbb3b1c6feb5ddd38e8a1eb7dad0ba6e5 Mon Sep 17 00:00:00 2001 From: Daniel Date: Mon, 2 Sep 2024 22:29:04 +0200 Subject: [PATCH] `ObserverAutoPtr`: use observer factory of the specified type --- CMakeLists.txt | 3 +- .../tulz/observer/EternalObserverAutoPtr.h | 13 +++++++++ include/tulz/observer/ObserverAutoPtr.h | 29 ++++++++++--------- include/tulz/observer/Subject.h | 4 +-- include/tulz/observer/routing/SubjectRouter.h | 7 +++-- tests/tulz/observer/EternalObserverTest.cpp | 28 ++++++++++++++++++ 6 files changed, 66 insertions(+), 18 deletions(-) create mode 100644 include/tulz/observer/EternalObserverAutoPtr.h diff --git a/CMakeLists.txt b/CMakeLists.txt index d33741e..fcccb13 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -22,7 +22,8 @@ set(TULZ_OBSERVER_SOURCES include/tulz/observer/ObserverAutoPtr.h include/tulz/observer/EternalObserver.h include/tulz/observer/detail/ObserverFactory.h - include/tulz/observer/EternalObserverFactory.h) + include/tulz/observer/EternalObserverFactory.h + include/tulz/observer/EternalObserverAutoPtr.h) set(TULZ_THREADING_SOURCES include/tulz/threading/Runnable.h diff --git a/include/tulz/observer/EternalObserverAutoPtr.h b/include/tulz/observer/EternalObserverAutoPtr.h new file mode 100644 index 0000000..530e754 --- /dev/null +++ b/include/tulz/observer/EternalObserverAutoPtr.h @@ -0,0 +1,13 @@ +#ifndef TULZ_ETERNALOBSERVERAUTOPTR_H +#define TULZ_ETERNALOBSERVERAUTOPTR_H + +#include +#include +#include + +namespace tulz { +template +using EternalObserverAutoPtr = ObserverAutoPtr; +} + +#endif //TULZ_ETERNALOBSERVERAUTOPTR_H diff --git a/include/tulz/observer/ObserverAutoPtr.h b/include/tulz/observer/ObserverAutoPtr.h index 9a5ce50..2f325cd 100644 --- a/include/tulz/observer/ObserverAutoPtr.h +++ b/include/tulz/observer/ObserverAutoPtr.h @@ -2,7 +2,6 @@ #define TULZ_OBSERVERAUTOPTR_H #include -#include #include @@ -13,43 +12,47 @@ namespace tulz { * The `ObserverAutoPtr` class accepts three different types of objects: * * 1. Invocable objects: When an invocable object (e.g., lambda, function, functor) is provided, - * a new default observer will be created. + * a new default observer will be created using the factory of provided ObserverType. * 2. Unique pointers of derived observers: If a unique pointer to a derived observer type is passed, * the ownership will be transferred to the `ObserverAutoPtr`. * 3. Raw pointers of derived observers: When a raw pointer to a derived observer object is given, * the ownership will be transferred to the `ObserverAutoPtr`. * + * @tparam ObserverType The observer which factory will be used in case 1. * @tparam Args The template parameter pack representing the types of arguments for the observer. */ -template +template class ObserverType, typename ...Args> class ObserverAutoPtr { public: - using BaseObserver = Observer; - using DefaultObserver = EternalObserver; - using Ptr = std::unique_ptr; + using BaseObserver_t = Observer; + using Observer_t = ObserverType; + using Ptr_t = std::unique_ptr; public: template - ObserverAutoPtr(T &&val) requires std::invocable - : m_ptr(std::make_unique(std::forward(val))) {} + requires std::invocable || + std::invocable + ObserverAutoPtr(T &&val) + : m_ptr(typename Observer_t::Factory{}(std::forward(val))) {} template - ObserverAutoPtr(std::unique_ptr ptr) requires std::derived_from + requires std::derived_from + ObserverAutoPtr(std::unique_ptr ptr) : m_ptr(std::move(ptr)) {} - ObserverAutoPtr(BaseObserver *ptr) + ObserverAutoPtr(BaseObserver_t *ptr) : m_ptr(ptr) {} - Ptr operator*() { + Ptr_t operator*() { return std::move(m_ptr); } - Ptr pointer() { + Ptr_t pointer() { return std::move(m_ptr); } private: - Ptr m_ptr; + Ptr_t m_ptr; }; } diff --git a/include/tulz/observer/Subject.h b/include/tulz/observer/Subject.h index d63a972..60e1f27 100644 --- a/include/tulz/observer/Subject.h +++ b/include/tulz/observer/Subject.h @@ -6,7 +6,7 @@ #include #include "Observer.h" -#include "ObserverAutoPtr.h" +#include "EternalObserverAutoPtr.h" #include "Subscription.h" namespace tulz { @@ -16,7 +16,7 @@ class Subject { using Subscription_t = Subscription; using Observer_t = Observer; using ObserverPtr_t = ObserverPtr; - using ObserverAutoPtr_t = ObserverAutoPtr; + using ObserverAutoPtr_t = EternalObserverAutoPtr; public: Subject() = default; diff --git a/include/tulz/observer/routing/SubjectRouter.h b/include/tulz/observer/routing/SubjectRouter.h index 2a1b8c8..8088ce1 100644 --- a/include/tulz/observer/routing/SubjectRouter.h +++ b/include/tulz/observer/routing/SubjectRouter.h @@ -2,7 +2,7 @@ #define TULZ_SUBJECTROUTER_H #include -#include +#include #include #include @@ -18,6 +18,9 @@ class TULZ_API SubjectRouter { using DefaultSubject_t = Subject_t<>; + template + using ObserverAutoPtr_t = EternalObserverAutoPtr; + public: SubjectRouter(); @@ -50,7 +53,7 @@ class TULZ_API SubjectRouter { */ template Subscription subscribe(const RoutingKey &key, O &&observer) { - return m_rootNode.subscribe(key, *ObserverAutoPtr(std::forward(observer))); + return m_rootNode.subscribe(key, *ObserverAutoPtr_t(std::forward(observer))); } /** diff --git a/tests/tulz/observer/EternalObserverTest.cpp b/tests/tulz/observer/EternalObserverTest.cpp index 1dced80..1193855 100644 --- a/tests/tulz/observer/EternalObserverTest.cpp +++ b/tests/tulz/observer/EternalObserverTest.cpp @@ -3,6 +3,7 @@ #include #include #include +#include using namespace tulz; @@ -51,3 +52,30 @@ TEST(EternalObserverTest, ProducedByFactory) { ASSERT_EQ(value, 1); } + +TEST(EternalObserverTest, ProduceByAutoPtrThenInvalidate) { + Subject subject; + int counter {0}; + + auto produce = [](EternalObserverAutoPtr<> observer) { + return *observer; + }; + + using Observer = EternalObserver<>; + auto observer = produce([&counter](Observer::SelfView self) { + ++counter; + self->invalidate(); + }); + + auto subscription = subject.subscribe(std::move(observer)); + + ASSERT_TRUE(subscription.getObserver()->isValid()); + + subject.notify(); + + ASSERT_FALSE(subscription.isValid()); + + subject.notify(); + + ASSERT_EQ(counter, 1); +}