Blog

// switch_fsm.cpp — 상태별 분기가 모든 메서드에 흩어진다
#include <iostream>
#include <string>

enum class State { Closed, Listen, Established, Closing };   // Closing을 새로 추가했다

class Connection {
public:
	std::string send(const std::string &data)
	{
		switch (state_) {
		case State::Closed:      return "error: not connected";
		case State::Listen:      return "error: handshake not done";
		case State::Established: return "sent " + std::to_string(data.size()) + " bytes";
		}                                               // Closing 처리 누락
		return "?";
	}
	void open()  { if (state_ == State::Closed) state_ = State::Listen; }
	void ack()   { if (state_ == State::Listen) state_ = State::Established; }
	void close() { state_ = State::Closing; }
private:
	State state_ = State::Closed;
};

int main()
{
	Connection c;
	std::cout << c.send("hi") << '\n';
	c.open(); c.ack();
	std::cout << c.send("hello") << '\n';
	c.close();
	std::cout << c.send("late") << '\n';
}

// state_classes.cpp — GoF 상태 패턴: 상태마다 클래스, Context는 현재 상태 객체에 위임
#include <iostream>
#include <memory>
#include <string>

class Connection;

struct TcpState {
	virtual ~TcpState() = default;
	virtual const char *name() const = 0;
	virtual void open(Connection &) { std::cout << "  (open ignored in " << name() << ")\n"; }
	virtual void ack(Connection &)  { std::cout << "  (ack ignored in " << name() << ")\n"; }
	virtual void close(Connection &) { std::cout << "  (close ignored in " << name() << ")\n"; }
	virtual std::string send(Connection &, const std::string &) { return std::string("error: cannot send in ") + name(); }
};

class Connection {                                        // Context
public:
	Connection();
	void open()  { state_->open(*this); }
	void ack()   { state_->ack(*this); }
	void close() { state_->close(*this); }
	std::string send(const std::string &d) { return state_->send(*this, d); }
	void transition(std::unique_ptr<TcpState> next)
	{
		std::cout << "  " << state_->name() << " -> " << next->name() << '\n';
		state_ = std::move(next);
	}
	int bytesSent = 0;
private:
	std::unique_ptr<TcpState> state_;
};

struct Closed;
struct Established : TcpState {
	const char *name() const override { return "Established"; }
	std::string send(Connection &c, const std::string &d) override
	{ c.bytesSent += d.size(); return "sent " + std::to_string(d.size()) + " bytes"; }
	void close(Connection &c) override;
};
struct Listen : TcpState {
	const char *name() const override { return "Listen"; }
	void ack(Connection &c) override { c.transition(std::make_unique<Established>()); }
	void close(Connection &c) override;
};
struct Closed : TcpState {
	const char *name() const override { return "Closed"; }
	void open(Connection &c) override { c.transition(std::make_unique<Listen>()); }
};
void Established::close(Connection &c) { c.transition(std::make_unique<Closed>()); }
void Listen::close(Connection &c) { c.transition(std::make_unique<Closed>()); }

Connection::Connection() : state_(std::make_unique<Closed>()) {}

int main()
{
	Connection c;
	std::cout << c.send("hi") << '\n';
	c.ack();                       // Closed에서는 무시
	c.open();
	c.ack();
	std::cout << c.send("hello") << '\n';
	c.close();
	std::cout << c.send("late") << "\ntotal sent=" << c.bytesSent << '\n';
}

// variant_fsm.cpp — 상태를 variant로, 전이를 (상태, 이벤트) 쌍의 오버로드로
#include <iostream>
#include <string>
#include <variant>

struct Closed {};
struct Listen { int port; };
struct Established { int port; long bytes = 0; };
using State = std::variant<Closed, Listen, Established>;

struct Open { int port; };
struct Ack {};
struct Send { std::string data; };
struct Close {};
using Event = std::variant<Open, Ack, Send, Close>;

template <class... F> struct overloaded : F... { using F::operator()...; };

