>_<.

#ifndef __OBSERVER_HPP__
#define __OBSERVER_HPP__

class Observer 
{
	public: 
		virtual void update(void *) = 0;
}; 

#endif  // __OBSERVER_HPP__

#ifndef __OBSERABLE_HPP__
#define __OBSERABLE_HPP__

#include <vector> 

class Observable 
{ 
	public:
		Observable()
		{
			changed = false;
		}

		virtual ~Observable()
		{
			// do nothing
		}

		bool addObserver(Observer *a)
		{
			// check observer is valid
			if(a == NULL)
				return false;

			// don't add and observer more than once.
			for(std::vector<Observer*>::const_iterator observer_iterator=observers.begin(); 
					observer_iterator != observers.end(); 
					observer_iterator++ ) {
				if((*observer_iterator) == a) 
					return false;
			}

			// put observer into the list
			observers.push_back(a);

			return true;
		}

		void removeObserver(Observer *a)
		{
			// check observer is valid
			if(a == NULL)
				return;

			for(std::vector<Observer *>::iterator observer_iterator = observers.begin(); 
					observer_iterator != observers.end(); 
					observer_iterator++ ) {
				if(*observer_iterator == a) {
					observer_iterator = observers.erase(observer_iterator);
					return;
				}
			}
		}

		// notifyObservers 
		void notifyObservers(void *info)
		{ 
			// check info is valid
			if(info == NULL)
				return;
			
			// do nothing when observable is not changed
			if(!isChanged())
				return;

			for(std::vector<Observer *>::const_iterator observer_iterator = observers.begin(); 
					observer_iterator != observers.end(); 
					observer_iterator++ ) {
				(*observer_iterator)->update(info);
			}

			clearChanged();
		} 

		bool isChanged(void)
		{
			return changed;
		}

		size_t countObserver(void)
		{
			return observers.size();
		}

		void setChanged(void)
		{
			changed = true;
		}

		void clearChanged(void)
		{
			changed = false;
		}

	private:
		std::vector<Observer *>observers; 	// observer list 
		bool changed;
}; 

#endif  // __OBSERABLE_HPP__

#ifndef __ABSTRACTCONTROLLER_HPP__
#define __ABSTRACTCONTROLLER_HPP__

// #include "Observer.hpp"

class AbstractView;

class AbstractController 
{
	public:
		AbstractController()
		{
			// do nothing
		}

		AbstractController(Observable *m) : model(m)
		{
			// do nothing
		}

		virtual ~AbstractController()
		{
			// do nothing
		}

		void setModel(Observable *m)
		{
			model = m;
		}

		Observable *getModel(void)
		{
			return model;
		}

		void setView(AbstractView *v)
		{
			view = v;
		}

		AbstractView *getView(void)
		{
			return view;
		}

	protected:
		Observable *model;
		AbstractView *view;
};

#endif  // __ABSTRACTCONTROLLER_HPP__

#ifndef __ABSTRACTVIEW_HPP__
#define __ABSTRACTVIEW_HPP__

// #include "Observable.hpp"
// #include "Observer.hpp"
// #include "AbstractController.hpp"

class AbstractView : public Observer
{
	public:
		AbstractView()
		{
			// do nothing
		}

		AbstractView(Observable *m, AbstractController *c) : model(m), controller(c)
		{
			// do nothing
		}

		virtual ~AbstractView()
		{
			// do nothing
		}

		void setModel(Observable *m)
		{
			model = m;
		}

		Observable *getModel(void)
		{
			return model;
		}

		void setController(AbstractController *c)
		{
			controller = c;
			controller->setView(this);
		}

		AbstractController *getController(void)
		{
			return controller;
		}

	protected:
		Observable *model;
		AbstractController *controller;

};

#endif  // __ABSTRACTVIEW_HPP__

#include <cstdio>
#include <unistd.h>
// #include "mvc.hpp"

struct ClockModelInfo
{
	ClockModelInfo(int h, int m, int s) :
		  hour(h)
		, minute(m)
		, second(s)
	{
		// do nothing
	}

	int hour;
	int minute;
	int second;
};

class ClockModel : public Observable
{
	public:
		ClockModel()
		{
			hour = 0;
			minute = 0;
			second = 0;
		}

		virtual ~ClockModel()
		{
			// do nothing
		}

		void setHour(int h)
		{
			hour = h;
			notify();
		}

