comparison data/model/Model.h @ 1735:d91ff235e69d by-id

Some messing with Model and AlignmentModel

               public Playable
 {
     Q_OBJECT
 
 public:
+    typedef Id ModelId;
+    
     virtual ~Model();
 
     /**
      * Return true if the model was constructed successfully.  Classes
      * that refer to the model should always test this before use.

      * model API is concerned, this does nothing more than tell the
      * model to return true from isAbandoning().  The actual response
      * to this will depend on the model's context -- it's possible
      * nothing at all will change.
      */
+    //!!! aim to lose this
+    /*!!!
     virtual void abandon() {
         m_abandoning = true;
     }
-
+    */
+    
     /**
      * Query whether the model has been marked as abandoning.
      */
+    //!!! aim to lose this
+    /*!!!
     virtual bool isAbandoning() const { 
         return m_abandoning;
     }
-
+    */
     /**
      * Return true if the model has finished loading or calculating
      * all its data, for a model that is capable of calculating in a
      * background thread.
      *

     virtual const ZoomConstraint *getZoomConstraint() const {
         return 0;
     }
 
     /**
-     * If this model was derived from another, return the model it was
-     * derived from.  The assumption is that the source model's
-     * alignment will also apply to this model, unless some other
-     * property (such as a specific alignment model set on this model)
-     * indicates otherwise.
-     */
-    virtual Model *getSourceModel() const {
+     * If this model was derived from another, return the id of the
+     * model it was derived from.  The assumption is that the source
+     * model's alignment will also apply to this model, unless some
+     * other property (such as a specific alignment model set on this
+     * model) indicates otherwise.
+     */
+    virtual ModelId getSourceModel() const {
         return m_sourceModel;
     }
 
     /**
      * Set the source model for this model.
      */
-    virtual void setSourceModel(Model *model);
-
-    /**
-     * Specify an aligment between this model's timeline and that of a
-     * reference model.  The alignment model records both the
-     * reference and the alignment.  This model takes ownership of the
-     * alignment model.
-     */
-    virtual void setAlignment(AlignmentModel *alignment);
+    virtual void setSourceModel(ModelId model);
+
+    /**
+     * Specify an alignment between this model's timeline and that of
+     * a reference model. The alignment model, of type AlignmentModel,
+     * records both the reference and the alignment. This model "takes
+     * ownership" of alignmentModel, in that we take responsibility
+     * for calling ModelById::release() for it from our own destructor
+     * (no other class needs to know about the alignment model).
+
+     *!!! I don't think the above is a good idea - I think document
+          should record alignment models and release them
+     */
+    virtual void setAlignment(ModelId alignmentModel);
 
     /**
      * Retrieve the alignment model for this model.  This is not a
      * generally useful function, as the alignment you really want may
      * be performed by the source model instead.  You should normally
      * use getAlignmentReference, alignToReference and
      * alignFromReference instead of this.  The main intended
      * application for this function is in streaming out alignments to
      * the session file.
      */
-    virtual const AlignmentModel *getAlignment() const;
+    virtual const ModelId getAlignment() const;
 
     /**
      * Return the reference model for the current alignment timeline,
      * if any.
      */
-    virtual const Model *getAlignmentReference() const;
+    virtual const ModelId getAlignmentReference() const;
 
     /**
      * Return the frame number of the reference model that corresponds
      * to the given frame number in this model.
      */

     virtual QString toDelimitedDataString(QString delimiter,
                                           DataExportOptions options,
                                           sv_frame_t startFrame,
                                           sv_frame_t duration) const = 0;
 
+    /*!!!
 public slots:
     void aboutToDelete();
     void sourceModelAboutToBeDeleted();
-
+    */
+    
 signals:
     /**
      * Emitted when a model has been edited (or more data retrieved
      * from cache, in the case of a cached model that generates slowly)
      */

      * owning model telling the model that it is about to delete it;
      * there is nothing in the model to guarantee that this signal
      * will be emitted before the actual deletion.
      */
     //!!! our goal is to get rid of (the need for) this
-    void aboutToBeDeleted();
+//!!!    void aboutToBeDeleted();
 
 protected:
     Model() :
-        m_sourceModel(0), 
-        m_alignment(0), 
-        m_abandoning(false), 
-        m_aboutToDelete(false),
+//!!!        m_abandoning(false), 
+//!!!        m_aboutToDelete(false),
         m_extendTo(0) { }
 
     // Not provided.
-    Model(const Model &);
-    Model &operator=(const Model &); 
-
-    Model *m_sourceModel;
-    AlignmentModel *m_alignment;
+    Model(const Model &) =delete;
+    Model &operator=(const Model &) =delete;
+
+    ModelId m_sourceModel;
+    ModelId m_alignmentModel;
     QString m_typeUri;
-    bool m_abandoning;
-    bool m_aboutToDelete;
+//!!!    bool m_abandoning;
+//!!!    bool m_aboutToDelete;
     sv_frame_t m_extendTo;
 };
 
-typedef Model::Id ModelId;
+typedef Model::ModelId ModelId;
 typedef StaticById<Model, ModelId> ModelById;
 
 #endif