qscxmlstatemachine_p.h

++ // Copyright (C) 2016 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:significant

++

++ #ifndef QSCXMLSTATEMACHINE_P_H

++ #define QSCXMLSTATEMACHINE_P_H

++

++ //

++ //  W A R N I N G

++ //  -------------

++ //

++ // This file is not part of the Qt API.  It exists purely as an

++ // implementation detail.  This header file may change from version to

++ // version without notice, or even be removed.

++ //

++ // We mean it.

++ //

++

++ #include <QtScxml/private/qscxmlexecutablecontent_p.h>

++ #include <QtScxml/qscxmlstatemachine.h>

++ #include <QtScxml/private/qscxmlstatemachineinfo_p.h>

++ #include <QtCore/private/qobject_p.h>

++ #include <QtCore/private/qmetaobject_p.h>

++ #include <QtCore/private/qproperty_p.h>

++ #include <QtCore/qhash.h>

++ #include <QtCore/qmap.h>

++ #include <QtCore/qvariant.h>

++ #include <QtCore/qmetaobject.h>

++ #include "qscxmlglobals_p.h"

++

++ QT_BEGIN_NAMESPACE

++

++ namespace QScxmlInternal {

++ class EventLoopHook: public QObject

++ {

++     Q_OBJECT

++

++     QScxmlStateMachinePrivate *smp;

++

++ public:

++     EventLoopHook(QScxmlStateMachinePrivate *smp)

++         : smp(smp)

++     {}

++

++     void queueProcessEvents();

++

++     Q_INVOKABLE void doProcessEvents();

++

++ protected:

++     void timerEvent(QTimerEvent *timerEvent) override;

++ };

++

++ class ScxmlEventRouter : public QObject

++ {

++     Q_OBJECT

++ public:

++     ScxmlEventRouter(QObject *parent = nullptr) : QObject(parent) {}

++     QMetaObject::Connection connectToEvent(const QStringList &segments, const QObject *receiver,

++                                            const char *method, Qt::ConnectionType type);

++     QMetaObject::Connection connectToEvent(const QStringList &segments, const QObject *receiver,

++                                            void **slot, QtPrivate::QSlotObjectBase *method,

++                                            Qt::ConnectionType type);

++

++     void route(const QStringList &segments, QScxmlEvent *event);

++

++ signals:

++     void eventOccurred(const QScxmlEvent &event);

++

++ private:

++     QHash<QString, ScxmlEventRouter *> children;

++     ScxmlEventRouter *child(const QString &segment);

++

++     void disconnectNotify(const QMetaMethod &signal) override;

++ };

++

++ class StateMachineInfoProxy: public QObject

++ {

++     Q_OBJECT

++

++ public:

++     StateMachineInfoProxy(QObject *parent)

++         : QObject(parent)

++     {}

++

++ Q_SIGNALS:

++     void statesEntered(const QList<QScxmlStateMachineInfo::StateId> &states);

++     void statesExited(const QList<QScxmlStateMachineInfo::StateId> &states);

++     void transitionsTriggered(const QList<QScxmlStateMachineInfo::TransitionId> &transitions);

++ };

++ } // QScxmlInternal namespace

++

++ class QScxmlInvokableService;

++ class Q_SCXML_EXPORT QScxmlStateMachinePrivate: public QObjectPrivate

