#include <event.h>
#include <string>
#include <iostream>

class Subject
{
public:
	// events::Event is parameterized by the argument list passed to the event handlers.
	// I like to make events public and mutable. If you want you can hide them behind
	// mutators instead.
	mutable events::Event<std::string const&> NameChangedEvent;

	// I've decided not to make events invocable via operator(). It's too easy to 
	// accidentally invoke an event in this way.
	void SetName(std::string const& name)
	{
		m_name = name;
		NameChangedEvent.Invoke(m_name);
	}

private:
	std::string m_name;
};

class Observer
{
public:
	Observer(Subject const& subject) : m_subject(subject)
	{
		// Registers the OnNameChanged function of this object as a listener, and
		// stores the resultant connection object in the listener's connection set.
		// This is all you need to do for the most common case, where you want the
		// connection to be broken when the Observer is destroyed.
		m_cs.Add(m_subject.NameChangedEvent.Register(*this, &Observer::OnNameChanged));
	}

private:
	// I like to make my event handler functions private, delegating to public functions
	// as necessary.
	void OnNameChanged(std::string const& newName)
	{
		std::cout << "The subject's name is now " << newName << "." << std::endl;
	}

	// The connection set is a utility class which manages connection lifetimes for
	// you. It's similar in functionality to boost::signals::trackable, but provides
	// slightly more flexibility over connection lifetimes. For the normal case,
	// you only need one connection set per listening object (no matter how many
	// things it listens to) and you never need to do anything with it except call Add().
	events::ConnectionSet m_cs;

	Subject const& m_subject;
};

int main()
{
	Subject s;
	Observer o(s);

	s.SetName("Joe");
}