- Initial implementation of the basic Observer System

Author: LK-Simon

src/ESPressio_IObservable.hpp

@@ -14,10 +14,13 @@ namespace ESPressio {
         /// It is used to not only check if the `IObservable` still exists, but also to unregister the Observer when desired!
         class IObserverHandle {
             public:
+                /// Will null the `IObservable` reference to inform that the Observable is no longer valid
+                /// Do not call this method directly, it is called by the `IObservable` when it is destroyed
+                virtual void __invalidate() = 0;
                 /// Will Unregister this Observer from the `IObservable` if it still exists
                 virtual void Unregister() = 0;
                 /// Will return a `weak_ptr` to the `IObservable`
-                virtual std::weak_ptr<IObservable> GetObservable() = 0;
+                virtual IObservable* GetObservable() = 0;
                 /// Will return a pointer to the `IObserver`
                 virtual IObserver* GetObserver() = 0;
         };

src/ESPressio_Observable.hpp

@@ -13,36 +13,43 @@ namespace ESPressio {
 
         class Observable : public IObservable {
             private:
-                std::vector<IObserver*> _observers;
+                std::vector<IObserverHandle*> _observers;
             protected:
                 /// Will call the `callback` for each Observer
                 virtual void WithObservers(std::function<void(IObserver*)> callback) {
                     for (auto observer : _observers) {
-                        callback(observer);
+                        callback(observer->GetObserver());
                     }
                 }
 
                 /// Will call the `callback` for each Observer that is of type `ObserverType`
                 template <class ObserverType>
                 void WithObservers(std::function<void(ObserverType*)> callback) {
                     for (auto observer : _observers) {
-                        ObserverType* observerAsT = dynamic_cast<ObserverType*>(observer);
+                        ObserverType* observerAsT = dynamic_cast<ObserverType*>(observer->GetObserver());
                         if (!observerAsT) { continue; }
                         callback(observerAsT);
                     }
                 }
             public:
+                ~Observable() {
+                    for (auto observer : _observers) {
+                        observer->__invalidate();
+                    }
+                }
+
                 virtual IObserverHandle* RegisterObserver(IObserver* observer) {
                     for (auto thisObserver : _observers) {
-                        if (thisObserver == observer) { return new ObserverHandle(this, observer); }
+                        if (thisObserver->GetObserver() == observer) { return thisObserver; }
                     }
-                    _observers.push_back(observer);
-                    return new ObserverHandle(this, observer);
+                    IObserverHandle* handle = new ObserverHandle(this, observer);
+                    _observers.push_back(handle);
                 }
 
                 virtual void UnregisterObserver(IObserver* observer) {
                     for (auto thisObserver = _observers.begin(); thisObserver != _observers.end(); thisObserver++) {
-                        if (*thisObserver == observer) {
+                        if ((*thisObserver)->GetObserver() == observer) {
+                            (*thisObserver)->Unregister();
                             _observers.erase(thisObserver);
                             return;
                         }
@@ -51,7 +58,7 @@ namespace ESPressio {
 
                 virtual bool IsObserverRegistered(IObserver* observer) {
                     for (auto thisObserver : _observers) {
-                        if (thisObserver == observer) { return true; }
+                        if ((*thisObserver).GetObserver() == observer) { return true; }
                     }
                     return false;
                 }

src/ESPressio_ObserverHandle.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <memory>
 #include "ESPressio_IObservable.hpp"
 #include "ESPressio_IObserver.hpp"
 
@@ -10,23 +9,25 @@ namespace ESPressio {
 
         class ObserverHandle : public IObserverHandle {
             private:
-                std::weak_ptr<IObservable> _observable;
+                IObservable* _observable;
                 IObserver* _observer;
             public:
-                ObserverHandle(std::weak_ptr<IObservable> observable, IObserver* observer) : _observable(observable), _observer(observer) {}
-                ObserverHandle(IObservable* observable, IObserver* observer) : _observable(observable->shared_from_this()), _observer(observer) {}
+                ObserverHandle(IObservable* observable, IObserver* observer) : _observable(observable), _observer(observer) {}
 
                 ~ObserverHandle() {
                     Unregister();
                 }
 
+                virtual void __invalidate() {
+                    _observable = nullptr;
+                }
+
                 virtual void Unregister() {
-                    std::shared_ptr<IObservable> observable = _observable.lock();
-                    if (!observable) { return; }
-                    observable->UnregisterObserver(_observer);
+                    if (_observable == nullptr) { return; }
+                    _observable->UnregisterObserver(_observer);
                 }
 
-                virtual std::weak_ptr<IObservable> GetObservable() {
+                virtual IObservable* GetObservable() {
                     return _observable;
                 }