Parser des commandes (recv) proprement/efficacement ?

Version imprimable

Bonjour, je me permet de poster cette question, j'ai créer un petit programme client /serveur en C++. Cependant je me demandais si il y avait en C++ un moyen de parser proprement les commandes que je réceptionne avec rcv() pour éviter de me retrouver avec des if() else() à rallonge.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
void MyTCPclient::parseCommande(char * buffer) {
	if (strcmp ("com1",buffer) != 0) {
		// appel fonction MyTCPclient::com1
	}
	if (strcmp ("com2",buffer) != 0) {
		// appel fonction MyTCPclient::com1
	}
	if (strcmp ("com3",buffer) != 0) {
		// appel fonction MyTCPclient::com1
	}
...
}

Pour avoir plutot un truc du genre (JAVA):

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
 
package test;
 
import java.lang.reflect.Method;
 
public class ClassMethodTest {
 
	public static void main(String args[]) throws Exception {
 
		Testing t = new Testing("val1", false);
		Class tClass = t.getClass();
 
		Method gs1Method = tClass.getMethod("getString1", new Class[] {});
		String str1 = (String) gs1Method.invoke(t, new Object[] {});
		System.out.println("getString1 returned: " + str1);
 
		Method ss1Method = tClass.getMethod("setString1", new Class[] { String.class });
		System.out.println("calling setString1 with 'val2'");
		ss1Method.invoke(t, new Object[] { "val2" });
 
		str1 = (String) gs1Method.invoke(t, new Object[] {});
		System.out.println("getString1 returned: " + str1);
 
	}
}
}

