Another Finite State Machine

afsm is a finite state machine C++14 library designed for usage in multithreaded asynchronous environment.

Inspiration and Motivation

The afsm library was inspired by ::boost::msm library and implemented so that the migration from ::boost::msm was a bunch of search and replace operations. The main motivation was to create a thread-safe FSM library and to achieve decent compile times for large and complex state machines not sacrificing performance. A state machine defined with afms library compiles several times faster than same library defined with ::boost::msm and has similar (or better) performance. You can find some benchmark results here.

Features

• Statechart features
  • Hierarchical states
  • Entry and exit actions
  • Internal transitions
  • Transition actions
  • Transition guards (conditions)
  • State history
  • Event deferring
  • Orthogonal regions
• Statechart extensions
  • Optional event priority
  • Optional common base for states and easy definition of dispatching common interface calls to current state
  • Pushdown automaton
• Compile-time checks
• Thread safety
• Exception safety
• No vtables (unless common base feature is used)
• Header only
• Relatively fast compile time
• No external dependencies except STL

Planned features

• State machine persistense

Synopsis

Here is a UML diagram of a trivial state machine and source code that it is mapped to.

#include <afsm/fsm.hpp>
// Events
struct start {};
struct stop {};

// State machine definition
struct minimal_def : ::afsm::def::state_machine<minimal_def> {
    //@{
    /** @name States */
    struct initial      : state<initial> {};
    struct running      : state<running> {};
    struct terminated   : terminal_state<terminated> {};
    //@}

    using initial_state = initial;
    using transitions   = transition_table<
        /*  State       Event       Next        */
        tr< initial,    start,      running     >,
        tr< running,    stop,       terminated  >
    >;
};

// State machine object
using minimal = ::afsm::state_machine<minimal_def>;

void use()
{
    mimimal fsm;
    fsm.process_event(start{});
    fsm.process_event(stop{});
}

You can find a tutorial covering most of basic features here.

Documentation

Please see project wiki for documentation. TODO doxygen generated documentation.

Installation

The library is header only and doesn't requre build or installation. Just add the afsm/include and lib/meta/include directories under the root of this repository to your include paths.

CMake subproject

You can add the library to your project as a subtree, e.g. lib/afsm, and in your root CMakeLists.txt file just do the following:

add_subdirectory(lib/afsm)
include_directories(${AFSM_INCLUDE_DIRS})

TODO write docs on gitrc subtree commands and link to the repository

Installation to System Directories

git clone [email protected]:zmij/afsm.git
mkdir afsm/build
cd afsm/build
cmake ..
sudo make install

Finding the AFSM Package

find_package(AFSM REQUIRED) # Will set AFSM_INCLUDE_DIRS variable

License

The Artistic License 2.0