États du ping-pong

Cet exemple met en œuvre un diagramme d'états dans lequel deux états communiquent en envoyant des événements à la machine à états. Le diagramme d'état se présente comme suit :

Les états pinger et ponger sont des états parallèles, c'est-à-dire qu'ils sont entrés simultanément et prendront des transitions indépendamment l'un de l'autre.

L'état pinger affichera le premier événement ping à l'entrée ; l'état ponger répondra en affichant un événement pong, ce qui amènera l'état pinger à afficher un nouvel événement ping, et ainsi de suite.

class PingEvent : public QEvent
{
public:
    PingEvent() : QEvent(PingEventType) { }
};

class PongEvent : public QEvent
{
public:
    PongEvent() : QEvent(PongEventType) { }
};

Deux événements personnalisés sont définis, PingEvent et PongEvent.

class Pinger : public QState
{public: explicit Pinger(QState *parent) : QState(parent) { }protected: void onEntry(QEvent *) override { machine()->postEvent(new PingEvent) ;        qInfo() << "ping?";
    } } ;

La classe Pinger définit un état qui envoie un message PingEvent à la machine à états lors de l'entrée dans l'état.

class PingTransition : public QAbstractTransition
{public: PingTransition() {}protected: bool eventTest(QEvent *e) override { return  e->type() == PingEventType ; } void onTransition(QEvent *) override { machine()->postDelayedEvent(new PongEvent, 500) ;        qInfo() << "pong!";
    } } ;

La classe PingTransition définit une transition qui est déclenchée par des événements de type PingEvent, et qui envoie un message PongEvent (avec un délai de 500 millisecondes) à la machine à états lorsque la transition est déclenchée.

class PongTransition : public QAbstractTransition
{public: PongTransition() {}protected: bool eventTest(QEvent *e) override { return (e->type() == PingEventType) ; } void onTransition(QEvent *) override { machine()->postDelayedEvent(new PingEvent, 500) ;        qInfo() << "ping?";
    } } ;

La classe PongTransition définit une transition qui est déclenchée par des événements de type PongEvent, et qui envoie un message PingEvent (avec un délai de 500 millisecondes) à la machine à états lorsque la transition est déclenchée.

int main(int argc, char **argv)
{
    QCoreApplication app(argc, argv);

    QStateMachine machine;
    auto group = new QState(QState::ParallelStates);
    group->setObjectName("group");

La fonction main() commence par créer une machine à états et un groupe d'états parallèles.

    auto pinger = new Pinger(group);
    pinger->setObjectName("pinger");
    pinger->addTransition(new PongTransition);

    auto ponger = new QState(group);
    ponger->setObjectName("ponger");
    ponger->addTransition(new PingTransition);

Ensuite, les états pinger et ponger sont créés, avec le groupe d'états parallèles comme état parent. Notez que les transitions sont sans cible. Lorsqu'une telle transition est déclenchée, l'état source ne sera pas quitté et réintroduit ; seule la fonction onTransition() de la transition sera appelée, et la configuration de la machine à états restera la même, ce qui est précisément ce que nous voulons dans ce cas.

    machine.addState(group);
    machine.setInitialState(group);
    machine.start();

    return app.exec();
}

Enfin, le groupe est ajouté à l'automate à états, l'automate est démarré et la boucle événementielle de l'application est lancée.

Exemple de projet @ code.qt.io