Discussion :

[manticore]

Bonjour,

j'ai un problème de conception que je n'arrive pas à résoudre d'une façon qui me conviennent.

Je dois gérer différentes protocoles qui me viennent d'un buffer.

Exemple :
1. Je reçois des données brutes
2. Je les passe à une classe qui va me permettre d'accéder aux différents champs selon la pile de protocole (Exemple IPv4/TCP/HTTP).

Mon problème est la conception des classes jusqu'à présent je ne gérait qu'un protocole et j'avais une structure qui ressemblait à :

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
 
Class TCP
{
   TCP(char* data);
   //...
}
 
Class IPv4 : public TCP
{
   IPv4 (char* data);
//...
}
 
Class IPv6 : public TCP
{
   IPv6 (char* data);
//...
}
 
Class Http : public IPv4
{
   Http(char* data);
  // ...
}
 
Class Http : public IPv6
{
   Http(char* data);
  // ...
}

Le problème avec cette architecture et qu'à chaque fois que je rajoute un protocole c'est comme si j'ajoutais une branche à un arbre et je dois créer x classes. Cela n'est pas viable si le projet se développe.

Est-ce qu'il existe des outils en c++ qui permettent de résoudre ce problème ? Ou une meilleur conception ?

Sachant que je veux toujours accéder aux données brute


Merci de votre aide.

p.s. je sais que la logique dirait d'avoir des héritages dans le sens des couches OSI, mais je ne vais gérer que le TCP. Donc je préfère hériter de TCP.

[jblecanard]

Salut !

En quoi est-ce un problème ? Tu devras bien écrire du code spécifique à chaque protocole. Donc il faudra ranger ce code spécifique quelque part. Et dans une classe me paraît assez pertinent.

Ce qui va influer la conception ici, c'est ce que fait le reste du code avec ces classes, et là tu ne nous donnes pas trop d'infos. Dans l'idéal, il te faut une interface commune à toute les classes qui est manipulée par le reste du code. Ensuite tu n'as plus qu'à écrire un builder ou une factory qui est fonction du stream sera en mesure de le stocker dans la bonne classe sous-jacente.

Difficile de proposer plus sans mieux connaître le contexte

[manticore]

En quoi est-ce un problème ? Tu devras bien écrire du code spécifique à chaque protocole. Donc il faudra ranger ce code spécifique quelque part. Et dans une classe me paraît assez pertinent.

En faite, je pensais avoir un héritage entre les protocoles pour créer un paquet qui contient toute la pile de protocole.

Mais en imaginant la suite du projet, j'ai vite vu que c'était pas une bonne solution, le nombre de classe explosent (à chaque nouveau protocole, il faut implémenter tous les héritages).

Et je connais assez mal les factory/builder du coup je me suis pas dirigé vers cette solution.

Donc je vais faire quelques choses dans ce genre la :

Code :

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

1
2
3
4
5
6
 
Class packet
 
    private:
        m_layer3Protocole;
        m_layer4Protocole;

En faisant comme tu me le conseils avec un builder à qui je donne le stream.

Merci de ton aide.

[ternel]

Pas tout a fait, il faudrait plutot avoir un paquet templaté sur les différentes couches.

Code :

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

1
2
3
4
5
6
 
template <typename L3, typename L4> class packet {
    private:
        L3 m_layer3Protocole;
        L4 m_layer4Protocole;
};

Ce qui permet d'avoir un type packet<UDP, HTTP>, totalement distinct du type packet<UDP, FTP>

[manticore]

Ce qui permet d'avoir un type packet<UDP, HTTP>, totalement distinct du type packet<UDP, FTP>

Oui cela parait juste et bon

Merci