Discussion :

[Florian Goo]

Bonjour tous,

Dans mon projet, la plupart de mes « classes » sont des typedefs de templates variadiques. Ça fait du code joli et concis, jusque là tout va bien.

Sauf que souvent ces typedefs font références les uns aux autres. Pour résoudre les problèmes de dépendances cycliques engendrés, je dois écrire des pimpl. Et l'interface est plutôt lourde à reproduire…
Par exemple, alors qu'un typedef donnerait ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
typedef
	alternative_node
	<
		simple_declaration,
		asm_definition,
		namespace_alias_definition,
		using_declaration,
		using_directive
	>
	block_declaration
;

… je dois remplacer le code ci-dessus par celui-ci, pour mettre en place le pimpl (ne vous souciez pas du sens de ce code, ce n'est pas le sujet) :

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
 
/*certains des types présents dans ce typedef sont incomplets*/
typedef
	alternative_node
	<
		simple_declaration,
		asm_definition,
		namespace_alias_definition,
		using_declaration,
		using_directive
	>
	block_declaration_t
;
 
typedef
	alternative_node
	<
		asm_definition,
		namespace_alias_definition,
		using_declaration,
		using_directive
	>
	block_declaration_tail_t
;
 
class block_declaration: public composite_node
{
	public:
		typedef block_declaration_t type;
		typedef simple_declaration head_node_t;
		typedef block_declaration_tail_t tail_alternative_node_t;
 
		block_declaration(simple_declaration&& o);
 
		block_declaration(asm_definition&& o);
 
		block_declaration(namespace_alias_definition&& o);
 
		block_declaration(using_declaration&& o);
 
		block_declaration(using_directive&& o);
 
		block_declaration(const block_declaration& o);
 
		block_declaration(block_declaration&& o);
 
		~block_declaration();
 
		const block_declaration&
		operator=(const block_declaration& o);
 
		void
		get(boost::optional<const simple_declaration&>& node) const;
 
		void
		get(boost::optional<const asm_definition&>& node) const;
 
		void
		get(boost::optional<const namespace_alias_definition&>& node) const;
 
		void
		get(boost::optional<const using_declaration&>& node) const;
 
		void
		get(boost::optional<const using_directive&>& node) const;
 
	private:
		std::unique_ptr<type> impl_;
};

Comme vous le voyez, c'est un tantinet verbeux. Et encore, je n'ai pas mis les définitions des fonctions membres.

Voici donc ma question : Existe-t-il une technique de métaprogrammation (certainement à base de macros) qui me permettrait de factoriser le code ci-dessus par quelque chose comme celui-ci ?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
ALTERNATIVE_NODE_PIMPL
(
	block_declaration,
	simple_declaration,
	asm_definition,
	namespace_alias_definition,
	using_declaration,
	using_directive
)

Même si le nombre d'arguments doit être spécifié, je prends aussi !

Code :

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

1
2
3
4
5
6
7
8
9
10
 
ALTERNATIVE_NODE_PIMPL5
(
	block_declaration,
	simple_declaration,
	asm_definition,
	namespace_alias_definition,
	using_declaration,
	using_directive
)

[nicroman]

Tu veux dire les macros variadiques ?
Comme dans:

Code :

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

1
2
 
#define  LOG_DEBUG(...)        getLogger()->Log(Level.DEBUG,_VA_ARGS_)

[Florian Goo]

Apparemment, les macros variadiques au sens C99 ne sont pas suffisantes pour mon cas, même si j'ai déjà un début de solution qui en tire parti :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define SCALPEL_ALTERNATIVE_NODE_PIMPL_TYPE_TYPEDEF_BEGIN\
typedef\
	alternative_node\
	<
 
#define SCALPEL_ALTERNATIVE_NODE_PIMPL_TYPE_TYPEDEF_END\
	>\
	type\
;
 
#define SCALPEL_ALTERNATIVE_NODE_PIMPL_TYPE_TYPEDEF(...)
SCALPEL_ALTERNATIVE_NODE_PIMPL_TYPE_TYPEDEF_BEGIN\
	_VA_ARGS_\
SCALPEL_ALTERNATIVE_NODE_PIMPL_TYPE_TYPEDEF_END

[JolyLoic]

Tu as regardé du côté de boost::pp : http://www.boost.org/doc/libs/1_39_0...doc/index.html

[Florian Goo]

Argh, j'avais fouillé du côté de Boost.MPL, mais PP, je ne connaissais pas. Je sens que ça va m'intéresser

Merci beaucoup Loïc !

[Kalith]

Hum ça me parait trop facile mais bon : pourquoi ne pas faire... :

Code :

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

1
2
3
4
5
6
7
8
9
// Je met <...> pour ne pas avoir à recopier toute la liste des arguments du template
class block_declaration : public alternative_node<...>
{
public :
 
    // Avec eventuellement (si tu as besoin de faire la conversion entre le type template et ton "typedef") :
    block_declaration() {}
    block_declaration(const alternative_node<...>& obj) : alternative_node<...>(obj) {}
};

Ca marche très bien chez moi.

[Florian Goo]

Eh non, on ne peut hériter d'un type incomplet (incomplet == dont on n'a qu'une forward declaration) ! Sinon le typedef aurait fait l'affaire.
Edit : Ici, le template alternative_node est complet. C'est l'un des types arguments du template qui est incomplet, rendant donc l'instance du template elle-même incomplète.

De plus, ça n'aurait de toutes façons pas été très propre, puisque la classe alternative_node n'est pas conçue pour être héritée (pas de destructeur virtuel, pas abstrait, …).

Je précise que la piste boost.pp était bien la bonne

[Goten]

T'as utilisé pp comment pour résoudre ton problème au final? (ça m'intéresse et jvois pas trop)

