comparison framework/Document.cpp @ 53:de2b3c6479c8

* Introduce new Transform class which contains data necessary to describe the
  context for a plugin -- the plugin's name and output, the step/block size
  etc (formerly spread across ExecutionContext and TransformFactory).  Other
  code hasn't been updated to use this yet.
* Rename existing Transform stuff to Transformers (because they run Transforms)

I'm still not 100% sure about this change, don't rely on it.

 #include "base/CommandHistory.h"
 #include "base/Command.h"
 #include "view/View.h"
 #include "base/PlayParameterRepository.h"
 #include "base/PlayParameters.h"
-#include "plugin/transform/TransformFactory.h"
+#include "plugin/transform/TransformerFactory.h"
 #include <QApplication>
 #include <QTextStream>
 #include <iostream>
 
 // For alignment:

 Document::Document() :
     m_mainModel(0),
     m_autoAlignment(false)
 {
     connect(this, SIGNAL(modelAboutToBeDeleted(Model *)),
-            TransformFactory::getInstance(),
+            TransformerFactory::getInstance(),
             SLOT(modelAboutToBeDeleted(Model *)));
 }
 
 Document::~Document()
 {

     return newLayer;
 }
 
 Layer *
 Document::createDerivedLayer(LayerFactory::LayerType type,
-			     TransformId transform)
+			     TransformerId transform)
 {
     Layer *newLayer = createLayer(type);
     if (!newLayer) return 0;
 
     newLayer->setObjectName(getUniqueLayerName
-                            (TransformFactory::getInstance()->
-                             getTransformFriendlyName(transform)));
+                            (TransformerFactory::getInstance()->
+                             getTransformerFriendlyName(transform)));
 
     return newLayer;
 }
 
 Layer *
