comparison base/EventSeries.h @ 1796:ff8c57c364a0

Make EventSeries threadsafe

 #include "Event.h"
 #include "XmlExportable.h"
 
 #include <set>
 #include <functional>
+
+#include <QMutex>
 
 //#define DEBUG_EVENT_SERIES 1
 
 /**
  * Container storing a series of events, with or without durations,

  * This class is highly optimised for inserting events in increasing
  * order of start frame. Inserting (or deleting) events in the middle
  * does work, and should be acceptable in interactive use, but it is
  * very slow in bulk.
  *
- * EventSeries is not thread-safe.
+ * EventSeries is thread-safe.
  */
 class EventSeries : public XmlExportable
 {
 public:
     EventSeries() : m_finalDurationlessEventFrame(0) { }
     ~EventSeries() =default;
 
-    EventSeries(const EventSeries &) =default;
-
-    EventSeries &operator=(const EventSeries &) =delete;
-    EventSeries &operator=(EventSeries &&) =delete;
-    
-    bool operator==(const EventSeries &other) const {
-        return m_events == other.m_events;
-    }
+    EventSeries(const EventSeries &);
+
+    EventSeries &operator=(const EventSeries &);
+    EventSeries &operator=(EventSeries &&);
+    
+    bool operator==(const EventSeries &other) const;
 
     static EventSeries fromEvents(const EventVector &ee);
     
     void clear();
     void add(const Event &e);

                                   sv_samplerate_t sampleRate,
                                   sv_frame_t resolution,
                                   Event fillEvent) const;
     
 private:
+    mutable QMutex m_mutex;
+
+    EventSeries::EventSeries(const EventSeries &other, const QMutexLocker &);
+    
     /**
      * This vector contains all events in the series, in the normal
      * sort order. For backward compatibility we must support series
      * containing multiple instances of identical events, so
      * consecutive events in this vector will not always be distinct.

      * overall end frame or to find the last frame of all events
      * without this.
      */
     sv_frame_t m_finalDurationlessEventFrame;
     
-    /** Create a seam at the given frame, copying from the prior seam
-     *  if there is one. If a seam already exists at the given frame,
-     *  leave it untouched.
+    /** 
+     * Create a seam at the given frame, copying from the prior seam
+     * if there is one. If a seam already exists at the given frame,
+     * leave it untouched.
+     *
+     * Call with m_mutex locked.
      */
     void createSeam(sv_frame_t frame) {
         auto itr = m_seams.lower_bound(frame);
         if (itr == m_seams.end() || itr->first > frame) {
             if (itr != m_seams.begin()) {

         } else if (itr->first > frame) { // itr must be begin()
             m_seams[frame] = {};
         }
     }
 
+    /** 
+     * Return true if the two seam map entries contain the same set of
+     * events.
+     *
+     * Precondition: no duplicates, i.e. no event appears more than
+     * once in s1 or more than once in s2.
+     *
+     * Call with m_mutex locked.
+     */
     bool seamsEqual(const std::vector<Event> &s1,
                     const std::vector<Event> &s2) const {
         
         if (s1.size() != s2.size()) {
             return false;
         }
-
-        // precondition: no event appears more than once in s1 or more
-        // than once in s2
 
 #ifdef DEBUG_EVENT_SERIES
         for (int i = 0; in_range_for(s1, i); ++i) {
             for (int j = i + 1; in_range_for(s1, j); ++j) {
                 if (s1[i] == s1[j] || s2[i] == s2[j]) {