Издача сигналов из класса, если переход в QStateMachine прошел успешно

Question

Издача сигналов из класса, если переход в QStateMachine прошел успешно

Моя проблема заключается в следующем: мне нужно создать класс, который содержит экземпляр QStateMachine. Этот класс должен иметь слоты, через которые вы могли бы «попросить» конечный автомат сделать переход в другое состояние. И если переход прошел успешно, мой класс должен подать сигнал об этом. Как бы я это реализовал? Класс должен обладать способностью излучать определенные сигналы в соответствии с определенным интервалом вызова.
Вот небольшой пример класса:

class MyClass : public QObject
{
Q_OBJECT
public:
explicit MyClass(QObject *parent = 0)
{
mStateMachine = new QStateMachine(this);
QState *s1 = new QState(mStateMachine);
QState *s2 = new QState(mStateMachine);
QState *s3 = new QState(mStateMachine);

s1->addTransition(); // Transition to s2
s2->addTransition(); // Transition to s3
s3->addTransition(); // Transition to s1

mStateMachine->setInitialState(s1);
mStateMachine->start();
}

signals:
toS1();
toS2();
toS3();

public slots:
slotToS1()
{
/* post event to state machine about
transition to state s1,
if transition was successful,
then emit toS1() signal. */
};
slotToS2(){ /* Similar to slotToS1 */};
slotToS3(){ /* Similar to slotToS1 */};
private:
QStateMachine *mStateMachine;
}

Буду очень признателен за вашу помощь!

UPD:
Слоты представляют разные виды переходов, так что внешний класс (который будет использовать MyClass) может «попросить» о некотором переходе. Таким образом, слот отправляет событие или сигнал конечному автомату, он просматривает событие или сигнал и (если находится в правильном состоянии) выполняет этот переход. И я хочу уведомить внешний класс определенным сигналом, который был задан до того, как слот (переход) был выполнен успешно.

2

c++finite-state-machine qstatemachine qt

Решение

Другие решения

У меня была такая же проблема в прошлом, и я обнаружил, что самый простой способ — это наследовать fom QState с вашим собственным классом QState и реализовывать 2 метода, называемых QState :: onEntry (QEvent * event) QState :: onExit (QEvent * event)

Таким образом, вы можете испускать любой сигнал, который вам нравится, когда вы выходите и когда вы входите в новое состояние.

Вот и пример:

файл mystate.h

#include <QState>

class MyState : public QState
{
Q_OBJECT
public:
explicit MyState(qint32 stateId, QState * parent = 0);

protected:
void onEntry(QEvent * event);
void onExit(QEvent * event);

signals:
void exit(qint32 stateId);
void enter(qint32 stateId);

private:

qint32 stateId;

};

И файл mystate.cpp

#include "mystate.h"

MyState::MyState(qint32 stateId, QState *parent)
{
this->stateId = stateId;
}

void MyState::onEntry(QEvent *event)
{
emit enter(stateId);
}

void MyState::onExit(QEvent *event)
{
emit (exit(stateId));
}

2

Источник

Accepted Answer

Чтобы перейти на слот-вызов, нужно как-то привязать слот к QAbstractTransition, Есть два способа сделать это:
- Использовать QEventTransition и отправьте соответствующее событие, чтобы вызвать его.
- Использовать QSignalTransition и использовать внутренний сигнал для его запуска.
Чтобы излучать сигналы при переходе между состояниями, вы можете подключить QAbstractTransition::triggered или же QState::entered или же QState::exited сигналы к другие сигналы. Помните, что в Qt целью соединения может быть либо слот, либо сигнал.

Таким образом, используя сигнальные переходы:

class MyClass : public QObject
{
Q_OBJECT
QStateMachine machine;
QState s1, s2;
Q_SIGNAL void s_go_s1_s2();
Q_SIGNAL void s_go_s2_s1();
public:
Q_SIGNAL void transitioned_s1_s2();
Q_SIGNAL void transitioned_s2_s1();
Q_SLOT void go_s2_s1() { emit s_go_s2_s1(); }
Q_SLOT void go_s1_s2() { emit s_go_s1_s2(); }
explicit MyClass(QObject *parent = 0) : QObject(parent),
s1(&machine), s2(&machine) {
auto s1_s2 = s1.addTransition(this, SIGNAL(s_go_s1_s2()), &s2);
auto s2_s1 = s2.addTransition(this, SIGNAL(s_go_s2_s1()), &s1);
machine.setInitialState(&s1);
machine.start();
connect(s1_s2, &QAbstractTransition::triggered, this, &MyClass:: transitioned_s1_s2);
connect(s2_s1, &QAbstractTransition::triggered, this, &MyClass:: transitioned_s2_s1);
}
}

Использовать переходы событий немного сложнее, так как используемые вами события должны быть клонированы конечным автоматом. Конечный автомат основного модуля знает только, как клонировать None а также Timer события — увидеть его cloneEvent реализация.

Модуль виджетов добавляет поддержку различных событий GUI / Widgets — см. cloneEvent реализация там. Вы могли бы, в крайнем случае, использовать такие события GUI для своих собственных целей — в конце концов, они отправляются на простой QObject это не интерпретирует их особым образом.

Вы можете предоставить свой собственный cloneEvent реализация, которая связана с другими.

#include <private/qstatemachine_p.h>

class MyClass : public QObject
{
Q_OBJECT
QStateMachine machine;
QState s1, s2;
QEvent e_s1_s2, e_s2_s1;
QEventTransition s1_s2, s2_s1;
public:
Q_SIGNAL void transitioned_s1_s2();
Q_SIGNAL void transitioned_s2_s1();
Q_SLOT void go_s2_s1() { QCoreApplication::sendEvent(this, &e_s2_s1); }
Q_SLOT void go_s1_s2() { QCoreApplication::sendEvent(this, &e_s1_s2); }
explicit MyClass(QObject *parent = 0) : QObject(parent),
s1(&machine), s2(&machine),
e_s1_s2((QEvent::Type)(QEvent::User + 1)),
e_s2_s1((QEvent::Type)(QEvent::User + 2)),
s1_s2(this, e_s1_s2.type()),
s2_s1(this, e_s2_s1.type()) {
s1_s2.setTargetState(&s2);
s2_s1.setTargetState(&s1);
s1.addTransition(&s1_s2);
s2.addTransition(&s2_s1);
machine.setInitialState(&s1);
machine.start();
connect(&s1_s2, &QAbstractTransition::triggered, this, &MyClass::transitioned_s1_s2);
connect(&s2_s1, &QAbstractTransition::triggered, this, &MyClass::transitioned_s2_s1);
}
}

static const QStateMachinePrivate::Handler * last_handler = 0;

static QEvent * cloneEvent(QEvent * e) {
if (e->type() >= QEvent::User && e->type() < QEvent::User+100) {
return new QEvent(e->type());
return last_handler->cloneEvent(e);
}

const QStateMachinePrivate::Handler our_handler = {
cloneEvent
};

void registerHandler() {
last_handler = QStateMachinePrivate::handler;
QStateMachinePrivate::handler = &our_handler;
}
Q_CONSTRUCTOR_FUNCTION(registerHandler())

void unregisterHandler() {
QStateMachinePrivate::handler = last_handler;

}
Q_DESTRUCTOR_FUNCTION(unregisterHandler())

4