Ping Pong Staaten

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

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

Der Zustand pinger sendet beim Eintritt das erste Ereignis ping; der Zustand ponger antwortet mit einem Ereignis pong; dies veranlasst den Zustand pinger, ein neues Ereignis ping zu senden, und so weiter.

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

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

Zwei benutzerdefinierte Ereignisse sind 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 eine PingEvent an den Zustandsautomaten sendet, wenn der Zustand betreten wird.

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 des Typs PingEvent ausgelöst wird, und der eine PongEvent (mit einer Verzögerung von 500 Millisekunden) an den Zustandsautomaten sendet, wenn der Übergang ausgelöst 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 des Typs PongEvent ausgelöst wird, und der eine PingEvent (mit einer Verzögerung von 500 Millisekunden) an den Zustandsautomaten sendet, wenn der Übergang ausgelöst 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 eines Zustandsautomaten 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);

Als nächstes werden die Zustände pinger und ponger erstellt, wobei die parallele Zustandsgruppe als ihr übergeordneter Zustand dient. Beachten Sie, dass die Übergänge ziellos sind. Wenn ein solcher Übergang ausgelöst wird, wird der Ausgangszustand nicht verlassen und wieder betreten; nur die onTransition()-Funktion des Übergangs wird aufgerufen, und die Konfiguration des Zustandsautomaten bleibt unverändert, was genau das ist, was wir in diesem Fall wollen.

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

    return app.exec();
}

Abschließend wird die Gruppe dem Zustandsautomaten hinzugefügt, der Automat gestartet und die Ereignisschleife der Anwendung wird betreten.

Beispielprojekt @ code.qt.io