Discussion :

[3DArchi]

Bonjour,
J'utilise boost::spirit pour parser un fichier en entrée. J'utilise un itérateur position_iterator<file_iterator<char> >. Je souhaite faire une IHM avec un avancement. Je ne vois pas beaucoup de possibilités:
1/ Wrapper position_iterator<file_iterator<char> > avec un itérateur maison qui m'informe au fur et à mesure de l'avancement,
2/ Rajouter une action à chacune des règles.
Le 1/ est-il possible?
Le 2/ me parait un peu lourd.
Existe-t-il une autre piste?
Merci.

[Invité2]

Je ne suis pas un pro avec BOOST.Spirit, mais wrapper me semble impossible, la seule solution est l'ajout d'un incrémenteur dans chaques fonctions, c'est très lourd, je sais...

Mais j'ai une question : tu veux un %age d'avancement ou un nombre de hit ?
Car pour le %age, à moins de connaitre le nombre de hit à atteindre, c'est pas possible...

[Invité2]

Si, on peux, en appelant deux fonctions la seconde étant l'acotre increment_a(ref)

[3DArchi]

Je ne suis pas un pro avec BOOST.Spirit, mais wrapper me semble impossible, la seule solution est l'ajout d'un incrémenteur dans chaques fonctions, c'est très lourd, je sais...

Mais j'ai une question : tu veux un %age d'avancement ou un nombre de hit ?
Car pour le %age, à moins de connaitre le nombre de hit à atteindre, c'est pas possible...

Effectivement, je me suis rendu compte que ma question était 'stupide'. En effet, un pourcentage d'avancement peut ne pas avoir de sens si il y a des aller/retour pour tester différentes possibilites (typiquement truc|machin).
J'ai creusé un peu: On peut wrapper les itérateurs mais ce serait pas trop approprié. Les autres pistes que j'ai explorer ont été les suivantes: redéfinir les politiques du parser. Cela se fait assez facilement une fois qu'on a compris le truc:

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
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
 
template<class IterationPolicy>
struct Mon_iteration_policy :public IterationPolicy
{
  template <typename ScannerT>
  void
  advance(ScannerT const& scan) const
  {
     IterationPolicy::advance(scan);
  }
 
  template <typename ScannerT>
  bool at_end(ScannerT const& scan) const
  {
     return IterationPolicy::at_end(scan);
  }
 
  template <typename T>
  T filter(T ch) const
  {
     return IterationPolicy::filter(ch);
  }
 
  template <typename ScannerT>
  typename ScannerT::ref_t
  get(ScannerT const& scan) const
  {
     return IterationPolicy::get(scan);
  }
};
 
class MaGrammaire
   :public grammar<MaGrammaire>
{
public:
   template <typename ScannerT>
   typename parser_result<self_t, ScannerT>::type
   parse(ScannerT const& scan) const
   {
      //change_policies
      scanner_policies<
        Mon_iteration_policy<ScannerT::policies_t::iteration_policy_t>,
        ScannerT::policies_t::match_policy_t,
        ScannerT::policies_t::action_policy_t
      > MaNouvellePolitique;
 
      return grammar::parse(scan.change_policies(MaNouvellePolitique));
   }
   template <typename ScannerT>
   struct definition
   {
   ...

Je pourrais aussi me placer au niveau de match pour savoir lorsqu'une règle a été vérifiée. Mais bon, après un w.e. de repos et réflexion, il me semble qu'effectivement se placer sur les actions est plus approprié. Certes ça alourdit la grammaire. Mais bon...
Merci pour tes remarques.