Spirit / actors / philosophie
Bonjour,
Merci à ceux qui lirons ce post, et encore plus à ceux qui pourront y répondre.
Je débute en spirit, je dois en être à mon troisième parseur, et je dois que je n'aime pas beaucoup les habitudes que j'ai prise. Il y a sans doute une ou plusieurs erreurs dans ma façon de faire.
Voici un cas concret. Je veux parser le texte suivant :
Code:
1
2
3
| "{14,12}
{18,4}
{27,2}" |
Et mettre les valeurs dans un conteneur de structures, quelque chose comme :
Code:
1
2
3
4
5
6
7
| struct A
{
int x,y;
};
typedef std::list<A*> Contenair
Contenair maListe; |
Pour le moment, j'utilise les foncteur suivants :
Code:
1
2
3
4
5
6
7
8
9
10
11
| struct ReaderX
{
int x&;
ReaderX(int& newX) :x(newX)
{
};
void operator()(int val)
{
x = val;
};
}; |
et
Code:
1
2
3
4
5
6
7
8
9
10
11
12
| struct ReaderY
{
int x&;
Contenair cont;
ReaderX(int& newX, Contenair & newContenair) : x(newX), cont(newContenair)
{
};
void operator()(int val)
{
newContenair.push_back(new A(x,val));
};
}; |
du coup, mon parsage ressemble à ça :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
Contenair maListe;
int variable_locale;
ReaderX(variable_locale)
ReaderY(variable_locale, maListe)
Rule_t rule =
*(
ch_p{'{'} >>
int_p[ReaderX] >>
ch_p{','} >>
int_p[ReaderY] >>
ch_p{'}'};
);
parse(...,rule); |
On voit bien la philosophie de ce code : j'utilise un premier Actor qui se contente de mettre à jour une variable locale à l'aide d'une référence, puis j'utilise un second Actor qui crée mon objet en utilisant cette référence.
On voit aussi bien que c'est absurde. Il me semble qu'il ne devrait y avoir qu'un unique Actor :
- la propriété de la variable ne devrait pas appartenir au code appelant. En particulier, il n'y a pas de raison que quelqu'un d'autre que le foncteur ait accés à cette variable.
- Si mes objets contenaient non-pas 2, mais 40 valeurs, il y aurait 40 variables locales "polluantes".
Je suppose qu'une meilleure attitude serait quelque chose comme :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
Contenair maListe;
Reader(maListe)
Rule_t rule =
*(
ch_p{'{'} >>
int_p[Utilise_Fonction<Reader,setX>] >>
ch_p{','} >>
int_p[Utilise_Fonction<Reader,setY>] >>
ch_p{'}'};
);
parse(...,rule); |
ou quelque chose comme ça.
Merci à ceux qui pourront m'aider, ou simplement donner leur avis.
