Делать было не чего, время было темное.
Пример, что такое диспетчер сообщений. Такой простенький и юзающий STL.
Наврядли подойдет. Т.к. классы используют один тип сообщения. Хотя сообщение можно настроить. Передавать поинтеры например.
TSTBase.h| Код | #ifndef __TST_BASE__
#define __TST_BASE__
#pragma warning(disable:4786) // 'identifier' : identifier was truncated to 'number' characters in the debug information
#include "windows.h"
#include <algorithm>
#include "TSTConst.h"
namespace tst{
typedef DWORD TYPEOBJECT;
typedef DWORD NUMOBJECT;
typedef std::pair<TYPEOBJECT,NUMOBJECT> IDOBJECT;
} //namespace tst
#endif //__TST_BASE__
|
TSTMessage.h
| Код | #ifndef __TST_MESSAGE__
#define __TST_MESSAGE__
#include "TSTBase.h"
namespace tst{
struct cMessage {
DWORD m_wObjType;
DWORD m_wObjId;
DWORD m_dwEvent;
DWORD m_dwParm;
DWORD m_dwParm1;
WORD m_wBackupPortID;
};
typedef std::pair<IDOBJECT,cMessage> MESSAGE;
} //namespace tst
#endif //__TST_MESSAGE__
|
TSTObject.h
| Код | #ifndef __TST_OJECT__
#define __TST_OJECT__
#include "TSTMessage.h"
#include <map> // STL!
namespace tst{
class cDispatcher;
/************************************************************************/
/* class cObject */
/************************************************************************/
class cObject
{
typedef cObject* POBJECT;
typedef std::map<IDOBJECT,POBJECT> OBJECTCONTAINER;
friend class cDispatcher;
public:
cObject(const TYPEOBJECT& TypeObj, const NUMOBJECT& IdObj);
virtual ~ cObject();
TYPEOBJECT GetType() const { return m_ID.first; }
NUMOBJECT GetNum() const { return m_ID.second; }
IDOBJECT GetID() const { return m_ID; }
virtual BOOL ProcessMessage(const cMessage&) = 0;
protected:
IDOBJECT m_ID;
private:
static OBJECTCONTAINER m_ObjConatiner;
};
} //namespace tst
#endif //__TST_OJECT__
|
TSTObject.cpp
| Код | #include "TSTOBJECT.H"
using namespace tst;
cObject::OBJECTCONTAINER cObject::m_ObjConatiner;
/************************************************************************/
/* FUNCTION : cObject( const TYPEOBJECT& TypeObj, */
/* const NUMOBJECT& IdObj) */
/* OBJECT : cObject */
/* PURPOSE : Constructor */
/* PARAMETERS : TypeObj - Type of object */
/* NUMOBJECT - unique number of object */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
cObject::cObject(const TYPEOBJECT& TypeObj, const NUMOBJECT& IdObj):
m_ID(std::make_pair(TypeObj,IdObj))
{
m_ID=std::make_pair(TypeObj,IdObj);
if ( cObject::m_ObjConatiner.find(m_ID) != cObject::m_ObjConatiner.end() ) // ELEM EXIST
{
//std::out_of_range("Elem exist");
}
else
cObject::m_ObjConatiner.insert( OBJECTCONTAINER::value_type(m_ID, this) );
}
/************************************************************************/
/* FUNCTION : ~cObject() */
/* OBJECT : cObject */
/* PURPOSE : Destructor */
/* PARAMETERS : none */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
cObject::~cObject()
{
OBJECTCONTAINER::iterator i= cObject::m_ObjConatiner.find(m_ID);
if ( i != cObject::m_ObjConatiner.end() ) // ELEM EXIST
cObject::m_ObjConatiner.erase(i);
else
throw ("BRED"); // CRITICAL !!!
} |
TSTDispatch.h
| Код | #ifndef __TST_DISPATCH__
#define __TST_DISPATCH__
#include <queue> // STL!
#include "TSTMessage.h"
namespace tst{
void InitDispatcher(); // prototype
void DeInitDispatcher(); // prototype
void Dispatch(); // prototype
void PutMessageMain(const IDOBJECT& Id, const cMessage& Msg); // prototype
void PutMessageMain(const MESSAGE& Msg); // prototype
/************************************************************************/
/* cDispatcher */
/************************************************************************/
class cDispatcher
{
typedef std::queue<MESSAGE> QUEUE;
friend void InitDispatcher();
friend void DeInitDispatcher();
friend void Dispatch();
friend void PutMessageMain(const IDOBJECT& Id, const cMessage& Msg);
friend void PutMessageMain(const MESSAGE& Msg);
void PutMessageMain(const IDOBJECT& Id, const cMessage& Msg);
void PutMessageMain(const MESSAGE& Msg);
cDispatcher() { cDispatcher::m_pDispatcher=this; }
~ cDispatcher() { cDispatcher::m_pDispatcher=NULL; }
cDispatcher(const cDispatcher&);
static cDispatcher* m_pDispatcher;
QUEUE m_MainQueue;
void Dispatch();
};
} //namespace tst
#endif //__TST_DISPATCH__
|
TSTDispatch.cpp
| Код | #include "TSTDISPATCH.H"
#include "TSTObject.h"
using namespace tst;
cDispatcher* cDispatcher::m_pDispatcher=NULL;
/************************************************************************/
/* FUNCTION : InitDispatcher() */
/* OBJECT : none */
/* PURPOSE : Initialization of dispatcher */
/* PARAMETERS : none */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void tst::InitDispatcher()
{
if ( !cDispatcher::m_pDispatcher ) new cDispatcher();
}
/************************************************************************/
/* FUNCTION : DeInitDispatcher() */
/* OBJECT : none */
/* PURPOSE : Deinitialization of dispatcher */
/* PARAMETERS : none */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void tst::DeInitDispatcher()
{
if ( cDispatcher::m_pDispatcher ) delete cDispatcher::m_pDispatcher;
}
/************************************************************************/
/* FUNCTION : Dispatch() */
/* OBJECT : none */
/* PURPOSE : Message dispatch */
/* PARAMETERS : none */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void tst::Dispatch()
{
cDispatcher::m_pDispatcher->Dispatch();
}
/************************************************************************/
/* FUNCTION : PutMessageMain(const IDOBJECT& Id, const cMessage& Msg)*/
/* OBJECT : none */
/* PURPOSE : To put message to main queue */
/* PARAMETERS : Id - id of object */
/* Msg - message */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void tst::PutMessageMain(const IDOBJECT& Id, const cMessage& Msg)
{
cDispatcher::m_pDispatcher->PutMessageMain(Id,Msg);
}
/************************************************************************/
/* FUNCTION : PutMessageMain(const MESSAGE& Msg) */
/* OBJECT : none */
/* PURPOSE : To put message to main queue */
/* PARAMETERS : Msg - message */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void tst::PutMessageMain(const MESSAGE& Msg)
{
cDispatcher::m_pDispatcher->PutMessageMain(Msg);
}
/************************************************************************/
/* FUNCTION : Dispatch() */
/* OBJECT : cDispatcher */
/* PURPOSE : Message dispatch */
/* PARAMETERS : none */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void cDispatcher::Dispatch()
{
while ( !m_MainQueue.empty() )
{
cObject::OBJECTCONTAINER::iterator i=cObject::m_ObjConatiner.find( m_MainQueue.front().first );
if ( i!=cObject::m_ObjConatiner.end() )
i->second->ProcessMessage(m_MainQueue.front().second);
m_MainQueue.pop();
}
}
/************************************************************************/
/* FUNCTION : PutMessageMain(const IDOBJECT& Id, const cMessage& Msg)*/
/* OBJECT : cDispatcher */
/* PURPOSE : To put message to main queue */
/* PARAMETERS : Id - id of object */
/* Msg - message */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void cDispatcher::PutMessageMain(const IDOBJECT& Id, const cMessage& Msg)
{
m_MainQueue.push( std::make_pair( Id, Msg) );
}
/************************************************************************/
/* FUNCTION : PutMessageMain(const MESSAGE& Msg) */
/* OBJECT : cDispatcher */
/* PURPOSE : To put message to main queue */
/* PARAMETERS : Msg - message */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void cDispatcher::PutMessageMain(const MESSAGE& Msg)
{
m_MainQueue.push(Msg);
} |
TSTTimer.h
| Код | #ifndef __TST_TIMER__
#define __TST_TIMER__
#include "TSTObject.h"
#include <list> // STL!
namespace tst{
void InitTimers(); // prototype
void DeInitTimers(); // prototype
void ProcessTimers(); // prototype
IDOBJECT StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg); // prototype
BOOL StopTimer (const IDOBJECT& Id); // prototype
class cTimerContainer;
/************************************************************************/
/* cTimer */
/************************************************************************/
class cTimer: public cObject
{
friend cTimerContainer;
public:
cTimer();
virtual ~ cTimer(){};
virtual BOOL ProcessMessage(const cMessage&) { return TRUE; }
MESSAGE m_Message;
DWORD m_dwInterval;
DWORD m_dwExpirationTime;
static NUMOBJECT m_Next;
};
/************************************************************************/
/* cTimerContainer */
/************************************************************************/
class cTimerContainer
{
typedef std::list<cTimer*> CONTAINER;
friend void InitTimers();
friend void DeInitTimers();
friend void ProcessTimers();
friend IDOBJECT StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg);
friend BOOL StopTimer (const IDOBJECT& Id);
class FindTimeOut // predicate
{
public:
FindTimeOut(const DWORD& Time):m_Time(Time){}
bool operator()(const cTimer *timer1) const;
DWORD m_Time;
};
public:
IDOBJECT StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg);
BOOL StopTimer (const IDOBJECT& Id);
void Process();
protected:
private:
cTimerContainer();
~cTimerContainer();
static cTimerContainer* m_pTimerContainer;
void NormalizeTimers(const DWORD& dwValue);
CONTAINER m_ListTimers;
DWORD m_CountActiveTimer;
DWORD m_dwLastAccess;
};
} //namespace tst
|
TSTTimer.cpp
| Код | #include "TSTTimer.h"
#include "TSTDispatch.h"
#include <algorithm> // STL!
using namespace tst;
NUMOBJECT cTimer::m_Next = NULL;
cTimerContainer* cTimerContainer::m_pTimerContainer = NULL;
/************************************************************************/
/* FUNCTION : cTimer */
/* OBJECT : cTimer */
/* PURPOSE : Constructor */
/* PARAMETERS : none */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
cTimer::cTimer(): cObject(TST_OBJ_TIMER,m_Next)
{
++m_Next; // Next number of timer object
}
/************************************************************************/
/* FUNCTION : InitTimers() */
/* OBJECT : none */
/* PURPOSE : Initialization of class cTimerContainer */
/* PARAMETERS : none */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void tst::InitTimers()
{
if ( !cTimerContainer::m_pTimerContainer ) new cTimerContainer();
}
/************************************************************************/
/* FUNCTION : DeInitTimers() */
/* OBJECT : none */
/* PURPOSE : DeInitialization of class cTimerContainer */
/* PARAMETERS : none */
/* RETURN VALUE: none */
/* COMMENT : none */
/************************************************************************/
void tst::DeInitTimers()
{
if ( cTimerContainer::m_pTimerContainer ) delete cTimerContainer::m_pTimerContainer;
}
IDOBJECT tst::StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg)
{
return cTimerContainer::m_pTimerContainer->StartTimer(Interval,Id,Msg);
}
BOOL tst::StopTimer (const IDOBJECT& Id)
{
return cTimerContainer::m_pTimerContainer->StopTimer(Id);
}
void tst::ProcessTimers()
{
cTimerContainer::m_pTimerContainer->Process();
}
cTimerContainer::cTimerContainer():m_CountActiveTimer(0UL)
{
m_pTimerContainer=this;
m_dwLastAccess=GetTickCount();
}
cTimerContainer::~cTimerContainer()
{
for ( CONTAINER::iterator i=m_ListTimers.begin(); i!=m_ListTimers.end(); ++i )
{
delete (*i);
--m_CountActiveTimer;
}
m_ListTimers.clear();
m_pTimerContainer=0;
}
IDOBJECT cTimerContainer::StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg)
{
cTimer* Temp= new cTimer();
Temp->m_Message=std::make_pair(Id,Msg);
Temp->m_dwExpirationTime = GetTickCount()+Interval;
m_ListTimers.push_back( Temp );
++m_CountActiveTimer;
return Temp->GetID();
}
class findID
{
public:
findID(const IDOBJECT& Id):m_ID(Id){}
bool operator()(const cTimer *timer1)
{
return timer1->GetID() == m_ID;
}
IDOBJECT m_ID;
};
BOOL cTimerContainer::StopTimer(const IDOBJECT& Id)
{
CONTAINER::iterator i = std::find_if( m_ListTimers.begin(),m_ListTimers.end(),findID(Id) );
if ( i!=m_ListTimers.end() )
{
m_ListTimers.erase(i);
delete (*i);
--m_CountActiveTimer;
return TRUE;
}
return FALSE;
}
bool cTimerContainer::FindTimeOut::operator()(const cTimer *timer1) const
{
if ( timer1->m_dwExpirationTime <= m_Time )
PutMessageMain(timer1->m_Message);
return timer1->m_dwExpirationTime <= m_Time;
}
void cTimerContainer::Process()
{
DWORD dwTime=GetTickCount();
if(dwTime < m_dwLastAccess) NormalizeTimers(m_dwLastAccess);
m_dwLastAccess=dwTime;
m_ListTimers.remove_if( FindTimeOut(dwTime) );
}
void cTimerContainer::NormalizeTimers(const DWORD& dwValue)
{
for ( CONTAINER::iterator i=m_ListTimers.begin(); i!=m_ListTimers.end(); ++i )
(*i)->m_dwExpirationTime -= dwValue;
}
|
А вот его использование:
MAIN.CPP
| Код | #include "TSTDispatch.h"
#include "TSTTimer.h"
#define TST_OBJ_TEST 0x100
class cTest:public tst::cObject
{
public:
cTest():cObject(TST_OBJ_TEST,m_Next)
{
++m_Next;
}
~cTest(){}
BOOL ProcessMessage(const tst::cMessage& Msg)
{
printf("\nProcessMessage:");
printf("\n TYPEOBJECT = %08X",GetType());
printf("\n NUMOBJECT = %08X",GetNum());
return TRUE;
}
tst::IDOBJECT StartTimer(DWORD Int)
{
tst::cMessage Msg;
return tst::StartTimer(Int,GetID(),Msg);
}
protected:
private:
static tst::NUMOBJECT m_Next;
};
tst::NUMOBJECT cTest::m_Next=0;
int main(int argc, char* argv[])
{
printf("Hello World!\n");
tst::InitDispatcher();
tst::InitTimers();
cTest Test;
Test.StartTimer(1000);
Test.StartTimer(1500);
Test.StartTimer(2000);
while (true) {
tst::ProcessTimers();
tst::Dispatch();
}
return 0;
} |
Этот простенький примерчик посылает сообщения другим объектам по таймеру. Т.е. один объект посылает сообщение другому объекту. Этот другой принимает сообщение через определенное время. В общем реальный диспетчер 
З.Ы.: Народ! По-критикуйте плиз  Буду очень благодарен за критику. |
