include/library/register-queue.hpp

   1 #ifndef _library__register_queue__hpp__included__
   2 #define _library__register_queue__hpp__included__
   3
   4 #include "threadtypes.hpp"
   5 #include <string>
   6 #include <list>
   7 #include <set>
   8
   9 /**
  10  * Object registration queue.
  11  */
  12 template<class G, class O>
  13 class register_queue
  14 {
  15 public:
  16 /**
  17  * Register an object.
  18  *
  19  * Parameter group: The group to register to.
  20  * Parameter name: The name for object.
  21  * Parameter object: The object to register.
  22  */
  23         static void do_register(G& group, const std::string& name, O& object)
  24         {
  25                 {
  26                         umutex_class h(get_mutex());
  27                         if(get_ready().count(&group)) {
  28                                 group.do_register(name, object);
  29                                 return;
  30                         }
  31                         queue_entry<G, O> ent;
  32                         ent.group = &group;
  33                         ent.name = name;
  34                         ent.object = &object;
  35                         get_pending().push_back(ent);
  36                 }
  37                 run();
  38         }
  39 /**
  40  * Unregister an object.
  41  *
  42  * Parameter group: The group to unregister from.
  43  * Parameter name: The name for object.
  44  */
  45         static void do_unregister(G& group, const std::string& name)
  46         {
  47                 umutex_class h(get_mutex());
  48                 auto& x = get_pending();
  49                 auto i = x.begin();
  50                 while(i != x.end()) {
  51                         auto e = i++;
  52                         if(&group == e->group && name == e->name)
  53                                 x.erase(e);
  54                 }
  55                 if(get_ready().count(&group))
  56                         group.do_unregister(name);
  57         }
  58 /**
  59  * Mark group ready/not ready.
  60  *
  61  * Parameter group: The group.
  62  * Parameter ready: True if ready, false if not.
  63  */
  64         static void do_ready(G& group, bool ready)
  65         {
  66                 {
  67                         umutex_class h(get_mutex());
  68                         if(ready)
  69                                 get_ready().insert(&group);
  70                         else
  71                                 get_ready().erase(&group);
  72                 }
  73                 run();
  74         }
  75 private:
  76         template<class G2, class O2>
  77         struct queue_entry
  78         {
  79                 G2* group;
  80                 std::string name;
  81                 O2* object;
  82         };
  83         static std::set<G*>& get_ready()
  84         {
  85                 static std::set<G*> x;
  86                 return x;
  87         }
  88         static std::list<queue_entry<G, O>>& get_pending()
  89         {
  90                 static std::list<queue_entry<G, O>> x;
  91                 return x;
  92         }
  93         static mutex_class& get_mutex()
  94         {
  95                 static mutex_class x;
  96                 return x;
  97         }
  98         static void run()
  99         {
 100                 umutex_class h(get_mutex());
 101                 auto& x = get_pending();
 102                 auto i = x.begin();
 103                 while(i != x.end()) {
 104                         auto e = i++;
 105                         if(get_ready().count(e->group)) {
 106                                 e->group->do_register(e->name, *e->object);
 107                                 x.erase(e);
 108                         }
 109                 }
 110         }
 111 };
 112
 113 #endif