Discussion :

[olive_le_malin]

Bonjour,

j'ai besoin d'un conseil concernant l'architecture d'un programme en C++.

Ce Prog "prog_main" discute (sockets TCP/IP Client/Serveur) avec 3 types de programmes :
- les "prog_type1"
- les "prog_type2"
- les "prog_type3"
Le nombre d'instance de chacun de ces types de prog n'est pas défini à priori.
Chacun de ces 3 types de prog a ses spécificités.

Donc voilà comment j'ai abordé le truc.
J'ai crée une Classe Interface CIntTypeX pour chacun des 3 types de prog, et une classe CTypeX pour chaque type de prog.
Chacune des classes CTypeX dérive d'une classe CType, qui représente les données communes à chacun.

Ainsi mon programme CMain appelle et utilise les 3 interfaces CIntType1, CIntType2 et CIntType3 (qui sont des singleton), et ce sont elles qui se chargent de gérer leur liste de CTypeX

Exemple :

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
 
class CType1 : CType
{
private:
SOCKET m_skt;
....
public:
CType1() : CType(), m_skt(0) {};
Init();
 
//Envoi un message
void SendMsg(const std::string& msg)
{
     send(m_skt, msg.c_str, msg.size());
}
 
};
 
 
class CIntCType1
{
private :
std::list<CType1*> m_listCType1;
int m_data1;
CIntCType1() : m_data1(0) {}
 
public:
~CIntCType1() {}
 
static CIntCType1& GetInterface1 {
static CIntCType1 inst;
return inst;
 
//Envoi un message au prog CType1 n° "num"
void SendMsg(const std::string& msg, int num)
{
CType1* pProg = GetProg(num);
pProg->SendMsg(msg);
}
 
//Récupère le prog CType1 n° num de la liste
CType1* GetProg(int num)
{
//parcours de la liste avec un find_if + prédicat
}
 
...
...
};

Est-ce que j'ai été assez clair ?

Que pensez-vous de cette façon de faire par rapport à la situation ??
Comment feriez-vous ?

Merci par avance.
@+

[olive_le_malin]

Bonjour,

est-ce que j'ai mal exposé mon problème ?

@+

[r0d]

Je ne comprends pas trés bien, mais en ce moment je ne suis pas en forme

* Les programmes qui discutent avec ton prog_main doivent-ils discuter également entre eux?
* Je ne comprend pas pourquoi tu as besoin de tout ce mécanisme d'héritage. Car si tes clients balancent leurs infos sur un port donné, et que le serveur récupère ces infos, je ne vois pas pourquoi tu as besoin d'en savoir plus.

[olive_le_malin]

* Les programmes qui discutent avec ton prog_main doivent-ils discuter également entre eux?

--> Non

* Je ne comprend pas pourquoi tu as besoin de tout ce mécanisme d'héritage. Car si tes clients balancent leurs infos sur un port donné, et que le serveur récupère ces infos, je ne vois pas pourquoi tu as besoin d'en savoir plus.

Je comprends ton interrogation.
Voilà, chaqun de ces clients à ses infos propres, et notamment son type de gestion C / S. Par exemple le client1 se gère en dialogue synchrone, alors que le client 2 se gère en asynchrone, avec création d'un thread de dialogue retour.

Ensuite, il y a également un envoi de trames par le prog principal vers les progs satellites en fonction de certains évènement liés au programme lui-même.
En effet, le prog principal réalise un pilotage d'un autocom au moyen de la norme TAPI, et en fonction de l'état de certains appels, il renvoie des "tickets" vers certains de ces prog satellites.


Donc je ne peux pas simplement me limiter à récupérer des trames venant de ces clients et à les traiter sans chercher à en savoir +.

J'espère que ça a un peu eclairé ...
@+

[olive_le_malin]

Personne ne peut me conseiller ?