State next(const State &s, const Event &e)
{
	return std::visit(overloaded{
		[](const Closed &, const Open &o) -> State { return Listen{o.port}; },
		[](const Listen &l, const Ack &) -> State { return Established{l.port}; },
		[](const Established &est, const Send &d) -> State { auto n = est; n.bytes += d.data.size(); return n; },
		[](const Listen &, const Close &) -> State { return Closed{}; },
		[](const Established &, const Close &) -> State { return Closed{}; },
#ifndef STRICT
		[](const auto &cur, const auto &) -> State { std::cout << "  (ignored)\n"; return cur; },   // 그 외 조합
#endif
	}, s, e);
}

const char *name(const State &s)
{
	return std::visit(overloaded{
		[](const Closed &) { return "Closed"; },
		[](const Listen &) { return "Listen"; },
		[](const Established &) { return "Established"; },
	}, s);
}

int main()
{
	State s = Closed{};
	for (Event e : {Event{Ack{}}, Event{Open{8080}}, Event{Ack{}}, Event{Send{"hello"}}, Event{Send{"world!"}}, Event{Close{}}}) {
		State prev = s;
		s = next(s, e);
		std::cout << name(prev) << " -> " << name(s);
		if (auto *est = std::get_if<Established>(&s))
			std::cout << " port=" << est->port << " bytes=" << est->bytes;
		std::cout << '\n';
	}
	std::cout << "sizeof(State)=" << sizeof(State) << " (no heap allocation per transition)\n";
}

/* table_fsm.c — C 상태 머신: (현재 상태, 이벤트) → (다음 상태, 동작) 전이 표 */
#include <stdio.h>

enum state { CLOSED, LISTEN, ESTABLISHED, NSTATE };
enum event { EV_OPEN, EV_ACK, EV_SEND, EV_CLOSE, NEVENT };

static const char *state_name[] = { "CLOSED", "LISTEN", "ESTABLISHED" };
static const char *event_name[] = { "open", "ack", "send", "close" };

struct conn { enum state st; long bytes; };

static void act_none(struct conn *c, int arg) { (void)c; (void)arg; }
static void act_send(struct conn *c, int arg) { c->bytes += arg; }
static void act_reset(struct conn *c, int arg) { (void)arg; c->bytes = 0; }

struct transition {
	enum state next;
	void (*action)(struct conn *c, int arg);
	int valid;
};

/* 전이 규칙이 한눈에 보이는 표. 빈 칸(0)은 허용되지 않는 이벤트 */
static const struct transition table[NSTATE][NEVENT] = {
	[CLOSED]      = { [EV_OPEN]  = { LISTEN, act_none, 1 } },
	[LISTEN]      = { [EV_ACK]   = { ESTABLISHED, act_none, 1 },
			  [EV_CLOSE] = { CLOSED, act_none, 1 } },
	[ESTABLISHED] = { [EV_SEND]  = { ESTABLISHED, act_send, 1 },
			  [EV_CLOSE] = { CLOSED, act_reset, 1 } },
};

static void dispatch(struct conn *c, enum event e, int arg)
{
	const struct transition *t = &table[c->st][e];

	if (!t->valid) {
		printf("  %-11s --%-5s--> rejected\n", state_name[c->st], event_name[e]);
		return;
	}
	t->action(c, arg);
	printf("  %-11s --%-5s--> %-11s bytes=%ld\n", state_name[c->st], event_name[e], state_name[t->next], c->bytes);
	c->st = t->next;
}

int main(void)
{
	struct conn c = { CLOSED, 0 };
	struct { enum event e; int arg; } script[] = {
		{ EV_SEND, 3 }, { EV_OPEN, 0 }, { EV_ACK, 0 }, { EV_SEND, 5 }, { EV_SEND, 6 }, { EV_OPEN, 0 }, { EV_CLOSE, 0 },
	};

	for (size_t i = 0; i < sizeof(script) / sizeof(script[0]); i++)
		dispatch(&c, script[i].e, script[i].arg);
	return 0;
}