		void setMinute(int m)
		{
			minute = m;
			notify();
		}

		void setSecond(int s)
		{
			second = s;
			notify();
		}

		int getHour(int h)
		{
			return hour;
		}

		int getMinute(int m)
		{
			return minute;
		}

		int getSecond(int s)
		{
			return second;
		}

		void incHour(void)
		{
			hour += 1;
			if(hour >= 24) {
				hour = 0;
			}

			notify();
		}

		void incMinute(void)
		{
			minute += 1;
			if(minute >= 60) {
				minute = 0;
				incHour();
			}

			notify();
		}

		void incSecond(void)
		{
			second += 1;
			if(second >= 60) {
				second = 0;
				incMinute();
			}

			notify();
		}
	
	private:
		void notify(void)
		{
			setChanged();

			ClockModelInfo info(hour, minute, second);
			notifyObservers(&info);
		}

		int hour;
		int minute;
		int second;
};

class ClockView : public AbstractView
{
	public:
		ClockView()
		{
			// do nothing
		}

		virtual ~ClockView()
		{
			// do nothing
		}

		void update(void *info)
		{
			int hour = static_cast<ClockModelInfo *>(info)->hour;
			int minute = static_cast<ClockModelInfo *>(info)->minute;
			int second = static_cast<ClockModelInfo *>(info)->second;

			std::printf("\r%02d:%02d:%02d", hour, minute, second); 
			std::fflush(stdout);
		}
};

class ClockController : public AbstractController
{
	public:
		ClockController()
		{
			// do nothing
		}

		virtual ~ClockController()
		{
			// do nothing
		}

		int run(void)
		{
			while(1) {
				sleep(1);
				static_cast<ClockModel *>(model)->incSecond();
			}

			std::printf("\n");
			return 0;
		}
};

class ClockApplication
{
	public:
		explicit ClockApplication()
		{
			model.addObserver(&view);
			model.setHour(0);
			model.setMinute(0);
			model.setSecond(0);

			view.setModel(&model);
			view.setController(&controller);

			controller.setModel(&model);
		}

		virtual ~ClockApplication()
		{
			// do nothing
		}

		int run(int argc, char **argv)
		{
			return controller.run();
		}
	
	private:
		ClockModel model;
		ClockView view;
		ClockController controller;
};

int main(int argc, char **argv)
{
	ClockApplication app;

	return app.run(argc, argv);
}

module EventDispatcher
	def setup_listeners
		@listeners = {}
		@change = false
	end

	def register_listener(listener, event)
		(@listeners[event] ||= []) << listener
	end

	def remove_listener(listener, event)
		(@listeners[event] ||= []).delete listener
	end

	def remove_listeners(event)
		@listeners[event] = []
	end

	def count_listeners(event)
		(@listeners[event] ||= []).size
	end

	def changed?
		@change
	end

	protected
	def notify(event, arg)
		return if not @change
		if @listeners[event]
			callback = ("update_at_" + event.to_s).to_sym
			@listeners[event].each do |listener|
				if listener.respond_to? callback
					listener.send callback, arg
				elsif listener.respond_to? :update
					listener.update event, arg
				end
			end
		end
		@change = false
		return nil	
	end

	def changed
		@change = true
	end
end	

class TestFactory
	include EventDispatcher
	
	def initialize
		setup_listeners
	end	

	def create_button(color)
		changed
		notify(:new_button, {:color => color})
	end

	def create_label(text)
		changed
		notify(:new_label, {:text => text})
	end
end

class TestWidgetCounter
	def initialize(widget_factory)
		@counts = Hash.new(0)
		widget_factory.register_listener(self, :new_button)
		widget_factory.register_listener(self, :new_label)
	end

	def update(event, arg)
		case event
		when :new_label
			puts "#{arg[:text]} label created."
		end	
	end

	def update_at_new_button(arg)
		color = arg[:color]
		@counts[color] += 1
		puts "#{@counts[color]} #{color} button(s) created."
	end
end



f = TestFactory.new
t = TestWidgetCounter.new(f)

f.create_button("red")
f.create_button("blue")
f.create_button("green")
f.create_label("name")
f.create_button("red")

f.remove_listener(t, :new_label)
f.create_label("cellphone")

f.create_button("blue")

1 red button(s) created.
1 blue button(s) created.
1 green button(s) created.
name label created.
2 red button(s) created.
2 blue button(s) created.