Ping-Pong-Staaten

In diesem Beispiel wird ein Zustandsdiagramm implementiert, in dem zwei Zustände miteinander kommunizieren, indem sie Ereignisse an die Zustandsmaschine senden. Das Zustandsdiagramm sieht wie folgt aus:

Die Zustände „ pinger “ und „ ponger “ sind parallele Zustände, d. h., sie werden gleichzeitig betreten und durchlaufen Übergänge unabhängig voneinander.

Der Zustand „ pinger “ sendet beim Eintritt das erste „ ping “-Ereignis; der Zustand „ ponger “ reagiert darauf mit dem Senden eines „ pong “-Ereignisses; dies veranlasst den Zustand „ pinger “, ein neues „ ping “-Ereignis zu senden; und so weiter.

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

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

Es sind zwei benutzerdefinierte Ereignisse definiert: „ PingEvent “ und „ PongEvent “.

class Pinger : public QState
{
public:
    explicit Pinger(QState*parent) : QState(parent) { }

protected:
    void onEntry(QEvent*) override
    {
        machine()->postEvent(new PingEvent);
        qInfo() << "ping?";
    }
};

Die Klasse „ Pinger “ definiert einen Zustand, der beim Eintritt in diesen Zustand eine „ PingEvent “ an die Zustandsmaschine sendet.

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!";
    }
};

Die Klasse „ PingTransition “ definiert einen Übergang, der durch Ereignisse vom Typ „ PingEvent “ ausgelöst wird und bei dessen Auslösung ein „ PongEvent “ (mit einer Verzögerung von 500 Millisekunden) an die Zustandsmaschine gesendet wird.

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?";
    }
};

Die Klasse „ PongTransition “ definiert einen Übergang, der durch Ereignisse vom Typ „ PongEvent “ ausgelöst wird und bei dessen Auslösung ein „ PingEvent “ (mit einer Verzögerung von 500 Millisekunden) an die Zustandsmaschine gesendet wird.

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

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

Die Funktion `main()` beginnt mit der Erstellung einer Zustandsmaschine und einer parallelen Zustandsgruppe.

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

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

Anschließend werden die Zustände „ pinger “ und „ ponger “ angelegt, wobei die parallele Zustandsgruppe als übergeordneter Zustand dient. Beachten Sie, dass die Übergänge zielfrei sind. Wenn ein solcher Übergang ausgelöst wird, wird der Quellzustand nicht verlassen und erneut betreten; es wird lediglich die Funktion `onTransition()` des Übergangs aufgerufen, und die Konfiguration der Zustandsmaschine bleibt unverändert – genau das ist in diesem Fall beabsichtigt.

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

    return app.exec();
}

Abschließend wird die Gruppe zur Zustandsmaschine hinzugefügt, die Maschine wird gestartet und die Ereignisschleife der Anwendung wird aufgerufen.

Beispielprojekt @ code.qt.io