Bonsoir

J'ai une fonction qui prend pas mal de paramètres template qui sont en fait des types de foncteur. Par exemple,

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
template <typename skipping_condition, 
		  typename required_condition,
		  typename seq_iterator>
std::size_t function(seq_iterator seq_begin, seq_iterator seq_end)
{	
}
skipping_condition et required_condition sont deux foncteurs booléens prenant un ou deux paramètres (d'où mon thread de cet aprem : ici).

La fonction ci-dessus encapsule la skipping condition dans un filter_iterator et appelle la même fonction sans le paramètre template encapsulé :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
template <typename required_condition,
		  typename seq_iterator>
std::size_t function(seq_iterator seq_begin, seq_iterator seq_end)
{	
}
Et vu qu'il y a plus que 2 paramètres templates, ce "dépilage" de template continue encore en encapsulant chaque fois une condition dans un filter ou transform_iterator.

J'aimerais trouver un moyen qui me permette de rentre optionnel ces conditions en passant par une structure "no_skipping_condition" par exemple. L'effet serait d'ignorer ce paramètre template et de ne pas l'encapsuler dans un itérateur.

Alors évidemment on peut utiliser typeid ou d'autre RTTI. Il faut que ça soit fait à la compilation...


Ensuite j'ai un deuxième problème (en quelque sorte similaire au premier) qui a émané suite à mon premier poste.

Considérons la fonction suivante :

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
template<typename skipping_condition,
typename required_condition,
....
>
std::size_t checksum(seq_iterator seq_begin, seq_iterator seq_end, counter_type &counter)
{	
  if(function_trait<skipping_condition>::arity == 1)
  {
    checksum<required_condition, ..., seq_iterator>(boost::filter_iterator(skipping_condition, seq_begin, seq_end),
	                                               boost::filter_iterator(skipping_condition, seq_end, seq_end),
												   counter);
  }
  if(function_trait<skipping_condition>::arity == 2)
  {
    checksum<required_condition, ..., seq_iterator>(boost::filter_iterator(boost::bind(skipping_condition, boost::bind(deref<counter_type>, counter)), seq_begin, seq_end),
	                                               boost::filter_iterator(boost::bind(skipping_condition, boost::bind(deref<counter_type>, counter)), seq_end, seq_end),
												   counter);
  }
}
 
template<class T> T& deref( T* p ) { return *p; }
Le problème c'est que vérifier l'arité de la fonction est une vérification du runtime alors qu'il me faut vérifier tout ça au compile-time... J'ai bien regardé du côté de boost::mpl mais je ne trouve pas LA fonction qui fera mon bonheur

J'espère que j'ai été assez clair sur ce que je n'arrivais pas à faire.

Merci pour vos réponses.