fix(Core/Misc): bunch of crashfixes (#7307)

src/common/Utilities/EventProcessor.cpp

@@ -5,11 +5,20 @@
  */
 
 #include "EventProcessor.h"
+#include "Errors.h"
 
-EventProcessor::EventProcessor()
+void BasicEvent::ScheduleAbort()
 {
-    m_time = 0;
-    m_aborting = false;
+    ASSERT(IsRunning()
+           && "Tried to scheduled the abortion of an event twice!");
+    m_abortState = AbortState::STATE_ABORT_SCHEDULED;
+}
+
+void BasicEvent::SetAborted()
+{
+    ASSERT(!IsAborted()
+           && "Tried to abort an already aborted event!");
+    m_abortState = AbortState::STATE_ABORTED;
 }
 
 EventProcessor::~EventProcessor()
@@ -27,63 +36,92 @@ void EventProcessor::Update(uint32 p_time)
     while (((i = m_events.begin()) != m_events.end()) && i->first <= m_time)
     {
         // get and remove event from queue
-        BasicEvent* Event = i->second;
+        BasicEvent* event = i->second;
         m_events.erase(i);
 
-        if (!Event->to_Abort)
+        if (event->IsRunning())
         {
-            if (Event->Execute(m_time, p_time))
+            if (event->Execute(m_time, p_time))
             {
                 // completely destroy event if it is not re-added
-                delete Event;
+                delete event;
             }
+            continue;
         }
-        else
+
+        if (event->IsAbortScheduled())
         {
-            Event->Abort(m_time);
-            delete Event;
+            event->Abort(m_time);
+            // Mark the event as aborted
+            event->SetAborted();
         }
+
+        if (event->IsDeletable())
+        {
+            delete event;
+            continue;
+        }
+
+        // Reschedule non deletable events to be checked at
+        // the next update tick
+        AddEvent(event, CalculateTime(1), false);
     }
 }
 
 void EventProcessor::KillAllEvents(bool force)
 {
-    // prevent event insertions
-    m_aborting = true;
-
     // first, abort all existing events
-    for (EventList::iterator i = m_events.begin(); i != m_events.end();)
+    for (auto itr = m_events.begin(); itr != m_events.end();)
     {
-        EventList::iterator i_old = i;
-        ++i;
-
-        i_old->second->to_Abort = true;
-        i_old->second->Abort(m_time);
-        if (force || i_old->second->IsDeletable())
+        // Abort events which weren't aborted already
+        if (!itr->second->IsAborted())
         {
-            delete i_old->second;
-
-            if (!force)                                      // need per-element cleanup
-            {
-                m_events.erase (i_old);
-            }
+            itr->second->SetAborted();
+            itr->second->Abort(m_time);
         }
+
+        // Skip non-deletable events when we are
+        // not forcing the event cancellation.
+        if (!force && !itr->second->IsDeletable())
+        {
+            ++itr;
+            continue;
+        }
+
+        delete itr->second;
+
+        if (force)
+            ++itr; // Clear the whole container when forcing
+        else
+            itr = m_events.erase(itr);
     }
 
-    // fast clear event list (in force case)
     if (force)
-    {
         m_events.clear();
-    }
 }
 
 void EventProcessor::AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime)
 {
-    if (set_addtime) { Event->m_addTime = m_time; }
+    if (set_addtime)
+        Event->m_addTime = m_time;
     Event->m_execTime = e_time;
     m_events.insert(std::pair<uint64, BasicEvent*>(e_time, Event));
 }
 
