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;
2009 typedef decltype(f()) Ret;
2013 CbPtr exec_cb(
new TaskManagerHelper2::FunctorResultExec<Ret, FType>(std::forward<Func>(f), ret));
2014 CbPtr do_fail_cb(
Callback::make_ref(&TaskManagerHelper2::FunctorResultWrapper<Ret, FType>::do_fail,
2016 add_task(std::move(exec_cb), std::move(do_fail_cb));
2150 template <
class Ret,
class Func>
2153 std::unique_ptr<const Cgu::Callback::Callback> fail,
2156 GMainContext* context,
2296 template <
class When,
class Fail,
class Func,
2297 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value
2298 && !std::is_convertible<Fail, std::unique_ptr<const Callback::Callback>>::value>::type>
2304 GMainContext* context,
2306 typedef decltype(func()) Ret;
2307 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2308 Callback::lambda<const Ret&>(std::forward<When>(when))
2310 std::unique_ptr<const Callback::Callback> fail_ptr(
2311 Callback::lambda<>(std::forward<Fail>(fail))
2315 std::move(fail_ptr),
2319 std::forward<Func>(func));
2397 template <
class Ret,
class Func>
2399 GMainContext* context,
2403 std::unique_ptr<const Cgu::Callback::Callback>(),
2407 std::forward<Func>(f));
2496 template <
class When,
class Func,
2497 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value>::type>
2499 GMainContext* context,
2501 typedef decltype(func()) Ret;
2502 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2503 Callback::lambda<const Ret&>(std::forward<When>(when))
2507 std::unique_ptr<const Cgu::Callback::Callback>(),
2511 std::forward<Func>(func));
2590 template <
class Ret,
class Func>
2592 GMainContext* context,
2596 std::unique_ptr<const Cgu::Callback::Callback>(),
2600 std::forward<Func>(f));
2691 template <
class Func,
class When,
2692 class =
typename std::enable_if<!std::is_convertible<When, std::unique_ptr<const Callback::CallbackArg<const typename std::result_of<Func()>::type&>>>::value>::type>
2694 GMainContext* context,
2696 typedef decltype(func()) Ret;
2697 std::unique_ptr<const Callback::CallbackArg<const Ret&>> when_ptr(
2698 Callback::lambda<const Ret&>(std::forward<When>(when))
2702 std::unique_ptr<const Cgu::Callback::Callback>(),
2706 std::forward<Func>(func));
2771 template <
class Func>
2780 typedef decltype(f()) Ret;
2782 std::packaged_task<Ret()> task{std::forward<Func>(f)};
2783 std::future<Ret> ret{task.get_future()};
2913 template <
class When,
class Func>
2917 GMainContext* context,
3008 template <
class When,
class Func>
3010 GMainContext* context,
3016 std::forward<Func>(func));
3110 template <
class When,
class Func>
3112 GMainContext* context,
3118 std::forward<Func>(func));
3166 TaskManager(
unsigned int max = 8,
unsigned int min = 0,
3167 unsigned int idle = 10000,
bool blocking =
true,
3309 #include <c++-gtk-utils/task_manager.tpp>