include/library/dispatch.hpp

   1 #ifndef _library__dispatch__hpp__included__
   2 #define _library__dispatch__hpp__included__
   3
   4 #include <iostream>
   5 #include <map>
   6 #include <set>
   7 #include <list>
   8 #include <functional>
   9 #include "threads.hpp"
  10
  11 namespace dispatch
  12 {
  13 threads::lock& global_init_lock();
  14
  15 template<typename... T> struct source;
  16
  17 /**
  18  * Dispatch target handler.
  19  */
  20 template<typename... T> struct target
  21 {
  22 /**
  23  * Create a new target handler.
  24  */
  25         target()
  26         {
  27                 src = NULL;
  28                 fn = dummy;
  29         }
  30 /**
  31  * Destroy a target, detaching it from source.
  32  */
  33         inline ~target();
  34 /**
  35  * Connect a target to given source and give a handler.
  36  *
  37  * Parameter d: The source to connect to.
  38  * Parameter _fn: The function to use as handler.
  39  */
  40         inline void set(source<T...>& d, std::function<void(T...)> _fn);
  41 private:
  42         static void dummy(T... args) {};
  43         void set_source(source<T...>* d) { src = d; }
  44         void call(T... args) { fn(args...); }
  45         source<T...>* src;
  46         std::function<void(T...)> fn;
  47         friend class source<T...>;
  48 };
  49
  50 /**
  51  * Dispatch source (event generator).
  52  */
  53 template<typename... T> struct source
  54 {
  55 /**
  56  * Create a new event source.
  57  *
  58  * Parameter _name: The name of the event.
  59  */
  60         source(const char* _name)
  61         {
  62                 init();
  63                 name = _name;
  64         }
  65 /**
  66  * Destory an event source.
  67  *
  68  * All targets are disconnected.
  69  */
  70         ~source()
  71         {
  72                 delete _targets;
  73                 delete lck;
  74                 lck = NULL;
  75         }
  76 /**
  77  * Send an event.
  78  *
  79  * Parameter args: The arguments to send.
  80  */
  81         void operator()(T... args)
  82         {
  83                 init();
  84                 uint64_t k = 0;
  85                 typename std::map<uint64_t, target<T...>*>::iterator i;
  86                 lck->lock();
  87                 i = targets().lower_bound(k);
  88                 while(i != targets().end()) {
  89                         k = i->first + 1;
  90                         target<T...>* t = i->second;
  91                         lck->unlock();
  92                         try {
  93                                 t->call(args...);
  94                         } catch(std::exception& e) {
  95                                 (*errstrm) << name << ": Error in handler: " << e.what() << std::endl;
  96                         }
  97                         lck->lock();
  98                         i = targets().lower_bound(k);
  99                 }
 100                 lck->unlock();
 101         }
 102 /**
 103  * Connect a new target.
 104  *
 105  * Parameters target: The target to connect.
 106  */
 107         void connect(target<T...>& target)
 108         {
 109                 init();
 110                 threads::alock h(*lck);
 111                 targets()[next_cbseq++] = &target;
 112                 target.set_source(this);
 113         }
 114 /**
 115  * Disconnect a target.
 116  *
 117  * Parameters target: The target to disconnect.
 118  */
 119         void disconnect(target<T...>& target)
 120         {
 121                 init();
 122                 if(!lck)
 123                         return;
 124                 threads::alock h(*lck);
 125                 for(auto i = targets().begin(); i != targets().end(); i++)
 126                         if(i->second == &target) {
 127                                 targets().erase(i);
 128                                 break;
 129                         }
 130                 target.set_source(NULL);
 131         }
 132 /**
 133  * Set stream to send error messages to.
 134  *
 135  * Parameter to: The stream (if NULL, use std::cerr).
 136  */
 137         void errors_to(std::ostream* to)
 138         {
 139                 errstrm = to ? to : &std::cerr;
 140         }
 141 private:
 142         void init()
 143         {
 144                 if(inited)
 145                         return;
 146                 threads::alock h(global_init_lock());
 147                 if(inited)
 148                         return;
 149                 errstrm = &std::cerr;
 150                 next_cbseq = 0;
 151                 name = "(unknown)";
 152                 _targets = NULL;
 153                 lck = new threads::lock;
 154                 inited = true;
 155         }
 156         threads::lock* lck;
 157         std::map<uint64_t, target<T...>*>& targets()
 158         {
 159                 if(!_targets) _targets = new std::map<uint64_t, target<T...>*>;
 160                 return *_targets;
 161         }
 162         std::map<uint64_t, target<T...>*>* _targets;
 163         uint64_t next_cbseq;
 164         std::ostream* errstrm;
 165         const char* name;
 166         bool inited;
 167         source(const source<T...>&);
 168         source<T...>& operator=(const source<T...>&);
 169 };
 170
 171 template <typename... T> target<T...>::~target()
 172 {
 173         if(src)
 174                 src->disconnect(*this);
 175 }
 176
 177 template <typename... T> void target<T...>::set(source<T...>& d, std::function<void(T...)> _fn)
 178 {
 179         fn = _fn;
 180         src = &d;
 181         if(src)
 182                 src->connect(*this);
 183 }
 184 }
 185 #endif