+void EventProcessor::ModifyEventTime(BasicEvent* event, Milliseconds newTime)
+{
+    for (auto itr = m_events.begin(); itr != m_events.end(); ++itr)
+    {
+        if (itr->second != event)
+            continue;
+
+        event->m_execTime = newTime.count();
+        m_events.erase(itr);
+        m_events.insert(std::pair<uint64, BasicEvent*>(newTime.count(), event));
+        break;
+    }
+}
+
 uint64 EventProcessor::CalculateTime(uint64 t_offset) const
 {
     return (m_time + t_offset);

src/common/Utilities/EventProcessor.h

@@ -8,58 +8,77 @@
 #define __EVENTPROCESSOR_H
 
 #include "Define.h"
+#include "Duration.h"
 
 #include <map>
 
-// Note. All times are in milliseconds here.
+class EventProcessor;
 
+// Note. All times are in milliseconds here.
 class BasicEvent
 {
-public:
-    BasicEvent()
+
+    friend class EventProcessor;
+
+    enum class AbortState : uint8
     {
-        to_Abort = false;
-        m_addTime = 0;
-        m_execTime = 0;
-    }
-    virtual ~BasicEvent() = default;                           // override destructor to perform some actions on event removal
+        STATE_RUNNING,
+        STATE_ABORT_SCHEDULED,
+        STATE_ABORTED
+        };
 
-    // this method executes when the event is triggered
-    // return false if event does not want to be deleted
-    // e_time is execution time, p_time is update interval
-    virtual bool Execute(uint64 /*e_time*/, uint32 /*p_time*/) { return true; }
+    public:
+        BasicEvent()
+            : m_abortState(AbortState::STATE_RUNNING), m_addTime(0), m_execTime(0) { }
 
-    [[nodiscard]] virtual bool IsDeletable() const { return true; }   // this event can be safely deleted
+        virtual ~BasicEvent() { } // override destructor to perform some actions on event removal
 
-    virtual void Abort(uint64 /*e_time*/) { }           // this method executes when the event is aborted
+        // this method executes when the event is triggered
+        // return false if event does not want to be deleted
+        // e_time is execution time, p_time is update interval
+        [[nodiscard]] virtual bool Execute(uint64 /*e_time*/, uint32 /*p_time*/) { return true; }
 
-    bool to_Abort;                                      // set by externals when the event is aborted, aborted events don't execute
-    // and get Abort call when deleted
+        [[nodiscard]] virtual bool IsDeletable() const { return true; }   // this event can be safely deleted
 
-    // these can be used for time offset control
-    uint64 m_addTime;                                   // time when the event was added to queue, filled by event handler
-    uint64 m_execTime;                                  // planned time of next execution, filled by event handler
+        virtual void Abort(uint64 /*e_time*/) { }           // this method executes when the event is aborted
+
+        // Aborts the event at the next update tick
+        void ScheduleAbort();
+
+    private:
+        void SetAborted();
+        bool IsRunning() const { return (m_abortState == AbortState::STATE_RUNNING); }
+        bool IsAbortScheduled() const { return (m_abortState == AbortState::STATE_ABORT_SCHEDULED); }
+        bool IsAborted() const { return (m_abortState == AbortState::STATE_ABORTED); }
+
+        AbortState m_abortState;                            // set by externals when the event is aborted, aborted events don't execute
+
+        // these can be used for time offset control
+        uint64 m_addTime;                                   // time when the event was added to queue, filled by event handler
+        uint64 m_execTime;                                  // planned time of next execution, filled by event handler
 };
 
 typedef std::multimap<uint64, BasicEvent*> EventList;
 
 class EventProcessor
 {
-public:
-    EventProcessor();
-    ~EventProcessor();
+    public:
+        EventProcessor() : m_time(0) { }
+        ~EventProcessor();
 
-    void Update(uint32 p_time);
-    void KillAllEvents(bool force);
-    void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime = true);
-    [[nodiscard]] uint64 CalculateTime(uint64 t_offset) const;
+        void Update(uint32 p_time);
+        void KillAllEvents(bool force);
+        void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime = true);
+        void ModifyEventTime(BasicEvent* event, Milliseconds newTime);
+        [[nodiscard]] uint64 CalculateTime(uint64 t_offset) const;
 
-    // Xinef: calculates next queue tick time
-    [[nodiscard]] uint64 CalculateQueueTime(uint64 delay) const;
+        //calculates next queue tick time
+        [[nodiscard]] uint64 CalculateQueueTime(uint64 delay) const;
 
-protected:
-    uint64 m_time;
-    EventList m_events;
-    bool m_aborting;
+    protected:
+        uint64 m_time;
+        EventList m_events;
+        bool m_aborting;
 };
+
 #endif