- Initial implementation of the basic Observer System

Author: LK-Simon

src/ESPressio_IObservable.hpp

@@ -3,6 +3,8 @@
 #include <functional>
 #include <memory>
 
+#include "ESPressio_IObserver.hpp"
+
 namespace ESPressio {
 
     namespace Observable {
@@ -20,12 +22,12 @@ namespace ESPressio {
 
         class IObservable : public std::enable_shared_from_this<IObservable> {
             public:
-                /// Will Register the `void*` (Pointer to an Observer Object) with this `IObservable`
-                virtual void RegisterObserver(void* observer) = 0;
-                /// Will Unregister the `void*` (Pointer to an Observer Object) from this `IObservable`
-                virtual void UnregisterObserver(void* observer) = 0;
-                /// Will return `true` if the `void*` (Pointer to an Observer Object) is registered with this `IObservable`
-                virtual bool IsObserverRegistered(void* observer) = 0;
+                /// Will Register the`IObserver` with this `IObservable`
+                virtual void RegisterObserver(IObserver* observer) = 0;
+                /// Will Unregister the `IObserver` from this `IObservable`
+                virtual void UnregisterObserver(IObserver* observer) = 0;
+                /// Will return `true` if the `IObserver` is registered with this `IObservable`
+                virtual bool IsObserverRegistered(IObserver* observer) = 0;
         };
 
     }

src/ESPressio_IObserver.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace ESPressio {
+
+    namespace Observable {
+
+        class IObserver {
+            public:
+                virtual ~IObserver() = default;
+        };
+
+    }
+
+}

src/ESPressio_Observable.hpp

@@ -4,48 +4,49 @@
 #include <vector>
 
 #include "ESPressio_IObservable.hpp"
+#include "ESPressio_IObserver.hpp"
 
 namespace ESPressio {
 
     namespace Observable {
 
         class Observable : public IObservable {
             private:
-                std::vector<void*> observers;
+                std::vector<IObserver*> _observers;
             protected:
                 /// Will call the `callback` for each Observer
-                virtual void WithObservers(std::function<void(void*)> callback) {
-                    for (auto observer : observers) {
+                virtual void WithObservers(std::function<void(IObserver*)> callback) {
+                    for (auto observer : _observers) {
                         callback(observer);
                     }
                 }
 
                 /// 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) {
+                    for (auto observer : _observers) {
                         ObserverType* observerAsT = dynamic_cast<ObserverType*>(observer);
                         if (!observerAsT) { continue; }
                         callback(observerAsT);
                     }
                 }
             public:
-                virtual void RegisterObserver(void* observer) {
+                virtual void RegisterObserver(IObserver* observer) {
                     if (IsObserverRegistered(observer)) { return; }
-                    observers.push_back(observer);
+                    _observers.push_back(observer);
                 }
 
-                virtual void UnregisterObserver(void* observer) {
-                    for (auto thisObserver = observers.begin(); thisObserver != observers.end(); thisObserver++) {
+                virtual void UnregisterObserver(IObserver* observer) {
+                    for (auto thisObserver = _observers.begin(); thisObserver != _observers.end(); thisObserver++) {
                         if (*thisObserver == observer) {
-                            observers.erase(thisObserver);
+                            _observers.erase(thisObserver);
                             return;
                         }
                     }
                 }
 
-                virtual bool IsObserverRegistered(void* observer) {
-                    for (auto thisObserver : observers) {
+                virtual bool IsObserverRegistered(IObserver* observer) {
+                    for (auto thisObserver : _observers) {
                         if (thisObserver == observer) { return true; }
                     }
                     return false;