[LEGACY CODE] Conseil architecture basée sur des set/get
Bonjour,
Je reviens vers vous car je me trouve face à ceci: (j'ai réduis le tout au fond du problème, il y a des raccourcis mais mon souci est bien évoqué ici )
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
| class App {
void setFirst(bool value) {
drawFirst = _value;
}
bool getFirst() {
return drawFirst;
}
void setLast(bool value) {
drawLast = _value;
}
bool getLast() {
return drawLast;
}
void setMiddle(bool value) {
drawMiddle = _value;
}
bool getMiddle() {
return drawMiddle;
}
<autres fonctions >
private:
bool drawFirst;
bool drawLast;
bool drawMiddle;
<autres données >
void draw();
void drawFirstlayer();
void drawLastlayer();
void drawMiddleLayer();
<autres fonctions >
}; |
drawFirst, drawLast , drawMiddle ne sont que des indicateurs boolean qui indiquent si on doit tracer ou non des plans. Pour tracer ces plans, l'application applique dont la fonction draw qui récapitule --en gros-- tout cela :
Code:
1
2
3
4
5
6
7
8
9
10
|
void App::draw()
{
if (drawFirst)
drawFirstLayer;
if (drawMiddle)
drawMiddleLayer;
if (drawLast)
drawLastlayer;
} |
et il y a aussi, ailleurs dans le code, les fameux :
Code:
app->setFirst(!app->getFirst());
Aussi pour les yeux de tous, et pour les miens, je souhaite me prendre un peu de mon temps pour modifier cela. Mes collègues refusent d'y toucher car "ca marche".
Oui c'est bien le cas, ca marche. Mais si je les laisse faire j'aurais bientôt plus de set/get que d'autres fonctions dans le soft. (:calim2:)
Je sais pertinemment que je dois penser : qu'offre la classe ?
Je pourrais remplacer par exemple:
Code:
1
2
3
4
5
6
7
|
void setFirst(bool value) {
drawFirst = _value;
}
bool getFirst() {
return drawFirst;
} |
par
Code:
1
2
3
4
5
6
7
8
9
| void showFirst() {
drawFirst = true;
}
void hideFirst() {
drawFirst = false;
}
void toggleFirst() {
drawFirst = !drawFirst;
} |
J'ai plus de fonctions qui offrent un service. Mais sur mon exemple, je passe du couple get/set à un trio.
Non pas que je déteste les trios, mais c'est encore plus long qu'avant et je me retrouve encore avec une multitude de copier/coller de fonctions et en faisant cela je n'ai pas l'impression de faire du C++
Alors je pourrais écrire trois fonctions génériques genre:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
enum class APP_VALUE : char {NONE, FIRST_LAYER, LAST_LAYER, MIDDLE_LAYER};
void show(APP_VALUE LayerValue) {
switch(Layervalue) {
case FIRST_LAYER: drawFirst = true;
case LAST_LAYER: drawLast = true;
case MIDDLE_LAYER : drawMiddle = true;
default : break;
}
}
void hide(APP_VALUE LayerValue); //pareil : construction identique
void toggle(APP_VALUE LayerValue); // pareil : construction identique |
Je me retrouve avec 3 fonctions au lieu de 9. Je ne sais pas comment qualifier cette modification. J'ai encore pas l'impression de faire du C++
Si je prend mon problème d'un point de vue plus global:
Si j'applique le principe de la responsabilité unique, je devrais découper App au moins en deux entitées : App et AppDraw
donc toutes les fonctions draw disparaissent dans appDraw, je gagne en clarté et ma classe App ne s'occupe plus que d'un truc. (que doit afficher App ??)
Maintenant, en amont, je regarde qui appelle ma classe App.
Il s'agit d'une seule classe AppEvent qui gère les évents liées à App.
Un truc comme
Code:
enum class APP_VALUE : char {NONE, FIRST_LAYER, LAST_LAYER, MIDDLE_LAYER};
existe déjà
Donc tous les get/set ne servent qu'à une seule chose : donner à AppEvent le bon nom de la fonction à appeler.
On peut alors passer toute la classe App en friend class AppEvent, mais j'ai toujours pas l'impression de faire du C++
Aussi comment puis je modifier intelligemment ma classe App ?
J'ai malheureusement aussi la contrainte que je ne peux pas repenser à zéro le soft de A à Z, ni même localement : mes collègues et mon patron y sont hostiles car "ça marche".
Or je souhaite bouger les choses. Que feriez vous à ma place ?
En vous remerciant par avance !
Cordialement,
