Discussion :

[hicham.gi]

Bonjour à tous,
voila un peu mon soucis: dans mon application, une demande (tache affecté à un ingénieur developpeur) passe par trois états :
En attente (crée non affecté à personne encore)
En cours (affecté à quelqu'un travillant dessus)
Close (terminée)

j'ai un peu fait un petit diagramme d'états illustrant ceci, sachant que j'ai fait un diagramme de classe (contenant bien sur une classe Demande) à partir duquel j'ai généré une squelette de code.

Je veux savoir comment cet état pourrait se traduire en terme de code sur mon entité demande?
Je sais que bien sur il ne faut pas avoir un attribut qui designe l'état sur la classe demande !!
Merci à tous

[bruno_pages]

Dans le générateur de Bouml j'associe une classe à chaque état, les imbrications des états produisant les mêmes imbrications de classes

mais ce n'est qu'une des implémentations possiblesdes machines à états

[hicham.gi]

Excusez moi mais je n'ai pas bien saisi ce que tu veux dire, surtout par imbrication !!
si j'ai un peu pigé, il y a moyen de lier chaque classe à son diagramme d'états et puis génerer le code à partir du diagramme de classes, mais ma question c'est comment cela (so vous savez comment) va se traduire sur le code ?
des if else.. en pricipe sur la classe ?...

[bruno_pages]

Excusez moi mais je n'ai pas bien saisi ce que tu veux dire, surtout par imbrication !!

Tu as la machine à etats demande contenant les sous états enAttente, enCours et terminée. Dans Bouml le générateur produit la classe demande contenant les classes (imbriquées donc) enAttente, enCours et terminée (en suposant qu'il y ai vraiment un état terminée c.a.d. que l'etat terminal de la norme ne suffise pas)

si j'ai un peu pigé, il y a moyen de lier chaque classe à son diagramme d'états

non, une machine à état est un comportement et est donc associée à une opération par exemple, mais pas à une classe. Par conter une classe peut implémenter une machine à états.

comment cela (so vous savez comment) va se traduire sur le code ?

si j'utilise l'état terminal 'officiel' pour ne pas surcharger :



avec l'implémentation en C++ cela donne les classes :

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#ifndef _DEMANDE_H
#define _DEMANDE_H


// implement the state machine demande
class demande {
  protected:
    // Mother class of all the classes representing states
    class AnyState {
      public:
        // return the upper state
        virtual AnyState * _upper(demande &) = 0;

        virtual void create(demande &);

    };
    
    // implement the state demande
    class demande_State : public AnyState {
      public:
        // implement the state enAttente
        class enAttente_State : public AnyState {
          public:
            virtual bool _completion(demande & stm);

            // to manage the event create
            virtual void create(demande & stm);

            // returns the state containing the current
            virtual AnyState * _upper(demande & stm);

        };
        
        // implement the state enCours
        class enCours_State : public AnyState {
          public:
            virtual bool _completion(demande & stm);

            // to manage the event create
            virtual void create(demande & stm);

            // returns the state containing the current
            virtual AnyState * _upper(demande & stm);

        };
        
        // memorize the instance of the state enAttente, internal
        enAttente_State _enattente_state;

        // memorize the instance of the state enCours, internal
        enCours_State _encours_state;

        // to manage the event create
        virtual void create(demande & stm);

        // returns the state containing the current
        virtual AnyState * _upper(demande &);

    };
    
    // memorize the instance of the state demande, internal
    demande_State _demande_state;


  public:
    demande();

    // the operation you call to signal the event create
    bool create();

  friend class demande_State::enAttente_State;
  friend class demande_State::enCours_State;
  friend class demande_State;

  protected:
    // change the current state, internal
    inline void _set_currentState(AnyState & st);

    // execution done, internal
    void _final();

    // contains the current state, internal
    AnyState * _current_state;

};
// change the current state, internal
inline void demande::_set_currentState(demande::AnyState & st) {
    _current_state = &st;
}

#endif

avec :

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#include "demande.h"

void demande::AnyState::create(demande &) {
}

bool demande::demande_State::enAttente_State::_completion(demande & stm) {
    {
      stm._set_currentState(stm._demande_state._encours_state);
#ifdef VERBOSE_STATE_MACHINE
      puts("DEBUG : current state is now .demande.enCours");
#endif
      stm._demande_state._encours_state.create(stm);
      return (bool) 1;
    }
}

// to manage the event create
void demande::demande_State::enAttente_State::create(demande & stm) {
  	_completion(stm);
}

// returns the state containing the current
demande::AnyState * demande::demande_State::enAttente_State::_upper(demande & stm) {
    return &stm._demande_state;
}

bool demande::demande_State::enCours_State::_completion(demande & stm) {
    {
      stm._set_currentState(stm._demande_state);
#ifdef VERBOSE_STATE_MACHINE
      puts("DEBUG : current state is now .demande");
#endif
      stm._final();
      return (bool) 1;
    }
}

// to manage the event create
void demande::demande_State::enCours_State::create(demande & stm) {
  	_completion(stm);
}

// returns the state containing the current
demande::AnyState * demande::demande_State::enCours_State::_upper(demande & stm) {
    return &stm._demande_state;
}

// to manage the event create
void demande::demande_State::create(demande & stm) {
    {
      stm._set_currentState(stm._demande_state._enattente_state);
#ifdef VERBOSE_STATE_MACHINE
      puts("DEBUG : current state is now .demande.enAttente");
#endif
      stm._demande_state._enattente_state.create(stm);
    }
}

// returns the state containing the current
demande::AnyState * demande::demande_State::_upper(demande &) {
    return 0;
}

demande::demande() {
    _current_state = 0;
}

// the operation you call to signal the event create
bool demande::create() {
  if (_current_state == 0)
  (_current_state = &(*this)._demande_state)->create(*this);
  return (_current_state != 0);
}

// execution done, internal
void demande::_final() {
    _current_state = 0;
#ifdef VERBOSE_STATE_MACHINE
    puts("DEBUG : final state reached");
#endif
}

mais je suis pas sure que cela te serve vraiment

tu devrais chercher sur internet ... ou dans tes cours

Bruno

[hed62]

Renseigne toi surtout sur le design pattern "State" ("Etat")

[hicham.gi]

Oh que si !! Merci beacoup Bruno, aussi Hed62
j'ai une bonne idée maintenant de comment ca marche,
je me premet de revenir vers vous bientot
j'ai des bases pour mieux chercher maintenant !!
bonne journée a vous deux