foncteur, type fonction, composition
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:
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:
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:
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:
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 :aie:
