src/base/callback.hh

   1 /*
   2  * Copyright (c) 2003-2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifndef __BASE_CALLBACK_HH__
  30 #define __BASE_CALLBACK_HH__
  31
  32 #include <list>
  33 #include <string>
  34
  35 /**
  36  * Generic callback class.  This base class provides a virtual process
  37  * function that gets called when the callback queue is processed.
  38  */
  39 class Callback
  40 {
  41   protected:
  42     friend class CallbackQueue;
  43     virtual void autoDestruct() {}
  44
  45   public:
  46     /**
  47      * virtualize the destructor to make sure that the correct one
  48      * gets called.
  49      */
  50     virtual ~Callback() {}
  51
  52     /**
  53      * virtual process function that is invoked when the callback
  54      * queue is executed.
  55      */
  56     virtual void process() = 0;
  57 };
  58
  59 /// Helper template class to turn a simple class member function into
  60 /// a callback.
  61 template <class T, void (T::* F)()>
  62 class MakeCallback : public Callback
  63 {
  64   protected:
  65     T *object;
  66     const bool autoDestroy;
  67
  68     void autoDestruct() { if (autoDestroy) delete this; }
  69
  70   public:
  71     MakeCallback(T *o, bool auto_destroy = false)
  72         : object(o), autoDestroy(auto_destroy)
  73     { }
  74
  75     MakeCallback(T &o, bool auto_destroy = false)
  76         : object(&o), autoDestroy(auto_destroy)
  77     { }
  78
  79     void process() { (object->*F)(); }
  80 };
  81
  82 class CallbackQueue
  83 {
  84   protected:
  85     /**
  86      * Simple typedef for the data structure that stores all of the
  87      * callbacks.
  88      */
  89     typedef std::list<Callback *> queue;
  90
  91     /**
  92      * List of all callbacks.  To be called in fifo order.
  93      */
  94     queue callbacks;
  95
  96   public:
  97     ~CallbackQueue();
  98     std::string name() const { return "CallbackQueue"; }
  99
 100     /**
 101      * Add a callback to the end of the queue
 102      * @param callback the callback to be added to the queue
 103      */
 104     void
 105     add(Callback *callback)
 106     {
 107         callbacks.push_back(callback);
 108     }
 109
 110     template <class T, void (T::* F)()>
 111     void
 112     add(T *obj)
 113     {
 114         add(new MakeCallback<T, F>(obj, true));
 115     }
 116
 117     template <class T, void (T::* F)()>
 118     void
 119     add(T &obj)
 120     {
 121         add(new MakeCallback<T, F>(&obj, true));
 122     }
 123
 124     /**
 125      * Find out if there are any callbacks in the queue
 126      */
 127     bool empty() const { return callbacks.empty(); }
 128
 129     /**
 130      * process all callbacks
 131      */
 132     void
 133     process()
 134     {
 135         queue::iterator i = callbacks.begin();
 136         queue::iterator end = callbacks.end();
 137
 138         while (i != end) {
 139             (*i)->process();
 140             ++i;
 141         }
 142     }
 143
 144     /**
 145      * clear the callback queue
 146      */
 147     void
 148     clear()
 149     {
 150         callbacks.clear();
 151     }
 152 };
 153
 154 #endif // __BASE_CALLBACK_HH__