Les États du ping-pong

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

Les états « pinger » et « ponger » sont des états parallèles, c’est-à-dire qu’ils sont activés simultanément et qu’ils effectueront des transitions indépendamment l’un de l’autre.

L'état « pinger » enverra le premier événement « ping » dès son entrée ; l'état « ponger » répondra en envoyant un événement « pong » ; cela provoquera l'envoi par l'état « pinger » d'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 lorsque cet état est activé.

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 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 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 destination. Lorsqu’une telle transition est déclenchée, l’état source n’est ni quitté ni réintégré ; seule la fonction onTransition() de la transition est appelée, et la configuration de la machine à états reste inchangée, ce qui correspond exactement à ce que nous souhaitons dans ce cas précis.

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

    return app.exec();
}

Enfin, le groupe est ajouté à la machine à états, celle-ci est lancée, puis la boucle d’événements de l’application est activée.

Exemple de projet sur code.qt.io