template <typename ListenerT,typename TriggerFuncT>
class Delegate
{
public:
    typedef TriggerFuncT tiggerFunc_t; // trigger function type
    typedef boost::shared_ptr<ListenerT> listenerP_t; // function pointer type
    typedef boost::weak_ptr<ListenerT> listenerWkP_t; // weak function pointer type
    // connects a function pointer to the delegate
    inline void Connect(listenerP_t func) { boost::mutex::scoped_lock lock(mutex);functions.push_back(listenerWkP_t(func)); };

    // triggers all objects in functions vector
    void Trigger(TriggerFuncT &trigger)
    {
        boost::mutex::scoped_lock lock(mutex); // lock access mutex
        typedef typename std::vector<listenerWkP_t>::iterator it_t;
        listenerP_t p;
        for (it_t i=functions.begin();i!=functions.end();i++)
        {
            // copy to shared_ptr
            p=i->lock();
            // if not expired then trigger
            if (!i->expired())
                trigger(p);
            else // elsewise remove from functions list
                functions.erase(i);
        }
    }
private:
    boost::mutex mutex; // access mutex
    std::vector<listenerWkP_t> functions; // list of functions
};

// USAGE EXAMPLE

// EXAMPLE LISTENER BASE CLASS
class ResChangeListener
{
    public:
    virtual void operator()(const math::vector2i &resolution) = 0;
};

// EXAMPLE LISTENER TRIGGER
class ResChangeTrigger
{
public:
    // delegate type
    typedef Delegate<ResChangeListener,ResChangeTrigger> delegate_t;
    // function pointer type
    typedef delegate_t::listenerP_t listenerP_t;

    ResChangeTrigger(const math::vector2i &resolution_) : resolution(resolution_) {};
    void operator () (listenerP_t func)
    { func->operator()(resolution); };
private:
    math::vector2i resolution; // new resolution
};

// EXAMPLE USE OF A DELEGATE
class Window
{
public:
    // constructs window
    Window(const std::string &appTitle,math::vector2i &resolution,bool isFullscreen);
    // sets the window dimensions
    void SetResolution(const math::vector2i &resolution);
    // swaps the display buffers
    void SwapBuffers() const { glfwSwapBuffers(); };
    // issues request to close window
    void Quit() {};
    // set an on reschange listener
    void OnResChange(ResChangeTrigger::listenerP_t func) { resChangeEvent.Connect(func); };
private:
    ResChangeTrigger::delegate_t resChangeEvent;
    boost::mutex mutex; // thread mutex for window
    GLFWInstance glfwIns; // glfw Instance
};

// EXAMPLE RESCHANGE LISTENER OBJECT
class ResChanger : public renwin::ResChangeListener
{
    public:
    ResChanger(math::vector2i &resolution_) : resolution(resolution_),isChanged(false) {};
    void operator()(const math::vector2i &resolution_)
    {
        boost::mutex::scoped_lock lock(mutex);
        isChanged=true;
        resolution=resolution_;
    };
    bool IsChanged() { return isChanged; };
    math::vector2i Resolution() { boost::mutex::scoped_lock lock(mutex);return resolution; };
    private:
    volatile bool isChanged; // is changed flag
    math::vector2i resolution; // screen resolution
    boost::mutex mutex; // access mutex
};

// EXAMPLE IMPLEMENTATION CODE IN MAIN
math::vector2i screen(1024,768); // screen dimensions

renwin::ResChangeTrigger::listenerP_t func(new ResChanger(screen));
window.OnResChange(func);
window.SetResolution(math::vector2i(800,600));

log.Mode(lg::MESSAGE)<<screen; // logs the screen dimensions to file
if (((ResChanger*)func.get())->IsChanged())
    screen=((ResChanger*)func.get())->Resolution();
log.Mode(lg::MESSAGE)<<screen; // logs the screen dimensions to file