QP/C++  7.0.1
Real-Time Embedded Framework
qep.hpp
Go to the documentation of this file.
1//============================================================================
2// QP/C++ Real-Time Embedded Framework (RTEF)
3// Copyright (C) 2005 Quantum Leaps, LLC. All rights reserved.
4//
5// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
6//
7// This software is dual-licensed under the terms of the open source GNU
8// General Public License version 3 (or any later version), or alternatively,
9// under the terms of one of the closed source Quantum Leaps commercial
10// licenses.
11//
12// The terms of the open source GNU General Public License version 3
13// can be found at: <www.gnu.org/licenses/gpl-3.0>
14//
15// The terms of the closed source Quantum Leaps commercial licenses
16// can be found at: <www.state-machine.com/licensing>
17//
18// Redistributions in source code must retain this top-level comment block.
19// Plagiarizing this software to sidestep the license obligations is illegal.
20//
21// Contact information:
22// <www.state-machine.com>
23// <info@state-machine.com>
24//============================================================================
31#ifndef QEP_HPP
32#define QEP_HPP
33
34//============================================================================
38#define QP_VERSION 701U
39
43#define QP_VERSION_STR "7.0.1"
44
46#define QP_RELEASE 0x7C7E85E2U
47
48//============================================================================
49#ifndef Q_SIGNAL_SIZE
57 #define Q_SIGNAL_SIZE 2U
58#endif
59
60//============================================================================
61// Aliases for basic numerical types; MISRA-C++ 2008 rule 3-9-2(req).
62
64using int_t = int;
65
67using enum_t = int;
68
77using float32_t = float;
78
87using float64_t = double;
88
89//============================================================================
97#define Q_EVT_CAST(class_) (static_cast<class_ const *>(e))
98
107#define Q_UINT2PTR_CAST(type_, uint_) (reinterpret_cast<type_ *>(uint_))
108
115#define QEVT_INITIALIZER(sig_) { static_cast<QP::QSignal>(sig_), 0U, 0U }
116
117//============================================================================
119namespace QP {
120
122 constexpr char const versionStr[]{QP_VERSION_STR};
123
124#if (Q_SIGNAL_SIZE == 1U)
125 using QSignal = std::uint8_t;
126#elif (Q_SIGNAL_SIZE == 2U)
136 using QSignal = std::uint16_t;
137#elif (Q_SIGNAL_SIZE == 4U)
138 using QSignal = std::uint32_t;
139#else
140 #error "Q_SIGNAL_SIZE defined incorrectly, expected 1U, 2U, or 4U"
141#endif
142
143#ifndef Q_EVT_CTOR // Is QEvt just a POD (Plain Old Datatype)?
144
155 struct QEvt {
157 std::uint8_t poolId_;
158 std::uint8_t volatile refCtr_;
159 };
160
161#else // QEvt is a full-blown class (not a POD)
162
163 class QEvt {
164 public:
166 QEvt(QSignal const s) noexcept
167 : sig(s)
168 // poolId_/refCtr_ intentionally uninitialized
169 {}
170
172 enum StaticEvt : std::uint8_t { STATIC_EVT };
173 constexpr QEvt(QSignal const s, StaticEvt /*dummy*/) noexcept
174 : sig(s),
175 poolId_(0U),
176 refCtr_(0U)
177 {}
178
179#ifdef Q_EVT_XTOR
181 virtual ~QEvt() noexcept {}
182#endif // Q_EVT_XTOR
183
184 public:
185 QSignal sig;
186
187 private:
188 std::uint8_t poolId_;
189 std::uint8_t volatile refCtr_;
190
191 friend class QF;
192 friend class QS;
193 friend class QActive;
194 friend class QMActive;
195 friend class QTimeEvt;
196 friend class QEQueue;
197 friend class QTicker;
198 friend class QXThread;
199 friend std::uint8_t QF_EVT_POOL_ID_ (QEvt const * const e) noexcept;
200 friend std::uint8_t QF_EVT_REF_CTR_ (QEvt const * const e) noexcept;
201 friend void QF_EVT_REF_CTR_INC_(QEvt const * const e) noexcept;
202 friend void QF_EVT_REF_CTR_DEC_(QEvt const * const e) noexcept;
203 };
204
205#endif // Q_EVT_CTOR
206
207// forward declarations...
208struct QMState;
209struct QMTranActTable;
210class QXThread;
211
213using QState = std::uint_fast8_t;
214
216using QStateHandler = QState (*)(void * const me, QEvt const * const e);
217
219using QActionHandler = QState (*)(void * const me);
220
222using QXThreadHandler = void (*)(QXThread * const me);
223
229union QHsmAttr {
233 QMState const *obj;
235};
236
237//============================================================================
258class QHsm {
261
262public:
263
264#ifdef Q_HSM_XTOR // provide the destructor for the QHsm and its subclasses?
266 virtual ~QHsm() noexcept {}
267#endif
268
282 virtual void init(void const * const e,
283 std::uint_fast8_t const qs_id);
284
286 virtual void init(std::uint_fast8_t const qs_id) {
287 init(nullptr, qs_id);
288 }
289
306 virtual void dispatch(QEvt const * const e,
307 std::uint_fast8_t const qs_id);
308
327 bool isIn(QStateHandler const s) noexcept;
328
332 QStateHandler state(void) const noexcept {
333 return m_state.fun;
334 }
335
339 QStateHandler childState(QStateHandler const parent) noexcept;
340
361 static QState top(void * const me, QEvt const * const e) noexcept;
362
363protected:
374 explicit QHsm(QStateHandler const initial) noexcept;
375
376public:
377// facilities for the QHsm implementation strategy...
379 static constexpr QState Q_RET_SUPER {static_cast<QState>(0)};
380
382 static constexpr QState Q_RET_SUPER_SUB {static_cast<QState>(1)};
383
385 static constexpr QState Q_RET_UNHANDLED {static_cast<QState>(2)};
386
388 static constexpr QState Q_RET_HANDLED {static_cast<QState>(3)};
389
391 static constexpr QState Q_RET_IGNORED {static_cast<QState>(4)};
392
394 static constexpr QState Q_RET_ENTRY {static_cast<QState>(5)};
395
397 static constexpr QState Q_RET_EXIT {static_cast<QState>(6)};
398
400 static constexpr QState Q_RET_NULL {static_cast<QState>(7)};
401
403 static constexpr QState Q_RET_TRAN {static_cast<QState>(8)};
404
406 static constexpr QState Q_RET_TRAN_INIT {static_cast<QState>(9)};
407
409 static constexpr QState Q_RET_TRAN_EP {static_cast<QState>(10)};
410
412 static constexpr QState Q_RET_TRAN_HIST {static_cast<QState>(11)};
413
415 static constexpr QState Q_RET_TRAN_XP {static_cast<QState>(12)};
416
417protected:
419 QState tran(QStateHandler const target) noexcept {
420 m_temp.fun = target;
421 return Q_RET_TRAN;
422 }
423
425 QState tran_hist(QStateHandler const hist) noexcept {
426 m_temp.fun = hist;
427 return Q_RET_TRAN_HIST;
428 }
429
431 QState super(QStateHandler const superstate) noexcept {
432 m_temp.fun = superstate;
433 return Q_RET_SUPER;
434 }
435
440 };
441
442// protected facilities for the QMsm implementation strategy...
445 QState qm_tran(void const * const tatbl) noexcept {
446 m_temp.tatbl = static_cast<QP::QMTranActTable const *>(tatbl);
447 return Q_RET_TRAN;
448 }
449
452 QState qm_tran_hist(QMState const * const hist,
453 void const * const tatbl) noexcept
454 {
455 m_state.obj = hist;
456 m_temp.tatbl = static_cast<QP::QMTranActTable const *>(tatbl);
457 return Q_RET_TRAN_HIST;
458 }
459
462 QState qm_tran_init(void const * const tatbl) noexcept {
463 m_temp.tatbl = static_cast<QP::QMTranActTable const *>(tatbl);
464 return Q_RET_TRAN_INIT;
465 }
466
469 QState qm_tran_ep(void const * const tatbl) noexcept {
470 m_temp.tatbl = static_cast<QP::QMTranActTable const *>(tatbl);
471 return Q_RET_TRAN_EP;
472 }
473
477 void const *const tatbl) noexcept
478 {
479 m_state.act = xp;
480 m_temp.tatbl = static_cast<QP::QMTranActTable const *>(tatbl);
481 return Q_RET_TRAN_XP;
482 }
483
484#ifdef Q_SPY
486 QState qm_entry(QMState const * const s) noexcept {
487 m_temp.obj = s;
488 return Q_RET_ENTRY;
489 }
490
492 QState qm_exit(QMState const * const s) noexcept {
493 m_temp.obj = s;
494 return Q_RET_EXIT;
495 }
496
498 virtual QStateHandler getStateHandler() noexcept;
499#else
501 QState qm_entry(QMState const * const s) noexcept {
502 (void)s;
503 return Q_RET_ENTRY;
504 }
505
507 QState qm_exit(QMState const * const s) noexcept {
508 (void)s;
509 return Q_RET_EXIT;
510 }
511#endif // Q_SPY
512
514 QState qm_sm_exit(QMState const * const s) noexcept {
515 m_temp.obj = s;
516 return Q_RET_EXIT;
517 }
518
521 QState qm_super_sub(QMState const * const s) noexcept {
522 m_temp.obj = s;
523 return Q_RET_SUPER_SUB;
524 }
525
526private:
528 static constexpr std::int_fast8_t MAX_NEST_DEPTH_{6};
529
545 std::int_fast8_t hsm_tran(QStateHandler (&path)[MAX_NEST_DEPTH_],
546 std::uint_fast8_t const qs_id);
547
548 friend class QMsm;
549 friend class QActive;
550 friend class QMActive;
551 friend class QF;
552 friend class QS;
553 friend class QXK;
554 friend class QXThread;
555 friend class QXMutex;
556 friend class QXSemaphore;
557#ifdef Q_UTEST
558 friend class QHsmDummy;
559 friend class QActiveDummy;
560#endif // Q_UTEST
561};
562
563//============================================================================
581class QMsm : public QHsm {
582public:
596 void init(void const * const e,
597 std::uint_fast8_t const qs_id) override;
598
610 void init(std::uint_fast8_t const qs_id) override;
611
624 void dispatch(QEvt const * const e,
625 std::uint_fast8_t const qs_id) override;
626
641 bool isInState(QMState const * const st) const noexcept;
642
644 QMState const *stateObj(void) const noexcept {
645 return m_state.obj;
646 }
647
670 QMState const *childStateObj(QMState const * const parent) const noexcept;
671
672protected:
688 explicit QMsm(QStateHandler const initial) noexcept;
689
690#ifdef Q_SPY
692 QStateHandler getStateHandler() noexcept override;
693#endif
694
695private:
698 bool isIn(QStateHandler const s) noexcept = delete;
699
702 QStateHandler state(void) const noexcept = delete;
703
706 QStateHandler childState(QStateHandler const parent) noexcept = delete;
707
710 static QState top(void * const me, QEvt const * const e) noexcept = delete;
711
727 QState execTatbl_(QMTranActTable const * const tatbl,
728 std::uint_fast8_t const qs_id);
729
741 void exitToTranSource_(QMState const *s,
742 QMState const * const ts,
743 std::uint_fast8_t const qs_id);
744
758 QState enterHistory_(QMState const * const hist,
759 std::uint_fast8_t const qs_id);
760
762 static constexpr std::int_fast8_t MAX_ENTRY_DEPTH_ {4};
763
765 static QMState const msm_top_s;
766
767 friend class QMActive;
768};
769
780struct QMState {
786};
787
792};
793
794//============================================================================
796constexpr enum_t Q_USER_SIG {4};
797
798} // namespace QP
799
800//============================================================================
801// Macros for coding QHsm-style state machines...
802
805#define Q_STATE_DECL(state_) \
806 QP::QState state_ ## _h(QP::QEvt const * const e); \
807 static QP::QState state_(void * const me, QP::QEvt const * const e)
808
811#define Q_STATE_DEF(subclass_, state_) \
812 QP::QState subclass_::state_(void * const me, QP::QEvt const * const e) {\
813 return static_cast<subclass_ *>(me)->state_ ## _h(e); } \
814 QP::QState subclass_::state_ ## _h(QP::QEvt const * const e)
815
817#define Q_HANDLED() (Q_RET_HANDLED)
818
821#define Q_UNHANDLED() (Q_RET_UNHANDLED)
822
828#define Q_STATE_CAST(handler_) \
829 (reinterpret_cast<QP::QStateHandler>(handler_))
830
836#define Q_ACTION_CAST(act_) (reinterpret_cast<QP::QActionHandler>(act_))
837
840#define Q_ACTION_NULL (nullptr)
841
842//============================================================================
843// Macros for coding QMsm-style state machines...
844
847#define QM_STATE_DECL(state_) \
848 QP::QState state_ ## _h(QP::QEvt const * const e); \
849 static QP::QState state_(void * const me, QP::QEvt const * const e); \
850 static QP::QMState const state_ ## _s
851
854#define QM_SM_STATE_DECL(subm_, state_) \
855 QP::QState state_ ## _h(QP::QEvt const * const e); \
856 static QP::QState state_(void * const me, QP::QEvt const * const e); \
857 static SM_ ## subm_ const state_ ## _s
858
861#define QM_ACTION_DECL(action_) \
862 QP::QState action_ ## _h(void); \
863 static QP::QState action_(void * const me)
864
867#define QM_STATE_DEF(subclass_, state_) \
868 QP::QState subclass_::state_(void * const me, QP::QEvt const * const e) {\
869 return static_cast<subclass_ *>(me)->state_ ## _h(e); } \
870 QP::QState subclass_::state_ ## _h(QP::QEvt const * const e)
871
874#define QM_ACTION_DEF(subclass_, action_) \
875 QP::QState subclass_::action_(void * const me) { \
876 return static_cast<subclass_ *>(me)->action_ ## _h(); } \
877 QP::QState subclass_::action_ ## _h(void)
878
880#define QM_HANDLED() (Q_RET_HANDLED)
881
884#define QM_UNHANDLED() (Q_RET_UNHANDLED)
885
887#define QM_SUPER() (Q_RET_SUPER)
888
891#define QM_STATE_NULL (nullptr)
892
893#endif // QEP_HPP
Dummy Active Object class for testing (inherits QP::QActive)
Definition: qs.hpp:804
QActive active object class (based on QP::QHsm implementation strategy)
Definition: qf.hpp:139
QF real-time active object framework.
Definition: qf.hpp:790
Dummy HSM class for testing (inherits QP::QHsm)
Definition: qs.hpp:787
Hierarchical State Machine base class.
Definition: qep.hpp:258
static constexpr QState Q_RET_SUPER_SUB
event passed to submachine superstate
Definition: qep.hpp:382
QState qm_tran_init(void const *const tatbl) noexcept
Helper function to specify an initial state transition in a QM state-handler.
Definition: qep.hpp:462
QState qm_tran_hist(QMState const *const hist, void const *const tatbl) noexcept
Helper function to specifiy a transition to history in a QM state-handler.
Definition: qep.hpp:452
static constexpr QState Q_RET_HANDLED
event handled (internal transition)
Definition: qep.hpp:388
friend class QMsm
Definition: qep.hpp:548
static constexpr QState Q_RET_SUPER
event passed to the superstate to handle
Definition: qep.hpp:379
QState tran_hist(QStateHandler const hist) noexcept
Helper function to specify a transition to history.
Definition: qep.hpp:425
static constexpr QState Q_RET_UNHANDLED
event unhandled due to a guard evaluating to 'false'
Definition: qep.hpp:385
QState qm_entry(QMState const *const s) noexcept
Helper function to specify a state entry in a QM state-handler.
Definition: qep.hpp:486
virtual void dispatch(QEvt const *const e, std::uint_fast8_t const qs_id)
Dispatches an event to QHsm.
Definition: qep_hsm.cpp:192
static constexpr QState Q_RET_IGNORED
event silently ignored (bubbled up to top)
Definition: qep.hpp:391
ReservedHsmSignals
Definition: qep.hpp:436
@ Q_INIT_SIG
signal for nested initial transitions
Definition: qep.hpp:439
@ Q_EXIT_SIG
signal for exit actions
Definition: qep.hpp:438
@ Q_ENTRY_SIG
signal for entry actions
Definition: qep.hpp:437
QState tran(QStateHandler const target) noexcept
Helper function to specify a state transition.
Definition: qep.hpp:419
QState qm_tran_xp(QActionHandler const xp, void const *const tatbl) noexcept
Helper function to specify a transition to an exit point from a submachine state in a QM state-handle...
Definition: qep.hpp:476
static QState top(void *const me, QEvt const *const e) noexcept
The top-state handler.
Definition: qep_hsm.cpp:185
virtual void init(std::uint_fast8_t const qs_id)
overloaded init(qs_id)
Definition: qep.hpp:286
virtual QStateHandler getStateHandler() noexcept
Get the current state handler of the HSM.
Definition: qep_hsm.cpp:480
QState qm_tran_ep(void const *const tatbl) noexcept
Helper function to specify a transition to an entry point to a submachine state in a QM state-handler...
Definition: qep.hpp:469
virtual void init(void const *const e, std::uint_fast8_t const qs_id)
executes the top-most initial transition in QP::QHsm
Definition: qep_hsm.cpp:115
static constexpr QState Q_RET_TRAN_EP
entry-point transition into a submachine
Definition: qep.hpp:409
QState qm_super_sub(QMState const *const s) noexcept
Helper function to call in a QM state-handler when it passes the event to the host submachine state t...
Definition: qep.hpp:521
static constexpr QState Q_RET_TRAN_INIT
initial transition taken
Definition: qep.hpp:406
static constexpr QState Q_RET_NULL
return value without any effect
Definition: qep.hpp:400
static constexpr QState Q_RET_TRAN
regular transition taken
Definition: qep.hpp:403
QStateHandler childState(QStateHandler const parent) noexcept
Obtain the current active child state of a given parent.
Definition: qep_hsm.cpp:511
QHsmAttr m_state
current active state (state-variable)
Definition: qep.hpp:259
static constexpr QState Q_RET_EXIT
state exit action executed
Definition: qep.hpp:397
static constexpr std::int_fast8_t MAX_NEST_DEPTH_
maximum nesting depth of states in HSM
Definition: qep.hpp:528
QState qm_exit(QMState const *const s) noexcept
Helper function to specify a state exit in a QM state-handler.
Definition: qep.hpp:492
QStateHandler state(void) const noexcept
Obtain the current state (state handler function)
Definition: qep.hpp:332
QState super(QStateHandler const superstate) noexcept
Helper function to specify the superstate of a given state.
Definition: qep.hpp:431
QState qm_tran(void const *const tatbl) noexcept
Helper function to specify a regular state transition in a QM state-handler.
Definition: qep.hpp:445
bool isIn(QStateHandler const s) noexcept
Tests if a given state is part of the current active state configuration.
Definition: qep_hsm.cpp:486
static constexpr QState Q_RET_TRAN_HIST
transition to history of a given state
Definition: qep.hpp:412
QHsmAttr m_temp
temporary: transition chain, target state, etc.
Definition: qep.hpp:260
static constexpr QState Q_RET_TRAN_XP
exit-point transition out of a submachine
Definition: qep.hpp:415
std::int_fast8_t hsm_tran(QStateHandler(&path)[MAX_NEST_DEPTH_], std::uint_fast8_t const qs_id)
Helper function to take a transition in QP::QHsm.
Definition: qep_hsm.cpp:348
static constexpr QState Q_RET_ENTRY
state entry action executed
Definition: qep.hpp:394
QState qm_sm_exit(QMState const *const s) noexcept
Helper function to specify a submachine exit in a QM state-handler.
Definition: qep.hpp:514
QHsm(QStateHandler const initial) noexcept
Protected constructor of QHsm.
Definition: qep_hsm.cpp:109
QMActive active object (based on QP::QMsm implementation)
Definition: qf.hpp:535
QM State Machine implementation strategy.
Definition: qep.hpp:581
void exitToTranSource_(QMState const *s, QMState const *const ts, std::uint_fast8_t const qs_id)
Internal helper function to exit current state to transition source.
Definition: qep_msm.cpp:357
bool isIn(QStateHandler const s) noexcept=delete
disallow inherited isIn() function in QP::QMsm and subclasses
static QMState const msm_top_s
the top state object for the QMsm
Definition: qep.hpp:765
QStateHandler getStateHandler() noexcept override
Get the current state handler of the QMsm.
Definition: qep_msm.cpp:285
QStateHandler state(void) const noexcept=delete
disallow inhertited state() function in QP::QMsm and subclasses
static QState top(void *const me, QEvt const *const e) noexcept=delete
disallow inherited top() function in QP::QMsm and subclasses
QState execTatbl_(QMTranActTable const *const tatbl, std::uint_fast8_t const qs_id)
Internal helper function to execute a transition-action table.
Definition: qep_msm.cpp:291
void dispatch(QEvt const *const e, std::uint_fast8_t const qs_id) override
Dispatches an event to a MSM.
Definition: qep_msm.cpp:113
static constexpr std::int_fast8_t MAX_ENTRY_DEPTH_
maximum depth of implemented entry levels for transitions to history
Definition: qep.hpp:762
QMState const * childStateObj(QMState const *const parent) const noexcept
Obtain the current active child state of a given parent (read only)
Definition: qep_msm.cpp:459
QStateHandler childState(QStateHandler const parent) noexcept=delete
disallow inhertited childState() function in QP::QMsm and subclasses
QState enterHistory_(QMState const *const hist, std::uint_fast8_t const qs_id)
Internal helper function to enter state history.
Definition: qep_msm.cpp:387
void init(void const *const e, std::uint_fast8_t const qs_id) override
Performs the second step of SM initialization by triggering the top-most initial transition.
Definition: qep_msm.cpp:70
QMState const * stateObj(void) const noexcept
Return the current active state object (read only)
Definition: qep.hpp:644
bool isInState(QMState const *const st) const noexcept
Tests if a given state is part of the active state configuration.
Definition: qep_msm.cpp:443
QS software tracing facilities for output (QS-TX)
Definition: qs.hpp:74
QXK preemptive, dual-mode (blocking/non-blocking) real-time kernel.
Definition: qxk.hpp:158
Priority Ceiling Mutex the QXK preemptive kernel.
Definition: qxthread.hpp:427
Counting Semaphore of the QXK preemptive kernel.
Definition: qxthread.hpp:298
Extended (blocking) thread of the QXK preemptive kernel.
Definition: qxthread.hpp:59
namespace associated with the QP/C++ framework
Definition: exa_native.dox:1
std::uint8_t QF_EVT_POOL_ID_(QEvt const *const e) noexcept
return the Pool-ID of an event e
Definition: qf_pkg.hpp:132
std::uint_fast8_t QState
Type returned from state-handler functions.
Definition: qep.hpp:213
void QF_EVT_REF_CTR_DEC_(QEvt const *const e) noexcept
decrement the refCtr_ of an event e
Definition: qf_pkg.hpp:147
void(*)(QXThread *const me) QXThreadHandler
Pointer to a thread-handler function.
Definition: qep.hpp:222
QActionHandler const act[1]
Definition: qep.hpp:791
std::uint8_t QF_EVT_REF_CTR_(QEvt const *const e) noexcept
return the Reference Conter of an event e
Definition: qf_pkg.hpp:137
QMState const * obj
pointer to QMState object
Definition: qep.hpp:233
QMTranActTable const * tatbl
transition-action table
Definition: qep.hpp:234
constexpr char const versionStr[]
the current QP version number string based on QP_VERSION_STR
Definition: qep.hpp:122
QActionHandler const entryAction
entry action handler function
Definition: qep.hpp:783
QMState const * superstate
superstate of this state
Definition: qep.hpp:781
QState(*)(void *const me) QActionHandler
Pointer to an action-handler function.
Definition: qep.hpp:219
QMState const * target
Definition: qep.hpp:790
constexpr enum_t Q_USER_SIG
Offset or the user signals.
Definition: qep.hpp:796
QActionHandler const initAction
init action handler function
Definition: qep.hpp:785
QState(*)(void *const me, QEvt const *const e) QStateHandler
Pointer to state-handler function.
Definition: qep.hpp:216
QActionHandler const exitAction
exit action handler function
Definition: qep.hpp:784
QStateHandler const stateHandler
state handler function
Definition: qep.hpp:782
QXThreadHandler thr
pointer to an thread-handler function
Definition: qep.hpp:232
QStateHandler fun
pointer to a state handler function
Definition: qep.hpp:230
std::uint16_t QSignal
QSignal represents the signal of an event.
Definition: qep.hpp:136
void QF_EVT_REF_CTR_INC_(QEvt const *const e) noexcept
increment the refCtr_ of an event e
Definition: qf_pkg.hpp:142
QActionHandler act
pointer to an action-handler function
Definition: qep.hpp:231
State object for the QP::QMsm class (QM State Machine).
Definition: qep.hpp:780
Transition-Action Table for the QP::QMsm State Machine.
Definition: qep.hpp:789
Attribute of for the QHsm class (Hierarchical State Machine)
Definition: qep.hpp:229
int enum_t
alias for enumerations used for event signals
Definition: qep.hpp:67
int int_t
alias for line numbers in assertions and return from QF::run()
Definition: qep.hpp:64
float float32_t
alias for 32-bit IEEE 754 floating point numbers
Definition: qep.hpp:77
#define QP_VERSION_STR
The current QP version number string of the form XX.Y.Z, where XX is a 2-digit major version number,...
Definition: qep.hpp:43
double float64_t
alias for 64-bit IEEE 754 floating point numbers
Definition: qep.hpp:87
QEvt base class.
Definition: qep.hpp:155
QSignal sig
signal of the event instance
Definition: qep.hpp:156
std::uint8_t volatile refCtr_
reference counter
Definition: qep.hpp:158
std::uint8_t poolId_
pool ID (0 for static event)
Definition: qep.hpp:157