/Users/eddyxu/work/quiplib/ace/srcs/Callbacks.h

Go to the documentation of this file.

//-*- C++ -*-
//--------------------------------------------------------------
// $Id: Callbacks.h 14 2007-06-08 14:40:22Z eddyxu $

#ifndef QLIB_ACE_CALLBACKS_H
#define QLIB_ACE_CALLBACKS_H

#include <map>
#include <boost/call_traits.hpp>

#include "Command.h"
#include "Functors.h"

namespace qlib {
        
        namespace ace {
                using boost::call_traits;

                template<
                        typename Result 
                        >
                struct Callback : public Command<Result> {
                public:
                        typedef Result result_type;
                        typedef Result* result_pointer;
                public:
                        virtual ~Callback() {};
                public: 
                        virtual int exec(void) = 0;

                        virtual int exec(result_pointer result) = 0;

                        virtual int operator() (void) { return this->exec(); }

                        virtual int operator() (result_pointer result) { return this->exec(result);}
                public:

                        virtual int cancel(void) {};
                        /*
                        virtual int timeout(void) {};
                        virtual int failed(void) {};
                        */
                };

                template<
                        typename Seq,
                        typename CallBack 
                        >
                class Callback_Manager {
                        typedef typename call_traits<Seq>::param_type param_type;
                public: 
                        enum { ADD_REPLACE, ADD_WARNING };
                        typedef Seq sequence_type;

                        typedef CallBack callback_type;
                        typedef callback_type* callback_pointer;
                        typedef callback_type& callback_reference;

                        //typedef Ctn container_type;
                        typedef typename std::map<Seq, callback_pointer> container_type;
                public:
                        Callback_Manager(void) {};
                        ~Callback_Manager(void) { 
                                for_each(callbacks_.begin(), callbacks_.end(), Delete_Second_Ptr()); 
                        }
                public:
                        int add(param_type seq_id, callback_pointer callback, int option = ADD_REPLACE);

                        int callback(param_type seq_id);
                
                        int callback(param_type seq_id, typename callback_type::result_type *result);

                        int cancel(param_type seq_id);

                        callback_pointer find(param_type seq_id){
                                typename container_type::iterator it = callbacks_.find(seq_id); 
                                if(it == callbacks_.end())
                                        return NULL;

                                return it->second;
                        }

                        typename container_type::size_type size(void) { return callbacks_.size(); }
                protected:
                        int dispose(param_type seq_id, int return_value);
                private:
                        container_type callbacks_;
                };
        
        } // ace

}// qlib

#include "Callbacks.inl"

#endif /* QLIB_ACE_CALLBACKS_H */

---