hdicoreCallback.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_CALLBACK__
#define __HDI_CORE_CALLBACK__
 
#include <assert.h>
 
#include "hdicoreTypes.h"

#define HDI_CORE_CALLBACK_T(__HDI_C__)  hdi::core::__Callback<__HDI_C__>

#define HDI_CORE_CALLBACK(__HDI_C__, __HDI_O__, __HDI_M__) \
    hdi::core::__Callback<__HDI_C__>(__HDI_O__, &__HDI_C__::__HDI_M__)

#define HDI_CORE_CALLBACK_NONE  HDI_CORE_CALLBACK(hdi::core::__Dummy, NULL, nothing)
 
namespace hdi
{
    namespace core
    {
        class Callback
        {
            public:
                virtual void execute() const = 0;
                
                virtual Callback* clone() const = 0;

                virtual ~Callback()
                {
                    // no-op
                }
 
 
            protected:
                Callback()
                {
                    // no-op
                }
        };
        
        typedef std::unique_ptr<Callback> CallbackUP;
        typedef std::shared_ptr<Callback> CallbackSP;
        typedef std::weak_ptr<Callback> CallbackWP;
 
 

        template <class hdiTargetType>
        class __Callback : public Callback
        {
            private:
                typedef hdiTargetType TargetType;

                typedef void (TargetType::*ActionType)(void);

                typedef void (TargetType::*ConstActionType)(void) const;

                TargetType* __target;

                ActionType __action;

                ConstActionType __constAction;
 
 
            public:
                explicit __Callback(TargetType* target_, ActionType action_) :
                    Callback(),
                    __target(target_),
                    __action(action_),
                    __constAction(NULL)
                {
//                  #if defined(HDI_CORE_DEBUG)
//                      assert(target_ != NULL);
//                      assert(action_ != NULL);
//                  #endif
                }
 
                explicit __Callback(TargetType* target_, ConstActionType action_) :
                    Callback(),
                    __target(target_),
                    __action(NULL),
                    __constAction(action_)
                {
//                  #if defined(HDI_CORE_DEBUG)
//                      assert(target_ != NULL);
//                      assert(action_ != NULL);
//                  #endif
                }

                __Callback(const __Callback<TargetType>& cb_) :
                    Callback(),
                    __target(cb_.__target),
                    __action(cb_.__action),
                    __constAction(cb_.__constAction)
                {
                    // no-op
                }

                virtual ~__Callback()
                {
                    // no-op
                }

                virtual __Callback<TargetType>* clone() const
                {
                    return new __Callback<TargetType>(*this);
                }
                
                virtual void execute() const
                {
                    if(!this->__target)
                        return;
 
                    if(this->__action)
                    {
                        (this->__target->*this->__action)();
                    }
                    else if(this->__constAction)
                    {
                        (this->__target->*this->__constAction)();
                    }
                }
 
 
            private:
                __Callback() : Callback(), __target(NULL), __action(NULL), __constAction(NULL)
                {
                    // no-op
                }
        };

        class __Dummy
        {
            public:
                void nothing();
 
 
            private:
                __Dummy();
                
                __Dummy(const __Dummy&);

                ~__Dummy();

                __Dummy& operator=(const __Dummy&);
        };
    }
}
 
#endif
// __HDI_CORE_CALLBACK__