304 #ifdef CGU_USE_SCHED_YIELD
311 #include <unordered_set>
313 #include <functional>
315 #include <type_traits>
357 std::unordered_set<Callback::SafeFunctor> disconnect_set;
494 template <
class... FreeArgs>
497 #ifndef DOXYGEN_PARSING
502 Callback::FunctorArg<FreeArgs...> f1;
506 f1(f1_), f2(f2_), blocked(false) {}
510 std::list<ListItem> emission_list;
513 void tracking_disconnect(
const Callback::FunctorArg<FreeArgs...>&);
604 class =
typename std::enable_if<!std::is_convertible<typename std::remove_reference<F>::type,
607 return connect(Callback::lambda<FreeArgs...>(std::forward<F>(f)));
635 class =
typename std::enable_if<!std::is_convertible<typename std::remove_reference<F>::type,
638 return connect(Callback::lambda<FreeArgs...>(std::forward<F>(f)), r);
703 template <
class... FreeArgs>
705 for(
const auto& l: emission_list) {l.f2();}
708 template <
class... FreeArgs>
740 std::list<ListItem> local_list = emission_list;
742 for (
const auto& l: local_list) {
743 if (!l.blocked) l.f1(args...);
747 template <
class... FreeArgs>
749 if (emission_list.empty())
return false;
754 template <
class... FreeArgs>
760 template <
class... FreeArgs>
773 emission_list.emplace_back(f1, f2);
782 template <
class... FreeArgs>
786 auto iter = emission_list.begin();
788 iter = std::find_if(iter, emission_list.end(),
789 [&arg](
const ListItem& p) ->
bool {
return p.f1 == arg;});
790 if (iter != emission_list.end()) {
795 iter = emission_list.erase(iter);
804 template <
class... FreeArgs>
806 auto iter = emission_list.begin();
808 iter = std::find_if(iter, emission_list.end(),
809 [&arg](
const ListItem& p) ->
bool {
return p.f1 == arg;});
810 if (iter != emission_list.end()) {
812 iter = emission_list.erase(iter);
818 template <
class... FreeArgs>
822 auto iter = emission_list.begin();
824 iter = std::find_if(iter, emission_list.end(),
825 [&arg](
const ListItem& p) ->
bool {
return p.f1 == arg;});
826 if (iter != emission_list.end()) {
827 iter->blocked =
true;
834 template <
class... FreeArgs>
838 auto iter = emission_list.begin();
840 iter = std::find_if(iter, emission_list.end(),
841 [&arg](
const ListItem& p) ->
bool {
return p.f1 == arg;});
842 if (iter != emission_list.end()) {
843 iter->blocked =
false;
920 template <
class... FreeArgs>
923 #ifndef DOXYGEN_PARSING
932 f1(f1_), f2(f2_), blocked(false) {}
936 std::list<ListItem> emission_list;
937 mutable Thread::Mutex mutex;
940 void tracking_disconnect(
const Callback::SafeFunctorArg<FreeArgs...>&);
1037 class =
typename std::enable_if<!std::is_convertible<typename std::remove_reference<F>::type,
1040 return connect(Callback::lambda<FreeArgs...>(std::forward<F>(f)));
1068 class =
typename std::enable_if<!std::is_convertible<typename std::remove_reference<F>::type,
1071 return connect(Callback::lambda<FreeArgs...>(std::forward<F>(f)), r);
1145 template <
class... FreeArgs>
1152 while (!emission_list.empty()) {
1153 auto iter = emission_list.begin();
1156 (iter->f2)(&result);
1159 emission_list.erase(iter);
1164 #ifdef CGU_USE_SCHED_YIELD
1174 template <
class... FreeArgs>
1236 std::list<ListItem> local_list;
1239 local_list = emission_list;
1242 for (
const auto& l: local_list) {
1243 if (!l.blocked) l.f1(args...);
1247 template <
class... FreeArgs>
1250 std::list<ListItem> local_list;
1253 if (emission_list.empty())
return false;
1254 local_list = emission_list;
1257 for (
const auto& l: local_list) {
1258 if (!l.blocked) l.f1(args...);
1263 template <
class... FreeArgs>
1269 emission_list.splice(emission_list.end(), std::move(tmp));
1273 template <
class... FreeArgs>
1291 std::list<ListItem> tmp{ListItem{f1, f2}};
1293 emission_list.splice(emission_list.end(), std::move(tmp));
1302 template <
class... FreeArgs>
1307 auto iter = emission_list.begin();
1310 iter = std::find_if(iter, emission_list.end(),
1311 [&arg](
const ListItem& p) ->
bool {
return p.f1 == arg;});
1312 if (iter != emission_list.end()) {
1315 (iter->f2)(&result);
1318 iter = emission_list.erase(iter);
1323 #ifdef CGU_USE_SCHED_YIELD
1331 iter = emission_list.begin();
1341 template <
class... FreeArgs>
1344 auto iter = emission_list.begin();
1346 iter = std::find_if(iter, emission_list.end(),
1347 [&arg](
const ListItem& p) ->
bool {
return p.f1 == arg;});
1348 if (iter != emission_list.end()) {
1350 iter = emission_list.erase(iter);
1356 template <
class... FreeArgs>
1361 auto iter = emission_list.begin();
1363 iter = std::find_if(iter, emission_list.end(),
1364 [&arg](
const ListItem& p) ->
bool {
return p.f1 == arg;});
1365 if (iter != emission_list.end()) {
1366 iter->blocked =
true;
1373 template <
class... FreeArgs>
1378 auto iter = emission_list.begin();
1380 iter = std::find_if(iter, emission_list.end(),
1381 [&arg](
const ListItem& p) ->
bool {
return p.f1 == arg;});
1382 if (iter != emission_list.end()) {
1383 iter->blocked =
false;