Discussion :

[Mehyan]

Salut,
Information :
Pour un projet en cours j'ai implémenté dans une classe existante une méthode event() et un liste contenant des action à faire.

En gros, pour certain Event une action est crée et sera traitée par une autre méthode ProcessAction().

Actuellement vu, le nombre d'event et d'action possible voila ce que je fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
enum e_EventType
{
    EVENT_PLAYER_LEAVE           ,
    EVENT_GROUP_LEAVE            ,
    EVENT_PLAYER_LOG_ON         ,
    EVENT_PLAYER_LOG_OFF        ,
    ...
};
 
struct s_ActionMsg
{
    e_ActionType        Action;
    OGuid               Guid;
    uint32              Uint32Value;
    uint32              Uint32Value2;
	...
    s_LfgActionMsg(e_ActionType action, OGuid guid, uint32 uvalue = 0, uint32 uvalue2 = 0)
    {
        Action = action;
        Guid = guid;
        Uint32Value = uvalue;
        Uint32Value2 = uvalue2;
    }
    s_ActionMsg(e_ActionType action, uint32 uvalue = 0, uint32 uvalue2 = 0)
    {
        Action = action;
        Uint32Value = uvalue;
        Uint32Value2 = uvalue2;
    }
	...
};
 
class myclass
{ 
    ...
    Event(e_EventType eventType, OGuid guid=OGuid(), uint32 uintValue1 = 0, uint32 uintValue2 = 0);
    ...
    ProcessAction();
}
 
// dans le code
 
 
void myclass::Event(e_EventType eventType, Guid guid, uint32 uintValue1, uint32 uintValue2)
{
    switch (eventType)
    {
    case EVENT_PLAYER_LOG_ON :
        {
            ....
            break;
        }
 
    case EVENT_PLAYER_LOG_OFF :
        {
            s_ActionMsg* actionMsg = new s_ActionMsg(ACTION_REMOVE_PLAYER, guid, 15);
            m_ActionMsgList.Add(actionMsg);
            break;
        }
 
    case EVENT_PLAYER_LEAVE :
        {
            s_ActionMsg* actionMsg = new s_ActionMsg(ACTION_REMOVE_PLAYER, guid);
            m_ActionMsgList.Add(actionMsg);
            break;
		}
		...
	}
}

La methode ProcessAction est en fait un thread à part.
Tout fonctionne mais ce n'est pas beau...
1 : Lorsque j'appelle la fonction Event.
J'ai reussi à me limitter à 4 paramettre jusqu'ici. Mais si je dois appeler Event et transmettre un nouveau type de donnée je devrais l'ajouter...
Je ne pense pas que "Event(e_EventType eventType, OGuid guid=OGuid(), uint32 uintValue1 = 0, uint32 uintValue2 = 0, char* nchar=NULL);" soit plus propres...
Je pourrais appeler Event avec le pointeur d'un structure ce serais plus propre mais...
L'appel de Event se fait naturelement en dehors de la classe, je devrais donc definir une structure utilisable dans tout le programme pour l'Event.
Mais aussi je me confrontrerai au même problème que ce qui suis...

2 : La structure s_ActionMsg.
J'ai bien aimé l'utilisation de constructeur forcé, ca me fait un code très propre et lisible.
Malheureusement je me heurte au même problèmes que précedement. A chaque nouveau type de donnée dont j'ai besoin je devrais l'ajouté à la structure.
C'est pas bien grave quand on utilise 4 variable avec des type de données standard comme dans l'exemple mais dans la pratique ce n'est pas le cas.
J'ai une 10 aines de possibilité avec quelques classes complexe dont j'ai besoin d'une copie integrale dans le message. (appel au constructeur)
Si j'ai besoin d'une action qui ne necessite pas de paramettre, j'aimerais eviter que lors du "new" les autres classes soient créee pour rien.

Bref ce type d'implementation est limité que me conseillé vous comme piste?

[Mat007]

Salut,

Ça va peut-être te paraître un peu complexe (et ça utilise fortement boost et c'est pas thread-safe) mais ça peut peut-être te donner des idées sur ce qu'il est possible de faire : controller.hpp et event.hpp
Les tests unitaires sont dans controller_test.cpp pour voir comment ça s'utilise...

MAT.

[Mehyan]

Merci pour votre intervention.
Dure dure effectivement :p Mais je vais étudier cela au moins pour comprendre le fonctionnement.

Néanmoins, dans mon exemple m_ActionMsgList est une classe thread safe. Absolument nécessaire... Mais votre code est peu être adaptable.
Ce qui m'inquiète surtout c'est la portabilité de ce code...

[vikki]

Tu peux reprendre cet exemple en utilisant boost.signal2 qui lui est thread safe (au moins pour la partie connexion/deconnexion des slots). Et rien ne t'empêche d'ajouter tes propres systèmes de lock dans les partie sensibles.
Concernant la portabilité, je fait personnellement plus confiance à boost qu'à un code maison, y compris (surtout) le mien.

[r0d]

Sinon tu peux faire un pattern command tout simple. Quelque chose du style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct IEventParam{}; // structure de base vide, juste pour permettre la généricité
 
struct IEvent // I pour interface
{
   virtual void Execute( IEventParam * param ) = 0; 
}; 
 
struct ExampleParam : public IEventParam
{
   std::string name;
};
 
struct ExampleEvent : public IEvent
{
   void Execute( IEventParam * param )
   {
      std::cout << ((ExampleParam*) param)->name << std::endl;
   }
};

c'est pas super élégant, mais c'est ce qu'il y a de plus simple. Avec la possibilité de mettre tes Events dans un conteneur (grace à "l'interface" IEvent).

Après, pour que ce soit thread safe, de toutes façon il va falloir que tu gères ça un minimum dans ton propre code. Et c'est pas ce qu'il y a de plus simple.

[Mehyan]

Je pense avoir trouvé un compromis pour l'appel de ma fonction Event.
J'utilise la possibilité d'avoir une liste d'argument variable.
Grâce a l'ID de l'event je connais les types de donnée présent donc je n'ai plus qu'a les récupérer. Je peu ajouter autant d'argument que je veux.

Par contre concernant la liste d'action j'avoue que je tourne en rond concernant les data que je devrais transmettre en plus de l'ID de l'action.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
struct myData
{
    int         myInt;
    bool        myBool;
 
    someType    data;
 
    myData(const int& intValue, const bool& boolValue, const someType& dataValue)
    {
        myInt = intValue;
        myBool = boolValue;
        data = dataValue;        
    }
}
 
std::list < myData* > myList;
 
...
 
main
{
    myData* d = new myData(5, true, 1);
    myList.push_back(d);
    d = new myData(5, true, "hello");
    myList.push_back(d);
    ...
}

Existe t'il une possibilité d'évité l'utilisation de pointeur void* (et bien sur des new et delete associé) pour someType?

J'ai travailler autour des template mais je n'ai rien trouver de concluant.