Bonjour à tous, j'essaie de me mettre à boost::constrained_object (http://student.agh.edu.pl/~kawulak/c...lue/index.html). Je voudrais donc créer un type basé sur boost::posix_time::time_period qui obligerait la création de période valide (c'est-à-dire non nulle). Pour cela j'ai crée un premier foncteur déterminant la validité d'une période:
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
 
#include <boost/date_time.hpp>
	//pour la période
 
using boost::posix_time::time_period;
 
/** @class is_null
* @brief classe foncteur déterminant la validité d'une période
*/
struct is_null
{
	typedef time_period argument_type;
 
	bool operator()(time_period p) const
	{ return p.is_null(); }
};
maintenant, je voudrais juste créer un foncteur comme la négation du premier, pour ça j'ai crée un autre foncteur:
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
 
/** @class not
* @brief classe foncteur template définissant la négation du foncteur template
*/
template<typename Foncteur>
struct not
{
	typedef typename Foncteur::argument_type argument_type;
 
	bool operator()(typename Foncteur::argument_type elt) const
	{ return !f(elt); }
 
private:
	Foncteur f;
};
ce qui me permet alors d'écrire mon type:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
 
#include <boost/constrained_value.hpp>
	//pour contraindre la période à être valide
 
/** Le type représentant une période valide. Si la date de fin de période est <= à la date de début de période une exception est levée */
	typedef boost::constrained_value::constrained<time_period, not<is_null>> not_null_period;
bon ok ça marche mais je me suis dit "pourquoi ne pas utiliser les foncteurs définis par la STL?" et bien là, je vois pas trop comment utiliser le unary_negate de la STL puisqu'il impose à sa construction de prendre une instance du foncteur à nier.
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
 
template<class _Fn1>
	class unary_negate
	: public unary_function<typename _Fn1::argument_type, bool>
	{	// functor adapter !_Func(left)
public:
	explicit unary_negate(const _Fn1& _Func)
		: _Functor(_Func)
		{	// construct from functor
		}
 
	bool operator()(const typename _Fn1::argument_type& _Left) const
		{	// apply functor to operand
		return (!_Functor(_Left));
		}
 
protected:
	_Fn1 _Functor;	// the functor to apply
	};
(c'est la version de visual 2008)
En gros de ce que j'en comprend, ça crée un type à partir d'une instance du foncteur alors que dans ma démarche ce serait plus de la création de type à partir d'un type fonction.
Est-ce que j'ai loupé un truc? Y-a t-il des éléments dans boost qui vont dans le sens de ce que j'ai écris (mais alors en mieux)... voilà, j'ai un peu de mal à m'y retrouver dans tout ça