Blog

// push_pull.cpp — 같은 데이터를 보는 두 뷰: push(변경값을 넘긴다) vs pull(알림만, 값은 직접 읽는다)
#include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>

class Sales;

struct Observer {
	virtual ~Observer() = default;
	virtual void onChanged(const Sales &s, const std::string &region, int value) = 0;
};

class Sales {                                                   // Subject
public:
	void attach(Observer *o) { obs_.push_back(o); }
	void set(const std::string &region, int v)
	{
		data_[region] = v;
		for (auto *o : obs_)
			o->onChanged(*this, region, v);                 // push: 바뀐 것을 넘김
	}
	int total() const { int t = 0; for (auto &[k, v] : data_) t += v; return t; }
	const std::map<std::string, int> &all() const { return data_; }
private:
	std::map<std::string, int> data_;
	std::vector<Observer *> obs_;
};

struct ChangeLog : Observer {                                   // push 모델: 넘어온 값만 쓴다
	void onChanged(const Sales &, const std::string &r, int v) override
	{ std::cout << "  log  : " << r << " = " << v << '\n'; }
};

struct BarChart : Observer {                                    // pull 모델: 필요한 것을 주체에서 다시 읽는다
	void onChanged(const Sales &s, const std::string &, int) override
	{
		int mx = 1;
		for (auto &[k, v] : s.all()) mx = std::max(mx, v);
		std::cout << "  chart: ";
		for (auto &[k, v] : s.all())
			std::cout << k << '[' << std::string(v * 10 / mx, '#') << "] ";
		std::cout << "total=" << s.total() << '\n';
	}
};

int main()
{
	Sales sales;
	ChangeLog log;
	BarChart chart;
	sales.attach(&log);
	sales.attach(&chart);

	sales.set("seoul", 120);
	sales.set("busan", 60);
	sales.set("seoul", 30);
}

// weak_observers.cpp — 주체가 weak_ptr만 들고 있어, 관찰자가 사라지면 자동으로 빠진다
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <vector>

struct View {
	std::string name;
	explicit View(std::string n) : name(std::move(n)) {}
	void update(int v) const { std::cout << "  " << name << " <- " << v << '\n'; }
};

class Temperature {
public:
	void attach(std::weak_ptr<View> v) { views_.push_back(std::move(v)); }
	void set(int v)
	{
		std::size_t before = views_.size();
		std::erase_if(views_, [](const auto &w) { return w.expired(); });   // 죽은 관찰자 정리
		for (const auto &w : views_)
			if (auto s = w.lock())                         // 통지 중에는 살아 있도록 잠깐 소유
				s->update(v);
		std::cout << "  (observers: " << before << " -> " << views_.size() << ")\n";
	}
private:
	std::vector<std::weak_ptr<View>> views_;
};

int main()
{
	Temperature t;
	auto panel = std::make_shared<View>("panel");
	t.attach(panel);
	{
		auto popup = std::make_shared<View>("popup");
		t.attach(popup);
		std::cout << "set 21:\n"; t.set(21);
	}                                                          // popup 소멸: 해제 호출 없음
	std::cout << "set 22:\n"; t.set(22);
}

// batch.cpp — 변경 1000번에 통지 1000번 vs 묶어서 1번
#include <functional>
#include <iostream>
#include <vector>

class Model {
public:
	void subscribe(std::function<void(const Model &)> f) { subs_.push_back(std::move(f)); }
	void push(int v) { items_.push_back(v); notify(); }
	struct Batch {                                     // RAII: 범위가 끝날 때 한 번만 통지
		Model &m;
		explicit Batch(Model &mm) : m(mm) { ++m.depth_; }
		~Batch() { if (--m.depth_ == 0 && m.dirty_) { m.dirty_ = false; m.fire(); } }
	};
	std::size_t size() const { return items_.size(); }
private:
	void notify() { if (depth_ > 0) dirty_ = true; else fire(); }
	void fire() { for (auto &f : subs_) f(*this); }
	std::vector<int> items_;
	std::vector<std::function<void(const Model &)>> subs_;
	int depth_ = 0;
	bool dirty_ = false;
};

int main()
{
	Model m;
	int redraws = 0;
	m.subscribe([&](const Model &) { ++redraws; });   // 비싼 다시 그리기라고 가정

	for (int i = 0; i < 1000; ++i)
		m.push(i);
	std::cout << "unbatched: items=" << m.size() << " redraws=" << redraws << '\n';

	redraws = 0;
	{
		Model::Batch b(m);
		for (int i = 0; i < 1000; ++i)
			m.push(i);
		{ Model::Batch nested(m); m.push(-1); }       // 중첩해도 가장 바깥에서 한 번
	}
	std::cout << "batched  : items=" << m.size() << " redraws=" << redraws << '\n';
}

// throwing.cpp — 관찰자 하나가 예외를 던지면 뒤의 관찰자는 통지를 못 받는다
#include <functional>
#include <iostream>
#include <stdexcept>
#include <vector>

using Sub = std::function<void(int)>;

void notify_naive(const std::vector<Sub> &subs, int v)
{
	for (auto &s : subs) s(v);
}

void notify_isolated(const std::vector<Sub> &subs, int v)
{
	for (std::size_t i = 0; i < subs.size(); ++i) {
		try { subs[i](v); }
		catch (const std::exception &e) { std::cout << "  observer " << i << " failed: " << e.what() << '\n'; }
	}
}

int main()
{
	std::vector<Sub> subs = {
		[](int v) { std::cout << "  #0 got " << v << '\n'; },
		[](int)   { throw std::runtime_error("disk full"); },
		[](int v) { std::cout << "  #2 got " << v << '\n'; },
	};
	std::cout << "naive:\n";
	try { notify_naive(subs, 7); } catch (const std::exception &e) { std::cout << "  aborted: " << e.what() << '\n'; }
	std::cout << "isolated:\n";
	notify_isolated(subs, 7);
}

/* watch.c — inotify: 커널이 주체, 프로세스가 관찰자. 디렉터리 변화를 구독한다 */
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>

static const char *what(uint32_t m)
{
	if (m & IN_CREATE)      return "CREATE";
	if (m & IN_CLOSE_WRITE) return "CLOSE_WRITE";
	if (m & IN_MOVED_TO)    return "MOVED_TO";
	if (m & IN_DELETE)      return "DELETE";
	return "OTHER";
}

int main(int argc, char **argv)
{
	int fd = inotify_init1(IN_CLOEXEC);
	char buf[4096] __attribute__((aligned(__alignof__(struct inotify_event))));
	int seen = 0, want = argc > 2 ? atoi(argv[2]) : 4;

	if (fd < 0 || inotify_add_watch(fd, argv[1], IN_CREATE | IN_CLOSE_WRITE | IN_MOVED_TO | IN_DELETE) < 0) {
		perror("inotify");
		return 1;
	}
	printf("watching %s\n", argv[1]);
	fflush(stdout);
	while (seen < want) {
		ssize_t n = read(fd, buf, sizeof(buf));        /* 이벤트가 올 때까지 잠든다 */
		if (n <= 0)
			break;
		for (char *p = buf; p < buf + n; ) {
			struct inotify_event *e = (struct inotify_event *)p;
			printf("  %-11s %s\n", what(e->mask), e->len ? e->name : "");
			fflush(stdout);
			seen++;
			p += sizeof(*e) + e->len;
		}
	}
	close(fd);
	return 0;
}