++ {

++     Q_DECLARE_PUBLIC(QScxmlStateMachine)

++

++     static QAtomicInt m_sessionIdCounter;

++

++ public: // types

++     typedef QScxmlExecutableContent::StateTable StateTable;

++

++     class HistoryContent

++     {

++         QHash<int, int> storage;

++

++     public:

++         HistoryContent() { storage.reserve(4); }

++

++         int &operator[](int idx) {

++             QHash<int, int>::Iterator i = storage.find(idx);

++             return (i == storage.end()) ? storage.insert(idx, StateTable::InvalidIndex).value() :

++                                           i.value();

++         }

++

++         int value(int idx) const {

++             QHash<int, int>::ConstIterator i = storage.constFind(idx);

++             return (i == storage.constEnd()) ? StateTable::InvalidIndex : i.value();

++         }

++     };

++

++     class ParserData

++     {

++     public:

++         QScopedPointer<QScxmlDataModel> m_ownedDataModel;

++         QList<QScxmlError> m_errors;

++     };

++

++     // The OrderedSet is a set where it elements are in insertion order. See

++     // http://www.w3.org/TR/scxml/#AlgorithmforSCXMLInterpretation under Algorithm, Datatypes. It

++     // is used to keep lists of states and transitions in document order.

++     class OrderedSet

++     {

++         std::vector<int> storage;

++

++     public:

++         OrderedSet(){}

++         OrderedSet(std::initializer_list<int> l): storage(l) {}

++

++         std::vector<int> takeList() const

++         { return std::move(storage); }

++

++         const std::vector<int> &list() const

++         { return storage; }

++

++         bool contains(int i) const

++         {

++             return std::find(storage.cbegin(), storage.cend(), i) != storage.cend();

++         }

++

++         bool remove(int i)

++         {

++             std::vector<int>::iterator it = std::find(storage.begin(), storage.end(), i);

++             if (it == storage.end()) {

++                 return false;

++             }

++             storage.erase(it);

++             return true;

++         }

++

++         void removeHead()

++         { if (!isEmpty()) storage.erase(storage.begin()); }

++

++         bool isEmpty() const

++         { return storage.empty(); }

++

++         void add(int i)

++         { if (!contains(i)) storage.push_back(i); }

++

++         bool intersectsWith(const OrderedSet &other) const

++         {

++             for (auto i : storage) {

++                 if (other.contains(i)) {

++                     return true;

++                 }

++             }

++             return false;

++         }

++

++         void clear()

++         { storage.clear(); }

++

++         typedef std::vector<int>::const_iterator const_iterator;

++         const_iterator begin() const { return storage.cbegin(); }

++         const_iterator end() const { return storage.cend(); }

++     };

++

++     class Queue

++     {

++         QList<QScxmlEvent *> storage;

++

++     public:

++         Queue()

++         { storage.reserve(4); }

++

++         ~Queue()

++         {  qDeleteAll(storage); }

++

++         void enqueue(QScxmlEvent *e)

++         { storage.append(e); }

++

++         bool isEmpty() const

++         { return storage.empty(); }

++

++         QScxmlEvent *dequeue()

++         {

++             Q_ASSERT(!isEmpty());

++             QScxmlEvent *e = storage.first();

++             storage.pop_front();

++             int sz = storage.size();

++             if (Q_UNLIKELY(sz > 4 && sz * 8 < storage.capacity())) {

++                 storage.squeeze();

++             }

++             return e;

++         }

++     };

++

++ public:

++     QScxmlStateMachinePrivate(const QMetaObject *qMetaObject);

++     ~QScxmlStateMachinePrivate();

++

++     static QScxmlStateMachinePrivate *get(QScxmlStateMachine *t)

++     { return t->d_func(); }

++

++     static QString generateSessionId(const QString &prefix);

++

++     ParserData *parserData();

++

++     void setIsInvoked(bool invoked)

++     { m_isInvoked = invoked; }

++

++     void addService(int invokingState);

++     void removeService(int invokingState);

++     QScxmlInvokableServiceFactory *serviceFactory(int id);

++

++     bool executeInitialSetup();

++

++     void routeEvent(QScxmlEvent *event);

++     void postEvent(QScxmlEvent *event);

++     void submitDelayedEvent(QScxmlEvent *event);

++     void submitError(const QString &type, const QString &msg, const QString &sendid = QString());

++

++     void start();

++     void pause();

++     void processEvents();

++

++     void setEvent(QScxmlEvent *event);

++     void resetEvent();

++

++     void emitStateActive(int stateIndex, bool active);

++     void emitInvokedServicesChanged();

++

++     void attach(QScxmlStateMachineInfo *info);

++     const OrderedSet &configuration() const { return m_configuration; }

++

++     void updateMetaCache();

++

++ private:

++     QStringList stateNames(const std::vector<int> &stateIndexes) const;

++     std::vector<int> historyStates(int stateIdx) const;

++

++     void exitInterpreter();

++     void returnDoneEvent(QScxmlExecutableContent::ContainerId doneData);

++     bool nameMatch(const StateTable::Array &patterns, QScxmlEvent *event) const;

++     void selectTransitions(OrderedSet &enabledTransitions,

++                            const std::vector<int> &configInDocumentOrder,

++                            QScxmlEvent *event) const;

++     void removeConflictingTransitions(OrderedSet *enabledTransitions) const;

++     void getProperAncestors(std::vector<int> *ancestors, int state1, int state2) const;

++     void microstep(const OrderedSet &enabledTransitions);

++     void exitStates(const OrderedSet &enabledTransitions);

++     void computeExitSet(const OrderedSet &enabledTransitions, OrderedSet &statesToExit) const;

++     void executeTransitionContent(const OrderedSet &enabledTransitions);

++     void enterStates(const OrderedSet &enabledTransitions);

++     void computeEntrySet(const OrderedSet &enabledTransitions,

++                          OrderedSet *statesToEnter,

++                          OrderedSet *statesForDefaultEntry,

++                          HistoryContent *defaultHistoryContent) const;

++     void addDescendantStatesToEnter(int stateIndex,

++                                     OrderedSet *statesToEnter,

++                                     OrderedSet *statesForDefaultEntry,

++                                     HistoryContent *defaultHistoryContent) const;

++     void addAncestorStatesToEnter(int stateIndex,

++                                   int ancestorIndex,

++                                   OrderedSet *statesToEnter,

++                                   OrderedSet *statesForDefaultEntry,

++                                   HistoryContent *defaultHistoryContent) const;

++     std::vector<int> getChildStates(const StateTable::State &state) const;

++     bool hasDescendant(const OrderedSet &statesToEnter, int childIdx) const;

++     bool allDescendants(const OrderedSet &statesToEnter, int childdx) const;

++     bool isDescendant(int state1, int state2) const;

++     bool allInFinalStates(const std::vector<int> &states) const;

++     bool someInFinalStates(const std::vector<int> &states) const;

++     bool isInFinalState(int stateIndex) const;

++     int getTransitionDomain(int transitionIndex) const;

++     int findLCCA(OrderedSet &&states) const;

++     void getEffectiveTargetStates(OrderedSet *targets, int transitionIndex) const;

++

++ public: // types & data fields:

++     QString m_sessionId;

++     bool m_isInvoked;

++

++     void isInitializedChanged()

++     {

++         emit q_func()->initializedChanged(m_isInitialized.value());

++     }

++     Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QScxmlStateMachinePrivate,

++                                          bool, m_isInitialized, false,

++                                          &QScxmlStateMachinePrivate::isInitializedChanged);

