QScxmlStateMachine Class

Documentation des fonctions membres

[invokable] QStringList QScxmlStateMachine::activeStateNames(bool compress = true) const

Récupère la liste des noms de tous les états actifs.

Lorsqu’un état est actif, tous ses états parents le sont par définition. Lorsque compress est défini sur true (valeur par défaut), les états parents sont filtrés et seuls les états feuilles sont renvoyés. Lorsqu’il est défini sur false, la liste complète des états actifs est renvoyée.

[invokable] void QScxmlStateMachine::cancelDelayedEvent(const QString &sendId)

Annule un événement différé avec l’ sendId spécifiée.

Crée une connexion de l'type donnée, à partir de l'événement spécifié par scxmlEventSpec vers functor, qui peut être un foncteur ou une fonction membre de l'objet facultatif context.

L'functor du récepteur doit prendre un QScxmlEvent en paramètre.

Contrairement aux spécifications d'événements dans les documents SCXML, les espaces ne sont pas autorisés dans l'scxmlEventSpec ici. Afin de se connecter à plusieurs événements ayant des préfixes différents, connectToEvent() doit être appelée plusieurs fois.

Renvoie un descripteur de connexion, qui pourra être utilisé ultérieurement pour se déconnecter.

QMetaObject::Connection QScxmlStateMachine::connectToEvent(const QString &scxmlEventSpec, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion de l’ type spécifiée, depuis l’événement indiqué par scxmlEventSpec vers l’ method dans l’objet receiver. La méthode method du récepteur peut prendre une QScxmlEvent en paramètre. Par exemple :

void mySlot(const QScxmlEvent &event);

Contrairement aux spécifications d’événements dans les documents SCXML, les espaces ne sont pas autorisés dans l’ scxmlEventSpec. Afin de se connecter à plusieurs événements avec des préfixes différents, la méthode connectToEvent() doit être appelée plusieurs fois.

Renvoie un descripteur de connexion, qui peut être utilisé ultérieurement pour se déconnecter.

Crée une connexion de l’ type donnée, à partir de l’état spécifié par scxmlStateName vers functor, qui peut être un foncteur ou une fonction membre de l’objet facultatif context.

L'functor du récepteur doit prendre un argument booléen indiquant si l'état connecté est devenu actif ou inactif.

Renvoie un descripteur de la connexion, qui pourra être utilisé ultérieurement pour se déconnecter.

QMetaObject::Connection QScxmlStateMachine::connectToState(const QString &scxmlStateName, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion entre l'type donnée et l'état identifié par scxmlStateName, vers l'method de l'objet receiver. La méthode method du récepteur peut prendre un argument booléen indiquant si l'état connecté est devenu actif ou inactif. Par exemple :

void mySlot(bool active);

Renvoie un descripteur de connexion, qui pourra être utilisé ultérieurement pour se déconnecter.

QScxmlDataModel *QScxmlStateMachine::dataModel() const

Renvoie le modèle de données utilisé par la machine à états.

Voir aussi setDataModel().

[signal] void QScxmlStateMachine::finished()

Ce signal est émis lorsque la machine à états atteint un état final de niveau supérieur.

Voir également running.

[static] QScxmlStateMachine *QScxmlStateMachine::fromData(QIODevice *data, const QString &fileName = QString())

Crée une machine à états à partir du fichier QIODevice spécifié par data.

Cette méthode renvoie toujours une machine à états. Si des erreurs surviennent lors de la lecture du fichier SCXML fileName, la machine à états ne peut pas être lancée. Les erreurs peuvent être récupérées en appelant la méthode parseErrors().

Voir également parseErrors().

[static] QScxmlStateMachine *QScxmlStateMachine::fromFile(const QString &fileName)

Crée une machine à états à partir du fichier SCXML spécifié par fileName.

Cette méthode renvoie toujours une machine à états. Si des erreurs surviennent lors de la lecture du fichier SCXML, la machine à états ne peut pas être lancée. Les erreurs peuvent être récupérées en appelant la méthode parseErrors().

Voir également parseErrors().

[slot] bool QScxmlStateMachine::init()

Initialise la machine à états.

L'initialisation de la machine à états consiste à appeler la méthode ` QScxmlDataModel::setup()`, à définir les valeurs initiales des éléments ` <data> ` et à exécuter toutes les balises ` <script> ` de la balise ` <scxml> `. Les valeurs initiales des données sont extraites de la propriété ` initialValues `.

Renvoie ` false ` si des erreurs d’analyse se produisent ou si l’une des étapes d’initialisation échoue. Renvoie ` true ` dans le cas contraire.

[invokable] bool QScxmlStateMachine::isActive(const QString &scxmlStateName) const

Renvoie « true » si l'état spécifié par « scxmlStateName » est actif, et « false » dans le cas contraire.

[protected] bool QScxmlStateMachine::isActive(int stateIndex) const

Renvoie « true » si l'état dont l'ID est « stateIndex » est actif.

Cette méthode fait partie de l'interface de la représentation compilée des machines à états SCXML. Elle ne doit être utilisée qu'en interne et par les machines à états compilées à partir de documents SCXML.

[invokable] bool QScxmlStateMachine::isDispatchableTarget(const QString &target) const

Renvoie « true » si un message destiné à « target » peut être envoyé par cette machine à états.

Les cibles valides sont :

• #_parent la machine à états parente si la machine à états actuelle est lancée par <invoke>
• #_internal pour la machine à états actuelle
• #_scxml_sessionid, où sessionid est l’ID de session de la machine à états actuelle
• #_servicename, où servicename est l’identifiant ou le nom d’un service lancé avec l’option « <invoke> » par cette machine à états

bool QScxmlStateMachine::isRunning() const

Renvoie « true » si la machine à états est en cours d'exécution, « false » dans le cas contraire.

Voir également setRunning() et runningChanged().

[signal] void QScxmlStateMachine::log(const QString &label, const QString &msg)

Ce signal est émis si une balise ` <log> ` est utilisée dans le SCXML. ` label ` correspond à la valeur de l'attribut `label` de la balise ` <log> `. ` msg ` correspond à la valeur de l'attribut `expr` (après évaluation) de la balise ` <log> `. En l'absence d'attribut `expr`, une chaîne vide est renvoyée.

[static] template <typename Functor> std::function<void (bool)> QScxmlStateMachine::onEntry(Functor functor)

Renvoie un foncteur qui accepte un argument booléen et appelle l’ functor on fournie si cet argument est « true ». L’ functor on fournie ne doit accepter aucun argument.

Ceci est utile pour encapsuler des gestionnaires destinés à ` connectToState()` qui ne doivent être exécutés que lorsque l’état est activé.

[static] std::function<void (bool)> QScxmlStateMachine::onEntry(const QObject *receiver, const char *method)

Renvoie un foncteur qui accepte un argument booléen et appelle l'method on donnée sur receiver à l'aide de QMetaObject::invokeMethod() si cet argument est true et si receiver n'a pas encore été supprimé.

L’ method e fournie ne doit accepter aucun argument. « method » correspond au nom de la méthode tel quel, sans être encadré par « SIGNAL() » ou « SLOT() ».

Cela est utile pour encapsuler des gestionnaires pour connectToState() qui ne doivent être exécutés que lorsque l’état est activé.

[static] template <typename PointerToMemberFunction> std::function<void (bool)> QScxmlStateMachine::onEntry(const typename QtPrivate::FunctionPointer<PointerToMemberFunction>::Object *receiver, PointerToMemberFunction method)

Renvoie un functor qui accepte un argument booléen et appelle l'method on donnée sur receiver si cet argument est true et si l'receiver n'a pas encore été supprimée. L'method on donnée ne doit accepter aucun argument.

Cela est utile pour encapsuler des gestionnaires pour connectToState() qui ne doivent être exécutés que lorsque l'état est activé.

[static] template <typename Functor> std::function<void (bool)> QScxmlStateMachine::onExit(Functor functor)

Renvoie un foncteur qui accepte un argument booléen et appelle l’ functor donnée si cet argument est « false ». L’ functor donnée ne doit accepter aucun argument.

Ceci est utile pour encapsuler des gestionnaires de l'connectToState() qui ne doivent être exécutés que lorsque l'on quitte l'état.

[static] std::function<void (bool)> QScxmlStateMachine::onExit(const QObject *receiver, const char *method)

Renvoie un foncteur qui accepte un argument booléen et appelle l’ method on donnée sur receiver à l’aide de QMetaObject::invokeMethod() si cet argument est false et si receiver n’a pas encore été supprimé.

L'method e fournie ne doit accepter aucun argument. method correspond au nom de la méthode tel quel, sans être encadré par SIGNAL(...) ou SLOT(...).

Cela est utile pour encapsuler des gestionnaires autour d’ connectToState() qui ne doivent être exécutés que lorsque l’état est quitté.

[static] template <typename PointerToMemberFunction> std::function<void (bool)> QScxmlStateMachine::onExit(const typename QtPrivate::FunctionPointer<PointerToMemberFunction>::Object *receiver, PointerToMemberFunction method)

Renvoie un foncteur qui accepte un argument booléen et appelle l'method donnée sur receiver si cet argument est false et si le receiver n'a pas encore été supprimé. L'method donnée ne doit accepter aucun argument.

Cela est utile pour encapsuler des gestionnaires pour ` connectToState()` qui ne doivent être exécutés que lorsque l’état est quitté.

[signal] void QScxmlStateMachine::reachedStableState()

Ce signal est émis lorsque la file d'attente d'événements est vide à la fin d'une étape de macro ou lorsqu'un état final est atteint.

[signal] void QScxmlStateMachine::runningChanged(bool running)

Ce signal est émis lorsque la propriété « running » est modifiée avec « running » comme argument.

void QScxmlStateMachine::setDataModel(QScxmlDataModel *model)

Définit le modèle de données de cette machine à états sur model. Il existe une relation 1:1 entre les machines à états et les modèles. Une fois le modèle défini, il ne peut plus être modifié. Toute tentative ultérieure de définir le modèle à l'aide de cette méthode sera ignorée.

Voir également dataModel().

void QScxmlStateMachine::setRunning(bool running)

Lance la machine à états si running a la valeur true, ou l'arrête dans le cas contraire.

Voir également start(), stop(), isRunning() et runningChanged().

[slot] void QScxmlStateMachine::start()

Lance cette machine à états. Lorsqu'un état final de niveau supérieur est atteint, la machine émet le signal finished().

Voir également runningChanged(), setRunning(), stop() et finished().

[invokable] QStringList QScxmlStateMachine::stateNames(bool compress = true) const

Récupère la liste des noms de tous les États.

Lorsque ` compress ` est défini sur ` true ` (valeur par défaut), les états contenant des états enfants sont filtrés et seuls les états feuilles sont renvoyés. Lorsqu'il est défini sur ` false`, la liste complète de tous les états est renvoyée.

La liste renvoyée ne contient pas les états des machines à états imbriquées éventuelles.

[slot] void QScxmlStateMachine::stop()

Arrête cette machine à états. La machine n'effectuera plus aucune transition d'état. Sa propriété « running » est définie sur « false ».

Voir également runningChanged(), start() et setRunning().

[invokable] void QScxmlStateMachine::submitEvent(QScxmlEvent *event)

Envoie l'event d'événement SCXML vers la file d'attente d'événements interne ou externe, en fonction de la priorité de l'événement.

Lorsqu'un délai est défini, l'événement est mis en file d'attente pour être transmis une fois le délai écoulé. La machine à états prend en charge l'event et la supprime après traitement.

[invokable] void QScxmlStateMachine::submitEvent(const QString &eventName)

Méthode utilitaire permettant de créer et d'envoyer un événement externe portant le nom « eventName ».

[invokable] void QScxmlStateMachine::submitEvent(const QString &eventName, const QVariant &data)

Méthode d'utilité permettant de créer et d'envoyer un événement externe avec le nom « eventName » et les données de charge utile « data ».