4509400661

Build Type

push

github

Committed by igor-krechetov

Commit Message

[0.33.0][r] improvement to timers API

Run Details

46 of 46 new or added lines in 5 files covered. (100.0%)

1921 of 2338 relevant lines covered (82.16%)

161238.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.86

/src/hsm.cpp

// Copyright (C) 2021 Igor Krechetov
// Distributed under MIT license. See file LICENSE for details

#include "hsmcpp/hsm.hpp"

#include "HsmImpl.hpp"

namespace hsmcpp {

HierarchicalStateMachine::HierarchicalStateMachine(const StateID_t initialState)
    : mImpl(new HierarchicalStateMachine::Impl(this, initialState)) {
}

HierarchicalStateMachine::~HierarchicalStateMachine() {
    mImpl->release();
    mImpl->resetParent();
}

void HierarchicalStateMachine::setInitialState(const StateID_t initialState) {
    mImpl->setInitialState(initialState);
}

bool HierarchicalStateMachine::initialize(const std::weak_ptr<IHsmEventDispatcher>& dispatcher) {
    return mImpl->initialize(dispatcher);
}

bool HierarchicalStateMachine::isInitialized() const {
    return mImpl->isInitialized();
}

void HierarchicalStateMachine::release() {
    mImpl->release();
}

void HierarchicalStateMachine::registerFailedTransitionCallback(const HsmTransitionFailedCallback_t& onFailedTransition) {
    mImpl->registerFailedTransitionCallback(onFailedTransition);
}

void HierarchicalStateMachine::registerState(const StateID_t state,
                                             HsmStateChangedCallback_t onStateChanged,
                                             HsmStateEnterCallback_t onEntering,
                                             HsmStateExitCallback_t onExiting) {
    mImpl->registerState(state, onStateChanged, onEntering, onExiting);
}

void HierarchicalStateMachine::registerFinalState(const StateID_t state,
                                                  const EventID_t event,
                                                  HsmStateChangedCallback_t onStateChanged,
                                                  HsmStateEnterCallback_t onEntering,
                                                  HsmStateExitCallback_t onExiting) {
    mImpl->registerFinalState(state, event, onStateChanged, onEntering, onExiting);
}

void HierarchicalStateMachine::registerHistory(const StateID_t parent,
                                               const StateID_t historyState,
                                               const HistoryType type,
                                               const StateID_t defaultTarget,
                                               HsmTransitionCallback_t transitionCallback) {
    mImpl->registerHistory(parent, historyState, type, defaultTarget, transitionCallback);
}

bool HierarchicalStateMachine::registerSubstate(const StateID_t parent, const StateID_t substate) {
    return mImpl->registerSubstate(parent, substate);
}

bool HierarchicalStateMachine::registerSubstateEntryPoint(const StateID_t parent,
                                                          const StateID_t substate,
                                                          const EventID_t onEvent,
                                                          const HsmTransitionConditionCallback_t& conditionCallback,
                                                          const bool expectedConditionValue) {
    return mImpl->registerSubstateEntryPoint(parent, substate, onEvent, conditionCallback, expectedConditionValue);
}

void HierarchicalStateMachine::registerTimer(const TimerID_t timerID, const EventID_t event) {
    mImpl->registerTimer(timerID, event);
}

void HierarchicalStateMachine::registerTransition(const StateID_t from,
                                                  const StateID_t to,
                                                  const EventID_t onEvent,
                                                  HsmTransitionCallback_t transitionCallback,
                                                  HsmTransitionConditionCallback_t conditionCallback,
                                                  const bool expectedConditionValue) {
    mImpl->registerTransition(from, to, onEvent, transitionCallback, conditionCallback, expectedConditionValue);
}

void HierarchicalStateMachine::registerSelfTransition(const StateID_t state,
                                                      const EventID_t onEvent,
                                                      const TransitionType type,
                                                      HsmTransitionCallback_t transitionCallback,
                                                      HsmTransitionConditionCallback_t conditionCallback,
                                                      const bool expectedConditionValue) {
    mImpl->registerSelfTransition(state, onEvent, type, transitionCallback, conditionCallback, expectedConditionValue);
}

StateID_t HierarchicalStateMachine::getLastActiveState() const {
    return mImpl->getLastActiveState();
}

const std::list<StateID_t>& HierarchicalStateMachine::getActiveStates() const {
    return mImpl->getActiveStates();
}

bool HierarchicalStateMachine::isStateActive(const StateID_t state) const {
    return mImpl->isStateActive(state);
}

void HierarchicalStateMachine::transitionWithArgsArray(const EventID_t event, const VariantVector_t& args) {
    return mImpl->transitionWithArgsArray(event, args);
}

bool HierarchicalStateMachine::transitionExWithArgsArray(const EventID_t event,
                                                         const bool clearQueue,
                                                         const bool sync,
                                                         const int timeoutMs,
                                                         const VariantVector_t& args) {
    return mImpl->transitionExWithArgsArray(event, clearQueue, sync, timeoutMs, args);
}

bool HierarchicalStateMachine::transitionInterruptSafe(const EventID_t event) {
    return mImpl->transitionInterruptSafe(event);
}

void HierarchicalStateMachine::startTimer(const TimerID_t timerID, const unsigned int intervalMs, const bool isSingleShot) {
    mImpl->startTimer(timerID, intervalMs, isSingleShot);
}

void HierarchicalStateMachine::restartTimer(const TimerID_t timerID) {
    mImpl->restartTimer(timerID);
}

void HierarchicalStateMachine::stopTimer(const TimerID_t timerID) {
    mImpl->stopTimer(timerID);
}

bool HierarchicalStateMachine::isTimerRunning(const TimerID_t timerID) {
    return mImpl->isTimerRunning(timerID);
}

bool HierarchicalStateMachine::enableHsmDebugging() {
    return mImpl->enableHsmDebugging();
}

bool HierarchicalStateMachine::enableHsmDebugging(const std::string& dumpPath) {
    return mImpl->enableHsmDebugging(dumpPath);
}

void HierarchicalStateMachine::disableHsmDebugging() {
    mImpl->disableHsmDebugging();
}

std::string HierarchicalStateMachine::getStateName(const StateID_t state) const {
    std::string name;

    if (state != INVALID_HSM_STATE_ID) {
        name = std::to_string(state);
    }

    return name;
}

std::string HierarchicalStateMachine::getEventName(const EventID_t event) const {
    std::string name;

    if (event != INVALID_HSM_EVENT_ID) {
        name = std::to_string(event);
    }

    return name;
}

bool HierarchicalStateMachine::isTransitionPossibleImpl(const EventID_t event, const VariantVector_t& args) {
    return mImpl->isTransitionPossible(event, args);
}

bool HierarchicalStateMachine::registerStateActionImpl(const StateID_t state,
                                                       const StateActionTrigger actionTrigger,
                                                       const StateAction action,
                                                       const VariantVector_t& args) {
    return mImpl->registerStateAction(state, actionTrigger, action, args);
}

}  // namespace hsmcpp

