Did a bit of provider cleanup

src/dawn/state/State.hpp

@@ -46,6 +46,8 @@ namespace Dawn {
       std::vector<IStateOwnerEventLegacy*> eventLegacyBridge;
   
     public:
+      std::vector<std::function<void()>> _stateProviderListeners;
+
       /**
        * Called by the state event when it is disposing (before the StateOwner
        * itself is).
@@ -228,6 +230,13 @@ namespace Dawn {
        * useEffects or useEvents.
        */
       virtual ~StateOwner() {
+        auto providers = this->_stateProviderListeners;
+        auto itProvider = providers.begin();
+        while(itProvider != providers.end()) {
+          (*itProvider)();
+          ++itProvider;
+        }
+
         auto it = this->eventsSubscribed.begin();
         while(it != this->eventsSubscribed.end()) {
           (*it)->_stateOwnerDestroyed(this);

src/dawn/state/StateProvider.hpp

@@ -38,12 +38,13 @@ namespace Dawn {
         l.data = data;
         this->listeners.push_back(l);
 
-        return std::bind([&](struct StateListener<D, A...> listener) {
+        auto unsub = std::bind([&](struct StateListener<D, A...> listener) {
+          // Not yet implemented
           assertUnreachable();
-          // auto it = std::find(listeners.begin(), listeners.end(), listener);
-          // assertFalse(it == listeners.end());
-          // listeners.erase(it);
         }, l);
+
+        context->_stateProviderListeners.push_back(unsub);
+        return unsub;
       }
   };
 }

src/dawn/time/ITimeManager.hpp

@@ -77,6 +77,16 @@ namespace Dawn {
     return context->getGame()->timeManager.timeoutProvider.addEffect(someCallback, timeout, context);
   }
 
+  /**
+   * Use interval provider method. Invokes your callback at a consistant and
+   * common time based on the interval you provide.
+   * 
+   * @tparam T Your context type (usually SceneItemComponent).
+   * @param someCallback Callback to be invoked.
+   * @param timeout Interval to invoke your callback.
+   * @param context Context of the component, just use (this).
+   * @return Method that when invoked will unsubscribe from the interval.
+   */
   template<class T>
   std::function<void()> useInterval(
     std::function<void()> callback,