39 #ifndef CGU_TASK_MANAGER_H
40 #define CGU_TASK_MANAGER_H
47 #include <type_traits>
64 virtual const char*
what()
const throw() {
return "TaskError\n";}
450 #ifndef DOXYGEN_PARSING
456 namespace TaskManagerHelper2 {
458 template <
class Ret,
class FType>
459 struct FunctorResultWrapper {
460 static void exec(FType& f,
464 static void do_fail(
const SharedLockPtr<AsyncResult<Ret>>& ret) {
484 template <
class Ret,
class FType>
486 mutable FType functor;
487 SharedLockPtr<AsyncResult<Ret>> ret;
492 template <
class FunctorArg>
493 FunctorResultExec(FunctorArg&& functor_,
494 const SharedLockPtr<AsyncResult<Ret>>& ret_): functor(
std::forward<FunctorArg>(functor_)),
499 #endif // DOXYGEN_PARSING
507 typedef std::pair<std::unique_ptr<const Callback::Callback>,
508 std::unique_ptr<const Callback::Callback>> QueueItemType;
518 static unsigned int init_max_tasks();
700 static unsigned int max_tasks = init_max_tasks();
890 add_task(std::unique_ptr<const Callback::Callback>(task),
891 std::unique_ptr<const Callback::Callback>());
957 void add_task(std::unique_ptr<const Callback::Callback> task,
958 std::unique_ptr<const Callback::Callback> fail);
1018 template <
class Task,
1019 class =
typename std::enable_if<!std::is_convertible<typename std::remove_reference<Task>::type,
1022 add_task(std::unique_ptr<const Callback::Callback>(Callback::lambda<>(std::forward<Task>(task))),
1023 std::unique_ptr<const Callback::Callback>());
1103 template <
class Task,
class Fail,
1104 class =
typename std::enable_if<!std::is_convertible<Task, std::unique_ptr<const Callback::Callback>>::value
1105 && !std::is_convertible<Fail, std::unique_ptr<const Callback::Callback>>::value>::type>
1107 std::unique_ptr<const Callback::Callback> task_cb(
1108 Callback::lambda<>(std::forward<Task>(task))
1110 std::unique_ptr<const Callback::Callback> fail_cb(
1111 Callback::lambda<>(std::forward<Fail>(fail))
1113 add_task(std::move(task_cb), std::move(fail_cb));
1192 template <
class Ret,
class... Params,
class... Args,
class T>
1194 Ret (T::*func)(Params...),
1331 template <
class Ret,
class... Params,
class... Args,
class T>
1334 std::unique_ptr<const Cgu::Callback::Callback> fail,
1337 GMainContext* context,
1339 Ret (T::*func)(Params...),
1432 template <
class Ret,
class... Params,
class... Args,
class T>
1434 GMainContext* context,
1436 Ret (T::*func)(Params...),
1438 static_assert(
sizeof...(Args) < 4,
1439 "No greater than three bound arguments can be passed to "
1440 "TaskManager::make_task_when() taking a member function.");
1444 std::unique_ptr<const Cgu::Callback::Callback>(),
1450 std::forward<Args>(args)...);
1511 template <
class Ret,
class... Params,
class... Args,
class T>
1513 Ret (T::*func)(Params...)
const,
1650 template <
class Ret,
class... Params,
class... Args,
class T>
1653 std::unique_ptr<const Cgu::Callback::Callback> fail,
1656 GMainContext* context,
1658 Ret (T::*func)(Params...)
const,
1751 template <
class Ret,
class... Params,
class... Args,
class T>
1753 GMainContext* context,
1755 Ret (T::*func)(Params...)
const,
1757 static_assert(
sizeof...(Args) < 4,
1758 "No greater than three bound arguments can be passed to "
1759 "TaskManager::make_task_when() taking a member function.");
1763 std::unique_ptr<const Cgu::Callback::Callback>(),
1769 std::forward<Args>(args)...);
1827 template <
class Ret,
class... Params,
class... Args>
1962 template <
class Ret,
class... Params,
class... Args>
1965 std::unique_ptr<const Cgu::Callback::Callback> fail,
1968 GMainContext* context,
1969 Ret (*func)(Params...),
2059 template <
class Ret,
class... Params,
class... Args>
2061 GMainContext* context,
2062 Ret (*func)(Params...),
2064 static_assert(
sizeof...(Args) < 5,
2065 "No greater than four bound arguments can be passed to "
2066 "TaskManager::make_task_when() taking a function.");
2070 std::unique_ptr<const Cgu::Callback::Callback>(),
2075 std::forward<Args>(args)...);
2148 template <
class Ret,
class Func>
2154 #ifndef DOXYGEN_PARSING
2155 template <
class Func>
2174 typedef typename std::remove_const<typename std::remove_reference<Func>::type>::type FType;
2179 typedef decltype(f()) Ret;
2183 CbPtr exec_cb(
new TaskManagerHelper2::FunctorResultExec<Ret, FType>(std::forward<Func>(f), ret));
2184 CbPtr do_fail_cb(
Callback::make_ref(&TaskManagerHelper2::FunctorResultWrapper<Ret, FType>::do_fail,
2186 add_task(std::move(exec_cb), std::move(do_fail_cb));
2322 template <
class Ret,
class Func>
2325 std::unique_ptr<const Cgu::Callback::Callback> fail,
2328 GMainContext* context,
2471 template <
class When,
class Fail,
class Func,
2472 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value
2473 && !std::is_convertible<Fail, std::unique_ptr<const Callback::Callback>>::value>::type>
2479 GMainContext* context,
2485 typedef decltype(func()) Ret;
2486 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2487 Callback::lambda<const Ret&>(std::forward<When>(when))
2489 std::unique_ptr<const Callback::Callback> fail_ptr(
2490 Callback::lambda<>(std::forward<Fail>(fail))
2494 std::move(fail_ptr),
2498 std::forward<Func>(func));
2587 template <
class Ret,
class Func>
2589 GMainContext* context,
2593 std::unique_ptr<const Cgu::Callback::Callback>(),
2597 std::forward<Func>(f));
2697 template <
class When,
class Func,
2698 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value>::type>
2700 GMainContext* context,
2706 typedef decltype(func()) Ret;
2707 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2708 Callback::lambda<const Ret&>(std::forward<When>(when))
2712 std::unique_ptr<const Cgu::Callback::Callback>(),
2716 std::forward<Func>(func));
2806 template <
class Ret,
class Func>
2808 GMainContext* context,
2812 std::unique_ptr<const Cgu::Callback::Callback>(),
2816 std::forward<Func>(f));
2918 template <
class Func,
class When,
2919 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value>::type>
2921 GMainContext* context,
2927 typedef decltype(func()) Ret;
2928 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2929 Callback::lambda<const Ret&>(std::forward<When>(when))
2933 std::unique_ptr<const Cgu::Callback::Callback>(),
2937 std::forward<Func>(func));
3004 template <
class Func>
3017 typedef decltype(f()) Ret;
3019 std::packaged_task<Ret()> task{std::forward<Func>(f)};
3020 std::future<Ret> ret{task.get_future()};
3153 template <
class When,
class Func>
3157 GMainContext* context,
3251 template <
class When,
class Func>
3253 GMainContext* context,
3259 std::forward<Func>(func));
3356 template <
class When,
class Func>
3358 GMainContext* context,
3364 std::forward<Func>(func));
3412 TaskManager(
unsigned int max = 8,
unsigned int min = 0,
3413 unsigned int idle = 10000,
bool blocking =
true,
3555 #include <c++-gtk-utils/task_manager.tpp>
unsigned int get_min_threads() const
StopMode
Definition: task_manager.h:504
unsigned int get_tasks() const
void add_task(const Callback::Callback *task)
Definition: task_manager.h:889
void make_task_packaged_compose(Func &&func, GMainContext *context, When &&when)
Definition: task_manager.h:3357
void make_task_compose(Func &&f, GMainContext *context, std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when)
Definition: task_manager.h:2807
A thread-pool class for managing tasks in multi-threaded programs.
Definition: task_manager.h:502
void make_task_when(When &&when, GMainContext *context, Func &&func)
Definition: task_manager.h:2699
CallbackArg< FreeArgs...> * make_ref(T &t, void(T::*func)(FreeArgs...))
Definition: callback.h:1358
Definition: task_manager.h:63
virtual const char * what() const
Definition: task_manager.h:64
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:1752
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:2060
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
void make_task_compose(Func &&func, GMainContext *context, When &&when)
Definition: task_manager.h:2920
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:3491
void make_task_when(std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when, GMainContext *context, Func &&f)
Definition: task_manager.h:2588
void make_task_packaged_when(When &&when, Cgu::Releaser *when_releaser, gint priority, GMainContext *context, Func &&func)
This file provides classes for type erasure.
TaskManager & operator=(const TaskManager &)=delete
void add_task(Task &&task, Fail &&fail)
Definition: task_manager.h:1106
void make_task_when_full(When &&when, Cgu::Releaser *when_releaser, Fail &&fail, Cgu::Releaser *fail_releaser, gint priority, GMainContext *context, Func &&func)
Definition: task_manager.h:2474
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:1433
static unsigned int get_max_tasks()
Definition: task_manager.h:693
A thread-safe asynchronous result class.
Definition: async_result.h:165
IncHandle(TaskManager &tm_)
Definition: task_manager.h:3537
void add_task(Task &&task)
Definition: task_manager.h:1021
auto exec(const std::string &preamble, const std::string &file, Translator &&translator) -> typename std::result_of< Translator(SCM)>::type
Definition: extension.h:1644
void set_stop_mode(StopMode mode)
void make_task_packaged_when(When &&when, GMainContext *context, Func &&func)
Definition: task_manager.h:3252
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
auto make_task_packaged(Func &&f) -> std::future< decltype(f())>
Definition: task_manager.h:3005
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:504
void change_max_threads(int delta)
void set_idle_time(unsigned int idle)
~IncHandle()
Definition: task_manager.h:3548
TaskManager(const TaskManager &)=delete
CallbackArg Callback
Definition: callback.h:567
Definition: task_manager.h:504
bool get_blocking() const
The callback interface class.
Definition: callback.h:567
#define CGU_GLIB_MEMORY_SLICES_FUNCS
Definition: cgu_config.h:84
A class used for tracking EmitterArg and SafeEmitterArg connections.
Definition: emitter.h:352