setter et flux

Version imprimable

setter et flux

Bonjour à tous,

Je me demandais s'il était possible d'appeler un setter à la lecture d'un flux plutôt que de passer par une variable temporaire. Ca donnerai un truc du genre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Foo { private: int valeur; public: void setValeur(const int newVal) { assert(newVal != 100); //par exemple ou une levée d'exception valeur = newVal; } }; int main (void) { Foo f; ifstream file ("data.txt"); file >> f.setValeur(); file.close(); return 0; }

Non.
Par contre, tu peux faire une fonction qui retourne une référence. Mais elle ne pourra effectuer aucun contrôle sur la valeur.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Foo { private: int valeur; public: int & getRefValeur() { return valeur; } }; int main (void) { Foo f; ifstream file ("data.txt"); file >> f.getRefValeur(); file.close(); return 0; }

Si on peut. En jouant avec des proxys.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct Proxy {
    typedef int value_type; // templatisable, tout ça
    Proxy(value_type &i, value_type max ) : m_i(i), m_max(max) {}
    void set(value_type i)  { if (i<m_max) m_i=i; else throw .../return false }
private
    value_type & m_i;
    value_type const m_max; // ou un "boost::function m_predicate;"
};
 
std::istream & operator>>(std::istream&is, Proxy & p) {
    Proxy::value_type i;
    if (is >> i) { p.set(i); // exception ou code de retour ?}
    return is;
}
 
struct A {
    Proxy setI() { return Proxy(m_i, 42); }
    Proxy setJ() { return Proxy(m_j, 100); }
};

A raffiner, ... tout ça.

Tu peux aussi faire une classe pour vérifier:

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
class IntSetter
{
public:
	typedef bool (*check_function)(int toCheck, intptr_t userData);
 
	explicit IntSetter(int *pInt, check_function func=0, intptr_t userData=0)
	 : m_pInt(pInt), m_func(func), m_userData(userData)
	{ }
 
	bool Set(int val) const
	{
		bool ok = true;
		if(m_func != 0)
			ok = m_func(val, m_userData);
		if(ok)
			*m_pInt = val;
		return ok;
	}
 
private:
	int * m_pInt;
	check_function m_func;
	intptr_t m_userData;
};
 
std::istream & operator>> (std::istream & is, IntSetter const &setter)
{
	int val;
	is >> val;
	setter.Set(val);
	return is;
}

Et l'utiliser ainsi:

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
class Foo
{
private:
	int valeur;
	static bool checkValeur(int newVal, intptr_t /*unused*/)
	{
		assert(newVal != 100); //par exemple ou une levée d'exception
		if(newVal != 100)
			return true;
		return false;
	}
public:
	IntSetter getSetValeur()
	{
		return IntSetter(&valeur, checkValeur);
	}
};
 
int main (void)
{
	Foo f;
	std::ifstream file ("data.txt");
	file >> f.getSetValeur();
	file.close();
	return 0;
}

Edit: Mince, post croisé avant que j'aie le temps de tester mon code...
Le code ci-dessus n'est pas testé...
Edit2: Testé et corrigé...

Et en voici une version Template:

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
70
71
72
73
#include <iostream>
#include <fstream>
#include <cassert>
 
template< class T >
struct SetterUtil
{
	typedef bool (*check_function)(T toCheck);
	typedef bool (*ref_check_function)(T const & toCheck);
};
 
template< class T, class Verif=typename SetterUtil<T>::ref_check_function >
class Setter
{
public:
	typedef T value_type;
	typedef Verif check_type;
 
	explicit Setter(value_type *pValue, check_type checker=0)
	 : m_pValue(pValue), m_checker(checker)
	{ }
 
	bool Set(value_type const & val) const
	{
		bool ok = true;
		if(m_checker != 0)
			ok = m_checker(val);
		if(ok)
			*m_pValue = val;
		return ok;
	}
 
private:
	int * m_pValue;
	check_type m_checker;
};
 
template< class T, class Verif >
std::istream & operator>> (std::istream & is, Setter< T, Verif > const &setter)
{
	T val;
	is >> val;
	setter.Set(val);
	return is;
}
 
 
class Foo
{
private:
	int valeur;
	static bool checkValeur(int newVal)
	{
		assert(newVal != 100); //par exemple ou une levée d'exception
		if(newVal != 100)
			return true;
		return false;
	}
public:
	typedef Setter<int, SetterUtil<int>::check_function> setter_type;
	setter_type getSetValeur()
	{
		return setter_type(&valeur, checkValeur);
	}
};
 
void TestProxy(void)
{
	Foo f;
	std::ifstream file ("data.txt");
	file >> f.getSetValeur();
	file.close();
}

05/06/2008, 14h47
Luc Hermitte

Citation:

Envoyé par Médinoc

Le code ci-dessus n'est pas testé...

T'inquiètes, le mien ne compile pas. ^^
05/06/2008, 15h24
CedricMocquillon

Merci beaucoup pour vos réponses très completes. Cependant, je crois que je vais rester avec mes variables temporaires (je ne pensai pas que les solutions pouvaient être aussi "compliquées"). Encore merci à tout les deux
05/06/2008, 19h26
Médinoc

Eh bien, la base est compliquée, mais la suite du code est assez réutilisable...