C++ 对象间通信框架 V2.0 ××××××× 之（五）

类定义:

=======================================================================

 // MemberFuncPointer.h: interface for the CMemberFuncPointer class.
 //
 //////////////////////////////////////////////////////////////////////

 #if !defined(AFX_MEMBERFUNCPOINTER_H__4D78718D_778E_4427_BBC1_C5F2D52C64E5__INCLUDED_)
 #define AFX_MEMBERFUNCPOINTER_H__4D78718D_778E_4427_BBC1_C5F2D52C64E5__INCLUDED_

 #if _MSC_VER > 1000
 #pragma once
 #endif // _MSC_VER > 1000

 // 成员函数指针最大长度
 #define MEMBER_FUNC_POINTER_MAX_SIZE 32
 class CMemberFuncPointer
 {
 public:
     void Reset();
     void Set(const void*pFunc,int p_size);
     void Get(void*pFunc);
     CMemberFuncPointer();
     CMemberFuncPointer(const char pointerdata[],int p_size);
     CMemberFuncPointer(void* pointerdata,int p_size);
     virtual ~CMemberFuncPointer();

     bool operator==(const CMemberFuncPointer &mfp) const;
     bool operator!=(const CMemberFuncPointer &mfp) const;

     CMemberFuncPointer& operator=(const CMemberFuncPointer &mfp);

 private:
     int m_size;
     char m_pointer_data[MEMBER_FUNC_POINTER_MAX_SIZE];
 };

 #endif // !defined(AFX_MEMBERFUNCPOINTER_H__4D78718D_778E_4427_BBC1_C5F2D52C64E5__INCLUDED_)

MemberFuncPointer.h

 // MemberFuncPointer.cpp: implementation of the CMemberFuncPointer class.
 //
 //////////////////////////////////////////////////////////////////////

 #include "stdafx.h"
 #include "OverlapRoutine.h"
 #include "MemberFuncPointer.h"

 #ifdef _DEBUG
 #undef THIS_FILE
 static char THIS_FILE[]=__FILE__;
 #define new DEBUG_NEW
 #endif

 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////

 CMemberFuncPointer::CMemberFuncPointer()
 {
     this->m_size = ;
 }

 CMemberFuncPointer::CMemberFuncPointer(const char pointerdata[],int p_size)
 {
     if(p_size<=MEMBER_FUNC_POINTER_MAX_SIZE)
     {
         this->m_size = p_size;
         memcpy(this->m_pointer_data,pointerdata,p_size);
     }
     else
     {
         this->m_size = ;
     }
 }

 CMemberFuncPointer::CMemberFuncPointer(void* pointerdata,int p_size)
 {
     if(p_size<=MEMBER_FUNC_POINTER_MAX_SIZE)
     {
         this->m_size = p_size;
         memcpy(this->m_pointer_data,pointerdata,p_size);
     }
     else
     {
         this->m_size = ;
     }
 }

 CMemberFuncPointer::~CMemberFuncPointer()
 {

 }

 bool CMemberFuncPointer::operator==(const CMemberFuncPointer &mfp) const
 {
     if(this->m_size==mfp.m_size) //mfp.m_size 可以访问私有成员
     {
         if(==memcmp(this->m_pointer_data,mfp.m_pointer_data,this->m_size))
         {
             return true;
         }
     }

     return false;
 }

 bool CMemberFuncPointer::operator!=(const CMemberFuncPointer &mfp) const
 {
     if(this->m_size==mfp.m_size) //mfp.m_size 可以访问私有成员
     {
         if(==memcmp(this->m_pointer_data,mfp.m_pointer_data,this->m_size))
         {
             return false;
         }
     }

     return true;
 }

 void CMemberFuncPointer::Get(void *pFunc)
 {
     memcpy(pFunc,this->m_pointer_data,this->m_size);
 }

 void CMemberFuncPointer::Set(const void *pFunc,int p_size)
 {
     memcpy(this->m_pointer_data,pFunc,p_size);
     this->m_size = p_size;
 }

 void CMemberFuncPointer::Reset()
 {
     this->m_size = ;
 }

 CMemberFuncPointer& CMemberFuncPointer::operator =(const CMemberFuncPointer &mfp)
 {
     if(this != &mfp)
     {
         memcpy(this->m_pointer_data,mfp.m_pointer_data,mfp.m_size); //mfp.m_pointer_data 可以访问私有成员
         this->m_size = mfp.m_size;  //mfp.m_size 可以访问私有成员
     }

     return *this;
 }

CMemberFuncPointer.cpp

 // _ss_slot_item.h: interface for the C_ss_slot_item class.
 //
 //////////////////////////////////////////////////////////////////////

 #if !defined(AFX__SS_SLOT_ITEM_H__9F9FE84E_5DDA_480C_88CA_9B8AAB534B07__INCLUDED_)
 #define AFX__SS_SLOT_ITEM_H__9F9FE84E_5DDA_480C_88CA_9B8AAB534B07__INCLUDED_

 #include "ss_type_def.h"
 #include <Afxtempl.h>

 #if _MSC_VER > 1000
 #pragma once
 #endif // _MSC_VER > 1000

 /*
   信号接收对象类: 包括信号接收对象指针,槽接口对象列表
 */

 class C_ss_slot_item
 {
 public:
     int DisConnectSS(CMemberFuncPointer slot_F);
     void Set_SLOTFUNC(SS_STAIC_SLOTFUNC slotfunc);
     int Signal(void *pSrc, void *pDes);
     int Add(CMemberFuncPointer &slot_F);
     void* Get_slotSelf();
     void Set_slotSelf(void *slot_pSelf);
     C_ss_slot_item();
     virtual ~C_ss_slot_item();

 private:
     void* m_slot_pSelf;
     CArray<CMemberFuncPointer*,CMemberFuncPointer*>*m_pMFPArray;
     SS_STAIC_SLOTFUNC m_slot_pFunc;
     CMemberFuncPointer m_curFuncPointer;
 };

 #endif // !defined(AFX__SS_SLOT_ITEM_H__9F9FE84E_5DDA_480C_88CA_9B8AAB534B07__INCLUDED_)

_ss_slot_item.h

 // _ss_slot_item.cpp: implementation of the C_ss_slot_item class.
 //
 //////////////////////////////////////////////////////////////////////

 #include "stdafx.h"
 #include "OverlapRoutine.h"
 #include "_ss_slot_item.h"
 #include <Afxtempl.h>

 #ifdef _DEBUG
 #undef THIS_FILE
 static char THIS_FILE[]=__FILE__;
 #define new DEBUG_NEW
 #endif

 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////

 C_ss_slot_item::C_ss_slot_item()
 {
     this->m_slot_pSelf = NULL;
     this->m_pMFPArray = new CArray<CMemberFuncPointer*,CMemberFuncPointer*>;
     this->m_slot_pFunc = NULL;
 }

 C_ss_slot_item::~C_ss_slot_item()
 {

 }

 void C_ss_slot_item::Set_slotSelf(void *slot_pSelf)
 {
     this->m_slot_pSelf = (void*)slot_pSelf;
 }

 void* C_ss_slot_item::Get_slotSelf()
 {
     return this->m_slot_pSelf;
 }

 int C_ss_slot_item::Add(CMemberFuncPointer &slot_F)
 {
     int len = this->m_pMFPArray->GetSize();
     CMemberFuncPointer *pTemp = NULL;
     for(int i=;i<len;i++)
     {
         pTemp = this->m_pMFPArray->GetAt(i);
         if(*pTemp == slot_F)
         {
             return ;
         }
     }
     pTemp = new CMemberFuncPointer;
     *pTemp = slot_F;
     this->m_pMFPArray->Add(pTemp);
     return ;
 }

 int C_ss_slot_item::Signal(void *pSrc, void *pDes)
 {
     int res = ;
     if(this->m_slot_pFunc!=NULL)
     {
         int len = this->m_pMFPArray->GetSize();
         for(int i=;i<len;i++)
         {
             CMemberFuncPointer tempFP = *(this->m_pMFPArray->GetAt(i));
             if(this->m_curFuncPointer != tempFP)
             {
                 this->m_curFuncPointer = tempFP;
                 this->m_slot_pFunc(this->m_slot_pSelf,tempFP,pSrc,pDes);
                 res+=;
             }  //防止嵌套调用死循环
             this->m_curFuncPointer.Reset();
         }
     }
     return res;
 }

 void C_ss_slot_item::Set_SLOTFUNC(SS_STAIC_SLOTFUNC slotfunc)
 {
     this->m_slot_pFunc = slotfunc;
 }

 int C_ss_slot_item::DisConnectSS(CMemberFuncPointer slot_F)
 {
     int len =  this->m_pMFPArray->GetSize();
     CMemberFuncPointer *pTemp;
     for(int i=;i<len;i++)
     {
         pTemp = this->m_pMFPArray->GetAt(i);
         if(*pTemp==slot_F)
         {
             delete pTemp;
             this->m_pMFPArray->RemoveAt(i);
             return ;
         }
     }
     return ;
 }

