Compile-time FSM 구현 — 템플릿으로 상태 전이 검증

1
constexpr auto next = transition<State::Idle, Event::Start>();   // 컴파일 타임
2
// next = State::Running
3

4
constexpr auto bad = transition<State::Idle, Event::Stop>();    // 컴파일 에러
5
// error: invalid transition

1
enum class State : uint8_t { Idle, Running, Paused, Stopped };
2
enum class Event : uint8_t { Start, Pause, Resume, Stop };
3

4
struct Transition {
5
    State from;
6
    Event event;
7
    State to;
8
};
9

10
constexpr Transition transitions[] = {
11
    {State::Idle,    Event::Start,  State::Running},
12
    {State::Running, Event::Pause,  State::Paused},
13
    {State::Running, Event::Stop,   State::Stopped},
14
    {State::Paused,  Event::Resume, State::Running},
15
    {State::Paused,  Event::Stop,   State::Stopped},
16
};
17

18
constexpr State next_state(State current, Event event) {
19
    for (const auto& t : transitions) {
20
        if (t.from == current && t.event == event) return t.to;
21
    }
22
    return current;   // no transition
23
}
24

25
// 런타임 또는 컴파일 타임
26
constexpr State s = next_state(State::Idle, Event::Start);
27
static_assert(s == State::Running);

1
template<State From, Event Ev>
2
struct TransitionT {
3
    static constexpr bool valid = false;
4
    static constexpr State to = From;   // no change
5
};
6

7
// 명시적 specialization으로 valid 전이 정의
8
template<> struct TransitionT<State::Idle, Event::Start> {
9
    static constexpr bool valid = true;
10
    static constexpr State to = State::Running;
11
};
12

13
template<> struct TransitionT<State::Running, Event::Pause> {
14
    static constexpr bool valid = true;
15
    static constexpr State to = State::Paused;
16
};
17

18
template<> struct TransitionT<State::Running, Event::Stop> {
19
    static constexpr bool valid = true;
20
    static constexpr State to = State::Stopped;
21
};
22

23
// ... 모든 valid 전이
24

25
// 사용
26
template<State From, Event Ev>
27
constexpr State transition() {
28
    static_assert(TransitionT<From, Ev>::valid,
29
                  "Invalid state transition");
30
    return TransitionT<From, Ev>::to;
31
}
32

33
constexpr State s1 = transition<State::Idle, Event::Start>();   // OK
34
// constexpr State s2 = transition<State::Idle, Event::Stop>();  // 컴파일 에러

1
struct Idle {};
2
struct Running { uint32_t since; };
3
struct Paused { uint32_t since; };
4
struct Stopped {};
5

6
using State = std::variant<Idle, Running, Paused, Stopped>;
7

8
struct StartEvent {};
9
struct PauseEvent {};
10
struct ResumeEvent {};
11
struct StopEvent {};
12

13
// 전이 함수 — 각 (state, event) 조합
14
constexpr State transition(Idle, StartEvent) {
15
    return Running{get_time()};
16
}
17

18
constexpr State transition(Running r, PauseEvent) {
19
    return Paused{r.since};
20
}
21

22
constexpr State transition(Running, StopEvent) {
23
    return Stopped{};
24
}
25

26
constexpr State transition(Paused p, ResumeEvent) {
27
    return Running{p.since};
28
}
29

30
// catch-all — invalid transition은 현재 state 유지
31
template<typename S, typename E>
32
constexpr State transition(S s, E) {
33
    static_assert(sizeof(E) == 0, "Invalid transition");
34
    return s;
35
}
36

37
// 사용
38
template<typename E>
39
void send_event(State& current, E ev) {
40
    current = std::visit([&ev](auto&& state) -> State {
41
        return transition(state, ev);
42
    }, current);
43
}
44

45
State machine = Idle{};
46
send_event(machine, StartEvent{});   // Idle → Running
47
// send_event(machine, StopEvent{});   // Idle + StopEvent — static_assert 실패

1
#include <boost/sml.hpp>
2
namespace sml = boost::sml;
3

4
struct Start {};
5
struct Pause {};
6
struct Resume {};
7
struct Stop {};
8

9
struct Machine {
10
    auto operator()() {
11
        using namespace sml;
12
        return make_transition_table(
13
            *"Idle"_s    + event<Start>  / [](){ start_play(); }    = "Running"_s,
14
             "Running"_s + event<Pause>  / [](){ pause_play(); }    = "Paused"_s,
15
             "Running"_s + event<Stop>   / [](){ stop_play(); }     = "Stopped"_s,
16
             "Paused"_s  + event<Resume> / [](){ resume_play(); }   = "Running"_s,
17
             "Paused"_s  + event<Stop>   / [](){ stop_play(); }     = "Stopped"_s,
18
             "Stopped"_s + event<Start>  / [](){ start_play(); }    = "Running"_s
19
        );
20
    }
21
};
22

23
sml::sm<Machine> fsm;
24
fsm.process_event(Start{});
25
fsm.process_event(Pause{});
26
fsm.process_event(Resume{});

1
template<typename Parent = void>
2
struct StateBase {
3
    using parent_type = Parent;
4
};
5

6
struct Idle : StateBase<> {};
7
struct Working : StateBase<> {};
8
struct Reading : StateBase<Working> {};   // Working의 substate
9
struct Writing : StateBase<Working> {};
10

11
template<typename State>
12
constexpr bool is_in_state(/* ... */) {
13
    // ... 부모 상태 chain 추적
14
}

1
constexpr Transition trs[] = {
2
    {State::Idle,    Event::Start, State::Running},
3
    {State::Running, Event::Stop,  State::Stopped},
4
    // State::Paused — 도달 불가능
5
};
6

7
constexpr bool is_reachable(State s) {
8
    if (s == State::Idle) return true;   // 시작 state
9
    for (const auto& t : trs) {
10
        if (t.to == s && is_reachable(t.from)) return true;
11
    }
12
    return false;
13
}
14

15
static_assert(is_reachable(State::Running));
16
static_assert(is_reachable(State::Stopped));
17
// static_assert(is_reachable(State::Paused));   // 컴파일 에러 — unreachable

1
constexpr bool has_outgoing(State s) {
2
    for (const auto& t : trs) {
3
        if (t.from == s) return true;
4
    }
5
    return false;
6
}
7

8
static_assert(has_outgoing(State::Running));
9
// static_assert(has_outgoing(State::Stopped));   // dead state

1
# Runtime FSM (enum + switch)
2
.text: 380 B
3
total cycles: 8000
4

5
# Variant + visit
6
.text: 720 B
7
total cycles: 9000 (variant copy + visit)
8

9
# Compile-time (template specialization)
10
.text: 180 B   (대부분 인라인)
11
total cycles: 5000 (직접 dispatch)
12

13
# Boost.SML
14
.text: 920 B
15
total cycles: 7500