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";}
455 namespace TaskManagerHelper2 {
457 template <
class Ret,
class FType>
483 template <
class Ret,
class FType>
485 mutable FType functor;
491 template <
class FunctorArg>
505 typedef std::pair<std::unique_ptr<const Callback::Callback>,
506 std::unique_ptr<const Callback::Callback>> QueueItemType;
516 static unsigned int init_max_tasks();
698 static unsigned int max_tasks = init_max_tasks();
888 add_task(std::unique_ptr<const Callback::Callback>(task),
889 std::unique_ptr<const Callback::Callback>());
955 void add_task(std::unique_ptr<const Callback::Callback> task,
956 std::unique_ptr<const Callback::Callback> fail);
1016 template <
class Task,
1017 class =
typename std::enable_if<!std::is_convertible<typename std::remove_reference<Task>::type,
1020 add_task(std::unique_ptr<const Callback::Callback>(Callback::lambda<>(std::forward<Task>(task))),
1021 std::unique_ptr<const Callback::Callback>());
1101 template <
class Task,
class Fail,
1102 class =
typename std::enable_if<!std::is_convertible<Task, std::unique_ptr<const Callback::Callback>>::value
1103 && !std::is_convertible<Fail, std::unique_ptr<const Callback::Callback>>::value>::type>
1105 std::unique_ptr<const Callback::Callback> task_cb(
1106 Callback::lambda<>(std::forward<Task>(task))
1108 std::unique_ptr<const Callback::Callback> fail_cb(
1109 Callback::lambda<>(std::forward<Fail>(fail))
1111 add_task(std::move(task_cb), std::move(fail_cb));
1190 template <
class Ret,
class... Params,
class... Args,
class T>
1192 Ret (T::*func)(Params...),
1329 template <
class Ret,
class... Params,
class... Args,
class T>
1332 std::unique_ptr<const Cgu::Callback::Callback> fail,
1335 GMainContext* context,
1337 Ret (T::*func)(Params...),
1430 template <
class Ret,
class... Params,
class... Args,
class T>
1432 GMainContext* context,
1434 Ret (T::*func)(Params...),
1436 static_assert(
sizeof...(Args) < 4,
1437 "No greater than three bound arguments can be passed to "
1438 "TaskManager::make_task_when() taking a member function.");
1442 std::unique_ptr<const Cgu::Callback::Callback>(),
1448 std::forward<Args>(args)...);
1509 template <
class Ret,
class... Params,
class... Args,
class T>
1511 Ret (T::*func)(Params...)
const,
1648 template <
class Ret,
class... Params,
class... Args,
class T>
1651 std::unique_ptr<const Cgu::Callback::Callback> fail,
1654 GMainContext* context,
1656 Ret (T::*func)(Params...)
const,
1749 template <
class Ret,
class... Params,
class... Args,
class T>
1751 GMainContext* context,
1753 Ret (T::*func)(Params...)
const,
1755 static_assert(
sizeof...(Args) < 4,
1756 "No greater than three bound arguments can be passed to "
1757 "TaskManager::make_task_when() taking a member function.");
1761 std::unique_ptr<const Cgu::Callback::Callback>(),
1767 std::forward<Args>(args)...);
1825 template <
class Ret,
class... Params,
class... Args>
1960 template <
class Ret,
class... Params,
class... Args>
1963 std::unique_ptr<const Cgu::Callback::Callback> fail,
1966 GMainContext* context,
1967 Ret (*func)(Params...),
2057 template <
class Ret,
class... Params,
class... Args>
2059 GMainContext* context,
2060 Ret (*func)(Params...),
2062 static_assert(
sizeof...(Args) < 5,
2063 "No greater than four bound arguments can be passed to "
2064 "TaskManager::make_task_when() taking a function.");
2068 std::unique_ptr<const Cgu::Callback::Callback>(),
2073 std::forward<Args>(args)...);
2146 template <
class Ret,
class Func>
2152 #ifndef DOXYGEN_PARSING
2153 template <
class Func>
2172 typedef typename std::remove_const<typename std::remove_reference<Func>::type>::type FType;
2177 typedef decltype(f()) Ret;
2181 CbPtr exec_cb(
new TaskManagerHelper2::FunctorResultExec<Ret, FType>(std::forward<Func>(f), ret));
2182 CbPtr do_fail_cb(
Callback::make_ref(&TaskManagerHelper2::FunctorResultWrapper<Ret, FType>::do_fail,
2184 add_task(std::move(exec_cb), std::move(do_fail_cb));
2320 template <
class Ret,
class Func>
2323 std::unique_ptr<const Cgu::Callback::Callback> fail,
2326 GMainContext* context,
2469 template <
class When,
class Fail,
class Func,
2470 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value
2471 && !std::is_convertible<Fail, std::unique_ptr<const Callback::Callback>>::value>::type>
2477 GMainContext* context,
2483 typedef decltype(func()) Ret;
2484 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2485 Callback::lambda<const Ret&>(std::forward<When>(when))
2487 std::unique_ptr<const Callback::Callback> fail_ptr(
2488 Callback::lambda<>(std::forward<Fail>(fail))
2492 std::move(fail_ptr),
2496 std::forward<Func>(func));
2585 template <
class Ret,
class Func>
2587 GMainContext* context,
2591 std::unique_ptr<const Cgu::Callback::Callback>(),
2595 std::forward<Func>(f));
2695 template <
class When,
class Func,
2696 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value>::type>
2698 GMainContext* context,
2704 typedef decltype(func()) Ret;
2705 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2706 Callback::lambda<const Ret&>(std::forward<When>(when))
2710 std::unique_ptr<const Cgu::Callback::Callback>(),
2714 std::forward<Func>(func));
2804 template <
class Ret,
class Func>
2806 GMainContext* context,
2810 std::unique_ptr<const Cgu::Callback::Callback>(),
2814 std::forward<Func>(f));
2916 template <
class Func,
class When,
2917 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value>::type>
2919 GMainContext* context,
2925 typedef decltype(func()) Ret;
2926 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2927 Callback::lambda<const Ret&>(std::forward<When>(when))
2931 std::unique_ptr<const Cgu::Callback::Callback>(),
2935 std::forward<Func>(func));
3002 template <
class Func>
3015 typedef decltype(f()) Ret;
3017 std::packaged_task<Ret()> task{std::forward<Func>(f)};
3018 std::future<Ret> ret{task.get_future()};
3151 template <
class When,
class Func>
3155 GMainContext* context,
3249 template <
class When,
class Func>
3251 GMainContext* context,
3257 std::forward<Func>(func));
3354 template <
class When,
class Func>
3356 GMainContext* context,
3362 std::forward<Func>(func));
3410 TaskManager(
unsigned int max = 8,
unsigned int min = 0,
3411 unsigned int idle = 10000,
bool blocking =
true,
3553 #include <c++-gtk-utils/task_manager.tpp>
unsigned int get_min_threads() const
StopMode
Definition: task_manager.h:502
unsigned int get_tasks() const
void add_task(const Callback::Callback *task)
Definition: task_manager.h:887
void make_task_packaged_compose(Func &&func, GMainContext *context, When &&when)
Definition: task_manager.h:3355
void make_task_compose(Func &&f, GMainContext *context, std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when)
Definition: task_manager.h:2805
A thread-pool class for managing tasks in multi-threaded programs.
Definition: task_manager.h:500
void make_task_when(When &&when, GMainContext *context, Func &&func)
Definition: task_manager.h:2697
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:1750
This file provides thread-safe asynchronous queue classes.
static void exec(FType &f, const SharedLockPtr< AsyncResult< Ret >> &ret)
Definition: task_manager.h:459
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:2058
void dispatch() const
Definition: task_manager.h:488
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
static void do_fail(const SharedLockPtr< AsyncResult< Ret >> &ret)
Definition: task_manager.h:463
void make_task_compose(Func &&func, GMainContext *context, When &&when)
Definition: task_manager.h:2918
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:3489
void make_task_when(std::unique_ptr< const Cgu::Callback::CallbackArg< const Ret & >> when, GMainContext *context, Func &&f)
Definition: task_manager.h:2586
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:1104
FunctorResultExec(FunctorArg &&functor_, const SharedLockPtr< AsyncResult< Ret >> &ret_)
Definition: task_manager.h:492
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:2472
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)
Definition: task_manager.h:458
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:1431
static unsigned int get_max_tasks()
Definition: task_manager.h:691
Definition: task_manager.h:484
A thread-safe asynchronous result class.
Definition: async_result.h:165
IncHandle(TaskManager &tm_)
Definition: task_manager.h:3535
void add_task(Task &&task)
Definition: task_manager.h:1019
void set_stop_mode(StopMode mode)
void make_task_packaged_when(When &&when, GMainContext *context, Func &&func)
Definition: task_manager.h:3250
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:3003
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:502
void change_max_threads(int delta)
void set_idle_time(unsigned int idle)
~IncHandle()
Definition: task_manager.h:3546
TaskManager(const TaskManager &)=delete
CallbackArg Callback
Definition: callback.h:567
Definition: task_manager.h:502
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