1	// Copyright (C) 2021 Igor Krechetov
2	// Distributed under MIT license. See file LICENSE for details
3
4	#include "hsmcpp/hsm.hpp"
5
6	#include "HsmImpl.hpp"
7
8	namespace hsmcpp {
9
10	HierarchicalStateMachine::HierarchicalStateMachine(const StateID_t initialState)	2,000✔
11	: mImpl(new HierarchicalStateMachine::Impl(this, initialState)) {	2,000✔
12	}	2,000✔
13
14	HierarchicalStateMachine::~HierarchicalStateMachine() {	3,000✔
15	mImpl->release();	1,990✔
16	mImpl->resetParent();	1,990✔
17	}	3,000✔
18
19	void HierarchicalStateMachine::setInitialState(const StateID_t initialState) {	300✔
20	mImpl->setInitialState(initialState);	300✔
21	}	300✔
22
23	bool HierarchicalStateMachine::initialize(const std::weak_ptr<IHsmEventDispatcher>& dispatcher) {	2,000✔
24	return mImpl->initialize(dispatcher);	2,000✔
25	}
26
27	bool HierarchicalStateMachine::isInitialized() const {	×
28	return mImpl->isInitialized();	×
29	}
30
31	void HierarchicalStateMachine::release() {	×
32	mImpl->release();	×
33	}	×
34
35	void HierarchicalStateMachine::registerFailedTransitionCallback(const HsmTransitionFailedCallback_t& onFailedTransition) {	210✔
36	mImpl->registerFailedTransitionCallback(onFailedTransition);	210✔
37	}	210✔
38
39	void HierarchicalStateMachine::registerState(const StateID_t state,	5,230✔
40	HsmStateChangedCallback_t onStateChanged,
41	HsmStateEnterCallback_t onEntering,
42	HsmStateExitCallback_t onExiting) {
43	mImpl->registerState(state, onStateChanged, onEntering, onExiting);	10,920✔
44	}	5,230✔
45
46	void HierarchicalStateMachine::registerFinalState(const StateID_t state,	190✔
47	const EventID_t event,
48	HsmStateChangedCallback_t onStateChanged,
49	HsmStateEnterCallback_t onEntering,
50	HsmStateExitCallback_t onExiting) {
51	mImpl->registerFinalState(state, event, onStateChanged, onEntering, onExiting);	380✔
52	}	190✔
53
54	void HierarchicalStateMachine::registerHistory(const StateID_t parent,	100✔
55	const StateID_t historyState,
56	const HistoryType type,
57	const StateID_t defaultTarget,
58	HsmTransitionCallback_t transitionCallback) {
59	mImpl->registerHistory(parent, historyState, type, defaultTarget, transitionCallback);	100✔
60	}	100✔
61
62	bool HierarchicalStateMachine::registerSubstate(const StateID_t parent, const StateID_t substate) {	670✔
63	return mImpl->registerSubstate(parent, substate);	670✔
64	}
65
66	bool HierarchicalStateMachine::registerSubstateEntryPoint(const StateID_t parent,	860✔
67	const StateID_t substate,
68	const EventID_t onEvent,
69	const HsmTransitionConditionCallback_t& conditionCallback,
70	const bool expectedConditionValue) {
71	return mImpl->registerSubstateEntryPoint(parent, substate, onEvent, conditionCallback, expectedConditionValue);	860✔
72	}
73
74	void HierarchicalStateMachine::registerTimer(const TimerID_t timerID, const EventID_t event) {	140✔
75	mImpl->registerTimer(timerID, event);	140✔
76	}	140✔
77
78	void HierarchicalStateMachine::registerTransition(const StateID_t from,	4,550✔
79	const StateID_t to,
80	const EventID_t onEvent,
81	HsmTransitionCallback_t transitionCallback,
82	HsmTransitionConditionCallback_t conditionCallback,
83	const bool expectedConditionValue) {
84	mImpl->registerTransition(from, to, onEvent, transitionCallback, conditionCallback, expectedConditionValue);	9,100✔
85	}	4,550✔
86
87	void HierarchicalStateMachine::registerSelfTransition(const StateID_t state,	70✔
88	const EventID_t onEvent,
89	const TransitionType type,
90	HsmTransitionCallback_t transitionCallback,
91	HsmTransitionConditionCallback_t conditionCallback,
92	const bool expectedConditionValue) {
93	mImpl->registerSelfTransition(state, onEvent, type, transitionCallback, conditionCallback, expectedConditionValue);	140✔
94	}	70✔
95
96	StateID_t HierarchicalStateMachine::getLastActiveState() const {	750✔
97	return mImpl->getLastActiveState();	750✔
98	}
99
100	const std::list<StateID_t>& HierarchicalStateMachine::getActiveStates() const {	1,260✔
101	return mImpl->getActiveStates();	1,260✔
102	}
103
104	bool HierarchicalStateMachine::isStateActive(const StateID_t state) const {	×
105	return mImpl->isStateActive(state);	×
106	}
107
108	void HierarchicalStateMachine::transitionWithArgsArray(const EventID_t event, const VariantVector_t& args) {	×
109	return mImpl->transitionWithArgsArray(event, args);	×
110	}
111
112	bool HierarchicalStateMachine::transitionExWithArgsArray(const EventID_t event,	1,002,440✔
113	const bool clearQueue,
114	const bool sync,
115	const int timeoutMs,
116	const VariantVector_t& args) {
117	return mImpl->transitionExWithArgsArray(event, clearQueue, sync, timeoutMs, args);	1,002,440✔
118	}
119
120	bool HierarchicalStateMachine::transitionInterruptSafe(const EventID_t event) {	10✔
121	return mImpl->transitionInterruptSafe(event);	10✔
122	}
123
124	void HierarchicalStateMachine::startTimer(const TimerID_t timerID, const unsigned int intervalMs, const bool isSingleShot) {	40✔
125	mImpl->startTimer(timerID, intervalMs, isSingleShot);	40✔
126	}	40✔
127
128	void HierarchicalStateMachine::restartTimer(const TimerID_t timerID) {	10✔
129	mImpl->restartTimer(timerID);	10✔
130	}	10✔
131
132	void HierarchicalStateMachine::stopTimer(const TimerID_t timerID) {	20✔
133	mImpl->stopTimer(timerID);	20✔
134	}	20✔
135
136	bool HierarchicalStateMachine::isTimerRunning(const TimerID_t timerID) {	30✔
137	return mImpl->isTimerRunning(timerID);	30✔
138	}
139
140	bool HierarchicalStateMachine::enableHsmDebugging() {	×
141	return mImpl->enableHsmDebugging();	×
142	}
143
144	bool HierarchicalStateMachine::enableHsmDebugging(const std::string& dumpPath) {	×
145	return mImpl->enableHsmDebugging(dumpPath);	×
146	}
147
148	void HierarchicalStateMachine::disableHsmDebugging() {	×
149	mImpl->disableHsmDebugging();	×
150	}	×
151
152	std::string HierarchicalStateMachine::getStateName(const StateID_t state) const {	1,361,678✔
153	std::string name;	1,361,678✔
154
155	if (state != INVALID_HSM_STATE_ID) {	1,361,678✔
156	name = std::to_string(state);	1,361,678✔
157	}
158
159	return name;	1,361,678✔
160	}	×
161
162	std::string HierarchicalStateMachine::getEventName(const EventID_t event) const {	×
163	std::string name;	×
164
165	if (event != INVALID_HSM_EVENT_ID) {	×
166	name = std::to_string(event);	×
167	}
168
169	return name;	×
170	}	×
171
172	bool HierarchicalStateMachine::isTransitionPossibleImpl(const EventID_t event, const VariantVector_t& args) {	60✔
173	return mImpl->isTransitionPossible(event, args);	60✔
174	}
175
176	bool HierarchicalStateMachine::registerStateActionImpl(const StateID_t state,	170✔
177	const StateActionTrigger actionTrigger,
178	const StateAction action,
179	const VariantVector_t& args) {
180	return mImpl->registerStateAction(state, actionTrigger, action, args);	170✔
181	}
182
183	} // namespace hsmcpp

igor-krechetov / hsmcpp / 4509400661

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous