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:
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
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(); } };
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
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; };
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 #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;
(c'est la version de visual 2008)
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 };
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
Partager