- Initial implementation of the basic Observer System

Author: LK-Simon

src/ESPressio_IObservable.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+
+namespace ESPressio {
+
+    namespace Observable {
+        class IObservable;
+
+        /// An `IObserverHandle` is returned when registering your Observer with an `IObservable`
+        /// It is used to not only check if the `IObservable` still exists, but also to unregister the Observer when desired!
+        class IObserverHandle {
+            public:
+                /// 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;
+        };
+    
+        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;
+        };
+
+    }
+
+}

src/ESPressio_Observable.hpp

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

src/ESPressio_ObserverHandle.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+#include "ESPressio_IObservable.hpp"
+
+namespace ESPressio {
+
+    namespace Observable {
+
+        class ObserverHandle : public IObserverHandle {
+            private:
+                std::weak_ptr<IObservable> _observable;
+            public:
+                ObserverHandle(std::weak_ptr<IObservable> observable) : _observable(observable) {}
+                ObserverHandle(IObservable* observable) : _observable(observable->shared_from_this()) {}
+
+                virtual void Unregister() {
+                    std::shared_ptr<IObservable> observable = _observable.lock();
+                    if (!observable) { return; }
+                    observable->UnregisterObserver(this);
+                }
+
+                virtual std::weak_ptr<IObservable> GetObservable() {
+                    return _observable;
+                }
+        };
+
+    }
+
+}