Discussion :

[zequiche]

Bonjour,

je débute un petit projet C++ que je pourrais résumer comme ceci :
1 j'ai un fichier contenant des messages appartenant a differentes grandes catégories.
2 Je dois modifier ces messages moyennant l'interrogation d'une base de données postgres ou sqlite.

Voici comment j'ai modélisé le 1 :

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
class Fichier {
 
  vector<Category *> categoryList;
 
};
 
 
class Category {
 
  vector<Message *> messageList;
 
};
 
class Message {
 
 
};

Pour l'instant je n'utilise pas l'héritage.

Pour le point 2, je ne souhaiterais ouvrir qu'une seule connexion par fichier pour modifier l'ensemble des messages qu'il contient. Je pense donc à l'héritage au plus haut niveau, pour la classe Fichier, et en cascade aussi pour Category et Message.

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
class Fichier {
 
...
// plus de categoryList
 
};
 
class Category {
 
...
// plus de messageList
 
};
 
class Message {
 
...
 
};
class FichierPg : Fichier {
 
vector<CategoryPG> categoryList;
 
private :
  PGconn maConnexion;
 
 
}
 
class CategoryPG : Category {
 
  vector<MessagePG> messageList;
 
}
 
class MessagePG : Message {
 
 
int setMetadataVal(PGConn);
 
}
 
 
class Fichier SQlite : fichier {
 
vector<CategorySQlite> categoryList;
 
private:
  sqlite3 maConnexion;
 
}
 
class CategorySQlite : Category {
 
 
vector<MessageSQlite> messageList; 
 
}
 
class MessageSQlite : Message {
 
int setMetadataVal(sqlite3);
 
}

Est ce que c'est correct ?

Merci d'avance pour votre aide

[Bousk]

Salut,

ta hiérarchie des Messages, Catégories et Fichiers semble logique, mais que vient faire une connexion dans un fichier ? Et surtout quel est l'intérêt de créer une connexion par fichier ? (spoiler alert : sûrement aucune).
Ton programme a ses données, et une connexion qu'il utilisera pour upload/download dans/depuis la base de données. Et surtout les 2 ne devraient avoir aucun lien, ce sont des concepts orthogonaux et chaque partie devrait pouvoir être modifiée individuellement.

[zequiche]

Merci de ta réponse.
Donc pour être sûr d'avoir compris ta réponse:
je garde les classes définie en 1 et j'ajoute juste 2 methodes a la classe Message

Code :

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

1
2
3
4
5
6
7
8
9
 
class Message {
 ...
 
 int setValFromSQliteDB(sqlite3);
 
 int setValFromPgDB(PGconn);
 
};

Code :

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

1
2
3
4
5
6
7
8
9
 
main {
 
// ouverture de ma connexion
 
// boucle sur les messages contenus dans mon fichier
    // appel de la bonne methode selon le type de connexion pour modifier mon message
 
}

C'est bien ça ?
Merci !

[ternel]

Mieux, tu fais une fonction complètement extérieure, qui charge la connexion, obtient les valeurs, et retourne le "fichier" correspondant.

Ainsi, tu n'encombre pas ta classe fonctionnelle, à savoir, le message, avec du code de chargement.

Ta classe représente ton message.
Elle n'a pas a connaitre le fonctionnement de ta base de données.

[foetus]

Pour répondre de façon ultra théorique à la question

Tu vas avoir le "Domain Model" (<- lien wiki anglais) qui va contenir toute ta logique métier.

Dedans/ À côté, tu vas avoir des DTO (<- lien wiki français), une classe sans comportement, que des données membre) et des "repositories" (<- lien Martin Fowler anglais).

Dans ton exemple, ta classe Message est un DTO et ta classe Category est un "repository" (<- mais sans la partie requête)


Ensuite pour la partie "model"/ données du MVC, tu vas avoir une interface ultra générique (donc une classe virtuelle pure en C++)
Par exemple dans ton cas :

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
class App_Model {
// Lifetime Management, only the main object calls them
public:
 
    virtual void init(char* /*pathname*/);
 
    virtual void clear();
 
 
// Model
public:
 
    virtual void get_metadata(Message&) const = 0;
 
    virtual void set_metadata(Message&) const = 0;
 
// ....
}

Et tu vas avoir 2 classes concrètes qui vont hériter de cette interface : class Database : public App_Model {}; et class File : public App_Model {};.


Et pour faire ton code , c'est à dire que tes objets DO ("domain object") communiquent avec ton modèle, tu peux par exemple, faire des singletons pour les 2 modèles (donc global) et faire un proxy pour les utiliser.

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
 
// model_functions.h
 
inline void DATA_GET_METADATA(Message& message) {
	( (IHM_G_Space::g_model.database.get_metadata) (message) );
}
 
inline void DATA_SET_METADATA(Message& message) {
	( (IHM_G_Space::g_model.database.set_metadata) (message) );
}
 
inline void FILE_GET_METADATA(Message& message) {
	( (IHM_G_Space::g_model.file.get_metadata) (message) );
}
 
inline void FILE_SET_METADATA(Message& message) {
	( (IHM_G_Space::g_model.file.set_metadata) (message) );
}

[zequiche]

Merci à tous de vos conseils,
la dernière réponse est effectivement très théorique, je me pencherai dessus la cervelle plus reposée !