« Super » macro variadique

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:

---

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:

---

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:

---

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:

---

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 )

---

Tu veux dire les macros variadiques ?
Comme dans:

Code:

---

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

---

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:

---

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

---

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

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 ! :ccool:

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

Code:

---

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.

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 ;)

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

J'ai utilisé les séquences :

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 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:

---

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) )

---

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).