C++源码分享（五）：观察者模式泛型实现

提供观察者设计模式的泛型实现,特别是，当对象超出生命期时自动注销观察者

//<File>**********************************************************************

// Copyright (c) 2005

// 胡乐秋.

// 文件: ObserverEx.hpp

// 内容: 观察者模式的泛型实现

// 使用: 被观察者:

// 按以下形式声明类并在每一个更改状态的命令之后调用ObserverNotify(EventID,Parameters)

// class CMyClass : public HLQ_LIB::CObserverableT<CMyClass>

// {

// void ChangeState()

// {

// ...

// parameter_container_type Parameters;

// Parameters.push_back(OldState);

// Parameters.push_back(NewState);

// ObserverNotify(TEXT("ChangeState"),Parameters);

// }

// };

// 观察者:

// 按以下形式声明类，并实现OnObserveredEvent函数

// class UIMyClass : public HLQ_LIB::CMyClass::observer_type

// {

// virtual void OnObserveredEvent(const HLQ_LIB::CMyClass::observered_type* pMyClass,const CMyClass::event_id_type& EventID,const CMyClass::parameter_container_type& Parameters) const

// {

// state_type OldState=boost::any_cast<state_type>(Parameters[0]);

// state_type NewState=boost::any_cast<state_type>(Parameters[1]);

// MessageBox(0,EventID.c_str(),TEXT("OnObserveredEvent"),MB_OK);

// }

// };

// 初始化: 客户代码中应调用CMyClass或UIMyClass的Attach方法建立起被观察者和观察者对象之间的绑定关系

// 注意: 在观察者或被观察者对象超出其寿命范围时，组件可自动取消两者之间的绑定关系.

// 历史:

// 序号 修改时间 修改人 修改内容

// 1 2005/05/06 hlq 首次生成

//*********************************************************************</File>

//声明本头文件宏

#ifndef _OBSERVEREX_H

#define _OBSERVEREX_H

//包含头文件

#ifdef _MSC_VER

#if _MSC_VER < 1300

#pragma warning(disable:4786)

#endif //_MSC_VER < 1300

#endif //_MSC_VER

#include <vector>

#include <cassert>

#include <boost/any.hpp>

//开始名字空间

namespace HLQ_LIB

