Common interface for all classes implementing the Observer functionality in the Model/Observer design pattern. More...

#include <IObserver.h>

Inheritance diagram for imod::IObserver:

Public Member Functions
virtual bool	IsModelAttached (const IModel *modelPtr=NULL) const =0
	Checks if the specified model is currently attached to this observer.

virtual bool	OnModelAttached (IModel *modelPtr, istd::IChangeable::ChangeSet &changeMask)=0
	Callback invoked when an observable model is about to be attached to this observer.

virtual bool	OnModelDetached (IModel *modelPtr)=0
	Callback invoked when an observable model is about to be detached from this observer.

virtual void	BeforeUpdate (IModel *modelPtr)=0
	Callback invoked before an update of the observer's content occurs.

virtual void	AfterUpdate (IModel *modelPtr, const istd::IChangeable::ChangeSet &changeSet)=0
	Callback invoked after an update of the observer's content occurs.

Public Member Functions inherited from istd::IPolymorphic
virtual	~IPolymorphic ()

Detailed Description

Common interface for all classes implementing the Observer functionality in the Model/Observer design pattern.

Purpose

The IObserver interface is a key component of the Model/Observer pattern (also known as Model-View-Controller or MVC). It defines the contract for objects that need to be notified when an observed model's state changes. This enables loose coupling between data models and their visual representations or other dependent components.

The Observer Pattern

In the Observer pattern:

Model (Observable): Contains the data and business logic, implements IModel
Observer: Watches the model for changes, implements IObserver
Notification Flow: When model data changes, all attached observers are notified
Decoupling: Models don't need to know specific details about their observers

Observer Lifecycle

Attachment: Observer is attached to a model via OnModelAttached()
Filtering: Observer specifies which changes it's interested in (changeMask)
Updates: Observer receives BeforeUpdate() and AfterUpdate() notifications
Detachment: Observer is detached from model via OnModelDetached()

Example Implementation

// Example: GUI component observing a data model
class CPersonViewObserver: public imod::IObserver
{
public:
       CPersonViewObserver(QLabel* nameLabel, QLabel* ageLabel)
              : m_nameLabel(nameLabel), m_ageLabel(ageLabel) {}
 
       // Check if a specific model is attached
       virtual bool IsModelAttached(const IModel* modelPtr) const override
       {
              return m_attachedModel == modelPtr || 
                     (modelPtr == nullptr && m_attachedModel != nullptr);
       }
 
       // Called when model is being attached
       virtual bool OnModelAttached(IModel* modelPtr, 
                                   istd::IChangeable::ChangeSet& changeMask) override
       {
              // Verify the model is of expected type
              CPerson* person = dynamic_cast<CPerson*>(modelPtr);
              if (!person) {
                     return false;  // Reject incompatible models
              }
 
              m_attachedModel = modelPtr;
              
              // Specify which changes we're interested in
              changeMask.Set(CPerson::CF_NAME_CHANGED);
              changeMask.Set(CPerson::CF_AGE_CHANGED);
              
              // Initial update of display
              UpdateDisplay(person);
              return true;
       }
 
       // Called when model is being detached
       virtual bool OnModelDetached(IModel* modelPtr) override
       {
              if (m_attachedModel == modelPtr) {
                     m_attachedModel = nullptr;
                     // Clear display
                     m_nameLabel->clear();
                     m_ageLabel->clear();
                     return true;
              }
              return false;
       }
 
       // Called before model update starts
       virtual void BeforeUpdate(IModel* modelPtr) override
       {
              // Optional: Save current state for comparison
              // or prepare for update (e.g., block signals)
       }
 
       // Called after model has been updated
       virtual void AfterUpdate(IModel* modelPtr, 
                               const istd::IChangeable::ChangeSet& changeSet) override
       {
              CPerson* person = dynamic_cast<CPerson*>(modelPtr);
              if (!person) return;
 
              // Check which changes occurred and update accordingly
              if (changeSet.Contains(CPerson::CF_NAME_CHANGED)) {
                     m_nameLabel->setText(person->GetName());
              }
              if (changeSet.Contains(CPerson::CF_AGE_CHANGED)) {
                     m_ageLabel->setText(QString::number(person->GetAge()));
              }
       }
 
private:
       void UpdateDisplay(CPerson* person)
       {
              m_nameLabel->setText(person->GetName());
              m_ageLabel->setText(QString::number(person->GetAge()));
       }
 
