[Conception] Implémentation d'un gestionnaire d'événements

Version imprimable

Bonjour à tous,

j'ai besoin d'implémenter un gestionnaire d'événements, et il y a plusieurs points qui me posent problème.

D'abord, quelques specs:
-> l'appli n'utilise qu'un seul thread, donc pas besoin de gérer le multi-thread
-> un evenement tel que je le conçoit (peut-être que je me trompe ici) se définit par:
. une classe cible
. une fonction membre de cette classe cible
. zéro, un ou deux paramètre(s) de type string et/ou int

Voici une ébauche de mon gestionnaire d'événements tel que j'aimerais l'implémenter:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class EventManager { public: int PushFront( Event evt ) // ajoute un evenmt en fin de liste {eventList.push_front(evt);} int PushBack( Event evt ); // ajoute un evenmt en debut de liste {eventList.push_back(evt);} void ExecuteEvents(); // execute sequentiellement tous les evenmts private: std::list<Event> eventList; };
En gros j'ai 2 ou 3 classes susceptibles d'exécuter des évéments.
Un événement doit pouvoir être créé n'importe où dans le code (dans n'importe quelle classe) et ajouté au gestionnaire d'événement.

Le but c'est qu'au final, le code de EventManager::ExecuteEvents() ressemble à ça:
Code:

1 2 3 4 5 /*static*/ void ExecuteEvent(Event &event){event.Execute();} void EventManager::ExecuteEvents() { for_each( eventList.begin(), eventList.end(), ExecuteEvent ); }
Seulement voilà, je ne parviens pas à trouver une façon d'implémenter la classe Event pour pouvoir faire ça.

Je n'ai pas réussi à trouver grand chose sur le net à ce sujet (et puis la connexion que j'ai en ce moment ne facilite pas la recherche...).

Qu'en pensez-vous?

12/11/2007, 19h57
Alp

Tu aurais recours à boost ? (boost.signal, boost.bind, boost.function)
Auquel cas tu fais ta liste, tu déclenches les signaux et tous les "callbacks" sont appelés.

Il y a deux possibilités : soit tu considères un Event comme un boost.signal, soit tu le considères comme un pont entre un boost.signal lié à une instance de celui qui déclenche le signal et un callback lié à l'instance qui exécutera ce callback.

Salut,
je dirait que cette partie est mauvaise
Citation:
Envoyé par r0d
Code:

1 2 3 4 5 /*static*/ void ExecuteEvent(Event &event){event.Execute();} void EventManager::ExecuteEvents() { for_each( eventList.begin(), eventList.end(), ExecuteEvent ); }
Je pense que un truc comme ExecuteNextEvent() appeler dans une boucle infinie est meilleur. Tu pourra ainsi ajouter des evenement plus important pendant l'execution. Et ce que tu as écrit je l'appellerai ExecuteAllEvent().
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 class EventManager { public: int PushFront( Event evt ,Priority) // ajoute un evenmt en fin de liste int PushBack( Event evt ); // enlève un evenmt en debut de liste void ExecuteNextEvents(); // execute l' evenement prioritaire et l'enlève void ExecuteAllEvent();// execute tous les eveemnt et les enlève private: std::multimap<Event> eventList; }; . . . int main() { EventManager myEventManager; ... while (1) { ... myEventManager.ExecuteNextEvents(); ... } return 0; } }

13/11/2007, 09h35
befalimpertinent

Citation:

Un événement doit pouvoir être créé n'importe où dans le code (dans n'importe quelle classe) et ajouté au gestionnaire d'événement.

Pour cela une bonne solution serait d'en faire un singleton.
13/11/2007, 10h03
r0d

Citation:

Envoyé par Alp

Tu aurais recours à boost ? (boost.signal, boost.bind, boost.function)
Auquel cas tu fais ta liste, tu déclenches les signaux et tous les "callbacks" sont appelés.

Il y a deux possibilités : soit tu considères un Event comme un boost.signal, soit tu le considères comme un pont entre un boost.signal lié à une instance de celui qui déclenche le signal et un callback lié à l'instance qui exécutera ce callback.

Ok, c'est une bonne idée, je vais voir ça. :merci:

Citation:

Envoyé par Mongaulois

Salut,
je dirait que cette partie est mauvaise