En gros de pouvoir appeler toutes mes méthodes seulement en une condition. (je sais pas si c'est très clair ce que je raconte :aie:)

02/11/2015, 14h13
Médinoc

En C++/CLI, tu peux récupérer une méthode de classe par son nom, mais je ne le conseillerais pas de toute façon.
Utilise un Dictionary<String^, Delegate^> à la place. Et utilise quelque chose de plus évolué que recv().

...Ou en C++11 natif, tu peux utiliser une std::map<std::string, std::function<(prototype commun à toutes tes fonctions de traitement)> >.
03/11/2015, 11h55
Hellgast

Citation:

Envoyé par Médinoc

En C++/CLI, tu peux récupérer une méthode de classe par son nom, mais je ne le conseillerais pas de toute façon.
Utilise un Dictionary<String^, Delegate^> à la place. Et utilise quelque chose de plus évolué que recv().

...Ou en C++11 natif, tu peux utiliser une std::map<std::string, std::function<(prototype commun à toutes tes fonctions de traitement)> >.

Quelle serait une solution plus évolué que recv(), sachant que j'utilise du C++ natif ?

Je vais testé la solution avec std::map, cependant je me demandais si mes fonctions ont chacune un type différents si cela fonctionnerait ?
03/11/2015, 13h08
Médinoc

Si tu programmes en C++ natif, pourquoi postes-tu dans la section consacrée au langage C++/CLI? :roll:

Citation:

je me demandais si mes fonctions ont chacune un type différents si cela fonctionnerait

Hélas non. Le plus simple sera de faire, pour chaque fonction, une fonction qui récupère les différents arguments puis appelle l'original (dans le milieu des Appels de Procédure Distante, on appelle ça un "stub").
Si tu programmes en C++11, tu devrais pouvoir faire ça assez facilement avec des fonctions lambda.
03/11/2015, 14h32
bacelar

Regardez du coté du Design Pattern "Command". :weird:
04/11/2015, 22h58
Hellgast

Citation:

Envoyé par Médinoc

Si tu programmes en C++ natif, pourquoi postes-tu dans la section consacrée au langage C++/CLI? :roll:

Hélas non. Le plus simple sera de faire, pour chaque fonction, une fonction qui récupère les différents arguments puis appelle l'original (dans le milieu des Appels de Procédure Distante, on appelle ça un "stub").
Si tu programmes en C++11, tu devrais pouvoir faire ça assez facilement avec des fonctions lambda.

Heu oui .. je viens de me rendre compte que je me suis trompé de section de forum... (boulet le type :aie: j'ai voulu allé trop vite )
M'enfin les réponses attisent ma curiosité, je peux trouver de la doc sur le site à propos des "stubs" ?
Si vous avez des liens utiles je suis preneurs.

En gros, le proxy et le stub sont deux objets qui servent d'intermédiaires, et donc le code est le plus souvent généré par des outils (je prends l'exemple de Java ici, qui marche ainsi pour son procédé de Remote Method Invocation (RMI)).

Si je pars de cet exemple:

Code:

1
2
3
4
5
6
class Machin
{
public:
	void Hello(void);
	int FaireTruc(string const &chn, int a, int b);
};

Le proxy, c'est ce qu'il y a côté client, qui fera un truc de ce genre:

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
class MachinProxy
{
private:
	Reseau& monReseau;
	int monId;
public:
	MachinProxy(Reseau& reseau, int id) : monReseau(reseau), monId(id) { }
 
	void Hello(void) {
		Appel appel;
		appel.SetThisId(monId);
		appel.SetNomMethode("Hello");
		monReseau.AppelDistant(appel);
	}
	int FaireTruc(string const &chn, int a, int b) {
		Appel appel;
		appel.SetThisId(monId);
		appel.SetNomMethode("FaireTruc");
		appel.SetString(0, chn);
		appel.SetInt(1, a);
		appel.SetInt(2, b);
		monReseau.AppelDistant(appel);
		return appel.GetInt(Appel::Retour);
	}
};

Le stub, c'est ce qu'il y a côté client, qui fera un truc du genre:

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
class MachinStub : public StubBase //Doit forcément être le premier et non-virtuel
{
private:
	Machin& leVraiMachin;
public:
	MachinStub(Machin& machin) : StubBase(), leVraiMachin(machin) { }
 
	virtual map<string, PtrFonction> GetMap()
	{
		map<string, PtrFonction> ret;
		ret["Hello"] = static_cast<PtrFonction>(&MachinStub::Hello); //Ça DOIT passer avec static_cast, sinon ça veut dire qu'on fait n'importe quoi.
		ret["FaireTruc"] = static_cast<PtrFonction>(&MachinStub::FaireTruc);
	}
 
private:
 
	void Hello(Appel &appel) {
		(void)appel; //Hello est une fonction void(void), rien à traiter ici
		leVraiMachin.Hello();
	}
	void FaireTruc(Appel &appel) {
		int retour = leVraiMachin.FaireTruc(appel.GetString(0), appel.GetInt(1), appel.GetInt(2));
		appel.SetInt(Appel::Retour, retour);
	}
};

Attention par contre, c'est du code pré-C++11, on doit probablement pouvoir faire beaucoup plus propre de nos jours avec std::function<>, au niveau de remplissage de la map.

Je joins le code complet que j'ai utilisé pour modéliser mon exemple. Il compile, mais il foire probablement à l'édition de liens, vu que rien n'est implémenté.

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
#include <string>
#include <exception>
#include <map>
using namespace std;
 
class Machin
{
public:
	void Hello(void);
	int FaireTruc(string const &chn, int a, int b);
};
 
class Appel
{
public:
	static const int Retour = -1;
	void SetNomMethode(string nom);
	void SetThisId(int id);
	void SetInt(int index, int valeur); 
	void SetString(int index, string valeur);
 
	string GetNomMethode() const;
	int GetThisId() const;
	int GetInt(int index) const;
	string GetString(int index) const;
private:
	//Blabla implémentation
};
 
class Reseau
{
public:
	void AppelDistant(Appel &);
};
 
class MachinProxy
{
private:
	Reseau& monReseau;
	int monId;
public:
	MachinProxy(Reseau& reseau, int id) : monReseau(reseau), monId(id) { }
 
	void Hello(void) {
		Appel appel;
		appel.SetThisId(monId);
		monReseau.AppelDistant(appel);
	}
	int FaireTruc(string const &chn, int a, int b) {
		Appel appel;
		appel.SetThisId(monId);
		appel.SetString(0, chn);
		appel.SetInt(1, a);
		appel.SetInt(2, b);
		monReseau.AppelDistant(appel);
		return appel.GetInt(Appel::Retour);
	}
};
 
class StubBase
{
protected:
	typedef void(StubBase::*PtrFonction)(Appel &appel); //En C++11, on peut probablement utiliser std::function<void(Appel&)> à la place
 
	virtual map<string, PtrFonction> GetMap() = 0;
private:
	map<string, PtrFonction> maMap;
public:
	void Initialiser() { //Doit être appelée APRÈS avoir construit l'objet complètement
		maMap = GetMap();
	}
 
	void TraiterAppel(Appel& appel) {
		PtrFonction ptr = maMap[appel.GetNomMethode()];
		if(!ptr)
			throw exception("Méthode inconnue");
 
		(this->*ptr)(appel);
	}
};
 
class MachinStub : public StubBase //Doit forcément être le premier et non-virtuel
{
private:
	Machin& leVraiMachin;
public:
	MachinStub(Machin& machin) : StubBase(), leVraiMachin(machin) { }
 
	virtual map<string, PtrFonction> GetMap()
	{
		map<string, PtrFonction> ret;
		ret["Hello"] = static_cast<PtrFonction>(&MachinStub::Hello); //Ça DOIT passer avec static_cast, sinon ça veut dire qu'on fait n'importe quoi.
		ret["FaireTruc"] = static_cast<PtrFonction>(&MachinStub::FaireTruc);
	}
 
private:
 
	void Hello(Appel &appel) {
		(void)appel; //Hello est une fonction void(void), rien à traiter ici
		leVraiMachin.Hello();
	}
	void FaireTruc(Appel &appel) {
		int retour = leVraiMachin.FaireTruc(appel.GetString(0), appel.GetInt(1), appel.GetInt(2));
		appel.SetInt(Appel::Retour, retour);
	}
};

Si ton but ultime est de re-créer une telle infrastructure, je rappelle qu'il conviendrait d'y inclure un utilitaire qui génère, à partir de la classe Machin, les fichiers MachinProxy.cpp et MachinStub.cpp.