39 #ifndef CGU_TASK_MANAGER_H
40 #define CGU_TASK_MANAGER_H
46 #include <type_traits>
62 virtual const char*
what()
const throw() {
return "TaskError\n";}
410 #ifndef DOXYGEN_PARSING
416 namespace TaskManagerHelper2 {
418 template <
class Ret,
class FType>
419 struct FunctorResultWrapper {
420 static void exec(FType& f,
424 static void do_fail(
const SharedLockPtr<AsyncResult<Ret>>& ret) {
444 template <
class Ret,
class FType>
446 mutable FType functor;
447 SharedLockPtr<AsyncResult<Ret>> ret;
452 template <
class FunctorArg>
453 FunctorResultExec(FunctorArg&& functor_,
454 const SharedLockPtr<AsyncResult<Ret>>& ret_): functor(
std::forward<FunctorArg>(functor_)),
459 #endif // DOXYGEN_PARSING
467 typedef std::pair<std::unique_ptr<const Callback::Callback>,
468 std::unique_ptr<const Callback::Callback>> QueueItemType;
478 static unsigned int init_max_tasks();
660 static unsigned int max_tasks = init_max_tasks();
845 #ifdef CGU_USE_AUTO_PTR
846 add_task(std::auto_ptr<const Callback::Callback>(task),
847 std::auto_ptr<const Callback::Callback>());
849 add_task(std::unique_ptr<const Callback::Callback>(task),
850 std::unique_ptr<const Callback::Callback>());
928 #ifdef CGU_USE_AUTO_PTR
929 void add_task(std::auto_ptr<const Callback::Callback> task,
930 std::auto_ptr<const Callback::Callback> fail);
932 void add_task(std::unique_ptr<const Callback::Callback> task,
933 std::unique_ptr<const Callback::Callback> fail);
1007 template <
class Ret,
class... Params,
class... Args,
class T>
1009 Ret (T::*func)(Params...),
1145 template <
class Ret,
class... Params,
class... Args,
class T>
1146 #ifdef CGU_USE_AUTO_PTR
1149 std::auto_ptr<const Cgu::Callback::Callback> fail,
1152 GMainContext* context,
1154 Ret (T::*func)(Params...),
1159 std::unique_ptr<const Cgu::Callback::Callback> fail,
1162 GMainContext* context,
1164 Ret (T::*func)(Params...),
1257 template <
class Ret,
class... Params,
class... Args,
class T>
1258 #ifdef CGU_USE_AUTO_PTR
1260 GMainContext* context,
1262 Ret (T::*func)(Params...),
1264 static_assert(
sizeof...(Args) < 4,
1265 "No greater than three bound arguments can be passed to "
1266 "TaskManager::make_task_when() taking a member function.");
1270 std::auto_ptr<const Cgu::Callback::Callback>(),
1276 std::forward<Args>(args)...);
1280 GMainContext* context,
1282 Ret (T::*func)(Params...),
1284 static_assert(
sizeof...(Args) < 4,
1285 "No greater than three bound arguments can be passed to "
1286 "TaskManager::make_task_when() taking a member function.");
1290 std::unique_ptr<const Cgu::Callback::Callback>(),
1296 std::forward<Args>(args)...);
1353 template <
class Ret,
class... Params,
class... Args,
class T>
1355 Ret (T::*func)(Params...)
const,
1491 template <
class Ret,
class... Params,
class... Args,
class T>
1492 #ifdef CGU_USE_AUTO_PTR
1495 std::auto_ptr<const Cgu::Callback::Callback> fail,
1498 GMainContext* context,
1500 Ret (T::*func)(Params...)
const,
1505 std::unique_ptr<const Cgu::Callback::Callback> fail,
1508 GMainContext* context,
1510 Ret (T::*func)(Params...)
const,
1603 template <
class Ret,
class... Params,
class... Args,
class T>
1604 #ifdef CGU_USE_AUTO_PTR
1606 GMainContext* context,
1608 Ret (T::*func)(Params...)
const,
1610 static_assert(
sizeof...(Args) < 4,
1611 "No greater than three bound arguments can be passed to "
1612 "TaskManager::make_task_when() taking a member function.");
1616 std::auto_ptr<const Cgu::Callback::Callback>(),
1622 std::forward<Args>(args)...);
1626 GMainContext* context,
1628 Ret (T::*func)(Params...)
const,
1630 static_assert(
sizeof...(Args) < 4,
1631 "No greater than three bound arguments can be passed to "
1632 "TaskManager::make_task_when() taking a member function.");
1636 std::unique_ptr<const Cgu::Callback::Callback>(),
1642 std::forward<Args>(args)...);
1696 template <
class Ret,
class... Params,
class... Args>
1831 template <
class Ret,
class... Params,
class... Args>
1832 #ifdef CGU_USE_AUTO_PTR
1835 std::auto_ptr<const Cgu::Callback::Callback> fail,
1838 GMainContext* context,
1839 Ret (*func)(Params...),
1844 std::unique_ptr<const Cgu::Callback::Callback> fail,
1847 GMainContext* context,
1848 Ret (*func)(Params...),
1938 template <
class Ret,
class... Params,
class... Args>
1939 #ifdef CGU_USE_AUTO_PTR
1941 GMainContext* context,
1942 Ret (*func)(Params...),
1944 static_assert(
sizeof...(Args) < 5,
1945 "No greater than four bound arguments can be passed to "
1946 "TaskManager::make_task_when() taking a function.");
1950 std::auto_ptr<const Cgu::Callback::Callback>(),
1955 std::forward<Args>(args)...);
1958 GMainContext* context,
1959 Ret (*func)(Params...),
1961 static_assert(
sizeof...(Args) < 5,
1962 "No greater than four bound arguments can be passed to "
1963 "TaskManager::make_task_when() taking a function.");
1967 std::unique_ptr<const Cgu::Callback::Callback>(),
1972 std::forward<Args>(args)...);
2052 template <
class Ret,
class Func>
2058 #ifndef DOXYGEN_PARSING
2059 template <
class Func>
2078 typedef typename std::remove_const<typename std::remove_reference<Func>::type>::type FType;
2083 typedef decltype(f()) Ret;
2084 #ifdef CGU_USE_AUTO_PTR
2085 typedef std::auto_ptr<const Callback::Callback> CbPtr;
2087 typedef std::unique_ptr<const Callback::Callback> CbPtr;
2091 CbPtr exec_cb(
new TaskManagerHelper2::FunctorResultExec<Ret, FType>(std::forward<Func>(f), ret));
2092 CbPtr do_fail_cb(
Callback::make_ref(&TaskManagerHelper2::FunctorResultWrapper<Ret, FType>::do_fail,
2094 add_task(std::move(exec_cb), std::move(do_fail_cb));
2241 template <
class Ret,
class Func>
2242 #ifdef CGU_USE_AUTO_PTR
2245 std::auto_ptr<const Cgu::Callback::Callback> fail,
2248 GMainContext* context,
2253 std::unique_ptr<const Cgu::Callback::Callback> fail,
2256 GMainContext* context,
2357 template <
class Ret,
class Func>
2358 #ifdef CGU_USE_AUTO_PTR
2360 GMainContext* context,
2364 std::auto_ptr<const Cgu::Callback::Callback>(),
2368 std::forward<Func>(f));
2372 GMainContext* context,
2376 std::unique_ptr<const Cgu::Callback::Callback>(),
2380 std::forward<Func>(f));
2482 template <
class Ret,
class Func>
2483 #ifdef CGU_USE_AUTO_PTR
2485 GMainContext* context,
2489 std::auto_ptr<const Cgu::Callback::Callback>(),
2493 std::forward<Func>(f));
2497 GMainContext* context,
2501 std::unique_ptr<const Cgu::Callback::Callback>(),
2505 std::forward<Func>(f));
2554 TaskManager(
unsigned int max = 8,
unsigned int min = 0,
2555 unsigned int idle = 10000,
bool blocking =
true,
2697 #include <c++-gtk-utils/task_manager.tpp>
unsigned int get_min_threads() const
StopMode
Definition: task_manager.h:464
unsigned int get_tasks() const
void add_task(const Callback::Callback *task)
Definition: task_manager.h:844
void make_task_compose(Func &&f, GMainContext *context, std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when)
Definition: task_manager.h:2496
A thread-pool class for managing tasks in multi-threaded programs.
Definition: task_manager.h:462
CallbackArg< FreeArgs...> * make_ref(T &t, void(T::*func)(FreeArgs...))
Definition: callback.h:1701
Definition: task_manager.h:61
virtual const char * what() const
Definition: task_manager.h:62
void make_task_when(std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when, GMainContext *context, const T &t, Ret(T::*func)(Params...) const, Args &&...args)
Definition: task_manager.h:1625
This file provides thread-safe asynchronous queue classes.
void make_task_when(std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when, GMainContext *context, Ret(*func)(Params...), Args &&...args)
Definition: task_manager.h:1957
This is a smart pointer for managing the lifetime of objects allocated on freestore, with a thread safe reference count.
Definition: shared_ptr.h:644
auto exec(const std::string &preamble, const std::string &file, Translator translator) -> typename std::result_of< Translator(SCM)>::type
Definition: extension.h:1689
void set_max_threads(unsigned int max)
Cgu::SharedLockPtr< Cgu::AsyncResult< Ret > > make_task_result(T &t, Ret(T::*func)(Params...), Args &&...args)
void set_blocking(bool blocking)
unsigned int get_idle_time() const
A scoped handle for exception safe incrementing of the maximum number of threads that a TaskManager o...
Definition: task_manager.h:2633
void make_task_when(std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when, GMainContext *context, Func &&f)
Definition: task_manager.h:2371
This file provides classes for type erasure.
TaskManager & operator=(const TaskManager &)=delete
void make_task_when_full(std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when, Cgu::Releaser *when_releaser, std::unique_ptr< const Cgu::Callback::Callback > fail, Cgu::Releaser *fail_releaser, gint priority, GMainContext *context, T &t, Ret(T::*func)(Params...), Args &&...args)
void make_task_when(std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when, GMainContext *context, T &t, Ret(T::*func)(Params...), Args &&...args)
Definition: task_manager.h:1279
static unsigned int get_max_tasks()
Definition: task_manager.h:653
A thread-safe asynchronous result class.
Definition: async_result.h:165
IncHandle(TaskManager &tm_)
Definition: task_manager.h:2679
void set_stop_mode(StopMode mode)
unsigned int get_max_threads() const
unsigned int get_used_threads() const
This file provides a thread-safe signal/slot mechanism, with automatic disconnection.
Provides wrapper classes for pthread mutexes and condition variables, and scoped locking classes for ...
Definition: application.h:44
StopMode get_stop_mode() const
A scoped locking class for exception safe Mutex locking which tracks the status of its mutex...
Definition: mutex.h:331
This file provides a thread-safe asynchronous result class.
Definition: task_manager.h:464
void change_max_threads(int delta)
void set_idle_time(unsigned int idle)
~IncHandle()
Definition: task_manager.h:2690
TaskManager(const TaskManager &)=delete
Definition: task_manager.h:464
bool get_blocking() const
The callback interface class.
Definition: callback.h:522
#define CGU_GLIB_MEMORY_SLICES_FUNCS
Definition: cgu_config.h:84
A class used for tracking EmitterArg and SafeEmitterArg connections.
Definition: emitter.h:333