signals.h

/*   
 *   (c) Copyright 2008 Philipp Skadorov (philipp_s@users.sourceforge.net)
 *
 *   This file is part of FREESECS.
 *
 *   FREESECS is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   FREESECS is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with FREESECS, see COPYING.
 *   If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef _SIGNALS_H
#define _SIGNALS_H

#include <vector>
#include <algorithm>
#include <functional>
#include "callback.h"

namespace freesecs
{
    class signal_no_args_multiple_clients_t
    {
    public:
        template<class T>
        void add_handler(T *p_class, int(T::*p_func)())
        {
            _cbs.push_back(callback_t(p_class, p_func));
        }
        template<class T>
        void remove_handler(T *p_class, int(T::*p_func)())
        {
            if(!_cbs.empty())
            {
                callback_t cb(p_class, p_func);
                container_t::iterator it = 
                        find(_cbs.begin(), _cbs.end(), cb);
                if(it != _cbs.end())
                {
                    _cbs.erase(it);
                }
            }
        }
        void operator()()
        {
            if(!_cbs.empty())
            {
                for_each(_cbs.begin(), 
                         _cbs.end(), 
                         std::mem_fun_ref(&callback_t::operator()));
            }
        }
    private:
        typedef std::vector<callback_t> container_t;
        container_t _cbs;
    };

    class signal_no_args_single_client_t
    {
    public:
        template<class T>
        void add_handler(T *p_class, int(T::*p_func)())
        {
            _cb = callback_t(p_class, p_func);
        }
        template<class T>
        void remove_handler(T *p_class, int(T::*p_func)())
        {
        }
        void operator()()
        {
            _cb();
        }
    private:
        callback_t _cb;
    };


    template<class Arg>
    class signal_one_arg_multiple_clients_t
    {
    private:
        typedef std::vector< callback_1arg_t<Arg> > container_t;
    public:
        template<class T>
        void add_handler(T *p_class, int(T::*p_func)(const Arg&))
        {
            _cbs.push_back(callback_1arg_t<Arg>(p_class, p_func));
        }
        template<class T>
        void remove_handler(T *p_class, int(T::*p_func)(const Arg&))
        {
    /*        if(!_cbs.empty())
            {
                callback_1arg_t<Arg> cb(p_class, p_func);

                container_t::iterator it = 
                                find(_cbs.begin(), _cbs.end(), cb);
                if(it != _cbs.end())
                {
                    _cbs.erase(it);
                }
            }*/
        }
        void operator()(const Arg& arg)
        {
            if(!_cbs.empty())
            {
                for_each(_cbs.begin(), 
                         _cbs.end(), 
                         functor_t<Arg>(arg));
            }
        }
    private:
        template<class T>
        class functor_t
        {
        public:
            functor_t(const T& t):_t(t){}
            void operator()(callback_1arg_t<T> &cb)
            {
                cb(_t);
            }
        private:
            const T &_t;
        };
        container_t _cbs;
    };

    template<class Arg>
    class signal_one_arg_single_client_t
    {
    public:
        template<class T>
        void add_handler(T *p_class, int(T::*p_func)(const Arg&))
        {
            _cb = callback_1arg_t<Arg>(p_class, p_func);
        }
        template<class T>
        void remove_handler(T *p_class, int(T::*p_func)())
        {
        }
        void operator()(const Arg& arg)
        {
            _cb(arg);
        }
    private:
        callback_1arg_t<Arg> _cb;
    };

    #ifdef MULTIPLE_CLIENTS_FOR_SIGNAL
    #define signal_no_args_t signal_no_args_multiple_clients_t
    #define signal_one_arg_t signal_one_arg_multiple_clients_t
    #else
    #define signal_no_args_t signal_no_args_single_client_t
    #define signal_one_arg_t signal_one_arg_single_client_t
    #endif 
}//namespace

#endif 

---