comparison transform/ModelTransformerFactory.h @ 1740:fe3f7f8df3a3 by-id

More work on transformers

     class UserConfigurator {
     public:
         virtual bool configure(ModelTransformer::Input &input,
                                Transform &transform,
                                Vamp::PluginBase *plugin,
-                               Model *&inputModel,
+                               ModelId &inputModel,
                                AudioPlaySource *source,
                                sv_frame_t startFrame,
                                sv_frame_t duration,
-                               const QMap<QString, Model *> &modelMap,
+                               const QMap<QString, ModelId> &modelMap,
                                QStringList candidateModelNames,
                                QString defaultModelName) = 0;
     };
 
     /**
      * Fill out the configuration for the given transform (may include
      * asking the user by calling back on the UserConfigurator).
      * Returns the selected input model and channel if the transform
-     * is acceptable, or an input with a null model if the operation
+     * is acceptable, or an input with no model if the operation
      * should be cancelled.  Audio play source may be used to audition
      * effects plugins, if provided.
      */
     ModelTransformer::Input
     getConfigurationForTransform(Transform &transform,
-                                 const std::vector<Model *> &candidateInputModels,
-                                 Model *defaultInputModel,
+                                 std::vector<ModelId> candidateInputModels,
+                                 ModelId defaultInputModel,
                                  AudioPlaySource *source = 0,
                                  sv_frame_t startFrame = 0,
                                  sv_frame_t duration = 0,
                                  UserConfigurator *configurator = 0);
 
     class AdditionalModelHandler {
     public:
         virtual ~AdditionalModelHandler() { }
 
         // Exactly one of these functions will be called
-        virtual void moreModelsAvailable(std::vector<Model *> models) = 0;
+        virtual void moreModelsAvailable(std::vector<ModelId> models) = 0;
         virtual void noMoreModelsAvailable() = 0;
     };
     
     /**
      * Return the output model resulting from applying the named

      * handler is null) any such models will be discarded.
      *
      * The returned model is owned by the caller and must be deleted
      * when no longer needed.
      */
-    Model *transform(const Transform &transform,
-                     const ModelTransformer::Input &input,
-                     QString &message,
-                     AdditionalModelHandler *handler = 0);
+    ModelId transform(const Transform &transform,
+                      const ModelTransformer::Input &input,
+                      QString &message,
+                      AdditionalModelHandler *handler = 0);
 
     /**
      * Return the multiple output models resulting from applying the
      * named transforms to the given input model.  The transforms may
      * differ only in output identifier for the plugin: they must all

      * transform activity associated with these output models.
      *
      * The returned models are owned by the caller and must be deleted
      * when no longer needed.
      */
-    std::vector<Model *> transformMultiple(const Transforms &transform,
+    std::vector<ModelId> transformMultiple(const Transforms &transform,
                                            const ModelTransformer::Input &input,
                                            QString &message,
                                            AdditionalModelHandler *handler = 0);
 
     bool haveRunningTransformers() const;

 signals:
     void transformFailed(QString transformName, QString message);
                                                                                
 protected slots:
     void transformerFinished();
-
-    void modelAboutToBeDeleted(Model *);
 
 protected:
     ModelTransformer *createTransformer(const Transforms &transforms,
                                         const ModelTransformer::Input &input);