event_manager.cc

#include <iostream>
#include <vector>
#include <map>
#include <functional>

class some_arg_t {
    public:
        some_arg_t(const char *name) : name_(name) {};

        const char *name() const { return name_.c_str(); }

    private:
        std::string name_;
};

typedef std::pointer_to_unary_function<const some_arg_t &, int> fn_t;

typedef std::vector<fn_t> fn_vec_t;

typedef std::map<std::string, fn_vec_t > fn_map_t;

class event_manager_t {
    public:
        event_manager_t() {}

        void on(const char *name, int (*fn)(const some_arg_t &)) {
            fn_map_t::iterator iter = fnmap_.find(name);
            if (iter == fnmap_.end()) {
                std::pair<fn_map_t::iterator, bool> res =
                  fnmap_.insert(fn_map_t::value_type(name, fn_vec_t()));
                iter = res.first;
            }   
            iter->second.push_back(std::ptr_fun(fn));
        }

        void emit(const char *name, const some_arg_t &arg) {
            fn_map_t::const_iterator iter = fnmap_.find(name);
            if (iter != fnmap_.end()) {
                fn_vec_t::const_iterator vec_iter = iter->second.begin();
                for (; vec_iter != iter->second.end(); vec_iter++) {
                    (*vec_iter)(arg);
                }   
            }   
        }

    private:
        fn_map_t fnmap_;
};

int
do_some_event_1 (const some_arg_t &arg)
{
    std::cout << "a: " << arg.name() << std::endl;
    return 0;
}

int
do_some_event_2 (const some_arg_t &arg)
{
    std::cout << "b: " << arg.name() << std::endl;
    return 0;
}

int
main (int argc, char **argv)
{
    fn_map_t f;
    event_manager_t event_manager;

    event_manager.on("some-event", do_some_event_1);
    event_manager.on("some-event", do_some_event_2);

    event_manager.emit("some-event", some_arg_t("arg"));

    return 0;
}