include/core/queue.hpp

   1 #ifndef _queue__hpp__included__
   2 #define _queue__hpp__included__
   3
   4 #include "library/exrethrow.hpp"
   5 #include "library/keyboard.hpp"
   6 #include "library/threads.hpp"
   7 #include <functional>
   8 #include <deque>
   9
  10 namespace command
  11 {
  12         class group;
  13 }
  14
  15 /**
  16  * Information about keypress.
  17  */
  18 struct keypress_info
  19 {
  20 /**
  21  * Create null keypress (no modifiers, NULL key and released).
  22  */
  23         keypress_info();
  24 /**
  25  * Create new keypress.
  26  */
  27         keypress_info(keyboard::modifier_set mod, keyboard::key& _key, short _value);
  28 /**
  29  * Create new keypress (two keys).
  30  */
  31         keypress_info(keyboard::modifier_set mod, keyboard::key& _key, keyboard::key& _key2, short _value);
  32 /**
  33  * Modifier set.
  34  */
  35         keyboard::modifier_set modifiers;
  36 /**
  37  * The actual key (first)
  38  */
  39         keyboard::key* key1;
  40 /**
  41  * The actual key (second)
  42  */
  43         keyboard::key* key2;
  44 /**
  45  * Value for the press
  46  */
  47         short value;
  48 };
  49
  50 template<typename T>
  51 void functor_call_helper2(void* args)
  52 {
  53         (*reinterpret_cast<T*>(args))();
  54         delete reinterpret_cast<T*>(args);
  55 }
  56
  57 struct input_queue
  58 {
  59         struct function_queue_entry
  60         {
  61                 std::function<void()> fn;
  62                 std::function<void(std::exception& e)> onerror;
  63         };
  64
  65         //Queue stuff.
  66         threads::lock queue_lock;
  67         threads::cv queue_condition;
  68         std::deque<keypress_info> keypresses;
  69         std::deque<std::pair<const char*, std::string>> commands;
  70         std::deque<function_queue_entry> functions;
  71         volatile uint64_t functions_executed;
  72         volatile uint64_t next_function;
  73         volatile bool system_thread_available;
  74         bool queue_function_run;
  75 /**
  76  * Ctor.
  77  */
  78         input_queue(command::group& _command);
  79 /**
  80  * Queue keypress.
  81  *
  82  * - Can be called from any thread.
  83  *
  84  * Parameter k: The keypress to queue.
  85  */
  86         void queue(const keypress_info& k) throw(std::bad_alloc);
  87 /**
  88  * Queue command.
  89  *
  90  * - Can be called from any thread.
  91  *
  92  * Parameter c: The command to queue.
  93  */
  94         void queue(const std::string& c) throw(std::bad_alloc);
  95 /**
  96  * Queue command and arguments.
  97  *
  98  * - Can be called from any thread.
  99  *
 100  * Parameter c: The command to queue.
 101  * Parameter a: The arguments for function.
 102  */
 103         void queue(const char* c, const std::string& a) throw(std::bad_alloc);
 104 /**
 105  * Queue function to be called in emulation thread.
 106  *
 107  * - Can be called from any thread (exception: Synchronous mode can not be used from emulation nor main threads).
 108  *
 109  * Parameter f: The function to execute.
 110  * Parameter onerror: Function to call on error.
 111  * Parameter arg: Argument to pass to the function.
 112  * Parameter sync: If true, execute function call synchronously, else asynchronously.
 113  */
 114         void queue(std::function<void()> f, std::function<void(std::exception& e)> onerror, bool sync)
 115                 throw(std::bad_alloc);
 116 /**
 117  * Run all queues.
 118  */
 119         void run_queues() throw();
 120 /**
 121  * Call function synchronously in emulation thread.
 122  */
 123         void run(std::function<void()> fn)
 124         {
 125                 exrethrow::storage ex;
 126                 queue(fn, [&ex](std::exception& e) { ex = exrethrow::storage(e); }, true);
 127                 if(ex) ex.rethrow();
 128         }
 129 /**
 130  * Queue asynchrous function in emulation thread.
 131  */
 132         void run_async(std::function<void()> fn,
 133                 std::function<void(std::exception& e)> onerror)
 134         {
 135                 queue(fn, onerror, false);
 136         }
 137 /**
 138  * Run internal queues.
 139  */
 140         void run_queue(bool unlocked) throw();
 141 private:
 142         command::group& command;
 143 };
 144
 145 #endif