_ss_slot_item.cpp

 // _ss_signal_item.h: interface for the C_ss_signal_item class.
 //
 //////////////////////////////////////////////////////////////////////

 #if !defined(AFX__SS_SIGNAL_ITEM_H__CA28EC16_931C_4ACA_8897_0A81B3DA967B__INCLUDED_)
 #define AFX__SS_SIGNAL_ITEM_H__CA28EC16_931C_4ACA_8897_0A81B3DA967B__INCLUDED_

 #include "_ss_signal_func.h"
 #include <Afxtempl.h>

 #if _MSC_VER > 1000
 #pragma once
 #endif // _MSC_VER > 1000
 /*
   信号发起方对象类: 包含发起方对象指针,信号接口对象列表
 */
 class C_ss_signal_item
 {
 public:
     int DisConnectSS(CMemberFuncPointer signal_F, void *slot_pSelf, CMemberFuncPointer slot_F);
     int Signal(CMemberFuncPointer signal_F,void *pSrc, void *pDes);
     void Set_signalSelf(void *signal_pSelf);
     int Add(CMemberFuncPointer &signal_F, void *slot_pSelf, CMemberFuncPointer& slot_F,SS_STAIC_SLOTFUNC slot_pFunc);
     void* Get_signalSelf();
     C_ss_signal_item();
     virtual ~C_ss_signal_item();
 private:
     void* m_signal_pSelf;
     CArray<C_ss_signal_func*,C_ss_signal_func*>*m_pSFArray;
     SS_STAIC_SLOTFUNC m_slotfunc;
 };

 #endif // !defined(AFX__SS_SIGNAL_ITEM_H__CA28EC16_931C_4ACA_8897_0A81B3DA967B__INCLUDED_)

_ss_signal_item.h

 // _ss_signal_item.cpp: implementation of the C_ss_signal_item class.
 //
 //////////////////////////////////////////////////////////////////////

 #include "stdafx.h"
 #include "OverlapRoutine.h"
 #include "_ss_signal_item.h"

 #ifdef _DEBUG
 #undef THIS_FILE
 static char THIS_FILE[]=__FILE__;
 #define new DEBUG_NEW
 #endif

 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////
 C_ss_signal_item::C_ss_signal_item()
 {
     this->m_signal_pSelf = NULL;
     this->m_pSFArray = new CArray<C_ss_signal_func*,C_ss_signal_func*>;
     this->m_slotfunc = NULL;
 }

 C_ss_signal_item::~C_ss_signal_item()
 {

 }

 void* C_ss_signal_item::Get_signalSelf()
 {
     return this->m_signal_pSelf;
 }

 int C_ss_signal_item::Add(CMemberFuncPointer &signal_F, void *slot_pSelf,CMemberFuncPointer& slot_F,SS_STAIC_SLOTFUNC slot_pFunc)
 {
     int len = this->m_pSFArray->GetSize();
     C_ss_signal_func* pTemp=NULL;
     for(int i=;i<len;i++)
     {
         pTemp = this->m_pSFArray->GetAt(i);
         if(pTemp->Get_signal_F()==signal_F)
         {
             return pTemp->Add(slot_pSelf,slot_F,slot_pFunc);
         }
     }

     pTemp = new C_ss_signal_func;
     pTemp->Set_signal_F(signal_F);

     if(==pTemp->Add(slot_pSelf,slot_F,slot_pFunc))
     {
         this->m_pSFArray->Add(pTemp);
         return ;
     }

     delete pTemp;
     return -;
 }

 void C_ss_signal_item::Set_signalSelf(void *signal_pSelf)
 {
     this->m_signal_pSelf = (void*)signal_pSelf;
 }

 int C_ss_signal_item::Signal(CMemberFuncPointer signal_F, void *pSrc, void *pDes)
 {
     int res = ;
     int len = this->m_pSFArray->GetSize();
     C_ss_signal_func *p_signal_func;
     for(int i =;i<len;i++)
     {
         p_signal_func = this->m_pSFArray->GetAt(i);
         if(p_signal_func->Get_signal_F()==signal_F)
         {
             res = p_signal_func->Signal(pSrc,pDes);
             return res;
         }
     }
     return res;
 }

 int C_ss_signal_item::DisConnectSS(CMemberFuncPointer signal_F, void *slot_pSelf, CMemberFuncPointer slot_F)
 {
     int len = this->m_pSFArray->GetSize();
     C_ss_signal_func *pTemp = NULL;
     for(int i=;i<len;i++)
     {
         pTemp = this->m_pSFArray->GetAt(i);
         if(pTemp->Get_signal_F()==signal_F)
         {
             return pTemp->DisConnectSS(slot_pSelf,slot_F);
         }
     }
     return ;
 }