       IModel* m_attachedModel = nullptr;
       QLabel* m_nameLabel;
       QLabel* m_ageLabel;
};
 
// Usage
CPerson personModel("John", 30);
QLabel nameLabel, ageLabel;
CPersonViewObserver observer(&nameLabel, &ageLabel);
 
// Attach observer to model
personModel.AttachObserver(&observer);
 
// When model changes, observer is automatically notified
personModel.SetName("Jane");  // nameLabel is updated automatically
personModel.SetAge(25);       // ageLabel is updated automatically
 
// Detach when done
personModel.DetachObserver(&observer);

Best Practices

Always verify model type in OnModelAttached() before accepting
Specify precise change masks to avoid unnecessary updates
Keep update logic in AfterUpdate() fast to avoid UI freezing
Handle nullptr in IsModelAttached() to check for any attached model
Clean up resources in OnModelDetached()
BeforeUpdate() may be called without subsequent AfterUpdate() in some error cases

See also: imod::IModel, istd::IChangeable, imod::CModelObserverComp

Definition at line 155 of file IObserver.h.

Member Function Documentation

◆ AfterUpdate()

virtual void imod::IObserver::AfterUpdate	(	IModel *	modelPtr,
		const istd::IChangeable::ChangeSet &	changeSet
	)

pure virtual

Callback invoked after an update of the observer's content occurs.

This is the primary notification method where observers react to model changes. It's called after the model has finished updating its state. The implementation should examine the changeSet to determine what changed and update accordingly.

Parameters

modelPtr	Pointer to the model that has changed
changeSet	Contains information about what changed in the model. Use changeSet.Contains(changeId) to check for specific changes. The changeSet respects the mask specified in OnModelAttached().

Note: This is typically where you update your GUI, recalculate derived values, or trigger other dependent operations.; Keep this method fast - it's called frequently and may block the UI thread.; Use the changeSet to perform incremental updates rather than refreshing everything.

virtual void AfterUpdate(IModel* modelPtr, 
                        const istd::IChangeable::ChangeSet& changeSet)
{
       CMyModel* model = dynamic_cast<CMyModel*>(modelPtr);
       if (!model) return;
       
       // Selective update based on what changed
       if (changeSet.Contains(CMyModel::CF_NAME_CHANGED)) {
              m_nameLabel->setText(model->GetName());
       }
       if (changeSet.Contains(CMyModel::CF_VALUE_CHANGED)) {
              m_valueSpinBox->setValue(model->GetValue());
              RecalculateDependentValues();
       }
       
       // Re-enable signals if blocked in BeforeUpdate
       if (m_widget) {
              m_widget->blockSignals(false);
       }
}

See also: BeforeUpdate(), OnModelAttached()

◆ BeforeUpdate()

virtual void imod::IObserver::BeforeUpdate ( IModel * modelPtr )

pure virtual

Callback invoked before an update of the observer's content occurs.

This method is called at the start of a model update cycle, before any data actually changes. It allows the observer to prepare for the update, such as saving current state for comparison or disabling UI updates temporarily.

Parameters

modelPtr Pointer to the model that is about to change

Warning: In some error cases, this method may be called without a subsequent AfterUpdate() call. Don't rely on AfterUpdate() always being called.

Note: This method is optional to implement - if you don't need preparation logic, just provide an empty implementation.

virtual void BeforeUpdate(IModel* modelPtr)
{
       // Example: Block signals to prevent multiple GUI updates
       if (m_widget) {
              m_widget->blockSignals(true);
       }
       
       // Example: Save state for delta comparison
       m_previousValue = m_currentValue;
}

See also: AfterUpdate()

