source: NonGTP/FCollada/FUtils/FUEvent.h @ 964

/*
        Copyright (C) 2005-2006 Feeling Software Inc.
        MIT License: http://www.opensource.org/licenses/mit-license.php
*/
/*
        This file was taken off the Protect project on 26-09-2005
*/


#ifndef _EVENT_H_
#define _EVENT_H_

#include "FUtils/FUFunctor.h"

// Zero argument Event
class FUEvent0
{
private:
        typedef IFunctor0<void> Handler;
        typedef vector<Handler*> HandlerList;
        HandlerList handlers;

public:
        FUEvent0() {}
        ~FUEvent0()
        {
                FUAssert(handlers.empty(), CLEAR_POINTER_VECTOR(handlers));
        }

        size_t GetHandlerCount() { return handlers.size(); }

        void InsertHandler(Handler* functor)
        {
                handlers.push_back(functor);
        }

        template<class Class>
        void RemoveHandler(Class* handle, void (Class::*_function)(void))
        {
                void* function = *(void**)&_function;
                HandlerList::iterator it;
                for (it = handlers.begin(); it != handlers.end(); ++it)
                {
                        if ((*it)->Compare(handle, function))
                        {
                                delete (*it);
                                handlers.erase(it);
                break;
                        }
                }
        }

        void operator()()
        {
                HandlerList::iterator it;
                for (it = handlers.begin(); it != handlers.end(); ++it)
                {
                        (*(*it))();
                }
        }
};

// One argument Event
template <typename Arg1>
class FUEvent1
{
private:
        typedef IFunctor1<Arg1, void> Handler;
        typedef vector<Handler> HandlerList;
        HandlerList handlers;

public:
        FUEvent1() {}

        ~FUEvent1()
        {
                FUAssert(handlers.empty(), CLEAR_POINTER_VECTOR(handlers));
        }

        size_t GetHandlerCount() { return handlers.size(); }

        void InsertHandler(Handler* functor)
        {
                handlers.push_back(functor);
        }

        template <class Class, class _A1>
        void RemoveHandler(Class* handle, void (Class::*_function)(_A1))
        {
                typename HandlerList::iterator it;
                void* function = *(void**)&_function;
                for (it = handlers.begin(); it != handlers.end(); ++it)
                {
                        if ((*it)->Compare(handle, function))
                        {
                                delete (*it);
                                handlers.erase(it);
                break;
                        }
                }
        }

        void operator()(Arg1 sArgument1)
        {
                typename HandlerList::iterator it;
                for (it = handlers.begin(); it != handlers.end(); ++it)
                {
                        (*(*it))(sArgument1);
                }
        }
};

// Two arguments Event
template <typename Arg1, typename Arg2>
class FUEvent2
{
private:
        typedef IFunctor2<Arg1, Arg2, void> Handler;
        typedef vector<Handler*> HandlerList;
        HandlerList handlers;

public:
        FUEvent2() {}

        ~FUEvent2()
        {
                FUAssert(handlers.empty(), CLEAR_POINTER_VECTOR(handlers));
        }

        size_t GetHandlerCount() { return handlers.size(); }

        void InsertHandler(Handler* functor)
        {
                handlers.push_back(functor);
        }

        template <class Class, class _A1, class _A2>
        void RemoveHandler(Class* handle, void (Class::*_function)(_A1, _A2))
        {
                void* function = *(void**)&_function;
                typename HandlerList::iterator it;
                for (it = handlers.begin(); it != handlers.end(); ++it)
                {
                        if ((*it)->Compare(handle, function))
                        {
                                delete (*it);
                                handlers.erase(it);
                                break;
                        }
                }
        }

        void operator()(Arg1 sArgument1, Arg2 sArgument2)
        {
                typename HandlerList::iterator it;
                for (it = handlers.begin(); it != handlers.end(); ++it)
                {
                        (*(*it))(sArgument1, sArgument2);
                }
        }
};

#endif // _EVENT_H_