comparison data/model/NoteModel.h @ 1798:13bd41bd8a17

Some work on making Model classes thread-safe in typical use - and documenting this. Some of the implementations are simpler now that EventSeries is thread-safe

 #include "base/RealTime.h"
 #include "base/PlayParameterRepository.h"
 #include "base/Pitch.h"
 #include "system/System.h"
 
-#include <QMutex>
 #include <QMutexLocker>
 
 class NoteModel : public Model,
                   public TabularModel,
                   public NoteExportable,

         m_valueMinimum(0.f),
         m_valueMaximum(0.f),
         m_haveExtents(false),
         m_valueQuantization(0),
         m_units(""),
-        m_extendTo(0),
         m_notifier(this,
                    getId(),
                    notifyOnAdd ?
                    DeferredNotifier::NOTIFY_ALWAYS :
                    DeferredNotifier::NOTIFY_DEFERRED),

         m_valueMinimum(valueMinimum),
         m_valueMaximum(valueMaximum),
         m_haveExtents(true),
         m_valueQuantization(0),
         m_units(""),
-        m_extendTo(0),
         m_notifier(this,
                    getId(),
                    notifyOnAdd ?
                    DeferredNotifier::NOTIFY_ALWAYS :
                    DeferredNotifier::NOTIFY_DEFERRED),

     Subtype getSubtype() const { return m_subtype; }
     bool isSparse() const override { return true; }
     bool isOK() const override { return true; }
     
     sv_frame_t getStartFrame() const override {
+        QMutexLocker locker(&m_mutex);
         return m_events.getStartFrame();
     }
     sv_frame_t getTrueEndFrame() const override {
+        QMutexLocker locker(&m_mutex);
         if (m_events.isEmpty()) return 0;
         sv_frame_t e = m_events.getEndFrame();
         if (e % m_resolution == 0) return e;
         else return (e / m_resolution + 1) * m_resolution;
     }

     bool canPlay() const override { return true; }
     QString getDefaultPlayClipId() const override {
         return "elecpiano";
     }
 
-    QString getScaleUnits() const { return m_units; }
+    QString getScaleUnits() const {
+        QMutexLocker locker(&m_mutex);
+        return m_units;
+    }
     void setScaleUnits(QString units) {
+        QMutexLocker locker(&m_mutex);
         m_units = units;
         UnitDatabase::getInstance()->registerUnit(units);
     }
 
     float getValueQuantization() const { return m_valueQuantization; }

     
     int getCompletion() const override { return m_completion; }
 
     void setCompletion(int completion, bool update = true) {
 
-        {   QMutexLocker locker(&m_mutex);
+        {
             if (m_completion == completion) return;
             m_completion = completion;
         }
 
         if (update) {

      */
     void add(Event e) override {
 
         bool allChange = false;
            
-        {
-            QMutexLocker locker(&m_mutex);
-            m_events.add(e);
-
-            float v = e.getValue();
-            if (!ISNAN(v) && !ISINF(v)) {
-                if (!m_haveExtents || v < m_valueMinimum) {
-                    m_valueMinimum = v; allChange = true;
-                }
-                if (!m_haveExtents || v > m_valueMaximum) {
-                    m_valueMaximum = v; allChange = true;
-                }
-                m_haveExtents = true;
+        m_events.add(e);
+        float v = e.getValue();
+        if (!ISNAN(v) && !ISINF(v)) {
+            if (!m_haveExtents || v < m_valueMinimum) {
+                m_valueMinimum = v; allChange = true;
             }
+            if (!m_haveExtents || v > m_valueMaximum) {
+                m_valueMaximum = v; allChange = true;
+            }
+            m_haveExtents = true;
         }
         
         m_notifier.update(e.getFrame(), e.getDuration() + m_resolution);
 
         if (allChange) {
             emit modelChanged(getId());
         }
     }
     
     void remove(Event e) override {
-        {
-            QMutexLocker locker(&m_mutex);
-            m_events.remove(e);
-        }
+        m_events.remove(e);
         emit modelChangedWithin(getId(),
                                 e.getFrame(),
                                 e.getFrame() + e.getDuration() + m_resolution);
     }
 

 protected:
     Subtype m_subtype;
     sv_samplerate_t m_sampleRate;
     int m_resolution;
 
-    float m_valueMinimum;
-    float m_valueMaximum;
-    bool m_haveExtents;
+    std::atomic<float> m_valueMinimum;
+    std::atomic<float> m_valueMaximum;
+    std::atomic<bool> m_haveExtents;
     float m_valueQuantization;
     QString m_units;
-    sv_frame_t m_extendTo;
     DeferredNotifier m_notifier;
-    int m_completion;
+    std::atomic<int> m_completion;
 
     EventSeries m_events;
-
-    mutable QMutex m_mutex;
-
-    //!!! do we have general docs for ownership and synchronisation of models?
-    // this might be a good opportunity to stop using bare pointers to them
 };
 
 #endif