-Document::createDerivedLayer(TransformId transform,
+Document::createDerivedLayer(TransformerId transform,
                              Model *inputModel, 
-                             const PluginTransform::ExecutionContext &context,
+                             const PluginTransformer::ExecutionContext &context,
                              QString configurationXml)
 {
     Model *newModel = addDerivedModel(transform, inputModel,
                                       context, configurationXml);
     if (!newModel) {

 
     LayerFactory::LayerTypeSet types =
 	LayerFactory::getInstance()->getValidLayerTypes(newModel);
 
     if (types.empty()) {
-	std::cerr << "WARNING: Document::createLayerForTransform: no valid display layer for output of transform " << transform.toStdString() << std::endl;
+	std::cerr << "WARNING: Document::createLayerForTransformer: no valid display layer for output of transform " << transform.toStdString() << std::endl;
 	delete newModel;
 	return 0;
     }
 
     //!!! for now, just use the first suitable layer type

     // work quickly.  That means we need to put the same physical
     // model pointer in both layers, so they can't actually be cloned.
     
     if (newLayer) {
 	newLayer->setObjectName(getUniqueLayerName
-                                (TransformFactory::getInstance()->
-                                 getTransformFriendlyName(transform)));
+                                (TransformerFactory::getInstance()->
+                                 getTransformerFriendlyName(transform)));
     }
 
     emit layerAdded(newLayer);
     return newLayer;
 }

     m_mainModel = model;
 
     emit modelAdded(m_mainModel);
 
     std::vector<Layer *> obsoleteLayers;
-    std::set<QString> failedTransforms;
+    std::set<QString> failedTransformers;
 
     // We need to ensure that no layer is left using oldMainModel or
     // any of the old derived models as its model.  Either replace the
     // model, or delete the layer for each layer that is currently
     // using one of these.  Carry out this replacement before we

 //            std::cerr << "... it uses a model derived from the old main model, regenerating" << std::endl;
 
 	    // This model was derived from the previous main
 	    // model: regenerate it.
 	    
-	    TransformId transform = m_models[model].transform;
-            PluginTransform::ExecutionContext context = m_models[model].context;
+	    TransformerId transform = m_models[model].transform;
+            PluginTransformer::ExecutionContext context = m_models[model].context;
 	    
 	    Model *replacementModel =
                 addDerivedModel(transform,
                                 m_mainModel,
                                 context,
                                 m_models[model].configurationXml);
 	    
 	    if (!replacementModel) {
 		std::cerr << "WARNING: Document::setMainModel: Failed to regenerate model for transform \""
 			  << transform.toStdString() << "\"" << " in layer " << layer << std::endl;
-                if (failedTransforms.find(transform) == failedTransforms.end()) {
+                if (failedTransformers.find(transform) == failedTransformers.end()) {
                     emit modelRegenerationFailed(layer->objectName(),
                                                  transform);
-                    failedTransforms.insert(transform);
+                    failedTransformers.insert(transform);
                 }
 		obsoleteLayers.push_back(layer);
 	    } else {
                 std::cerr << "Replacing model " << model << " (type "
                           << typeid(*model).name() << ") with model "

     // we already emitted modelAboutToBeDeleted for this
     delete oldMainModel;
 }
 
 void
-Document::addDerivedModel(TransformId transform,
+Document::addDerivedModel(TransformerId transform,
                           Model *inputModel,
-                          const PluginTransform::ExecutionContext &context,
+                          const PluginTransformer::ExecutionContext &context,
                           Model *outputModelToAdd,
                           QString configurationXml)
 {
     if (m_models.find(outputModelToAdd) != m_models.end()) {
 	std::cerr << "WARNING: Document::addDerivedModel: Model already added"

 
     emit modelAdded(model);
 }
 
 Model *
-Document::addDerivedModel(TransformId transform,
+Document::addDerivedModel(TransformerId transform,
                           Model *inputModel,
-                          const PluginTransform::ExecutionContext &context,
+                          const PluginTransformer::ExecutionContext &context,
                           QString configurationXml)
 {
     Model *model = 0;
 
     for (ModelMap::iterator i = m_models.begin(); i != m_models.end(); ++i) {

             i->second.configurationXml == configurationXml) {
 	    return i->first;
 	}
     }
 
-    model = TransformFactory::getInstance()->transform
+    model = TransformerFactory::getInstance()->transform
 	(transform, inputModel, context, configurationXml);
 
     if (!model) {
 	std::cerr << "WARNING: Document::addDerivedModel: no output model for transform " << transform.toStdString() << std::endl;
     } else {

         if (!duplicate) return adjusted;
     }
 }
 
 std::vector<Model *>
-Document::getTransformInputModels()
+Document::getTransformerInputModels()
 {
     std::vector<Model *> models;
 
     if (!m_mainModel) return models;
 

 }
 
 bool
 Document::canAlign() 
 {
-    TransformId id = "vamp:match-vamp-plugin:match:path";
-    TransformFactory *factory = TransformFactory::getInstance();
-    return factory->haveTransform(id);
+    TransformerId id = "vamp:match-vamp-plugin:match:path";
+    TransformerFactory *factory = TransformerFactory::getInstance();
+    return factory->haveTransformer(id);
 }
 
 void
 Document::alignModel(Model *model)
 {

     // 1. an AggregateWaveModel to provide the mixdowns of the main
     // model and the new model in its two channels, as input to the
     // MATCH plugin
 
     // 2. a SparseTimeValueModel, which is the model automatically
-    // created by FeatureExtractionPluginTransform when running the
+    // created by FeatureExtractionPluginTransformer when running the
     // MATCH plugin (thus containing the alignment path)
 
     // 3. an AlignmentModel, which stores the path model and carries
     // out alignment lookups on it.
 

     components.push_back(AggregateWaveModel::ModelChannelSpec
                          (rm, -1));
 
     Model *aggregate = new AggregateWaveModel(components);
 
-    TransformId id = "vamp:match-vamp-plugin:match:path";
+    TransformerId id = "vamp:match-vamp-plugin:match:path";
     
-    TransformFactory *factory = TransformFactory::getInstance();
+    TransformerFactory *factory = TransformerFactory::getInstance();
 
     Model *transformOutput = factory->transform
         (id, aggregate,
-         factory->getDefaultContextForTransform(id, aggregate),
+         factory->getDefaultContextForTransformer(id, aggregate),
          "<plugin param-serialise=\"1\"/>");
 
     SparseTimeValueModel *path = dynamic_cast<SparseTimeValueModel *>
         (transformOutput);