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";}
396 namespace TaskManagerHelper2 {
398 template <
class Ret,
class FType>
424 template <
class Ret,
class FType>
426 mutable FType functor;
432 template <
class FunctorArg>
446 typedef std::pair<std::unique_ptr<const Callback::Callback>,
447 std::unique_ptr<const Callback::Callback>> QueueItemType;
789 add_task(std::unique_ptr<const Callback::Callback>(task),
790 std::unique_ptr<const Callback::Callback>());
854 void add_task(std::unique_ptr<const Callback::Callback> task,
855 std::unique_ptr<const Callback::Callback> fail);
913 template <
class Task,
914 class =
typename std::enable_if<!std::is_convertible<typename std::remove_reference<Task>::type,
917 add_task(std::unique_ptr<const Callback::Callback>(Callback::lambda<>(std::forward<Task>(task))),
918 std::unique_ptr<const Callback::Callback>());
996 template <
class Task,
class Fail,
997 class =
typename std::enable_if<!std::is_convertible<Task, std::unique_ptr<const Callback::Callback>>::value
998 && !std::is_convertible<Fail, std::unique_ptr<const Callback::Callback>>::value>::type>
1000 std::unique_ptr<const Callback::Callback> task_cb(
1001 Callback::lambda<>(std::forward<Task>(task))
1003 std::unique_ptr<const Callback::Callback> fail_cb(
1004 Callback::lambda<>(std::forward<Fail>(fail))
1006 add_task(std::move(task_cb), std::move(fail_cb));
1083 template <
class Ret,
class... Params,
class... Args,
class T>
1085 Ret (T::*func)(Params...),
1218 template <
class Ret,
class... Params,
class... Args,
class T>
1221 std::unique_ptr<const Cgu::Callback::Callback> fail,
1224 GMainContext* context,
1226 Ret (T::*func)(Params...),
1306 template <
class Ret,
class... Params,
class... Args,
class T>
1308 GMainContext* context,
1310 Ret (T::*func)(Params...),
1312 static_assert(
sizeof...(Args) < 4,
1313 "No greater than three bound arguments can be passed to "
1314 "TaskManager::make_task_when() taking a member function.");
1318 std::unique_ptr<const Cgu::Callback::Callback>(),
1324 std::forward<Args>(args)...);
1383 template <
class Ret,
class... Params,
class... Args,
class T>
1385 Ret (T::*func)(Params...)
const,
1518 template <
class Ret,
class... Params,
class... Args,
class T>
1521 std::unique_ptr<const Cgu::Callback::Callback> fail,
1524 GMainContext* context,
1526 Ret (T::*func)(Params...)
const,
1606 template <
class Ret,
class... Params,
class... Args,
class T>
1608 GMainContext* context,
1610 Ret (T::*func)(Params...)
const,
1612 static_assert(
sizeof...(Args) < 4,
1613 "No greater than three bound arguments can be passed to "
1614 "TaskManager::make_task_when() taking a member function.");
1618 std::unique_ptr<const Cgu::Callback::Callback>(),
1624 std::forward<Args>(args)...);
1680 template <
class Ret,
class... Params,
class... Args>
1811 template <
class Ret,
class... Params,
class... Args>
1814 std::unique_ptr<const Cgu::Callback::Callback> fail,
1817 GMainContext* context,
1818 Ret (*func)(Params...),
1895 template <
class Ret,
class... Params,
class... Args>
1897 GMainContext* context,
1898 Ret (*func)(Params...),
1900 static_assert(
sizeof...(Args) < 5,
1901 "No greater than four bound arguments can be passed to "
1902 "TaskManager::make_task_when() taking a function.");
1906 std::unique_ptr<const Cgu::Callback::Callback>(),
1911 std::forward<Args>(args)...);
1982 template <
class Ret,
class Func>
1988 #ifndef DOXYGEN_PARSING
1989 template <
class Func>
2008 typedef typename std::remove_const<typename std::remove_reference<Func>::type>::type FType;
2013 typedef decltype(f()) Ret;
2017 CbPtr exec_cb(
new TaskManagerHelper2::FunctorResultExec<Ret, FType>(std::forward<Func>(f), ret));
2018 CbPtr do_fail_cb(
Callback::make_ref(&TaskManagerHelper2::FunctorResultWrapper<Ret, FType>::do_fail,
2020 add_task(std::move(exec_cb), std::move(do_fail_cb));
2154 template <
class Ret,
class Func>
2157 std::unique_ptr<const Cgu::Callback::Callback> fail,
2160 GMainContext* context,
2300 template <
class When,
class Fail,
class Func,
2301 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value
2302 && !std::is_convertible<Fail, std::unique_ptr<const Callback::Callback>>::value>::type>
2308 GMainContext* context,
2314 typedef decltype(func()) Ret;
2315 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2316 Callback::lambda<const Ret&>(std::forward<When>(when))
2318 std::unique_ptr<const Callback::Callback> fail_ptr(
2319 Callback::lambda<>(std::forward<Fail>(fail))
2323 std::move(fail_ptr),
2327 std::forward<Func>(func));
2405 template <
class Ret,
class Func>
2407 GMainContext* context,
2411 std::unique_ptr<const Cgu::Callback::Callback>(),
2415 std::forward<Func>(f));
2504 template <
class When,
class Func,
2505 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value>::type>
2507 GMainContext* context,
2513 typedef decltype(func()) Ret;
2514 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2515 Callback::lambda<const Ret&>(std::forward<When>(when))
2519 std::unique_ptr<const Cgu::Callback::Callback>(),
2523 std::forward<Func>(func));
2602 template <
class Ret,
class Func>
2604 GMainContext* context,
2608 std::unique_ptr<const Cgu::Callback::Callback>(),
2612 std::forward<Func>(f));
2703 template <
class Func,
class When,
2704 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value>::type>
2706 GMainContext* context,
2712 typedef decltype(func()) Ret;
2713 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2714 Callback::lambda<const Ret&>(std::forward<When>(when))
2718 std::unique_ptr<const Cgu::Callback::Callback>(),
2722 std::forward<Func>(func));
2787 template <
class Func>
2800 typedef decltype(f()) Ret;
2802 std::packaged_task<Ret()> task{std::forward<Func>(f)};
2803 std::future<Ret> ret{task.get_future()};
2933 template <
class When,
class Func>
2937 GMainContext* context,
3028 template <
class When,
class Func>
3030 GMainContext* context,
3036 std::forward<Func>(func));
3130 template <
class When,
class Func>
3132 GMainContext* context,
3138 std::forward<Func>(func));
3186 TaskManager(
unsigned int max = 8,
unsigned int min = 0,
3187 unsigned int idle = 10000,
bool blocking =
true,
3329 #include <c++-gtk-utils/task_manager.tpp>