Home

Another Finite State Machine

afsm is a finite state machine C++11 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

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

Project Development

The project is mostly developed as a part of other projects (pg_async, PostgreSQL asynchronous driver, wire, an RPC library for C++) which are in turn developed as a part of a bigger commercial project.

License

The Artistic License 2.0