comparison transform/ModelTransformerFactory.cpp @ 1713:978c143c767f

Merge from branch single-point

 
 #include <iostream>
 #include <set>
 
 #include <QRegExp>
+#include <QMutexLocker>
 
 using std::vector;
 
 ModelTransformerFactory *
 ModelTransformerFactory::m_instance = new ModelTransformerFactory;

                                                       AudioPlaySource *source,
                                                       sv_frame_t startFrame,
                                                       sv_frame_t duration,
                                                       UserConfigurator *configurator)
 {
+    QMutexLocker locker(&m_mutex);
+    
     ModelTransformer::Input input(nullptr);
 
     if (candidateInputModels.empty()) return input;
 
     //!!! This will need revision -- we'll have to have a callback

                                            const ModelTransformer::Input &input,
                                            QString &message,
                                            AdditionalModelHandler *handler) 
 {
     SVDEBUG << "ModelTransformerFactory::transformMultiple: Constructing transformer with input model " << input.getModel() << endl;
+    
+    QMutexLocker locker(&m_mutex);
     
     ModelTransformer *t = createTransformer(transforms, input);
     if (!t) return vector<Model *>();
 
     if (handler) {

 }
 
 void
 ModelTransformerFactory::transformerFinished()
 {
+    QMutexLocker locker(&m_mutex);
+    
     QObject *s = sender();
     ModelTransformer *transformer = dynamic_cast<ModelTransformer *>(s);
     
 //    SVDEBUG << "ModelTransformerFactory::transformerFinished(" << transformer << ")" << endl;
 

 void
 ModelTransformerFactory::modelAboutToBeDeleted(Model *m)
 {
     TransformerSet affected;
 
-    for (TransformerSet::iterator i = m_runningTransformers.begin();
-         i != m_runningTransformers.end(); ++i) {
-
-        ModelTransformer *t = *i;
-
-        if (t->getInputModel() == m) {
-            affected.insert(t);
-        } else {
-            vector<Model *> mm = t->getOutputModels();
-            for (int i = 0; i < (int)mm.size(); ++i) {
-                if (mm[i] == m) affected.insert(t);
+    {
+        QMutexLocker locker(&m_mutex);
+    
+        for (TransformerSet::iterator i = m_runningTransformers.begin();
+             i != m_runningTransformers.end(); ++i) {
+
+            ModelTransformer *t = *i;
+
+            if (t->getInputModel() == m) {
+                affected.insert(t);
+            } else {
+                vector<Model *> mm = t->getOutputModels();
+                for (int i = 0; i < (int)mm.size(); ++i) {
+                    if (mm[i] == m) affected.insert(t);
+                }
             }
         }
     }
 
     for (TransformerSet::iterator i = affected.begin();

                    // transformerFinished, which will remove from
                    // m_runningTransformers and delete.
     }
 }
 
+bool
+ModelTransformerFactory::haveRunningTransformers() const
+{
+    QMutexLocker locker(&m_mutex);
+    
+    return (!m_runningTransformers.empty());
+}