Common interface for all classes that support delegation of their data updates to another class. More...

#include <IChangeDelegator.h>

Inheritance diagram for istd::IChangeDelegator:

Public Member Functions
virtual istd::IChangeable *	GetSlavePtr () const =0
	Gets the slave object pointer.

virtual void	SetSlavePtr (istd::IChangeable *slavePtr)=0
	Sets the slave object pointer for change delegation.

Public Member Functions inherited from istd::IChangeable
virtual int	GetSupportedOperations () const
	Get set of flags for supported operations.

virtual bool	CopyFrom (const IChangeable &object, CompatibilityMode mode=CM_WITHOUT_REFS)
	Copy this object from another one.

virtual bool	IsEqual (const IChangeable &object) const
	Compare this object with another object.

virtual istd::TUniqueInterfacePtr< istd::IChangeable >	CloneMe (CompatibilityMode mode=CM_WITHOUT_REFS) const
	Make a copy of this object.

virtual bool	ResetData (CompatibilityMode mode=CM_WITHOUT_REFS)
	Reset data to its default state.

virtual void	BeginChanges (const ChangeSet &changeSet)
	Starts the change transaction.

virtual void	EndChanges (const ChangeSet &changeSet)
	Ends the change transaction.

virtual void	BeginChangeGroup (const ChangeSet &changeSet)
	Starts group of changes.

virtual void	EndChangeGroup (const ChangeSet &changeSet)
	Ends group of changes.

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

Additional Inherited Members
Public Types inherited from istd::IChangeable
enum	ChangeFlags { CF_ACF_INTERNAL = 0 , CF_ALL_DATA , CF_ANY , CF_DESTROYING , CF_DELEGATED , CF_NO_UNDO }
	Data model change notification flags. More...

enum	SupportedOperations { SO_NONE = 0 , SO_OBSERVE = 1 << 0 , SO_COPY = 1 << 1 , SO_CLONE = 1 << 2 , SO_COMPARE = 1 << 3 , SO_RESET = 1 << 4 }
	Flags for supported operations. More...

enum	CompatibilityMode { CM_STRICT , CM_WITHOUT_REFS , CM_WITH_REFS , CM_CONVERT }
	Control how relationship betweeen objects are interpreted. More...

typedef QMultiMap< QByteArray, QVariant >	ChangeInfoMap

Static Public Member Functions inherited from istd::IChangeable
static const ChangeSet &	GetNoChanges ()
	Get empty set of changes.

static const ChangeSet &	GetAnyChange ()
	Get anonymous change set.

static const ChangeSet &	GetAllChanges ()
	Get anonymous change set.

static const ChangeSet &	GetDelegatedChanges ()
	Get delegated change set.

Protected Member Functions inherited from istd::IChangeable
virtual void	OnBeginChanges ()
	Callback function for begin change event.

virtual void	OnEndChanges (const ChangeSet &changeSet)
	Callback function for end change event.

Detailed Description

Common interface for all classes that support delegation of their data updates to another class.

This is useful for composed objects to delegate information about data changes from a child element to its owner, enabling hierarchical change notification patterns.

Purpose

The IChangeDelegator interface extends IChangeable to support automatic forwarding of change notifications from child objects to their parent or owner objects. This is essential in composite data structures where changes to child elements need to be propagated up the hierarchy.

Usage

When a class implements IChangeDelegator, it can forward its change notifications to a "slave" object (typically a parent or owner). When the delegator's BeginChanges() or EndChanges() methods are called, they will automatically propagate to the slave object.

Example

// Child class that delegates changes to parent
class CDataItem: public istd::TChangeDelegator<istd::IChangeable>
{
public:
       void SetValue(int value)
       {
              if (m_value != value) {
                     static ChangeSet changeSet(CF_VALUE_CHANGED, "Value changed");
                     BeginChanges(changeSet);
                     m_value = value;
                     EndChanges(changeSet);  // This will notify the slave (parent)
              }
       }
 
private:
       int m_value;
};
 
// Parent class that owns child items
class CDataContainer: virtual public istd::IChangeable
{
public:
       void AddItem(CDataItem* item)
       {
              m_items.append(item);
              // Register this container as the slave for change delegation
              item->SetSlavePtr(this);
       }
 
protected:
       // This method will be called when any child item changes
       virtual void OnEndChanges(const ChangeSet& changeSet)
       {
              if (changeSet.Contains(CF_DELEGATED)) {
                     // Handle child item changes
                     UpdateDisplay();
              }
       }
 
private:
       QList<CDataItem*> m_items;
};

See also: istd::IChangeable, istd::TChangeDelegator, istd::CChangeDelegator

Definition at line 79 of file IChangeDelegator.h.

Member Function Documentation

◆ GetSlavePtr()

virtual istd::IChangeable * istd::IChangeDelegator::GetSlavePtr ( ) const

pure virtual

Gets the slave object pointer.

The slave object will receive change notifications when this object's state changes. If no slave is set, returns nullptr.

Returns: Pointer to the slave IChangeable object, or nullptr if not set.

Implemented in istd::CChangeDelegator.

◆ SetSlavePtr()

virtual void istd::IChangeDelegator::SetSlavePtr ( istd::IChangeable * slavePtr )

pure virtual

Sets the slave object pointer for change delegation.

When a slave is set, all change notifications (BeginChanges and EndChanges) from this object will be automatically forwarded to the slave. This enables hierarchical change notification where child objects notify their parents of changes.

Parameters

slavePtr Pointer to the IChangeable object that should receive delegated change notifications. Pass nullptr to disable delegation.

Note: The slave object is not owned by this delegator. The caller is responsible for ensuring the slave object remains valid during the delegation lifetime.

See also: GetSlavePtr()