++

++     void initialValuesChanged()

++     {

++         emit q_func()->initialValuesChanged(m_initialValues.value());

++     }

++     Q_OBJECT_BINDABLE_PROPERTY(QScxmlStateMachinePrivate, QVariantMap, m_initialValues,

++                                &QScxmlStateMachinePrivate::initialValuesChanged);

++

++     void loaderChanged()

++     {

++         emit q_func()->loaderChanged(m_loader.value());

++     }

++     Q_OBJECT_BINDABLE_PROPERTY(QScxmlStateMachinePrivate, QScxmlCompiler::Loader*, m_loader,

++                                &QScxmlStateMachinePrivate::loaderChanged);

++

++     void setDataModel(QScxmlDataModel* loader)

++     {

++         q_func()->setDataModel(loader);

++     }

++     Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QScxmlStateMachinePrivate, QScxmlDataModel*, m_dataModel,

++                                        &QScxmlStateMachinePrivate::setDataModel, nullptr);

++

++     void setTableData(QScxmlTableData* tableData)

++     {

++         q_func()->setTableData(tableData);

++     }

++     Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QScxmlStateMachinePrivate, QScxmlTableData*, m_tableData,

++                                        &QScxmlStateMachinePrivate::setTableData, nullptr);

++

++     bool m_isProcessingEvents;

++     QScxmlCompilerPrivate::DefaultLoader m_defaultLoader;

++     QScxmlExecutionEngine *m_executionEngine;

++     const StateTable *m_stateTable;

++     QScxmlStateMachine *m_parentStateMachine;

++     QScxmlInternal::EventLoopHook m_eventLoopHook;

++     typedef std::vector<std::pair<int, QScxmlEvent *>> DelayedQueue;

++     DelayedQueue m_delayedEvents;

++     const QMetaObject *m_metaObject;

++     QScxmlInternal::ScxmlEventRouter m_router;

++

++ private:

++     QScopedPointer<ParserData> m_parserData; // used when created by StateMachine::fromFile.

++     typedef QHash<int, QList<int>> HistoryValues;

++     struct InvokedService {

++         int invokingState;

++         QScxmlInvokableService *service;

++         QString serviceName;

++     };

++

++     // TODO: move the stuff below to a struct that can be reset

++     HistoryValues m_historyValue;

++     OrderedSet m_configuration;

++     Queue m_internalQueue;

++     Queue m_externalQueue;

++     QSet<int> m_statesToInvoke;

++     std::vector<InvokedService> m_invokedServices;

++     QList<QScxmlInvokableService*> invokedServicesActualCalculation() const

++     {

++         QList<QScxmlInvokableService *> result;

++         for (size_t i = 0, ei = m_invokedServices.size(); i != ei; ++i) {

++             if (auto service = m_invokedServices[i].service)

++                 result.append(service);

++         }

++         return result;

++     }

++     Q_OBJECT_COMPUTED_PROPERTY(QScxmlStateMachinePrivate, QList<QScxmlInvokableService*>,

++                                m_invokedServicesComputedProperty,

++                                &QScxmlStateMachinePrivate::invokedServicesActualCalculation);

++     std::vector<bool> m_isFirstStateEntry;

++     std::vector<QScxmlInvokableServiceFactory *> m_cachedFactories;

++     enum { Invalid = 0, Starting, Running, Paused, Finished } m_runningState = Invalid;

++     bool isRunnable() const {

++         switch (m_runningState) {

++         case Starting:

++         case Running:

++         case Paused:

++             return true;

++         case Invalid:

++         case Finished:

++             return false;

++         }

++

++         return false; // Dead code, but many dumb compilers cannot (or are unwilling to) detect that.

++     }

++

++     bool isPaused() const { return m_runningState == Paused; }

++     bool isFinished() const { return m_runningState == Finished; }

++

++     QScxmlInternal::StateMachineInfoProxy *m_infoSignalProxy;

++

++     QHash<int, int> m_stateIndexToSignalIndex;

++     QHash<QString, int> m_stateNameToSignalIndex;

++ };

++

++ QT_END_NAMESPACE

++

++ #endif // QSCXMLSTATEMACHINE_P_H

++

Revision control