{

//<class>**********************************************************************

// 类名: CObserverT

// 目的: 观察者接口

//*********************************************************************</class>

template<class ObserveredType>

class CObserverT

{

////类型声明

public:

typedef typename ObserveredType::observer_type observer_type; //观察者类型

typedef typename ObserveredType::observered_type observered_type; //被观察者实际类型

typedef typename ObserveredType::event_id_type event_id_type; //被观察者事件ID类型，如字符串("删除对象")或int。缺省为字符串。

typedef typename ObserveredType::parameter_container_type parameter_container_type; //参数容器类型,常为std::vector或std::list等。缺省为std::vector。

typedef typename parameter_container_type::value_type parameter_type; //参数类型,常为变体如CComVariant、boost::any等。缺省为boost::any。

typedef std::vector<const observered_type*> observered_container_type;

typedef typename observered_container_type::value_type observered_value_type;

typedef typename observered_container_type::iterator observered_iterator;

typedef typename observered_container_type::const_iterator observered_const_iterator;

typedef typename observered_container_type::size_type observered_size_type;

typedef typename observered_container_type::size_type observered_index_type;

////基本查询

public:

//得到被观察者数量

observered_size_type GetObserveredCount() const {return m_Observereds.size();}

//检查是否已经绑定指定被观察者

bool HasAttach(const observered_type* pObservered) const;

//得到被观察者

observered_value_type GetObservered(observered_index_type Index) const{assert(Index<GetObserveredCount());return m_Observereds[Index];}

////命令

public:

//绑定被观察者(建立双向榜定)

void Attach(const observered_type* pObservered);

//取消被观察者绑定(取消双向榜定)

void Detach(const observered_type* pObservered);

//取消所有被观察者绑定(取消所有双向榜定)

void DetachAllObservereds();

////接口函数

protected:

//被观察者事件通知消息

friend observered_type;

virtual void OnObserveredEvent(const observered_type* pObservered,const event_id_type& EventID,const parameter_container_type& Parameters) const= 0;

////构造、析构函数

public:

//缺省构造函数

CObserverT(){};

//拷贝构造函数

CObserverT(const CObserverT& rhs);

//虚拟析构函数

virtual ~CObserverT();

//赋值操作俯重载

CObserverT& operator=(const CObserverT& rhs);

////数据成员

private:

observered_container_type m_Observereds;

};

//检查是否已经绑定指定观察者

template <class ObserveredType>

inline bool CObserverT<ObserveredType>::HasAttach(const observered_type* pObservered) const

{

//循环遍历每个观察者，检查是否已经注册

for(observered_const_iterator p=m_Observereds.begin();p!=m_Observereds.end();++p)

{

if(*p==pObservered)

return true;

}

return false;

}

//绑定被观察者(建立双向榜定)

template <class ObserveredType>

inline void CObserverT<ObserveredType>::Attach(const observered_type* pObservered)

{

assert(!HasAttach(pObservered));

m_Observereds.push_back(pObservered);

if(!pObservered->HasAttach(this))

(const_cast<observered_type*>(pObservered))->Attach(this);

assert(pObservered->HasAttach(this));

assert(HasAttach(pObservered));

}

//取消被观察者绑定(取消双向榜定)

template <class ObserveredType>

inline void CObserverT<ObserveredType>::Detach(const observered_type* pObservered)

{

assert(HasAttach(pObservered));

for(observered_iterator p=m_Observereds.begin();p!=m_Observereds.end();++p)

{

if(*p==pObservered)

{

m_Observereds.erase(p);

if(pObservered->HasAttach(this))

(const_cast<observered_type*>(pObservered))->Detach(this);

break;

}

}

assert(!pObservered->HasAttach(this));

assert(!HasAttach(pObservered));

}

//取消所有被观察者绑定(取消所有双向榜定)

template <class ObserveredType>

inline void CObserverT<ObserveredType>::DetachAllObservereds()

{

//循环释放每一个被观察者

while(GetObserveredCount()>0)

Detach(m_Observereds[0]);

}

//拷贝构造函数

template <class ObserveredType>

inline CObserverT<ObserveredType>::CObserverT(const CObserverT& rhs)

{

for(observered_const_iterator p=rhs.m_Observereds.begin();p!=rhs.m_Observereds.end();++p)

Attach(*p);

}

//虚拟析构函数(取消所有双向榜定)

template <class ObserveredType>

inline CObserverT<ObserveredType>::~CObserverT()

{

//清空所有被观察者

DetachAllObservereds();

}

//赋值操作俯重载

template <class ObserveredType>

CObserverT<ObserveredType>& CObserverT<ObserveredType>::operator=(const CObserverT& rhs)

{

if(&rhs!=this)

{

//清空所有被观察者

DetachAllObservereds();

for(observered_const_iterator p=rhs.m_Observereds.begin();p!=rhs.m_Observereds.end();++p)

Attach(*p);

}

return *this;

}

//<class>**********************************************************************

// 类名: CObserverableT

// 目的: 可被观察者

// 参数: ObserveredType - 被观察者具体类型，即本类的派生类

// EventIDType - 被观察者事件ID类型，如字符串("删除对象")或int。缺省为字符串。

// ParameterType - 参数类型,常为变体如CComVariant、boost::any等。缺省为boost::any。

// ParameterContainerType - 参数容器类型,常为std::vector或std::list等。缺省为std::vector。

//*********************************************************************</class>

template <class ObserveredType,class EventIDType=std::basic_string<TCHAR>,class ParameterType=boost::any,class ParameterContainerType=std::vector<ParameterType> >

class CObserverableT

{

////类型声明

public:

typedef CObserverableT<ObserveredType> observered_type;

typedef EventIDType event_id_type;

typedef ParameterType parameter_type;

typedef ParameterContainerType parameter_container_type;

typedef CObserverT<observered_type> observer_type;

typedef std::vector<const observer_type*> observer_container_type;

typedef typename observer_container_type::value_type observer_value_type;

typedef typename observer_container_type::iterator observer_iterator;

typedef typename observer_container_type::const_iterator observer_const_iterator;

typedef typename observer_container_type::size_type observer_size_type;

typedef typename observer_container_type::size_type observer_index_type;

////基本查询

public:

//得到观察者数量

observer_size_type GetObserverCount() const {return m_Observers.size();}

//检查是否已经绑定指定观察者

bool HasAttach(const observer_type* pObserver) const;

//得到观察者

observer_value_type GetObserver(observer_index_type Index) const{assert(Index<GetObserverCount());return m_Observers[Index];}

////命令

public:

//绑定观察者(建立双向榜定)

void Attach(const observer_type* pObserver);

//取消观察者绑定(取消双向榜定)

void Detach(const observer_type* pObserver);

//取消所有被观察者绑定(取消所有双向榜定)

void DetachAllObservers();

////派生类调用函数

protected:

//通知所有观察者

void ObserverNotify(const event_id_type& EventID,const parameter_container_type& Parameters=parameter_container_type()) const;

////构造、析构函数

public:

//缺省构造函数

CObserverableT(){};

//拷贝构造函数

CObserverableT(const CObserverableT& rhs);

//虚拟析构函数

virtual ~CObserverableT(void);

//赋值操作俯重载

CObserverableT& operator=(const CObserverableT& rhs);

////数据成员

private:

observer_container_type m_Observers;

};

//检查是否已经绑定指定观察者

template <class ObserveredType,class EventIDType,class ParameterType,class ParameterContainerType>

inline bool CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>::HasAttach(const observer_type* pObserver) const

{

//循环遍历每个观察者，检查是否已经注册

for(observer_const_iterator p=m_Observers.begin();p!=m_Observers.end();++p)

{

if(*p==pObserver)

return true;

}

return false;

}

//绑定观察者(建立双向榜定)

template <class ObserveredType,class EventIDType,class ParameterType,class ParameterContainerType>

inline void CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>::Attach(const observer_type* pObserver)

{

assert(!HasAttach(pObserver));

m_Observers.push_back(pObserver);

if(!pObserver->HasAttach(this))

(const_cast<observer_type*>(pObserver))->Attach(this);

assert(HasAttach(pObserver));

assert(pObserver->HasAttach(this));

}

//取消观察者绑定(取消双向榜定)

template <class ObserveredType,class EventIDType,class ParameterType,class ParameterContainerType>

inline void CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>::Detach(const observer_type* pObserver)

{

assert(HasAttach(pObserver));

for(observer_iterator p=m_Observers.begin();p!=m_Observers.end();++p)

{

if(*p==pObserver)

{

m_Observers.erase(p);

if(pObserver->HasAttach(this))

(const_cast<observer_type*>(pObserver))->Detach(this);

break;

}

}

assert(!HasAttach(pObserver));

assert(!pObserver->HasAttach(this));

}

//取消所有被观察者绑定(取消所有双向榜定)

template <class ObserveredType,class EventIDType,class ParameterType,class ParameterContainerType>

inline void CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>::DetachAllObservers()

{

//循环释放每一个观察者

while(GetObserverCount()>0)

Detach(m_Observers[0]);

}

//拷贝构造函数

template <class ObserveredType,class EventIDType,class ParameterType,class ParameterContainerType>

inline CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>::CObserverableT(const CObserverableT& rhs)

{

for(observer_const_iterator p=rhs.m_Observers.begin();p!=rhs.m_Observers.end();++p)

Attach(*p);

}

//虚拟析构函数

template <class ObserveredType,class EventIDType,class ParameterType,class ParameterContainerType>

inline CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>::~CObserverableT()

{

//清空所有观察者

DetachAllObservers();

}

//赋值操作俯重载

template <class ObserveredType,class EventIDType,class ParameterType,class ParameterContainerType>

CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>& CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>::operator=(const CObserverableT& rhs)

{

if(&rhs!=this)

{

//清空所有观察者

DetachAllObservers();

for(observer_const_iterator p=rhs.m_Observers.begin();p!=rhs.m_Observers.end();++p)

Attach(*p);

}

return *this;

}

//通知所有观察者

template <class ObserveredType,class EventIDType,class ParameterType,class ParameterContainerType>

inline void CObserverableT<ObserveredType,EventIDType,ParameterType,ParameterContainerType>::ObserverNotify(const event_id_type& EventID,const parameter_container_type& Parameters) const

{

for(observer_const_iterator p=m_Observers.begin();p!=m_Observers.end();++p)

{

(*p)->OnObserveredEvent(this,EventID,Parameters);

}

}

}//HLQ_LIB名字空间结束

#endif //假如未定义_OBSERVEREX_H宏

胡乐秋
2010/8/3 http://blog.csdn.net/hlqyq