5011739924

Build Type

push

github

Committed by igor-krechetov

Commit Message

[0.38.0] Variant container performance improvements

Run Details

107 of 107 new or added lines in 8 files covered. (100.0%)

2293 of 2488 relevant lines covered (92.16%)

14591.87 hits per line

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

70.97

/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);
}

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

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

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

void HierarchicalStateMachine::registerFailedTransitionCallback(HsmTransitionFailedCallback_t onFailedTransition) {
    mImpl->registerFailedTransitionCallback(std::move(onFailedTransition));
}

void HierarchicalStateMachine::registerState(const StateID_t state,
                                             HsmStateChangedCallback_t onStateChanged,
                                             HsmStateEnterCallback_t onEntering,
                                             HsmStateExitCallback_t onExiting) {
    mImpl->registerState(state, std::move(onStateChanged), std::move(onEntering), std::move(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, std::move(onStateChanged), std::move(onEntering), std::move(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, std::move(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,
                                                          HsmTransitionConditionCallback_t conditionCallback,
                                                          const bool expectedConditionValue) {
    return mImpl->registerSubstateEntryPoint(parent, substate, onEvent, std::move(conditionCallback), expectedConditionValue);
}

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

void HierarchicalStateMachine::registerTransition(const StateID_t fromState,
                                                  const StateID_t toState,
                                                  const EventID_t onEvent,
                                                  HsmTransitionCallback_t transitionCallback,
                                                  HsmTransitionConditionCallback_t conditionCallback,
                                                  const bool expectedConditionValue) {
    mImpl->registerTransition(fromState,
                              toState,
                              onEvent,
                              std::move(transitionCallback),
                              std::move(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,
                                  std::move(transitionCallback),
                                  std::move(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, VariantVector_t&& args) {
    return mImpl->transitionWithArgsArray(event, std::move(args));
}

bool HierarchicalStateMachine::transitionExWithArgsArray(const EventID_t event,
                                                         const bool clearQueue,
                                                         const bool sync,
                                                         const int timeoutMs,
                                                         VariantVector_t&& args) {
    return mImpl->transitionExWithArgsArray(event, clearQueue, sync, timeoutMs, std::move(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)	1,190✔
11	: mImpl(new HierarchicalStateMachine::Impl(this, initialState)) {}	2,380✔
12
13	HierarchicalStateMachine::~HierarchicalStateMachine() {	1,190✔
14	mImpl->release();	1,180✔
15	mImpl->resetParent();	1,180✔
16	}	1,190✔
17
18	void HierarchicalStateMachine::setInitialState(const StateID_t initialState) {	410✔
19	mImpl->setInitialState(initialState);	410✔
20	}	410✔
21
22	bool HierarchicalStateMachine::initialize(const std::weak_ptr<IHsmEventDispatcher>& dispatcher) {	1,190✔
23	return mImpl->initialize(dispatcher);	1,190✔
24	}
25
26	std::weak_ptr<IHsmEventDispatcher> HierarchicalStateMachine::dispatcher() const {	×
27	return mImpl->dispatcher();	×
28	}
29
30	bool HierarchicalStateMachine::isInitialized() const {	×
31	return mImpl->isInitialized();	×
32	}
33
34	void HierarchicalStateMachine::release() {	10✔
35	mImpl->release();	10✔
36	}	10✔
37
38	void HierarchicalStateMachine::registerFailedTransitionCallback(HsmTransitionFailedCallback_t onFailedTransition) {	210✔
39	mImpl->registerFailedTransitionCallback(std::move(onFailedTransition));	420✔
40	}	210✔
41
42	void HierarchicalStateMachine::registerState(const StateID_t state,	3,730✔
43	HsmStateChangedCallback_t onStateChanged,
44	HsmStateEnterCallback_t onEntering,
45	HsmStateExitCallback_t onExiting) {
46	mImpl->registerState(state, std::move(onStateChanged), std::move(onEntering), std::move(onExiting));	11,330✔
47	}	3,730✔
48
49	void HierarchicalStateMachine::registerFinalState(const StateID_t state,	270✔
50	const EventID_t event,
51	HsmStateChangedCallback_t onStateChanged,
52	HsmStateEnterCallback_t onEntering,
53	HsmStateExitCallback_t onExiting) {
54	mImpl->registerFinalState(state, event, std::move(onStateChanged), std::move(onEntering), std::move(onExiting));	620✔
55	}	270✔
56
57	void HierarchicalStateMachine::registerHistory(const StateID_t parent,	100✔
58	const StateID_t historyState,
59	const HistoryType type,
60	const StateID_t defaultTarget,
61	HsmTransitionCallback_t transitionCallback) {
62	mImpl->registerHistory(parent, historyState, type, defaultTarget, std::move(transitionCallback));	110✔
63	}	100✔
64
65	bool HierarchicalStateMachine::registerSubstate(const StateID_t parent, const StateID_t substate) {	740✔
66	return mImpl->registerSubstate(parent, substate);	740✔
67	}
68
69	bool HierarchicalStateMachine::registerSubstateEntryPoint(const StateID_t parent,	970✔
70	const StateID_t substate,
71	const EventID_t onEvent,
72	HsmTransitionConditionCallback_t conditionCallback,
73	const bool expectedConditionValue) {
74	return mImpl->registerSubstateEntryPoint(parent, substate, onEvent, std::move(conditionCallback), expectedConditionValue);	1,010✔
75	}
76
77	void HierarchicalStateMachine::registerTimer(const TimerID_t timerID, const EventID_t event) {	150✔
78	mImpl->registerTimer(timerID, event);	150✔
79	}	150✔
80
81	void HierarchicalStateMachine::registerTransition(const StateID_t fromState,	2,980✔
82	const StateID_t toState,
83	const EventID_t onEvent,
84	HsmTransitionCallback_t transitionCallback,
85	HsmTransitionConditionCallback_t conditionCallback,
86	const bool expectedConditionValue) {
87	mImpl->registerTransition(fromState,	8,940✔
88	toState,
89	onEvent,
90	std::move(transitionCallback),	2,980✔
91	std::move(conditionCallback),	2,980✔
92	expectedConditionValue);
93	}	2,980✔
94
95	void HierarchicalStateMachine::registerSelfTransition(const StateID_t state,	90✔
96	const EventID_t onEvent,
97	const TransitionType type,
98	HsmTransitionCallback_t transitionCallback,
99	HsmTransitionConditionCallback_t conditionCallback,
100	const bool expectedConditionValue) {
101	mImpl->registerSelfTransition(state,	270✔
102	onEvent,
103	type,
104	std::move(transitionCallback),	90✔
105	std::move(conditionCallback),	90✔
106	expectedConditionValue);
107	}	90✔
108
109	StateID_t HierarchicalStateMachine::getLastActiveState() const {	40✔
110	return mImpl->getLastActiveState();	40✔
111	}
112
113	const std::list<StateID_t>& HierarchicalStateMachine::getActiveStates() const {	2,310✔
114	return mImpl->getActiveStates();	2,310✔
115	}
116
117	bool HierarchicalStateMachine::isStateActive(const StateID_t state) const {	×
118	return mImpl->isStateActive(state);	×
119	}
120
121	void HierarchicalStateMachine::transitionWithArgsArray(const EventID_t event, VariantVector_t&& args) {	×
122	return mImpl->transitionWithArgsArray(event, std::move(args));	×
123	}
124
125	bool HierarchicalStateMachine::transitionExWithArgsArray(const EventID_t event,	2,240✔
126	const bool clearQueue,
127	const bool sync,
128	const int timeoutMs,
129	VariantVector_t&& args) {
130	return mImpl->transitionExWithArgsArray(event, clearQueue, sync, timeoutMs, std::move(args));	2,240✔
131	}
132
133	bool HierarchicalStateMachine::transitionInterruptSafe(const EventID_t event) {	10✔
134	return mImpl->transitionInterruptSafe(event);	10✔
135	}
136
137	void HierarchicalStateMachine::startTimer(const TimerID_t timerID, const unsigned int intervalMs, const bool isSingleShot) {	50✔
138	mImpl->startTimer(timerID, intervalMs, isSingleShot);	50✔
139	}	50✔
140
141	void HierarchicalStateMachine::restartTimer(const TimerID_t timerID) {	10✔
142	mImpl->restartTimer(timerID);	10✔
143	}	10✔
144
145	void HierarchicalStateMachine::stopTimer(const TimerID_t timerID) {	20✔
146	mImpl->stopTimer(timerID);	20✔
147	}	20✔
148
149	bool HierarchicalStateMachine::isTimerRunning(const TimerID_t timerID) {	60✔
150	return mImpl->isTimerRunning(timerID);	60✔
151	}
152
153	bool HierarchicalStateMachine::enableHsmDebugging() {	×
154	return mImpl->enableHsmDebugging();	×
155	}
156
157	bool HierarchicalStateMachine::enableHsmDebugging(const std::string& dumpPath) {	×
158	return mImpl->enableHsmDebugging(dumpPath);	×
159	}
160
161	void HierarchicalStateMachine::disableHsmDebugging() {	×
162	mImpl->disableHsmDebugging();	×
163	}	×
164
165	std::string HierarchicalStateMachine::getStateName(const StateID_t state) const {	×
166	std::string name;	×
167
168	if (state != INVALID_HSM_STATE_ID) {	×
169	name = std::to_string(state);	×
170	}
171
172	return name;	×
173	}	×
174
175	std::string HierarchicalStateMachine::getEventName(const EventID_t event) const {	×
176	std::string name;	×
177
178	if (event != INVALID_HSM_EVENT_ID) {	×
179	name = std::to_string(event);	×
180	}
181
182	return name;	×
183	}	×
184
185	bool HierarchicalStateMachine::isTransitionPossibleImpl(const EventID_t event, const VariantVector_t& args) {	60✔
186	return mImpl->isTransitionPossible(event, args);	60✔
187	}
188
189	bool HierarchicalStateMachine::registerStateActionImpl(const StateID_t state,	220✔
190	const StateActionTrigger actionTrigger,
191	const StateAction action,
192	const VariantVector_t& args) {
193	return mImpl->registerStateAction(state, actionTrigger, action, args);	220✔
194	}
195
196	} // namespace hsmcpp

igor-krechetov / hsmcpp / 5011739924

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