callback.h

/*   
 *   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 _CALLBACK_H
#define _CALLBACK_H

namespace freesecs
{
    class callback_t
    {
    private:
        class callback_base_t
        {
        public:
            virtual ~callback_base_t(){};
            virtual callback_base_t *clone() = 0;
            virtual int operator ()() = 0;
        };

        template<class T>
        class callback_impl_t : public callback_base_t
        {
        public:
            typedef int (T::*F)();

            T *p_this;
            F  p_func;

            callback_impl_t(T *pthis, F pfunc)
            {
                p_this = pthis;
                p_func = pfunc;
            }

            callback_impl_t<T> & operator = (const callback_impl_t& cb)
            {
                p_this = cb.p_this;
                p_func = cb.p_func;

                return *this;
            }

            callback_impl_t<T> *clone()
            {
                return new callback_impl_t<T>(p_this, p_func);
            }

            int operator()()
            {
                return (p_this->*p_func)();
            }
        };

            callback_base_t *base;

        public:
            virtual int operator()()
            {
                if(base)
                {
                    return (*base)();
                }
                return -1;
            }

            callback_t(const callback_t &cb)
            {
                base = cb.base->clone();
            }

            virtual ~callback_t()
            {
                if(base)
                {
                    delete base;
                }
            };

            callback_t &operator = (const callback_t& cb)
            {
                if(base)
                {
                    delete base;
                }
                base = cb.base->clone();
                return *this;
            }

            callback_t():base(NULL){}

            template<class T>
            callback_t(T *pclass, int (T::*pfunc)())
            {
                base = new callback_impl_t<T>(pclass, pfunc);
            }

            template<class T>
            bool operator == (const callback_t &other)
            {
                    callback_impl_t<T> *base_impl = (callback_impl_t<T>*)base;
                    callback_impl_t<T> *other_base_impl = (callback_impl_t<T>*)other.base;
                    return base_impl->p_this == other_base_impl->p_this
                        && base_impl->p_func == other_base_impl->p_func;
            }
    };

    template<class Arg>
    class callback_1arg_t
    {
    private:
        class callback_1arg_base_t
        {
        public:
            virtual ~callback_1arg_base_t(){};
            virtual callback_1arg_base_t *clone() = 0;
            virtual int operator ()(const Arg&) = 0;
        };

        template<class T>
        class callback_1arg_impl_t : public callback_1arg_base_t
        {
        public:
            typedef int (T::*F)(const Arg&);

            T *p_this;
            F  p_func;

            callback_1arg_impl_t(T *pthis, F pfunc)
            {
                p_this = pthis;
                p_func = pfunc;
            }

            virtual ~callback_1arg_impl_t(){}

            callback_1arg_impl_t<T> & operator = (const callback_1arg_impl_t& cb)
            {
                p_this = cb.p_this;
                p_func = cb.p_func;

                return *this;
            }

            callback_1arg_impl_t<T> *clone()
            {
                return new callback_1arg_impl_t<T>(p_this, p_func);
            }

            int operator()(const Arg &a)
            {
                return (p_this->*p_func)(a);
            }
        };

        callback_1arg_base_t *base;

    public:

        virtual int operator()(const Arg &a)
        {
            if(base)
            {
                return (*base)(a);
            }
            return -1;
        }

        callback_1arg_t(const callback_1arg_t &cb)
        {
            base = cb.base->clone();
        }

        virtual ~callback_1arg_t()
        {
            if(base)
            {
                delete base;
            }
        }

        callback_1arg_t &operator = (const callback_1arg_t& cb)
        {
            if(base)
            {
                delete base;
            }
            base = cb.base->clone();
            return *this;
        }

        callback_1arg_t():base(NULL){}

        template<class T>
        callback_1arg_t(T *pclass, int (T::*pfunc)(const Arg&))
        {
            base = new callback_1arg_impl_t<T>(pclass, pfunc);
        }

        template<class T>
        bool operator == (const callback_1arg_t &other)
        {
                callback_1arg_impl_t<T> *base_impl = (callback_1arg_impl_t<T>*)base;
                callback_1arg_impl_t<T> *other_base_impl = (callback_1arg_impl_t<T>*)other.base;
                return base_impl->p_this == other_base_impl->p_this
                    && base_impl->p_func == other_base_impl->p_func;
        }
    };

}//namespace

#endif//_CALLBACK_H

---