transition.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#include <concepts>
#include <type_traits>
#include <utility>
 
#include "tsm/type_list.h"
 
namespace tsm::detail {
 
struct Event {};
 
template<typename T>
struct wrapped_event : Event {
    using type = T;
};
 
template<typename Parent>
struct final_state {
    using final_parent = Parent;
};
 
template<typename T>
concept final_state_like = requires {
    typename T::final_parent;
};
 
template<typename Parent>
struct history_state {
    using history_parent = Parent;
};
 
template<typename T>
concept history_state_like = requires {
    typename T::history_parent;
};
 
template<typename Parent>
struct deep_history_state {
    using history_parent = Parent;
};
 
template<typename T>
concept deep_history_state_like = requires {
    typename T::history_parent;
} && std::same_as<T, deep_history_state<typename T::history_parent>>;
 
struct automatic_event {};
struct completion_event {};
 
struct choice {};
struct junction {};
struct region {};
struct fork {};
struct join {};
 
template<typename State, typename Event>
struct defer {
    using state = State;
    using event = Event;
};
 
template<typename T>
concept choice_like = std::derived_from<T, choice>;
 
template<typename T>
concept junction_like = std::derived_from<T, junction>;
 
template<typename T>
concept decision_pseudostate_like = choice_like<T> || junction_like<T>;
 
template<typename T>
concept region_like = std::derived_from<T, region>;
 
template<typename T>
concept fork_like = std::derived_from<T, fork>;
 
template<typename T>
concept join_like = std::derived_from<T, join>;
 
template<typename T>
concept defer_like = requires {
    typename T::state;
    typename T::event;
};
 
template<typename Fork, typename... Targets>
struct fork_to {
    using fork = Fork;
    using targets = type_list<Targets...>;
};
 
template<typename ForkMarker, typename... Targets>
using Fork = fork_to<ForkMarker, Targets...>;
 
template<typename Join, typename... Sources>
struct join_from {
    using join = Join;
    using sources = type_list<Sources...>;
};
 
template<typename Join, typename Target>
struct join_to {
    using join = Join;
    using target = Target;
};
 
template<typename JoinMarker, typename... Sources>
using Join = join_from<JoinMarker, Sources...>;
 
template<typename JoinMarker, typename Target>
using JoinTo = join_to<JoinMarker, Target>;
 
template<typename T>
concept fork_rule_like = requires {
    typename T::fork;
    typename T::targets;
} && fork_like<typename T::fork> && type_list_like<typename T::targets>;
 
template<typename T>
concept join_from_rule_like = requires {
    typename T::join;
    typename T::sources;
} && join_like<typename T::join> && type_list_like<typename T::sources>;
 
template<typename T>
concept join_to_rule_like = requires {
    typename T::join;
    typename T::target;
} && join_like<typename T::join>;
 
template<typename T>
concept synchronization_rule_like =
  fork_rule_like<T> || join_from_rule_like<T> || join_to_rule_like<T>;
 
template<typename T>
struct is_synchronization_rule
  : std::bool_constant<synchronization_rule_like<T>> {};
 
template<typename T>
concept has_synchronization_type_c = requires {
    typename T::synchronization;
};
 
template<typename T>
struct synchronization_of {
    using type = type_list<>;
};
 
template<typename T>
    requires has_synchronization_type_c<T>
struct synchronization_of<T> {
    using type = typename T::synchronization;
    static_assert(type_list_like<type>,
                  "tsm: synchronization must be tsm::synchronization<...>");
    static_assert(type_list_traits::all_satisfy<is_synchronization_rule, type>::value,
                  "tsm: synchronization entries must be fork_to, join_from, "
                  "or join_to rules");
};
 
enum class transition_kind {
    external,
    local,
    internal,
    reentering_external
};
 
template<typename From, typename Event, typename To>
struct on {
    using from = From;
    using event = Event;
    using to = To;
    static constexpr transition_kind kind = transition_kind::external;
};
 
template<transition_kind Kind, typename From, typename Event, typename To>
struct basic_transition {
    using from = From;
    using event = Event;
    using to = To;
    static constexpr transition_kind kind = Kind;
};
 
template<transition_kind Kind, typename From, typename Event, typename To, auto Action>
struct transition_with_action : basic_transition<Kind, From, Event, To> {
    using action_t = decltype(Action);
    static constexpr action_t action = Action;
};
 
template<transition_kind Kind, typename From, typename Event, typename To, auto Guard>
struct transition_with_guard : basic_transition<Kind, From, Event, To> {
    using guard_t = decltype(Guard);
    static constexpr guard_t guard = Guard;
};
 
template<transition_kind Kind,
         typename From,
         typename Event,
         typename To,
         auto Guard,
         auto Action>
struct transition_with_guard_action : basic_transition<Kind, From, Event, To> {
    using guard_t = decltype(Guard);
    using action_t = decltype(Action);
    static constexpr guard_t guard = Guard;
    static constexpr action_t action = Action;
};
 
template<typename From, typename Event, typename To, auto Action>
using with_action =
  transition_with_action<transition_kind::external, From, Event, To, Action>;
 
template<typename From, typename Event, typename To, auto Guard>
using with_guard =
  transition_with_guard<transition_kind::external, From, Event, To, Guard>;
 
template<typename From, typename Event, typename To, auto Guard, auto Action>
using with_guard_action =
  transition_with_guard_action<transition_kind::external,
                               From,
                               Event,
                               To,
                               Guard,
                               Action>;
 
template<transition_kind Kind, typename From, typename Event, typename To, auto... Behavior>
struct transition;
 
template<auto Guard>
struct guard
{
    static constexpr auto value = Guard;
};
 
template<auto Action>
struct action
{
    static constexpr auto value = Action;
};
 
template<typename From, typename Event, typename To, typename... Behavior>
struct edge;
 
template<typename From, typename Event, typename To>
struct edge<From, Event, To>
  : transition<transition_kind::external, From, Event, To>
{
};
 
template<typename From, typename Event, typename To, auto Guard>
struct edge<From, Event, To, guard<Guard>>
  : transition_with_guard<transition_kind::external, From, Event, To, Guard>
{
};
 
template<typename From, typename Event, typename To, auto Action>
struct edge<From, Event, To, action<Action>>
  : transition_with_action<transition_kind::external, From, Event, To, Action>
{
};
 
template<typename From, typename Event, typename To, auto Guard, auto Action>
struct edge<From, Event, To, guard<Guard>, action<Action>>
  : transition_with_guard_action<transition_kind::external,
                                 From,
                                 Event,
                                 To,
                                 Guard,
                                 Action>
{
};
 
template<typename From, typename Event, typename To, auto Action, auto Guard>
struct edge<From, Event, To, action<Action>, guard<Guard>>
  : transition_with_guard_action<transition_kind::external,
                                 From,
                                 Event,
                                 To,
                                 Guard,
                                 Action>
{
};
 
template<transition_kind Kind, typename From, typename Event, typename To>
struct transition<Kind, From, Event, To> : basic_transition<Kind, From, Event, To> {};
 
template<transition_kind Kind, typename From, typename Event, typename To, auto Action>
struct transition<Kind, From, Event, To, Action>
  : transition_with_action<Kind, From, Event, To, Action> {};
 
template<transition_kind Kind,
         typename From,
         typename Event,
         typename To,
         auto Action,
         auto Guard>
struct transition<Kind, From, Event, To, Action, Guard>
  : transition_with_guard_action<Kind, From, Event, To, Guard, Action> {};
 
template<typename From, typename Event, typename To, auto... Behavior>
struct T;
 
template<typename From, typename Event, typename To>
struct T<From, Event, To>
  : transition<transition_kind::external, From, Event, To> {};
 
template<typename From, typename Event, typename To, auto Action>
struct T<From, Event, To, Action>
  : transition<transition_kind::external, From, Event, To, Action> {};
 
template<typename From, typename Event, typename To, auto Action, auto Guard>
struct T<From, Event, To, Action, Guard>
  : transition<transition_kind::external, From, Event, To, Action, Guard> {};
 
template<typename From, typename Event, typename To, auto... Behavior>
struct local : transition<transition_kind::local, From, Event, To, Behavior...> {};
 
template<typename From, typename Event, auto... Behavior>
struct internal : transition<transition_kind::internal, From, Event, From, Behavior...> {};
 
template<typename From, typename Event, typename To, auto... Behavior>
struct Internal : transition<transition_kind::local, From, Event, To, Behavior...> {};
 
template<typename From, typename Event, typename To, auto... Behavior>
struct External
  : transition<transition_kind::reentering_external,
               From,
               Event,
               To,
               Behavior...> {};
 
struct ClockTickEvent {
    int ticks_{0};
};
 
template<typename From, typename To, auto... Behavior>
struct ClockedTransition : T<From, ClockTickEvent, To, Behavior...> {};
 
template<typename Transition>
concept transition_edge_like = requires {
    typename Transition::from;
    typename Transition::to;
};
 
template<typename Transition>
concept transition_like = transition_edge_like<Transition> && requires {
    typename Transition::event;
};
 
template<typename Transition>
struct is_transition : std::bool_constant<transition_like<Transition>> {};
 
template<typename Transition>
concept transition_has_guard = transition_like<Transition> && requires {
    Transition::guard;
};
 
template<typename Transition>
concept transition_has_action = transition_like<Transition> && requires {
    Transition::action;
};
 
template<typename Transition>
consteval transition_kind get_transition_kind() {
    if constexpr (requires { Transition::kind; }) {
        return Transition::kind;
    } else {
        return transition_kind::external;
    }
}
 
template<typename Transition>
inline constexpr transition_kind transition_kind_v =
  get_transition_kind<Transition>();
 
template<typename Transition, typename From, typename Event>
concept transition_matches =
  transition_like<Transition> &&
  std::same_as<typename Transition::from, From> &&
  std::same_as<typename Transition::event, Event>;
 
template<typename T>
concept has_transition_type_c = requires {
    typename T::transitions;
};
 
template<typename T>
concept has_transition_member_c = requires(T& context) {
    context.transitions();
};
 
template<typename T, typename = void>
struct transitions_of;
 
template<typename T>
    requires has_transition_type_c<T>
struct transitions_of<T> {
    using type = typename T::transitions;
};
 
template<typename T>
    requires(!has_transition_type_c<T> && has_transition_member_c<T>)
struct transitions_of<T> {
    using type =
      std::remove_cvref_t<decltype(std::declval<T&>().transitions())>;
};
 
template<typename T>
using transitions_of_t = typename transitions_of<T>::type;
 
template<typename T>
concept has_transitions_c =
  has_transition_type_c<T> || has_transition_member_c<T>;
 
template<transition_like Transition>
struct transition_traits {
    using from = typename Transition::from;
    using event = typename Transition::event;
    using to = typename Transition::to;
 
    static constexpr bool has_guard = transition_has_guard<Transition>;
    static constexpr bool has_action = transition_has_action<Transition>;
    static constexpr auto kind = transition_kind_v<Transition>;
 
    template<typename From, typename Event, typename To>
    static consteval auto with_endpoints_type() {
        if constexpr (has_guard && has_action) {
            return std::type_identity<
              transition_with_guard_action<kind,
                                           From,
                                           Event,
                                           To,
                                           Transition::guard,
                                           Transition::action>>{};
        } else if constexpr (has_guard) {
            return std::type_identity<
              transition_with_guard<kind, From, Event, To, Transition::guard>>{};
        } else if constexpr (has_action) {
            return std::type_identity<
              transition_with_action<kind, From, Event, To, Transition::action>>{};
        } else {
            return std::type_identity<transition<kind, From, Event, To>>{};
        }
    }
 
    template<typename From, typename Event, typename To>
    using with_endpoints =
      typename decltype(with_endpoints_type<From, Event, To>())::type;
};
 
} // namespace tsm::detail