src/core/queue.cpp

   1 #include "core/misc.hpp"
   2 #include "core/queue.hpp"
   3 #include "core/random.hpp"
   4 #include "library/command.hpp"
   5 #include "library/threads.hpp"
   6 #include <functional>
   7
   8 input_queue::input_queue(command::group& _command)
   9         : command(_command)
  10 {
  11         functions_executed = 0;
  12         next_function = 0;
  13         system_thread_available = false;
  14         queue_function_run = false;
  15 }
  16
  17
  18 keypress_info::keypress_info()
  19 {
  20         key1 = NULL;
  21         key2 = NULL;
  22         value = 0;
  23 }
  24
  25 keypress_info::keypress_info(keyboard::modifier_set mod, keyboard::key& _key, short _value)
  26 {
  27         modifiers = mod;
  28         key1 = &_key;
  29         key2 = NULL;
  30         value = _value;
  31 }
  32
  33 keypress_info::keypress_info(keyboard::modifier_set mod, keyboard::key& _key, keyboard::key& _key2, short _value)
  34 {
  35         modifiers = mod;
  36         key1 = &_key;
  37         key2 = &_key2;
  38         value = _value;
  39 }
  40
  41
  42 void input_queue::queue(const keypress_info& k) throw(std::bad_alloc)
  43 {
  44         threads::alock h(queue_lock);
  45         keypresses.push_back(k);
  46         queue_condition.notify_all();
  47 }
  48
  49 void input_queue::queue(const std::string& c) throw(std::bad_alloc)
  50 {
  51         threads::alock h(queue_lock);
  52         commands.push_back(std::make_pair(nullptr, c));
  53         queue_condition.notify_all();
  54 }
  55
  56 void input_queue::queue(const char* c, const std::string& a) throw(std::bad_alloc)
  57 {
  58         threads::alock h(queue_lock);
  59         commands.push_back(std::make_pair(c, a));
  60         queue_condition.notify_all();
  61 }
  62
  63 void input_queue::queue(std::function<void()> f, std::function<void(std::exception& e)> onerror, bool sync)
  64         throw(std::bad_alloc)
  65 {
  66         if(!system_thread_available) {
  67                 try {
  68                         f();
  69                 } catch(std::exception& e) {
  70                         onerror(e);
  71                 }
  72                 return;
  73         }
  74         threads::alock h(queue_lock);
  75         ++next_function;
  76         function_queue_entry entry;
  77         entry.fn = f;
  78         entry.onerror = onerror;
  79         functions.push_back(entry);
  80         queue_condition.notify_all();
  81         if(sync)
  82                 while(functions_executed < next_function && system_thread_available) {
  83                         threads::cv_timed_wait(queue_condition, h, threads::ustime(10000));
  84                         random_mix_timing_entropy();
  85                 }
  86 }
  87
  88 void input_queue::run_queue(bool unlocked) throw()
  89 {
  90         if(!unlocked)
  91                 queue_lock.lock();
  92         try {
  93                 //Flush keypresses.
  94                 while(!keypresses.empty()) {
  95                         keypress_info k = keypresses.front();
  96                         keypresses.pop_front();
  97                         queue_lock.unlock();
  98                         if(k.key1)
  99                                 k.key1->set_state(k.modifiers, k.value);
 100                         if(k.key2)
 101                                 k.key2->set_state(k.modifiers, k.value);
 102                         queue_lock.lock();
 103                         queue_function_run = true;
 104                 }
 105                 //Flush commands.
 106                 while(!commands.empty()) {
 107                         auto c = commands.front();
 108                         commands.pop_front();
 109                         queue_lock.unlock();
 110                         if(c.first)
 111                                 command.invoke(c.first, c.second);
 112                         else
 113                                 command.invoke(c.second);
 114                         queue_lock.lock();
 115                         queue_function_run = true;
 116                 }
 117                 //Flush functions.
 118                 while(!functions.empty()) {
 119                         function_queue_entry f = functions.front();
 120                         functions.pop_front();
 121                         queue_lock.unlock();
 122                         try {
 123                                 f.fn();
 124                         } catch(std::exception& e) {
 125                                 f.onerror(e);
 126                         }
 127                         queue_lock.lock();
 128                         ++functions_executed;
 129                         queue_function_run = true;
 130                 }
 131                 queue_condition.notify_all();
 132         } catch(std::bad_alloc& e) {
 133                 OOM_panic();
 134         } catch(std::exception& e) {
 135                 std::cerr << "Fault inside platform::run_queues(): " << e.what() << std::endl;
 136                 exit(1);
 137         }
 138         if(!unlocked)
 139                 queue_lock.unlock();
 140 }