[Florian Goo]

J'ai utilisé les séquences :

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
 
#define SCALPEL_ALTERNATIVE_NODE_PIMPL_DECLARATION_CONSTRUCTOR(r, alternative_node_type, type) \
alternative_node_type(type&& o);
 
#define SCALPEL_ALTERNATIVE_NODE_PIMPL_DECLARATION_GET_FUNCTION(r, x, type) \
void                                           \
get(boost::optional<const type&>& node) const; \
 
#define SCALPEL_ALTERNATIVE_NODE_PIMPL_DECLARATION(alternative_node_type, type_seq) \
class alternative_node_type: public node                                            \
{                                                                                   \
	public:                                                                         \
		typedef                                                                     \
			alternative_node                                                        \
			<                                                                       \
				BOOST_PP_SEQ_ENUM(type_seq)                                         \
			>                                                                       \
			type                                                                    \
		;                                                                           \
		typedef BOOST_PP_SEQ_HEAD(type_seq) head_node_t;                            \
		typedef                                                                     \
			alternative_node                                                        \
			<                                                                       \
				BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TAIL(type_seq))                      \
			>                                                                       \
			tail_alternative_node_t                                                 \
		;                                                                           \
                                                                                    \
		BOOST_PP_SEQ_FOR_EACH                                                       \
		(                                                                           \
			SCALPEL_ALTERNATIVE_NODE_PIMPL_DECLARATION_CONSTRUCTOR,                 \
			alternative_node_type,                                                  \
			type_seq                                                                \
		)                                                                           \
                                                                                    \
		alternative_node_type(const alternative_node_type& o);                      \
                                                                                    \
		alternative_node_type(alternative_node_type&& o);                           \
                                                                                    \
		~alternative_node_type();                                                   \
                                                                                    \
		const alternative_node_type&                                                \
		operator=(const alternative_node_type& o);                                  \
                                                                                    \
		child_const_iterator_range                                                  \
		children() const;                                                           \
                                                                                    \
		BOOST_PP_SEQ_FOR_EACH                                                       \
		(                                                                           \
			SCALPEL_ALTERNATIVE_NODE_PIMPL_DECLARATION_GET_FUNCTION,                \
			~,                                                                      \
			type_seq                                                                \
		)                                                                           \
                                                                                    \
	private:                                                                        \
		std::unique_ptr<type> impl_;                                                \
};

L'appel à la fonction donne cela :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
SCALPEL_ALTERNATIVE_NODE_PIMPL_DECLARATION
(
	block_declaration,
	(simple_declaration)
	(asm_definition)
	(namespace_alias_definition)
	(using_declaration)
	(using_directive)
)

[Kalith]

Au temps pour moi, j'avais confondu la situation
J'utilise cette méthode quand je veux faire des "typedef template" (avec une classe T inconnue).