Quick Start
Dependencies
No dependencies
Contributors: This Release
Documentation
Meta State Machine (MSM)
MSM is a Boost library that uses C++ metaprogramming for creating high-performance UML2 finite state machines.
It separates state machine modeling (front-end) from execution (back-end), allowing each to be chosen independently.
The classic back back-end supports C++03, the backmp11 back-end requires C++17.
The full documentation is available on Boost (latest release, develop).
Features
Front-end:
- State transitions (external, internal, completion) with actions and guards
- State entry & exit actions
- Deferred events — via state property and transition action
- Kleene (any) events — match any event in a transition
- Event hierarchies — use inheritance to match events in a transition
- Hierarchical state machines (composite states)
- Orthogonal regions
- History
- Pseudostates — entry, exit, fork, terminate
- State flags
Back-end (backmp11):
- Shared context in state machine hierarchies — data and root machine reference accessible across all submachines
- Observer — hook into state machine activities for logging and monitoring
- State visitor — traverse through active or all states
- Serialization — built-in support for Boost.Serialization, Boost.JSON, and nlohmann/json
- Compile-time trade-offs — choose between optimizing for runtime speed or compile time
- Heapless execution — configurable to avoid dynamic memory allocations
- Virtual dispatch support — encapsulate implementation details and swap implementations at runtime
Usage
This example models a connection to a host. It uses the functor front-end and the backmp11 back-end. More examples are available in the documentation.
#include <iostream>
#include <boost/msm/backmp11/state_machine.hpp>
#include <boost/msm/front/functor_row.hpp>
#include <boost/msm/front/state_machine_def.hpp>
namespace mp11 = boost::mp11;
namespace back = boost::msm::backmp11;
namespace front = boost::msm::front;
// Events
struct Connect
{
std::string host;
};
struct Disconnect {};
// Guards
struct IsValidHost
{
template <typename Fsm>
bool operator()(const Connect& event, Fsm&)
{
return !event.host.empty();
}
};
// Actions
struct LogConnection
{
template <typename Fsm>
void operator()(const Connect& event, Fsm& fsm)
{
std::cout << "Connected to " << event.host
<< " (connection #" << ++fsm.connection_count << ")"
<< std::endl;
}
};
// States
struct Disconnected : front::state<> {};
struct Connected : front::state<> {};
// State machine
struct Connection_ : front::state_machine_def<Connection_>
{
using initial_state = Disconnected;
using transition_table = mp11::mp_list<
// Source Event Target Action Guard
front::Row<Disconnected, Connect, Connected , LogConnection, IsValidHost>,
front::Row<Connected , Disconnect, Disconnected>
>;
size_t connection_count = 0;
};
using Connection = back::state_machine<Connection_>;
int main()
{
Connection sm;
sm.start();
sm.process_event(Connect{""}); // rejected by IsValidHost
sm.process_event(Connect{"localhost"}); // prints "Connected to localhost (connection #1)"
sm.process_event(Disconnect{});
}
Latest Boost.MetaStateMachine posts
All Contributors
