Blog

// dialog.cpp — 위젯끼리 서로를 모르고, 변화는 중재자에게만 알린다
#include <iostream>
#include <string>

class Mediator;

class Widget {                                            // Colleague
public:
	Widget(Mediator &m, std::string name) : m_(m), name_(std::move(name)) {}
	virtual ~Widget() = default;
	const std::string &name() const { return name_; }
	bool enabled = true;
protected:
	void changed();                                       // "나 바뀌었어"만 알린다
private:
	Mediator &m_;
	std::string name_;
};

class Mediator {
public:
	virtual ~Mediator() = default;
	virtual void widgetChanged(Widget &w) = 0;
};

void Widget::changed() { m_.widgetChanged(*this); }

class CheckBox : public Widget {
public:
	using Widget::Widget;
	void set(bool v) { checked = v; changed(); }
	bool checked = false;
};
class TextField : public Widget {
public:
	using Widget::Widget;
	void type(std::string s) { text = std::move(s); changed(); }
	std::string text;
};
class Button : public Widget { public: using Widget::Widget; };

class SignupDialog : public Mediator {                    // ConcreteMediator: 상호작용 규칙이 전부 여기
public:
	SignupDialog() : agree(*this, "agree"), email(*this, "email"), company(*this, "company"),
			 isCompany(*this, "isCompany"), submit(*this, "submit") { update(); }
	void widgetChanged(Widget &w) override
	{
		std::cout << "  " << w.name() << " changed -> ";
		update();
		std::cout << "company.enabled=" << company.enabled << " submit.enabled=" << submit.enabled << '\n';
	}
	CheckBox agree;
	TextField email, company;
	CheckBox isCompany;
	Button submit;
private:
	void update()
	{
		company.enabled = isCompany.checked;
		bool emailOk = email.text.find('@') != std::string::npos;
		bool companyOk = !isCompany.checked || !company.text.empty();
		submit.enabled = agree.checked && emailOk && companyOk;
	}
};

int main()
{
	SignupDialog d;
	std::cout << std::boolalpha;
	d.email.type("kim@example.com");
	d.agree.set(true);
	d.isCompany.set(true);           // 회사 체크 → 회사명 필수
	d.company.type("Junorion");
}

// chat.cpp — 사용자는 서로를 모르고 방(중재자)에게만 말한다. 라우팅·음소거 규칙은 방에 있다
#include <iostream>
#include <map>
#include <set>
#include <string>

class ChatRoom;

class User {
public:
	User(std::string n, ChatRoom &r);
	void say(const std::string &msg);
	void whisper(const std::string &to, const std::string &msg);
	void receive(const std::string &from, const std::string &msg) const
	{ std::cout << "  [" << name << "] " << from << ": " << msg << '\n'; }
	const std::string name;
private:
	ChatRoom &room_;
};

class ChatRoom {
public:
	void join(User &u) { users_[u.name] = &u; }
	void mute(const std::string &n) { muted_.insert(n); }
	void broadcast(const User &from, const std::string &msg)
	{
		if (muted_.count(from.name)) {
			std::cout << "  (" << from.name << " is muted)\n";
			return;
		}
		for (auto &[n, u] : users_)
			if (n != from.name)
				u->receive(from.name, msg);
	}
	void direct(const User &from, const std::string &to, const std::string &msg)
	{
		auto it = users_.find(to);
		if (it == users_.end())
			from.receive("room", "no such user: " + to);
		else
			it->second->receive(from.name + " (private)", msg);
	}
private:
	std::map<std::string, User *> users_;
	std::set<std::string> muted_;
};

User::User(std::string n, ChatRoom &r) : name(std::move(n)), room_(r) { r.join(*this); }
void User::say(const std::string &m) { room_.broadcast(*this, m); }
void User::whisper(const std::string &to, const std::string &m) { room_.direct(*this, to, m); }

int main()
{
	ChatRoom room;
	User kim("kim", room), lee("lee", room), park("park", room);
	std::cout << "kim says:\n";     kim.say("빌드 깨졌어요");
	std::cout << "lee whispers:\n"; lee.whisper("kim", "제가 볼게요");
	room.mute("park");
	std::cout << "park says:\n";    park.say("광고 메시지");
	std::cout << "kim whispers:\n"; kim.whisper("choi", "안녕");
}

// reentry.cpp — 양방향 동기화에서 중재자 재진입: 보호 없이 vs 갱신 중 플래그
#include <iostream>

struct Sync;

struct Control {                                       // 슬라이더, 스핀박스 공통
	const char *name;
	int value = 0;
	Sync *m = nullptr;
	void set(int v);                                    // 값이 바뀌면 중재자에 통지
};

struct Sync {
	Control slider{"slider"}, spin{"spin"};
	bool guard;
	int calls = 0;
	explicit Sync(bool g) : guard(g) { slider.m = spin.m = this; }
	void changed(Control &c)
	{
		if (++calls > 6) {                              // 데모용 안전장치
			std::cout << "  ... stopped after " << calls - 1 << " notifications\n";
			throw 0;
		}
		if (guard && updating_)
			return;                                     // 내가 바꾼 결과로 돌아온 통지는 무시
		updating_ = true;
		Control &other = (&c == &slider) ? spin : slider;
		std::cout << "  " << c.name << "=" << c.value << " -> set " << other.name << '\n';
		other.set(c.value);
		updating_ = false;
	}
private:
	bool updating_ = false;
};

void Control::set(int v) { value = v; m->changed(*this); }

int main()
{
	for (bool g : {false, true}) {
		std::cout << (g ? "with guard:\n" : "without guard:\n");
		Sync s(g);
		try {
			s.slider.set(42);
			std::cout << "  done, notifications=" << s.calls << " slider=" << s.slider.value
				  << " spin=" << s.spin.value << '\n';
		} catch (int) {}
	}
}

/* thermostat.c — C 중재자: 센서·히터·팬·디스플레이는 서로를 모르고 컨트롤러가 규칙을 정한다 */
#include <stdio.h>

struct controller;

struct heater  { int on; };
struct fan     { int speed; };
struct display { char line[64]; };

struct controller {                          /* 중재자 */
	struct heater *heater;
	struct fan *fan;
	struct display *display;
	double target;
};

/* 동료(센서)는 값이 바뀌면 중재자에게만 알린다 */
static void controller_on_temperature(struct controller *c, double t)
{
	c->heater->on = t < c->target - 0.5;
	c->fan->speed = t > c->target + 2.0 ? 2 : (t > c->target + 0.5 ? 1 : 0);
	snprintf(c->display->line, sizeof(c->display->line), "%.1fC heater=%s fan=%d",
		 t, c->heater->on ? "on" : "off", c->fan->speed);
}

struct sensor {
	struct controller *mediator;
	double value;
};

static void sensor_update(struct sensor *s, double v)
{
	s->value = v;
	controller_on_temperature(s->mediator, v);
}

int main(void)
{
	struct heater h = { 0 };
	struct fan f = { 0 };
	struct display d = { "" };
	struct controller c = { &h, &f, &d, 22.0 };
	struct sensor s = { &c, 0 };
	double readings[] = { 19.8, 21.7, 22.4, 23.1, 25.0 };

	for (size_t i = 0; i < sizeof(readings) / sizeof(readings[0]); i++) {
		sensor_update(&s, readings[i]);
		printf("%s\n", d.line);
	}
	return 0;
}