Implemented in ibase::CMultiObserverBinderComp, idoc::CSelectedDocModelBinderComp, idoc::CSerializedUndoManagerComp, imod::CModelUpdateBridge, imod::CSingleModelObserverBase, iqtgui::CCommandsMultiplexerComp, and imod::CMultiModelObserverBase.

◆ IsModelAttached()

virtual bool imod::IObserver::IsModelAttached ( const IModel * modelPtr = NULL ) const

pure virtual

Checks if the specified model is currently attached to this observer.

This method allows querying whether a specific model is being observed, or whether any model at all is attached.

Parameters

modelPtr Pointer to the model object to check. If nullptr, checks whether any model is attached to this observer.

Returns: true if the specified model (or any model when modelPtr is nullptr) is attached to this observer, false otherwise.

// Check if a specific model is attached
if (observer->IsModelAttached(myModel)) {
       // This specific model is being observed
}
 
// Check if any model is attached
if (observer->IsModelAttached(nullptr)) {
       // At least one model is attached
}

See also: OnModelAttached(), OnModelDetached()

Implemented in imod::CModelUpdateBridge, ibase::CMultiObserverBinderComp, imod::CSingleModelObserverBase, and imod::CMultiModelObserverBase.

◆ OnModelAttached()

virtual bool imod::IObserver::OnModelAttached	(	IModel *	modelPtr,
		istd::IChangeable::ChangeSet &	changeMask
	)

pure virtual

Callback invoked when an observable model is about to be attached to this observer.

This method is called by the model when attempting to establish an observer relationship. The implementation should:

Validate that the model is of an acceptable type
Set the changeMask to specify which changes to monitor
Return true to accept the attachment, or false to reject it

Parameters

modelPtr	Pointer to the model object being attached. Never nullptr.
changeMask	Output parameter where the observer specifies which change types it wants to be notified about. Set the appropriate change flags using changeMask.Set(changeId). An empty mask means the observer wants all changes.

Returns: true if the model is accepted and attachment succeeds, false to reject the attachment (e.g., if the model is of incompatible type).

Note: After successful attachment, the observer should initialize its state based on the current model data.; The changeMask allows filtering notifications for better performance. Only changes matching the mask will trigger AfterUpdate() calls.

virtual bool OnModelAttached(IModel* modelPtr, 
                            istd::IChangeable::ChangeSet& changeMask)
{
       // Type check
       CMyModel* model = dynamic_cast<CMyModel*>(modelPtr);
       if (!model) return false;
       
       // Set up change filtering
       changeMask.Set(CMyModel::CF_DATA_CHANGED);
       changeMask.Set(CMyModel::CF_STATUS_CHANGED);
       // Don't set CF_INTERNAL_CHANGED - we don't care about those
       
       // Initialize view from current model state
       UpdateViewFromModel(model);
       return true;
}

See also: OnModelDetached(), IsModelAttached(), AfterUpdate()

◆ OnModelDetached()

virtual bool imod::IObserver::OnModelDetached ( IModel * modelPtr )

pure virtual

Callback invoked when an observable model is about to be detached from this observer.

This method is called when the observer-model relationship is being terminated, either explicitly or because the model is being destroyed. The implementation should clean up any state or resources related to this model.

Parameters

modelPtr Pointer to the model object being detached

Returns: true if the detachment was handled successfully, false otherwise

Note: After this call, the observer should not access the model pointer anymore.; This method may be called even if OnModelAttached() previously returned false.; Clean up any cached data or references to this model.

virtual bool OnModelDetached(IModel* modelPtr)
{
       if (m_currentModel == modelPtr) {
              // Clear any cached data
              m_cachedData.clear();
              m_currentModel = nullptr;
              
              // Update UI to show no model is attached
              ClearDisplay();
              return true;
       }
       return false;
}

See also: OnModelAttached(), IsModelAttached()

The documentation for this class was generated from the following file:

Acf/Include/imod/IObserver.h

Public Member Functions

Detailed Description

Purpose

The Observer Pattern

Observer Lifecycle

Example Implementation

Best Practices

Member Function Documentation

◆ AfterUpdate()

◆ BeforeUpdate()

◆ IsModelAttached()

◆ OnModelAttached()

◆ OnModelDetached()