_ss_signal_item.cpp

 // _ss_signal_func.h: interface for the C_ss_signal_func class.
 //
 //////////////////////////////////////////////////////////////////////

 #if !defined(AFX__SS_SIGNAL_FUNC_H__59FB419F_4520_420E_BE2A_D9E6248FD1A1__INCLUDED_)
 #define AFX__SS_SIGNAL_FUNC_H__59FB419F_4520_420E_BE2A_D9E6248FD1A1__INCLUDED_

 #include "_ss_slot_item.h"
 #include "MemberFuncPointer.h"    // Added by ClassView
 #include <Afxtempl.h>

 #if _MSC_VER > 1000
 #pragma once
 #endif // _MSC_VER > 1000

 /*
   信号接口对象类: 包括信号接口对象地址,信号接收对象列表
 */

 class C_ss_signal_func
 {
 public:
     int DisConnectSS(void *slot_pSelf, CMemberFuncPointer slot_F);
     int Signal(void *pSrc, void *pDes);
     void Set_signal_F(CMemberFuncPointer &signal_F);
     int Add(void *slot_pSelf,CMemberFuncPointer &slot_F,SS_STAIC_SLOTFUNC slot_pFunc);
     CMemberFuncPointer& Get_signal_F();
     C_ss_signal_func();
     virtual ~C_ss_signal_func();
 private:
     CMemberFuncPointer m_signal_F;
     CArray<C_ss_slot_item*,C_ss_slot_item*>*m_pSlotArray;
 };

 #endif // !defined(AFX__SS_SIGNAL_FUNC_H__59FB419F_4520_420E_BE2A_D9E6248FD1A1__INCLUDED_)

_ss_signal_func.h

 // _ss_signal_func.cpp: implementation of the C_ss_signal_func class.
 //
 //////////////////////////////////////////////////////////////////////

 #include "stdafx.h"
 #include "OverlapRoutine.h"
 #include "_ss_signal_func.h"

 #ifdef _DEBUG
 #undef THIS_FILE
 static char THIS_FILE[]=__FILE__;
 #define new DEBUG_NEW
 #endif

 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////

 C_ss_signal_func::C_ss_signal_func()
 {
     this->m_pSlotArray = new CArray<C_ss_slot_item*,C_ss_slot_item*>;
 }

 C_ss_signal_func::~C_ss_signal_func()
 {

 }

 CMemberFuncPointer& C_ss_signal_func::Get_signal_F()
 {
     return this->m_signal_F;
 }

 int C_ss_signal_func::Add(void *slot_pSelf,CMemberFuncPointer &slot_F,SS_STAIC_SLOTFUNC slot_pFunc)
 {
     int len = this->m_pSlotArray->GetSize();
     C_ss_slot_item *pTemp=NULL;
     for(int i=;i<len;i++)
     {
         pTemp = this->m_pSlotArray->GetAt(i);
         if(pTemp->Get_slotSelf()==slot_pSelf)
         {
             return pTemp->Add(slot_F);
         }
     }

     pTemp = new C_ss_slot_item;
     pTemp->Set_slotSelf(slot_pSelf);
     pTemp->Set_SLOTFUNC(slot_pFunc);
     if(==pTemp->Add(slot_F))
     {
         this->m_pSlotArray->Add(pTemp);
         return ;
     }

     delete pTemp;
     return -;
 }

 void C_ss_signal_func::Set_signal_F(CMemberFuncPointer &signal_F)
 {
     this->m_signal_F = signal_F;
 }

 int C_ss_signal_func::Signal(void *pSrc, void *pDes)
 {
     int  res = ;
     int len = this->m_pSlotArray->GetSize();
     C_ss_slot_item *p_slot_item;
     for(int i=;i<len;i++)
     {
         p_slot_item = this->m_pSlotArray->GetAt(i);
         res += p_slot_item->Signal(pSrc,pDes);
     }
     return res;
 }

 int C_ss_signal_func::DisConnectSS(void *slot_pSelf, CMemberFuncPointer slot_F)
 {
     int len = this->m_pSlotArray->GetSize();
     C_ss_slot_item *pTemp = NULL;
     for(int i=;i<len;i++)
     {
         pTemp = this->m_pSlotArray->GetAt(i);
         if(pTemp->Get_slotSelf()==slot_pSelf)
         {
             return pTemp->DisConnectSS(slot_F);
         }
     }
     return ;
 }

_ss_signal_func.cpp