Discussion :

[D-j-O]

Bonjour,

J'ai un problème de conception et je sèche un peu. Peut être avez vous une petite idée ou piste pour m'aider.
Je cherche une solution élégante pour cacher l'implémentation réseau que j'utilise dans mon logiciel.
J'utilise des variadic template et une politique qui me permet de choisir de quelle façon je vais sérialiser mes objets et de ne pas m’inquiéter du nombre de membre.

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
 
                template<typename SerializePolicy>
		class NetworkSerializer
		{
		public:
 
 
			template<typename T, typename... Arguments>
			void serialize(T pValue)
			{
				static_cast<SerializePolicy*>(this)->serializeStrategy(pValue);
			}
 
			template<typename T, typename... Arguments>
			void serialize(T pValue, Arguments... pArgs)
			{
				static_cast<SerializePolicy*>(this)->serializeStrategy(pValue);
				serialize(pArgs...);
			}
 
 
			template<INetworkObservable*, typename... Arguments>
			void serialize(INetworkObservable* pNetObs)
			{
				static_cast<SerializePolicy*>(this)->serializeStrategy(pNetObs);
			}
 
 
			template<INetworkObservable*, typename... Arguments>
			void serialize(INetworkObservable* pNetObs, Arguments... pArgs)
			{
				static_cast<SerializePolicy*>(this)->serializeStrategy(pNetObs);
				serialize(pArgs...);
			}
 
 
		};

Je suis obligé d'écrire:

Code :

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

NetworkSerializer<MyNetworkSerializationPolicy> ns;

Cependant je veux cacher la politique que j'utilise, de sorte que mon logiciel puisse appeler le NetworkSerializer sans en connaitre la politique.
Je ne pense pas pouvoir utiliser des type erasure puisque mes fonctions sont templatés et que j'utilise des traits pour faire de la spécialisation partielle dans l'implémentation des policy, ou alors je suis passé à coté de quelque chose.

Une aide serait la bienvenue.

Merci.

[Bousk]

Salut,

pourquoi pas tout simplement typedef NetworkSerializer<MyNetworkSerializationPolicy> MyNetworkSerializer; pour pouvoir faire MyNetworkSerializer ns; ?

[D-j-O]

Bonjour,

Ca pourrait être une solution mais je perdrai pas mal d'avantage: Si je change d'implémentation pour le réseau je dois changer le typedef. De plus si le choix de mon implémentation est fait dans un fichier de config chargé au démarrage et que je choisis entre plusieurs NetworkSerializer<XXXXX> je ne peux pas utiliser cette solution.

[koala01]

Salut,

Bonjour,

Ca pourrait être une solution mais je perdrai pas mal d'avantage: Si je change d'implémentation pour le réseau je dois changer le typedef. De plus si le choix de mon implémentation est fait dans un fichier de config chargé au démarrage et que je choisis entre plusieurs NetworkSerializer<XXXXX> je ne peux pas utiliser cette solution.

Là, je crois qu'il y a confusion...

Un fichier config ne pourra être utilisé qu'à l'exécution, le typedef (ou, de manière générale, l'instanciation d'une classe template) s'effectue à la compilation. Si tu as plusieurs politiques qui t'intéressent et que tu souhaites pouvoir sélectionner l'une de ces politiques à l'exécution, il faudra que tu te soies arrangé pour que chaque politique qui t'intéresse ait été spécifiquement instanciée. La solution "classique" pour y arriver consiste à créer ce que l'on appelle une instanciation explicite.

Il ne faut donc pas confondre les différentes possibilités :

Soit tu veux décider toi-même une bonne fois pour toutes quelle est la meilleure politique à appliquer (quitte à changer dans deux versions), et, à ce moment là, le typedef semble être la solution la plus adaptée : si tu décide de choisir une autre politique, tu adaptes ton typedef, tu recompiles, et le tour est joué.

