Discussion :

[coda_blank]

Bonsoir, j'aimerais mettre en place une chaîne d'instructions comme dans un algorithme classique mais de manière à être configurable dans un fichier texte;

par exemple, pouvoir faire (en pseudo-code):

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
 
 
//création d'objets
create C1 object c1;
create C2 object c2;
create C3 object c3;
 
//appels de méthodes
call method m1 on object c1;
call method m2 on object c2;
 
//branchement
if (condition) then { call method m3 on object c3; }
else  { call method m1 on object c1; }
 
//parcours de liste
for(i=; i<100; ++i)
  call method m2 on object c2;

etc...

ce pseudo-code sera "traduit en classes" au chargement

en gros, enchaîner des instructions très basiques que je puisse ajouter ou retirer à la volée

Pour l'instant j'ai en tête une classe de base "TasksChain" dont dérivent 3 classes filles :

1. une classe "TasksList" pour traiter une suite d'appels de méthodes : je stocke les foncteurs correspondants dans un std::vector que je parcours ensuite; cette classe a un pointeur sur une autre instance de
   TasksChain
   
2. pour les branchements j'ai pensé à une classe "TaskConditional" avec pour chaque possibilité (stockées dans une std::map) un pointeur sur une autre instance de TasksChain
   
3. enfin pour les boucles une classe "TasksLoop" qui pointe sur une TasksList qui sera exécutée un nombre n de fois

Cette organisation vous semble-t-elle pertinente ?

sinon existe-il déjà des solutions ou des libs disponibles ?

[koala01]

Salut,

En fait, je ferais sans doute une classe de base Task, avec un seule fonction (en dehors des constructeurs et destructeurs ) virtuelle pure : execute.

A partir de là, pour chaque foncteur, il y aurait une classe qui hérite de cette classe de base, et, pour les "bloc d'instructions" comme les boucle et autres tests, on se baserait meme sur un pattern proche du composite.

La tache qui servirait pour les tests pourrait en effet ressembler à

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
class Task
{
    public:
        virtual ~Task(){}
        virtual void execute() = 0;
}
class Test : public Task
{
    public:
        Test(Functor * fun):fun_(fun){}
        virtual void execute()
        {
            if(fun() )
                executeAll(true_.begin(),true_.end());
            else
                executeAll(false_.begin(),false_.end());
        }
    private:
        template <typename iterator>
        void executeAll(iterator begin, iterator end)
        {
             while(begin!:end)
             {
                  (*begin)->execute();
                  ++begin;
             }
        }
        std::vector<Task*> true_;
        std::vector<Task*> false_;
};

Après, vient le problème du parsing et de la compréhension du fichier texte dans lequel le "script" est défini

[coda_blank]

Salut,

En fait, je ferais sans doute une classe de base Task, avec un seule fonction (en dehors des constructeurs et destructeurs ) virtuelle pure : execute.

A partir de là, pour chaque foncteur, il y aurait une classe qui hérite de cette classe de base, et, pour les "bloc d'instructions" comme les boucle et autres tests, on se baserait meme sur un pattern proche du composite.

La tache qui servirait pour les tests pourrait en effet ressembler à

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
class Task
{
    public:
        virtual ~Task(){}
        virtual void execute() const = 0;
}
class Test : public Task
{
    public:
        Test(Functor * fun):fun_(fun){}
        virtual void execute() const
        {
            if(fun() )
                executeAll(true_.begin(),true_.end());
            else
                executeAll(false_.begin(),false_.end());
        }
    private:
        template <typename iterator>
        void executeAll(iterator begin, iterator end) const
        {
             while(begin!:end)
             {
                  (*begin)->execute();
                  ++begin;
             }
        }
        std::vector<Task*> true_;
        std::vector<Task*> false_;
};

Après, vient le problème du parsing et de la compréhension du fichier texte dans lequel le "script" est défini

je vois , mais pour qu'il y ait chaine, il faut bien que Task pointe sur une autre Task, non ?

[bretus]

Bonsoir,

Pour ce dont te parle Koala, tu devrais trouver des ressources à l'aide des mots clés "Design Pattern Interpreter".

C'est pas très complexe à mettre en place, mais "chiant" (C++ seul est pauvre au runtime)

Tu n'as pas la possibilité d'utiliser un langage existant (python, ECMAScript, etc) qu'il te suffirait d'étendre?

[coda_blank]

Bonsoir,

Pour ce dont te parle Koala, tu devrais trouver des ressources à l'aide des mots clés "Design Pattern Interpreter".

C'est pas très complexe à mettre en place, mais "chiant" (C++ seul est pauvre au runtime)

Tu n'as pas la possibilité d'utiliser un langage existant (python, ECMAScript, etc) qu'il te suffirait d'étendre?

Interpeter c'est trop lourd par rapport à ce que je veux faire; j'ai juste besoin d'alias dans un fichier texte pour instancier quelques classes foncteurs

alors bien sûr un langage de script serait l'idéal mais il a l'inconvénient de la lenteur, même compilé, et je dois exécuter des instructions simples plusieurs dizaines de milliers de fois par secondes

sans compter que ça rajoute une dépendance au projet et que les bindings ne sont pas toujours très bien suivis

[bretus]

Désolé, mais j'ai du mal à percevoir la différence entre ce que tu veux et un moteur de script. Je me demande donc en quoi ça sera plus rapide qu'un autre moteur de script?

Le fait que tu ais de la conditionnelle dans ton fichier texte me laisse penser qu'il te faut évaluer des expressions avant de lancer l'exécution de tes listes de tâches.

Je ne vois que de la compilation à la volée à la rigueur pour y échapper (fichier texte => plugin => chargement et exécution)...

C'est ça que tu entends par "traduit en classes"?

[koala01]

je vois , mais pour qu'il y ait chaine, il faut bien que Task pointe sur une autre Task, non ?

Pas forcément...

Tu rajoutes ton pointeur vers une tache dans n'importe quelle collection de la STL (ex : j'ai utilisé un std::vector<Task*> pour true_ et false_ ) et tu parcoure cette collection élément par élément

Ta liste de taches ressemblerait alors à quelque chose comme

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
class TaskList
{
   public:
       ~TaskList(){clear();}
       void addTask(Task * toAdd){tasks_.push_back(toAdd);}
       void execute() const
       {
           for(std::vector<Task*>::const_iterator it=tasks_.begin()
               it!=tasks_.end();++it)
               (*it)->execute();
       }
       void clear()
       {
           for(std::vector<Task*>::const_iterator it=tasks_.begin()
               it!=tasks_.end();++it)
           {
                delete (*it);
            }
            tasks_.clear();
       }
    private:
       std::vector<Task*> tasks_;
}