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