#ifndef SIGNAL_HPP
#define SIGNAL_HPP 1

#include <boost/signal.hpp>
#include <boost/bind.hpp>

template <typename Function> struct Helper;

template <typename R, typename T1, typename T2>
struct Helper<R (T1, T2)>
{
    static const unsigned int arity = 2;
    typedef R result_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
};

template <typename Signature>
class Signal
{
    private:
        boost::signal<Signature> internalSignal;

    public:
        typedef typename Helper<Signature>::result_type result_type;
        typedef typename Helper<Signature>::arg1_type arg1_type;
        typedef typename Helper<Signature>::arg2_type arg2_type;

        // for global or static member functions
        void connect(Signature* function)
        {
            internalSignal.connect(function);
        }
        
        // for non-static member functions
        template <typename C>
        void connect(result_type (C::*member)(arg1_type, arg2_type), C* object)
        {
            internalSignal.connect(boost::bind(member, object, _1, _2));
        }
        
        result_type operator() (arg1_type t1, arg2_type t2)
        {
            return internalSignal(t1, t2);
        }
};

#endif

#ifndef TRACKABLE_HPP
#define TRACKABLE_HPP 1

#include <boost/signals/trackable.hpp>

typedef boost::signals::trackable Trackable;

#endif

#include <iostream>

#include "Signal.hpp"
#include "Trackable.hpp"

struct MyEmitter
{
    Signal<void (int, bool)> emit;
};

struct MyStruct : Trackable
{
    void print(int i, bool b)
    {
        std::cout << "Member " << i << ' ' << b << std::endl;
    }
};

void global(int i, bool b)
{
    std::cout << "Global " << i << ' ' << b << std::endl;
}

int main()
{
    MyEmitter emitter;
    
    emitter.emit.connect(&global);
    
    emitter.emit(1, false);
    
    {
        MyStruct obj;
        emitter.emit.connect(&MyStruct::print, &obj);
	    
        emitter.emit(2, true);
    }
    
    emitter.emit(3, false);

    system("pause");
}