Discussion :

[ternel]

Bonjour à tous

Je construis actuellement une bibliothèque pleine de builders.
Comme ils sont extrêmement répétitifs, j'ai opté pour une macro générant un champ privé et un setter
L'idée est de pouvoir chainer les appels, à la façon du "named parameter".

Code :

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

1
2
3
4
5
#define MACRO_BUILDER_PROPERTY(Self, Type, Name) \
private:\
	Type m_##Name;\
public:\
	Self& Name(Type const& Name) {m_##Name = Name; return *this;}

Supposons, la classe suivante:

Code :

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

1
2
3
4
5
6
7
class BiduleBuilder {
MACRO_BUILDER_PROPERTY(BiduleBuilder, int, valeur)
MACRO_BUILDER_PROPERTY(BiduleBuilder, optional<std::string>, nom)
 
public:
	Bidule build();
};

Cela génère:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
private:class BiduleBuilder {
	int m_valeur;
public:
	BiduleBuilder& valeur(int const& valeur) {m_valeur = valeur; return *this;}
 
private:
	optional<std::string> m_nom;
public:
	BiduleBuilder& nom(optional<std::string> const& nom) {m_nom = nom; return *this;}
 
public:
	Bidule build();
};

Cela permet alors d'écrire BiduleBuilder().valeur(1).nom(std::string("coin coin")).build();.

Jusque là, tout va bien. Les services rendus sont satisfaisant.

Mais pour des raisons d'ergonomies, on voudrait pouvoir se passer de la construction explicite du std::string dans le cas d'un optional<std::string> (ou en fait de tout optional<...>)
Et c'est là que le bât blesse.

La seule solution que permet optional (de boost ou prochainement de std), c'est de fournir aussi BiduleBuilder& nom(std::string const& nom);.
Donc, il faut que la macro réfléchisse comme une grande pour l'ajouter si besoin est, ou qu'elle ajoute une fonction dont l'appel sera impossible si on n'est pas dans le cas d'une optional.

J'ai bien pensé à enable_if, mais ce n'est possible que sur une template.

Que me conseillez-vous?

[jo_link_noir]

Ne serait-ce pas plus simple de laisser tous passer avec une référence universelle pour que l'erreur de compilation arrive sur l'affectation dans la fonction ?

template<class T> Self& Name(T && x) {m_##Name = std::forward<T>(x); return *this;}.

Il y a aussi std::is_convertible, mais c'est effectivement possible qu'avec une template.

[Pyramidev]

De mon côté, je n'ai rien de mieux que ceci :

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
#define MACRO_BUILDER_PROPERTY(Self, Type, Name) \
private:\
	Type m_##Name;\
public:\
	Self& Name(Type const& Name) {m_##Name = Name; return *this;}
 
#define MACRO_BUILDER_OPTIONAL_PROPERTY(Self, Type, Name) \
private:\
	boost::optional<Type> m_##Name;\
public:\
	Self& Name(boost::optional<Type> const& Name) {m_##Name = Name; return *this;}\
	Self& Name(Type const& Name)                  {m_##Name = Name; return *this;}
 
class BiduleBuilder {
	MACRO_BUILDER_PROPERTY(BiduleBuilder, int, valeur)
	MACRO_BUILDER_OPTIONAL_PROPERTY(BiduleBuilder, std::string, nom)
};
 
// Équivaut à :
/*
class BiduleBuilder {
private:
	int m_valeur;
public:
	BiduleBuilder& valeur(int const& valeur) {m_valeur = valeur; return *this;}
 
private:
	boost::optional<std::string> m_nom;
public:
	BiduleBuilder& nom(boost::optional<std::string> const& nom) {m_nom = nom; return *this;}
	BiduleBuilder& nom(std::string const& nom)                  {m_nom = nom; return *this;}
};
*/
 
int _tmain(int argc, _TCHAR* argv[])
{
	BiduleBuilder foo;
	foo.valeur(1).nom("coin coin"); // pas besoin d'écrire string
	foo.nom(boost::none);
	return 0;
}

[ternel]

Ne serait-ce pas plus simple de laisser tous passer avec une référence universelle pour que l'erreur de compilation arrive sur l'affectation dans la fonction ?

template<class T> Self& Name(T && x) {m_##Name = std::forward<T>(x); return *this;}.

Il y a aussi std::is_convertible, mais c'est effectivement possible qu'avec une template.

C'est possible en effet, mais je ne sais pas jusqu'à quel point c'est possible en C++03 (en fait gcc 4.4.7)
Ca doit être faisable avec une const&, mais pour "éviter les templates dans des macros" (dixit mon responsable), je suis parti sur la solution de Pyramidev

Merci à tous les deux pour vos avis.