Soit tu veux pouvoir sélectionner à l'exécution la politique la plus intéressante. A ce moment, tu devras veiller à ce que toutes les politiques envisagées soient instanciées, et il y a intérêt à veiller d'avoir classe de base fournissant les différents services attendus, de manière à pouvoir avoir un pointeur sur cette classe de base que tu feras pointer sur la politique adéquate par rapport à la configuration (bre, de l'orienté objet pur et simple, bien que les classes dérivées puissent être des classes templates )

Commence donc par faire le point sur ce qui est sur et certain, le reste, tu t'en inquiéteras "en temps utiles"

[D-j-O]

Effectivement mon exemple de fichier de config n'est pas pertinent ici.
Ce qui m'embête c'est de devoir montrer l'implémentation dans du code généric.

Par exemple dans mon manager de réseau je vais devoir écrire ça en suivant vos conseils

Code :

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

using NetworkSerializerImpl = NetworkSerializer<MySerializationPolicy>;

A priori je ne veux pas pas que mon implémentation soit visible ici. Mais je n'ai pas vraiment le choix et ça reste plutôt élégant tout de même.

... avoir un pointeur sur cette classe de base que tu feras pointer sur la politique adéquate par rapport à la configuration (bre, de l'orienté objet pur et simple, bien que les classes dérivées puissent être des classes templates

Ton dernier point m'intéresse mais je ne comprends pas ce que tu veux dire. Je ne peux pas avoir une classe de base avec des fonctions virtuelles si celles ci sont templatées.

[jblecanard]

Salut !

En effet, tu es ici face à un choix : si tu veux appeler des fonctions membres templates (variadiques qui plus est), tu es obligé de connaître le type réel. Si tu veux cacher l'implémentation, tu dois cacher le type réel.

Maintenant, un compromis exite : tu peux utiliser une classe template (dont le type réel sera connu), et qui elle appelle l'interface d'un serialiseur dont elle ne connait pas le type réel, pour peu que tout ce qui est appelé n'est pas template. Ainsi, tu gardes tes templates dans le code appelant et tu peux changer le sérialiseur à l'exécution si cela te plait. Ca s'utiliserais comme ça:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main() {
  NetworkSerializer ns_dumper;
 
  ns_dumper.SetSerializerImpl(new SerializerCSV);
  std::cout << ns_dumper.Serialize(1, 2.3,"Roger",4) << "\n";
 
  ns_dumper.SetSerializerImpl(new SerializerJSON);
  std::cout << ns_dumper.Serialize(2.3, 1,"Roger",4,"Marcel") << "\n";
 
  return 0;
}

Ca affiche ceci :

Code :

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

1
2
1;2.3;Roger;4
[2.3,1,"Roger",4,"Marcel"]

L'implémentation :

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
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
#include <string>
#include <sstream>
#include <ostream>
#include <iostream>
#include <memory>
 
struct Serializer {
  virtual ~Serializer() {}
 
  virtual void StartRecord() = 0;
  virtual void EndRecord() = 0;
  virtual std::string GetRecord() const = 0;
 
  virtual void Push(int value) = 0;
  virtual void Push(double value) = 0;
  virtual void Push(std::string const& value) = 0;
  // etc avec tous les types possibles
};
 
class SerializerCSV : public Serializer {
  std::ostringstream record_stream_;
  std::string result_;
  bool has_data_ = false;
 
  void PushSep() {
    if (has_data_) record_stream_ << ';';
    has_data_ = true;
  }
 
 public:
  void StartRecord() override {
    result_ = "";
    record_stream_.str("");
    has_data_ = false;
  }
 
  void EndRecord() override { result_ = record_stream_.str(); }
  std::string GetRecord() const override { return result_; }
  void Push(int value) override { PushSep(); record_stream_ << value; } 
  void Push(double value) override { PushSep(); record_stream_ << value; }
  void Push(std::string const& value) override { PushSep(); record_stream_ << value; }
};
 
class SerializerJSON : public Serializer {
  std::ostringstream record_stream_;
  std::string result_;
  bool has_data_ = false;
 
  void PushSep() {
    if (has_data_) record_stream_ << ',';
    has_data_ = true;
  }
 
 public:
  void StartRecord() override {
    result_ = "";
    record_stream_.str("");
    record_stream_ << "[";
    has_data_ = false;
  }
 
  void EndRecord() override { 
    record_stream_ << ']';
    result_ = record_stream_.str(); 
  }
  std::string GetRecord() const override { return result_; }
  void Push(int value) override { PushSep(); record_stream_ << value; } 
  void Push(double value) override { PushSep(); record_stream_ << value; }
  void Push(std::string const& value) override { PushSep(); record_stream_ << '"' << value << '"'; }
};
 
class NetworkSerializer {
  std::unique_ptr<Serializer> serializer_impl_;
 
  void Push() {}
  template <typename Arg, typename ... Args> void Push(Arg value, Args ... values) {
    serializer_impl_->Push(value);
    Push(values ...);
  }
 
 public:
  void SetSerializerImpl(std::unique_ptr<Serializer>&& serializer) { serializer_impl_ = std::move(serializer); }
  void SetSerializerImpl(Serializer* serializer) { SetSerializerImpl(std::unique_ptr<Serializer>(serializer)); }
 
  template <typename ... Args> std::string Serialize(Args ... values) {
    serializer_impl_->StartRecord();
    Push(values...);
    serializer_impl_->EndRecord();
    return serializer_impl_->GetRecord();
  }
};

C'est assez simple et ça s'approche de ton objectif, je pense, à arranger à ta sauce.

[D-j-O]

Merci!!!

Ta solution est vraiment pas mal. Je vais regarder comment je peux et si c'est pertinent d'intégrer ça.

Merci à vous tous.