Je pense que un truc comme ExecuteNextEvent() appeler dans une boucle infinie est meilleur. Tu pourra ainsi ajouter des evenement plus important pendant l'execution. Et ce que tu as écrit je l'appellerai ExecuteAllEvent().

Mmhh. Ca me plait pas... En fait, je voudrais pouvoir exécuter ma pile d'événement a un instant donné, mais pas de façon continue. En je tiens à rester en single-thread. Tu vois ce que je veux dire?

Citation:

Envoyé par befalimpertinent

Pour cela une bonne solution serait d'en faire un singleton.

En effet, c'est ce que je comptais faire :)
13/11/2007, 10h27
yan

Citation:

Envoyé par r0d

Mmhh. Ca me plait pas... En fait, je voudrais pouvoir exécuter ma pile d'événement a un instant donné, mais pas de façon continue. En je tiens à rester en single-thread. Tu vois ce que je veux dire?

C'est pour cela que j'avais mis aussi void ExecuteAllEvent();
Tu aura ainsi les deux methodes.
13/11/2007, 11h29
Davidbrcz

Même si tu te fiche du MT, fait attention à ne pas avoir de la singletonite aigu.

Bon, je suis parvenu à faire ce que je souhaitais grâce à boost.
Voici mon code de test, pour ceux que ça intéresse:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#include <iostream>
#include <list>
 
#include <boost/function.hpp>
 
// GPoint est une structure dont une instance va être passée en paramètre à
// la fonction appelée par l'event
struct GPoint
{
	GPoint(int px = 0, int py = 0) : x(px), y(py) {}
	int x,y;
};
 
// Target1 et Target2 sont des classes qui contiennent une fonction (f1 et f2) qui sera appelée par l'event
class Target1
{
public:
	Target1(int a = 0) : _i (a) {}
 
	// Add est la fonction qui va être appelée par l'event
	void f1(GPoint pt)	{
		_i = pt.x + pt.y;
	}
 
	void Print(){std::cout << "i = " << _i << std::endl;}
 
private:
	int _i;
};
 
class Target2
{
public:
	Target2(int a = 0) : _i (a) {}
 
	// Add est la fonction qui va être appelée par l'event
	void f2(GPoint pt)	{
		_i = pt.x - pt.y;
	}
 
	void Print(){std::cout << "i = " << _i << std::endl;}
 
private:
	int _i;
};
 
// classe abstraite IEvent (indispensable pour stocker les events dans un conteneur)
class IEvent
{
public:
	virtual void Execute() = 0;
};
 
// la classe event
template <typename TargetObjType, typename ParamObjType>
class GEvent : public IEvent
{
public:
	// le constructeur
	GEvent( TargetObjType* pTargetObj,
		boost::function<void (TargetObjType*, ParamObjType)> targetFunc,
		ParamObjType param):_targetObj(pTargetObj), _targetFunc(targetFunc),_param(param)
	{}
 
	// la fonction Execute
	void Execute(){
		_targetFunc( _targetObj, _param );
	}
 
private:
	TargetObjType*	_targetObj;
	boost::function<void (TargetObjType*, GPoint)>	_targetFunc;
	ParamObjType	_param;
};
 
// un exemple d'utilisation
int main(int argc, char* argv[])
{
	// création d'instances des classes cibles	
	Target1* pTarget1 = new Target1();
	Target2* pTarget2 = new Target2();
 
	// affichage de l'état des classes cibles
	pTarget1->Print();
	pTarget2->Print();
 
	// création de 2 evenements
	GEvent<Target1, GPoint> *evt1 = new GEvent<Target1, GPoint>(pTarget1, &Target1::f1, GPoint(10,20) );
	GEvent<Target2, GPoint> *evt2 = new GEvent<Target2, GPoint>(pTarget2, &Target2::f2, GPoint(1,2) );
 
	// stockage des evenements dans une liste
	std::list<IEvent*> l;
	l.push_back( evt1 );
	l.push_back( evt2 );
 
	// execution des evenements
	for ( std::list<IEvent*>::iterator it = l.begin();
		it != l.end();
		it++ )
	{
		(*it)->Execute();
	}
 
	// affichage de l'état des classes cibles
	pTarget1->Print();
	pTarget2->Print();
 
	std::cin.get();
	return 0;
}