Commit e1af1682 authored by Eric Niebler's avatar Eric Niebler Committed by Facebook Github Bot

flow_single works with concepts emulation

fbshipit-source-id: 73b62ddd46201b81ea7f69c83f7f498ab45f6d13
parent 97d89ff6
...@@ -20,13 +20,17 @@ struct countdownsingle { ...@@ -20,13 +20,17 @@ struct countdownsingle {
int* counter; int* counter;
template <class ExecutorRef> template <class ExecutorRef>
void operator()(ExecutorRef exec) { void operator()(ExecutorRef exec) const;
if (--*counter > 0) {
exec | op::submit(mi::make_single(*this));
}
}
}; };
template <class ExecutorRef>
void countdownsingle::operator()(ExecutorRef exec) const {
if (--*counter > 0) {
//exec | op::submit(mi::make_single(*this));
exec | op::submit(mi::single<countdownsingle, mi::abortEF, mi::ignoreDF>{*this});
}
}
struct inline_executor { struct inline_executor {
using properties = mi::property_set<mi::is_sender<>, mi::is_single<>>; using properties = mi::property_set<mi::is_sender<>, mi::is_single<>>;
template<class Out> template<class Out>
......
...@@ -4293,8 +4293,7 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn { ...@@ -4293,8 +4293,7 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
return flow_single<>{}; return flow_single<>{};
} }
PUSHMI_TEMPLATE (class VF) PUSHMI_TEMPLATE (class VF)
(requires not Receiver<VF> && !detail::is_v<VF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF> PUSHMI_AND not defer::Invocable<VF&>)))
!detail::is_v<VF, on_done_fn>)
auto operator()(VF vf) const { auto operator()(VF vf) const {
return flow_single<VF, abortEF, ignoreDF, ignoreStpF, ignoreStrtF>{ return flow_single<VF, abortEF, ignoreDF, ignoreStpF, ignoreStrtF>{
std::move(vf)}; std::move(vf)};
...@@ -4304,99 +4303,89 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn { ...@@ -4304,99 +4303,89 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
return flow_single<ignoreVF, on_error_fn<EFN...>, ignoreDF, ignoreStpF, ignoreStrtF>{ return flow_single<ignoreVF, on_error_fn<EFN...>, ignoreDF, ignoreStpF, ignoreStrtF>{
std::move(ef)}; std::move(ef)};
} }
template <class DF> PUSHMI_TEMPLATE(class DF)
auto operator()(on_done_fn<DF> df) const { (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<DF>)))
return flow_single<ignoreVF, abortEF, on_done_fn<DF>, ignoreStpF, ignoreStrtF>{ auto operator()(DF df) const {
std::move(df)}; return flow_single<ignoreVF, abortEF, DF, ignoreStpF, ignoreStrtF>{std::move(df)};
}
PUSHMI_TEMPLATE (class V, class PE, class E, class Wrapped)
(requires FlowSingleReceiver<Wrapped, V, PE, E> &&
!detail::is_v<Wrapped, none>)
auto operator()(Wrapped w) const {
return flow_single<V, PE, E>{std::move(w)};
} }
PUSHMI_TEMPLATE (class VF, class EF) PUSHMI_TEMPLATE (class VF, class EF)
(requires not Receiver<VF> && !detail::is_v<VF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF> PUSHMI_AND not defer::Invocable<EF&>)))
!detail::is_v<VF, on_done_fn> && !detail::is_v<EF, on_value_fn> &&
!detail::is_v<EF, on_done_fn>)
auto operator()(VF vf, EF ef) const { auto operator()(VF vf, EF ef) const {
return flow_single<VF, EF, ignoreDF, ignoreStpF, ignoreStrtF>{std::move(vf), return flow_single<VF, EF, ignoreDF, ignoreStpF, ignoreStrtF>{std::move(vf),
std::move(ef)}; std::move(ef)};
} }
template <class... EFN, class DF> PUSHMI_TEMPLATE(class EF, class DF)
auto operator()(on_error_fn<EFN...> ef, on_done_fn<DF> df) const { (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<EF>)))
return flow_single<ignoreVF, on_error_fn<EFN...>, on_done_fn<DF>, ignoreStpF, ignoreStrtF>{ auto operator()(EF ef, DF df) const {
std::move(ef), std::move(df)}; return flow_single<ignoreVF, EF, DF, ignoreStpF, ignoreStrtF>{std::move(ef), std::move(df)};
} }
PUSHMI_TEMPLATE (class VF, class EF, class DF) PUSHMI_TEMPLATE (class VF, class EF, class DF)
(requires Invocable<DF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
auto operator()(VF vf, EF ef, DF df) const { auto operator()(VF vf, EF ef, DF df) const {
return flow_single<VF, EF, DF, ignoreStpF, ignoreStrtF>{std::move(vf), return flow_single<VF, EF, DF, ignoreStpF, ignoreStrtF>{std::move(vf),
std::move(ef), std::move(df)}; std::move(ef), std::move(df)};
} }
PUSHMI_TEMPLATE (class VF, class EF, class DF, class StpF) PUSHMI_TEMPLATE (class VF, class EF, class DF, class StpF)
(requires Invocable<DF&> && Invocable<StpF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_AND defer::Invocable<StpF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
auto operator()(VF vf, EF ef, DF df, StpF stpf) const { auto operator()(VF vf, EF ef, DF df, StpF stpf) const {
return flow_single<VF, EF, DF, StpF, ignoreStrtF>{std::move(vf), return flow_single<VF, EF, DF, StpF, ignoreStrtF>{std::move(vf),
std::move(ef), std::move(df), std::move(stpf)}; std::move(ef), std::move(df), std::move(stpf)};
} }
PUSHMI_TEMPLATE (class VF, class EF, class DF, class StpF, class StrtF) PUSHMI_TEMPLATE (class VF, class EF, class DF, class StpF, class StrtF)
(requires Invocable<DF&> && Invocable<StpF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_AND defer::Invocable<StpF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
auto operator()(VF vf, EF ef, DF df, StpF stpf, StrtF strtf) const { auto operator()(VF vf, EF ef, DF df, StpF stpf, StrtF strtf) const {
return flow_single<VF, EF, DF, StpF, StrtF>{std::move(vf), std::move(ef), return flow_single<VF, EF, DF, StpF, StrtF>{std::move(vf), std::move(ef),
std::move(df), std::move(stpf), std::move(strtf)}; std::move(df), std::move(stpf), std::move(strtf)};
} }
PUSHMI_TEMPLATE(class Data) PUSHMI_TEMPLATE(class Data)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data>))
auto operator()(Data d) const { auto operator()(Data d) const {
return flow_single<Data, passDVF, passDEF, passDDF, passDStpF, passDStrtF>{ return flow_single<Data, passDVF, passDEF, passDDF, passDStpF, passDStrtF>{
std::move(d)}; std::move(d)};
} }
PUSHMI_TEMPLATE(class Data, class DVF) PUSHMI_TEMPLATE(class Data, class DVF)
(requires Receiver<Data> && !detail::is_v<DVF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Invocable<DVF&, Data&>)))
!detail::is_v<DVF, on_done_fn>)
auto operator()(Data d, DVF vf) const { auto operator()(Data d, DVF vf) const {
return flow_single<Data, DVF, passDEF, passDDF, passDStpF, passDStrtF>{ return flow_single<Data, DVF, passDEF, passDDF, passDStpF, passDStrtF>{
std::move(d), std::move(vf)}; std::move(d), std::move(vf)};
} }
PUSHMI_TEMPLATE(class Data, class... DEFN) PUSHMI_TEMPLATE(class Data, class... DEFN)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::Receiver<Data>))
auto operator()(Data d, on_error_fn<DEFN...> ef) const { auto operator()(Data d, on_error_fn<DEFN...> ef) const {
return flow_single<Data, passDVF, on_error_fn<DEFN...>, passDDF, passDStpF, passDStrtF>{ return flow_single<Data, passDVF, on_error_fn<DEFN...>, passDDF, passDStpF, passDStrtF>{
std::move(d), std::move(ef)}; std::move(d), std::move(ef)};
} }
PUSHMI_TEMPLATE(class Data, class DDF)
(requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
auto operator()(Data d, DDF df) const {
return flow_single<Data, passDVF, passDEF, DDF, passDStpF, passDStrtF>{
std::move(d), std::move(df)};
}
PUSHMI_TEMPLATE(class Data, class DVF, class DEF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF)
(requires Receiver<Data> && !detail::is_v<DVF, on_error_fn> && (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Invocable<DEF&, Data&>)))
!detail::is_v<DVF, on_done_fn> && !detail::is_v<DEF, on_done_fn>)
auto operator()(Data d, DVF vf, DEF ef) const { auto operator()(Data d, DVF vf, DEF ef) const {
return flow_single<Data, DVF, DEF, passDDF, passDStpF, passDStrtF>{std::move(d), std::move(vf), std::move(ef)}; return flow_single<Data, DVF, DEF, passDDF, passDStpF, passDStrtF>{std::move(d), std::move(vf), std::move(ef)};
} }
PUSHMI_TEMPLATE(class Data, class... DEFN, class DDF) PUSHMI_TEMPLATE(class Data, class DEF, class DDF)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
auto operator()(Data d, on_error_fn<DEFN...> ef, on_done_fn<DDF> df) const { auto operator()(Data d, DEF ef, DDF df) const {
return flow_single<Data, passDVF, on_error_fn<DEFN...>, on_done_fn<DDF>, passDStpF, passDStrtF>{ return flow_single<Data, passDVF, DEF, DDF, passDStpF, passDStrtF>{
std::move(d), std::move(ef), std::move(df)}; std::move(d), std::move(ef), std::move(df)};
} }
PUSHMI_TEMPLATE(class Data, class DDF)
(requires Receiver<Data>)
auto operator()(Data d, on_done_fn<DDF> df) const {
return flow_single<Data, passDVF, passDEF, on_done_fn<DDF>, passDStpF, passDStrtF>{
std::move(d), std::move(df)};
}
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF)
(requires Receiver<Data> && Invocable<DDF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
auto operator()(Data d, DVF vf, DEF ef, DDF df) const { auto operator()(Data d, DVF vf, DEF ef, DDF df) const {
return flow_single<Data, DVF, DEF, DDF, passDStpF, passDStrtF>{std::move(d), return flow_single<Data, DVF, DEF, DDF, passDStpF, passDStrtF>{std::move(d),
std::move(vf), std::move(ef), std::move(df)}; std::move(vf), std::move(ef), std::move(df)};
} }
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF)
(requires Receiver<Data> && Invocable<DDF&, Data&> && Invocable<DStpF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&> PUSHMI_AND defer::Invocable<DStpF&, Data&>))
auto operator()(Data d, DVF vf, DEF ef, DDF df, DStpF stpf) const { auto operator()(Data d, DVF vf, DEF ef, DDF df, DStpF stpf) const {
return flow_single<Data, DVF, DEF, DDF, DStpF, passDStrtF>{std::move(d), return flow_single<Data, DVF, DEF, DDF, DStpF, passDStrtF>{std::move(d),
std::move(vf), std::move(ef), std::move(df), std::move(stpf)}; std::move(vf), std::move(ef), std::move(df), std::move(stpf)};
} }
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF, class DStrtF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF, class DStrtF)
(requires Receiver<Data> && Invocable<DDF&, Data&> && Invocable<DStpF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&> PUSHMI_AND defer::Invocable<DStpF&, Data&>))
auto operator()(Data d, DVF vf, DEF ef, DDF df, DStpF stpf, DStrtF strtf) const { auto operator()(Data d, DVF vf, DEF ef, DDF df, DStpF stpf, DStrtF strtf) const {
return flow_single<Data, DVF, DEF, DDF, DStpF, DStrtF>{std::move(d), return flow_single<Data, DVF, DEF, DDF, DStpF, DStrtF>{std::move(d),
std::move(vf), std::move(ef), std::move(df), std::move(stpf), std::move(strtf)}; std::move(vf), std::move(ef), std::move(df), std::move(stpf), std::move(strtf)};
...@@ -4409,124 +4398,88 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn { ...@@ -4409,124 +4398,88 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
flow_single() -> flow_single<>; flow_single() -> flow_single<>;
PUSHMI_TEMPLATE(class VF) PUSHMI_TEMPLATE(class VF)
(requires not Receiver<VF> && !detail::is_v<VF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF> PUSHMI_AND not defer::Invocable<VF&>)))
!detail::is_v<VF, on_done_fn>) flow_single(VF) ->
flow_single(VF) flow_single<VF, abortEF, ignoreDF, ignoreStpF, ignoreStrtF>;
-> flow_single<VF, abortEF, ignoreDF, ignoreStpF, ignoreStrtF>;
template <class... EFN> template <class... EFN>
flow_single(on_error_fn<EFN...>) flow_single(on_error_fn<EFN...>) ->
-> flow_single< flow_single<ignoreVF, on_error_fn<EFN...>, ignoreDF, ignoreStpF, ignoreStrtF>;
ignoreVF,
on_error_fn<EFN...>, PUSHMI_TEMPLATE(class DF)
ignoreDF, (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<DF>)))
ignoreStpF, flow_single(DF) ->
ignoreStrtF>; flow_single<ignoreVF, abortEF, DF, ignoreStpF, ignoreStrtF>;
template <class DF>
flow_single(on_done_fn<DF>)
-> flow_single<ignoreVF, abortEF, on_done_fn<DF>, ignoreStpF, ignoreStrtF>;
PUSHMI_TEMPLATE(class V, class PE, class E, class Wrapped)
(requires FlowSingleReceiver<Wrapped, V, PE, E> &&
!detail::is_v<Wrapped, none>)
flow_single(Wrapped) -> flow_single<V, PE, E>;
PUSHMI_TEMPLATE(class VF, class EF) PUSHMI_TEMPLATE(class VF, class EF)
(requires not Receiver<VF> && !detail::is_v<VF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF> PUSHMI_AND not defer::Invocable<EF&>)))
!detail::is_v<VF, on_done_fn> && !detail::is_v<EF, on_value_fn> && flow_single(VF, EF) ->
!detail::is_v<EF, on_done_fn>) flow_single<VF, EF, ignoreDF, ignoreStpF, ignoreStrtF>;
flow_single(VF, EF)
-> flow_single<VF, EF, ignoreDF, ignoreStpF, ignoreStrtF>; PUSHMI_TEMPLATE(class EF, class DF)
(requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<EF>)))
template <class... EFN, class DF> flow_single(EF, DF) ->
flow_single(on_error_fn<EFN...>, on_done_fn<DF>) flow_single<ignoreVF, EF, DF, ignoreStpF, ignoreStrtF>;
-> flow_single<
ignoreVF,
on_error_fn<EFN...>,
on_done_fn<DF>,
ignoreStpF,
ignoreStrtF>;
PUSHMI_TEMPLATE(class VF, class EF, class DF) PUSHMI_TEMPLATE(class VF, class EF, class DF)
(requires Invocable<DF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
flow_single(VF, EF, DF) flow_single(VF, EF, DF) ->
-> flow_single<VF, EF, DF, ignoreStpF, ignoreStrtF>; flow_single<VF, EF, DF, ignoreStpF, ignoreStrtF>;
PUSHMI_TEMPLATE(class VF, class EF, class DF, class StpF) PUSHMI_TEMPLATE(class VF, class EF, class DF, class StpF)
(requires Invocable<DF&> && Invocable<StpF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_AND defer::Invocable<StpF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
flow_single(VF, EF, DF, StpF) flow_single(VF, EF, DF, StpF) ->
-> flow_single<VF, EF, DF, StpF, ignoreStrtF>; flow_single<VF, EF, DF, StpF, ignoreStrtF>;
PUSHMI_TEMPLATE(class VF, class EF, class DF, class StpF, class StrtF) PUSHMI_TEMPLATE(class VF, class EF, class DF, class StpF, class StrtF)
(requires Invocable<DF&> && Invocable<StpF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_AND defer::Invocable<StpF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
flow_single(VF, EF, DF, StpF, StrtF) flow_single(VF, EF, DF, StpF, StrtF) ->
-> flow_single<VF, EF, DF, StpF, StrtF>; flow_single<VF, EF, DF, StpF, StrtF>;
PUSHMI_TEMPLATE(class Data) PUSHMI_TEMPLATE(class Data)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data>))
flow_single(Data d) flow_single(Data d) ->
-> flow_single<Data, passDVF, passDEF, passDDF, passDStpF, passDStrtF>; flow_single<Data, passDVF, passDEF, passDDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DVF) PUSHMI_TEMPLATE(class Data, class DVF)
(requires Receiver<Data> && !detail::is_v<DVF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Invocable<DVF&, Data&>)))
!detail::is_v<DVF, on_done_fn>) flow_single(Data d, DVF vf) ->
flow_single(Data d, DVF vf) flow_single<Data, DVF, passDEF, passDDF, passDStpF, passDStrtF>;
-> flow_single<Data, DVF, passDEF, passDDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class... DEFN) PUSHMI_TEMPLATE(class Data, class... DEFN)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::Receiver<Data>))
flow_single(Data d, on_error_fn<DEFN...>) flow_single(Data d, on_error_fn<DEFN...>) ->
-> flow_single< flow_single<Data, passDVF, on_error_fn<DEFN...>, passDDF, passDStpF, passDStrtF>;
Data,
passDVF, PUSHMI_TEMPLATE(class Data, class DDF)
on_error_fn<DEFN...>, (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
passDDF, flow_single(Data d, DDF) ->
passDStpF, flow_single<Data, passDVF, passDEF, DDF, passDStpF, passDStrtF>;
passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DVF, class DEF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF)
(requires Receiver<Data> && !detail::is_v<DVF, on_error_fn> && (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Invocable<DEF&, Data&>)))
!detail::is_v<DVF, on_done_fn> && !detail::is_v<DEF, on_done_fn>) flow_single(Data d, DVF vf, DEF ef) ->
flow_single(Data d, DVF vf, DEF ef) flow_single<Data, DVF, DEF, passDDF, passDStpF, passDStrtF>;
-> flow_single<Data, DVF, DEF, passDDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class... DEFN, class DDF)
(requires Receiver<Data>)
flow_single(Data d, on_error_fn<DEFN...>, on_done_fn<DDF>)
-> flow_single<
Data,
passDVF,
on_error_fn<DEFN...>,
on_done_fn<DDF>,
passDStpF,
passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DDF) PUSHMI_TEMPLATE(class Data, class DEF, class DDF)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
flow_single(Data d, on_done_fn<DDF>) flow_single(Data d, DEF, DDF) ->
-> flow_single<Data, passDVF, passDEF, on_done_fn<DDF>, passDStpF, passDStrtF>; flow_single<Data, passDVF, DEF, DDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF)
(requires Receiver<Data> && Invocable<DDF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
flow_single(Data d, DVF vf, DEF ef, DDF df) flow_single(Data d, DVF vf, DEF ef, DDF df) ->
-> flow_single<Data, DVF, DEF, DDF, passDStpF, passDStrtF>; flow_single<Data, DVF, DEF, DDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF)
(requires Receiver<Data> && Invocable<DDF&, Data&> && Invocable<DStpF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&> PUSHMI_AND defer::Invocable<DStpF&, Data&>))
flow_single(Data d, DVF vf, DEF ef, DDF df, DStpF stpf) flow_single(Data d, DVF vf, DEF ef, DDF df, DStpF stpf) ->
-> flow_single<Data, DVF, DEF, DDF, DStpF, passDStrtF>; flow_single<Data, DVF, DEF, DDF, DStpF, passDStrtF>;
PUSHMI_TEMPLATE( PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF, class DStrtF)
class Data, (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&> PUSHMI_AND defer::Invocable<DStpF&, Data&>))
class DVF, flow_single(Data d, DVF vf, DEF ef, DDF df, DStpF stpf, DStrtF strtf) ->
class DEF, flow_single<Data, DVF, DEF, DDF, DStpF, DStrtF>;
class DDF,
class DStpF,
class DStrtF)
(requires Receiver<Data> && Invocable<DDF&, Data&> && Invocable<DStpF&, Data&>)
flow_single(Data d, DVF vf, DEF ef, DDF df, DStpF stpf, DStrtF strtf)
-> flow_single<Data, DVF, DEF, DDF, DStpF, DStrtF>;
#endif #endif
template <class V, class PE = std::exception_ptr, class E = PE> template <class V, class PE = std::exception_ptr, class E = PE>
......
...@@ -292,8 +292,7 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn { ...@@ -292,8 +292,7 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
return flow_single<>{}; return flow_single<>{};
} }
PUSHMI_TEMPLATE (class VF) PUSHMI_TEMPLATE (class VF)
(requires not Receiver<VF> && !detail::is_v<VF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF> PUSHMI_AND not defer::Invocable<VF&>)))
!detail::is_v<VF, on_done_fn>)
auto operator()(VF vf) const { auto operator()(VF vf) const {
return flow_single<VF, abortEF, ignoreDF, ignoreStpF, ignoreStrtF>{ return flow_single<VF, abortEF, ignoreDF, ignoreStpF, ignoreStrtF>{
std::move(vf)}; std::move(vf)};
...@@ -303,99 +302,89 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn { ...@@ -303,99 +302,89 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
return flow_single<ignoreVF, on_error_fn<EFN...>, ignoreDF, ignoreStpF, ignoreStrtF>{ return flow_single<ignoreVF, on_error_fn<EFN...>, ignoreDF, ignoreStpF, ignoreStrtF>{
std::move(ef)}; std::move(ef)};
} }
template <class DF> PUSHMI_TEMPLATE(class DF)
auto operator()(on_done_fn<DF> df) const { (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<DF>)))
return flow_single<ignoreVF, abortEF, on_done_fn<DF>, ignoreStpF, ignoreStrtF>{ auto operator()(DF df) const {
std::move(df)}; return flow_single<ignoreVF, abortEF, DF, ignoreStpF, ignoreStrtF>{std::move(df)};
}
PUSHMI_TEMPLATE (class V, class PE, class E, class Wrapped)
(requires FlowSingleReceiver<Wrapped, V, PE, E> &&
!detail::is_v<Wrapped, none>)
auto operator()(Wrapped w) const {
return flow_single<V, PE, E>{std::move(w)};
} }
PUSHMI_TEMPLATE (class VF, class EF) PUSHMI_TEMPLATE (class VF, class EF)
(requires not Receiver<VF> && !detail::is_v<VF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF> PUSHMI_AND not defer::Invocable<EF&>)))
!detail::is_v<VF, on_done_fn> && !detail::is_v<EF, on_value_fn> &&
!detail::is_v<EF, on_done_fn>)
auto operator()(VF vf, EF ef) const { auto operator()(VF vf, EF ef) const {
return flow_single<VF, EF, ignoreDF, ignoreStpF, ignoreStrtF>{std::move(vf), return flow_single<VF, EF, ignoreDF, ignoreStpF, ignoreStrtF>{std::move(vf),
std::move(ef)}; std::move(ef)};
} }
template <class... EFN, class DF> PUSHMI_TEMPLATE(class EF, class DF)
auto operator()(on_error_fn<EFN...> ef, on_done_fn<DF> df) const { (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<EF>)))
return flow_single<ignoreVF, on_error_fn<EFN...>, on_done_fn<DF>, ignoreStpF, ignoreStrtF>{ auto operator()(EF ef, DF df) const {
std::move(ef), std::move(df)}; return flow_single<ignoreVF, EF, DF, ignoreStpF, ignoreStrtF>{std::move(ef), std::move(df)};
} }
PUSHMI_TEMPLATE (class VF, class EF, class DF) PUSHMI_TEMPLATE (class VF, class EF, class DF)
(requires Invocable<DF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
auto operator()(VF vf, EF ef, DF df) const { auto operator()(VF vf, EF ef, DF df) const {
return flow_single<VF, EF, DF, ignoreStpF, ignoreStrtF>{std::move(vf), return flow_single<VF, EF, DF, ignoreStpF, ignoreStrtF>{std::move(vf),
std::move(ef), std::move(df)}; std::move(ef), std::move(df)};
} }
PUSHMI_TEMPLATE (class VF, class EF, class DF, class StpF) PUSHMI_TEMPLATE (class VF, class EF, class DF, class StpF)
(requires Invocable<DF&> && Invocable<StpF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_AND defer::Invocable<StpF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
auto operator()(VF vf, EF ef, DF df, StpF stpf) const { auto operator()(VF vf, EF ef, DF df, StpF stpf) const {
return flow_single<VF, EF, DF, StpF, ignoreStrtF>{std::move(vf), return flow_single<VF, EF, DF, StpF, ignoreStrtF>{std::move(vf),
std::move(ef), std::move(df), std::move(stpf)}; std::move(ef), std::move(df), std::move(stpf)};
} }
PUSHMI_TEMPLATE (class VF, class EF, class DF, class StpF, class StrtF) PUSHMI_TEMPLATE (class VF, class EF, class DF, class StpF, class StrtF)
(requires Invocable<DF&> && Invocable<StpF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_AND defer::Invocable<StpF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
auto operator()(VF vf, EF ef, DF df, StpF stpf, StrtF strtf) const { auto operator()(VF vf, EF ef, DF df, StpF stpf, StrtF strtf) const {
return flow_single<VF, EF, DF, StpF, StrtF>{std::move(vf), std::move(ef), return flow_single<VF, EF, DF, StpF, StrtF>{std::move(vf), std::move(ef),
std::move(df), std::move(stpf), std::move(strtf)}; std::move(df), std::move(stpf), std::move(strtf)};
} }
PUSHMI_TEMPLATE(class Data) PUSHMI_TEMPLATE(class Data)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data>))
auto operator()(Data d) const { auto operator()(Data d) const {
return flow_single<Data, passDVF, passDEF, passDDF, passDStpF, passDStrtF>{ return flow_single<Data, passDVF, passDEF, passDDF, passDStpF, passDStrtF>{
std::move(d)}; std::move(d)};
} }
PUSHMI_TEMPLATE(class Data, class DVF) PUSHMI_TEMPLATE(class Data, class DVF)
(requires Receiver<Data> && !detail::is_v<DVF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Invocable<DVF&, Data&>)))
!detail::is_v<DVF, on_done_fn>)
auto operator()(Data d, DVF vf) const { auto operator()(Data d, DVF vf) const {
return flow_single<Data, DVF, passDEF, passDDF, passDStpF, passDStrtF>{ return flow_single<Data, DVF, passDEF, passDDF, passDStpF, passDStrtF>{
std::move(d), std::move(vf)}; std::move(d), std::move(vf)};
} }
PUSHMI_TEMPLATE(class Data, class... DEFN) PUSHMI_TEMPLATE(class Data, class... DEFN)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::Receiver<Data>))
auto operator()(Data d, on_error_fn<DEFN...> ef) const { auto operator()(Data d, on_error_fn<DEFN...> ef) const {
return flow_single<Data, passDVF, on_error_fn<DEFN...>, passDDF, passDStpF, passDStrtF>{ return flow_single<Data, passDVF, on_error_fn<DEFN...>, passDDF, passDStpF, passDStrtF>{
std::move(d), std::move(ef)}; std::move(d), std::move(ef)};
} }
PUSHMI_TEMPLATE(class Data, class DDF)
(requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
auto operator()(Data d, DDF df) const {
return flow_single<Data, passDVF, passDEF, DDF, passDStpF, passDStrtF>{
std::move(d), std::move(df)};
}
PUSHMI_TEMPLATE(class Data, class DVF, class DEF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF)
(requires Receiver<Data> && !detail::is_v<DVF, on_error_fn> && (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Invocable<DEF&, Data&>)))
!detail::is_v<DVF, on_done_fn> && !detail::is_v<DEF, on_done_fn>)
auto operator()(Data d, DVF vf, DEF ef) const { auto operator()(Data d, DVF vf, DEF ef) const {
return flow_single<Data, DVF, DEF, passDDF, passDStpF, passDStrtF>{std::move(d), std::move(vf), std::move(ef)}; return flow_single<Data, DVF, DEF, passDDF, passDStpF, passDStrtF>{std::move(d), std::move(vf), std::move(ef)};
} }
PUSHMI_TEMPLATE(class Data, class... DEFN, class DDF) PUSHMI_TEMPLATE(class Data, class DEF, class DDF)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
auto operator()(Data d, on_error_fn<DEFN...> ef, on_done_fn<DDF> df) const { auto operator()(Data d, DEF ef, DDF df) const {
return flow_single<Data, passDVF, on_error_fn<DEFN...>, on_done_fn<DDF>, passDStpF, passDStrtF>{ return flow_single<Data, passDVF, DEF, DDF, passDStpF, passDStrtF>{
std::move(d), std::move(ef), std::move(df)}; std::move(d), std::move(ef), std::move(df)};
} }
PUSHMI_TEMPLATE(class Data, class DDF)
(requires Receiver<Data>)
auto operator()(Data d, on_done_fn<DDF> df) const {
return flow_single<Data, passDVF, passDEF, on_done_fn<DDF>, passDStpF, passDStrtF>{
std::move(d), std::move(df)};
}
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF)
(requires Receiver<Data> && Invocable<DDF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
auto operator()(Data d, DVF vf, DEF ef, DDF df) const { auto operator()(Data d, DVF vf, DEF ef, DDF df) const {
return flow_single<Data, DVF, DEF, DDF, passDStpF, passDStrtF>{std::move(d), return flow_single<Data, DVF, DEF, DDF, passDStpF, passDStrtF>{std::move(d),
std::move(vf), std::move(ef), std::move(df)}; std::move(vf), std::move(ef), std::move(df)};
} }
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF)
(requires Receiver<Data> && Invocable<DDF&, Data&> && Invocable<DStpF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&> PUSHMI_AND defer::Invocable<DStpF&, Data&>))
auto operator()(Data d, DVF vf, DEF ef, DDF df, DStpF stpf) const { auto operator()(Data d, DVF vf, DEF ef, DDF df, DStpF stpf) const {
return flow_single<Data, DVF, DEF, DDF, DStpF, passDStrtF>{std::move(d), return flow_single<Data, DVF, DEF, DDF, DStpF, passDStrtF>{std::move(d),
std::move(vf), std::move(ef), std::move(df), std::move(stpf)}; std::move(vf), std::move(ef), std::move(df), std::move(stpf)};
} }
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF, class DStrtF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF, class DStrtF)
(requires Receiver<Data> && Invocable<DDF&, Data&> && Invocable<DStpF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&> PUSHMI_AND defer::Invocable<DStpF&, Data&>))
auto operator()(Data d, DVF vf, DEF ef, DDF df, DStpF stpf, DStrtF strtf) const { auto operator()(Data d, DVF vf, DEF ef, DDF df, DStpF stpf, DStrtF strtf) const {
return flow_single<Data, DVF, DEF, DDF, DStpF, DStrtF>{std::move(d), return flow_single<Data, DVF, DEF, DDF, DStpF, DStrtF>{std::move(d),
std::move(vf), std::move(ef), std::move(df), std::move(stpf), std::move(strtf)}; std::move(vf), std::move(ef), std::move(df), std::move(stpf), std::move(strtf)};
...@@ -408,124 +397,88 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn { ...@@ -408,124 +397,88 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
flow_single() -> flow_single<>; flow_single() -> flow_single<>;
PUSHMI_TEMPLATE(class VF) PUSHMI_TEMPLATE(class VF)
(requires not Receiver<VF> && !detail::is_v<VF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF> PUSHMI_AND not defer::Invocable<VF&>)))
!detail::is_v<VF, on_done_fn>) flow_single(VF) ->
flow_single(VF) flow_single<VF, abortEF, ignoreDF, ignoreStpF, ignoreStrtF>;
-> flow_single<VF, abortEF, ignoreDF, ignoreStpF, ignoreStrtF>;
template <class... EFN> template <class... EFN>
flow_single(on_error_fn<EFN...>) flow_single(on_error_fn<EFN...>) ->
-> flow_single< flow_single<ignoreVF, on_error_fn<EFN...>, ignoreDF, ignoreStpF, ignoreStrtF>;
ignoreVF,
on_error_fn<EFN...>, PUSHMI_TEMPLATE(class DF)
ignoreDF, (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<DF>)))
ignoreStpF, flow_single(DF) ->
ignoreStrtF>; flow_single<ignoreVF, abortEF, DF, ignoreStpF, ignoreStrtF>;
template <class DF>
flow_single(on_done_fn<DF>)
-> flow_single<ignoreVF, abortEF, on_done_fn<DF>, ignoreStpF, ignoreStrtF>;
PUSHMI_TEMPLATE(class V, class PE, class E, class Wrapped)
(requires FlowSingleReceiver<Wrapped, V, PE, E> &&
!detail::is_v<Wrapped, none>)
flow_single(Wrapped) -> flow_single<V, PE, E>;
PUSHMI_TEMPLATE(class VF, class EF) PUSHMI_TEMPLATE(class VF, class EF)
(requires not Receiver<VF> && !detail::is_v<VF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF> PUSHMI_AND not defer::Invocable<EF&>)))
!detail::is_v<VF, on_done_fn> && !detail::is_v<EF, on_value_fn> && flow_single(VF, EF) ->
!detail::is_v<EF, on_done_fn>) flow_single<VF, EF, ignoreDF, ignoreStpF, ignoreStrtF>;
flow_single(VF, EF)
-> flow_single<VF, EF, ignoreDF, ignoreStpF, ignoreStrtF>; PUSHMI_TEMPLATE(class EF, class DF)
(requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<EF>)))
template <class... EFN, class DF> flow_single(EF, DF) ->
flow_single(on_error_fn<EFN...>, on_done_fn<DF>) flow_single<ignoreVF, EF, DF, ignoreStpF, ignoreStrtF>;
-> flow_single<
ignoreVF,
on_error_fn<EFN...>,
on_done_fn<DF>,
ignoreStpF,
ignoreStrtF>;
PUSHMI_TEMPLATE(class VF, class EF, class DF) PUSHMI_TEMPLATE(class VF, class EF, class DF)
(requires Invocable<DF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
flow_single(VF, EF, DF) flow_single(VF, EF, DF) ->
-> flow_single<VF, EF, DF, ignoreStpF, ignoreStrtF>; flow_single<VF, EF, DF, ignoreStpF, ignoreStrtF>;
PUSHMI_TEMPLATE(class VF, class EF, class DF, class StpF) PUSHMI_TEMPLATE(class VF, class EF, class DF, class StpF)
(requires Invocable<DF&> && Invocable<StpF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_AND defer::Invocable<StpF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
flow_single(VF, EF, DF, StpF) flow_single(VF, EF, DF, StpF) ->
-> flow_single<VF, EF, DF, StpF, ignoreStrtF>; flow_single<VF, EF, DF, StpF, ignoreStrtF>;
PUSHMI_TEMPLATE(class VF, class EF, class DF, class StpF, class StrtF) PUSHMI_TEMPLATE(class VF, class EF, class DF, class StpF, class StrtF)
(requires Invocable<DF&> && Invocable<StpF&>) (requires PUSHMI_EXP(defer::Invocable<DF&> PUSHMI_AND defer::Invocable<StpF&> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Receiver<VF>)))
flow_single(VF, EF, DF, StpF, StrtF) flow_single(VF, EF, DF, StpF, StrtF) ->
-> flow_single<VF, EF, DF, StpF, StrtF>; flow_single<VF, EF, DF, StpF, StrtF>;
PUSHMI_TEMPLATE(class Data) PUSHMI_TEMPLATE(class Data)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data>))
flow_single(Data d) flow_single(Data d) ->
-> flow_single<Data, passDVF, passDEF, passDDF, passDStpF, passDStrtF>; flow_single<Data, passDVF, passDEF, passDDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DVF) PUSHMI_TEMPLATE(class Data, class DVF)
(requires Receiver<Data> && !detail::is_v<DVF, on_error_fn> && (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Invocable<DVF&, Data&>)))
!detail::is_v<DVF, on_done_fn>) flow_single(Data d, DVF vf) ->
flow_single(Data d, DVF vf) flow_single<Data, DVF, passDEF, passDDF, passDStpF, passDStrtF>;
-> flow_single<Data, DVF, passDEF, passDDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class... DEFN) PUSHMI_TEMPLATE(class Data, class... DEFN)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::Receiver<Data>))
flow_single(Data d, on_error_fn<DEFN...>) flow_single(Data d, on_error_fn<DEFN...>) ->
-> flow_single< flow_single<Data, passDVF, on_error_fn<DEFN...>, passDDF, passDStpF, passDStrtF>;
Data,
passDVF, PUSHMI_TEMPLATE(class Data, class DDF)
on_error_fn<DEFN...>, (requires PUSHMI_EXP(defer::True<> PUSHMI_AND defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
passDDF, flow_single(Data d, DDF) ->
passDStpF, flow_single<Data, passDVF, passDEF, DDF, passDStpF, passDStrtF>;
passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DVF, class DEF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF)
(requires Receiver<Data> && !detail::is_v<DVF, on_error_fn> && (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_BROKEN_SUBSUMPTION(PUSHMI_AND not defer::Invocable<DEF&, Data&>)))
!detail::is_v<DVF, on_done_fn> && !detail::is_v<DEF, on_done_fn>) flow_single(Data d, DVF vf, DEF ef) ->
flow_single(Data d, DVF vf, DEF ef) flow_single<Data, DVF, DEF, passDDF, passDStpF, passDStrtF>;
-> flow_single<Data, DVF, DEF, passDDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class... DEFN, class DDF)
(requires Receiver<Data>)
flow_single(Data d, on_error_fn<DEFN...>, on_done_fn<DDF>)
-> flow_single<
Data,
passDVF,
on_error_fn<DEFN...>,
on_done_fn<DDF>,
passDStpF,
passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DDF) PUSHMI_TEMPLATE(class Data, class DEF, class DDF)
(requires Receiver<Data>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
flow_single(Data d, on_done_fn<DDF>) flow_single(Data d, DEF, DDF) ->
-> flow_single<Data, passDVF, passDEF, on_done_fn<DDF>, passDStpF, passDStrtF>; flow_single<Data, passDVF, DEF, DDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF)
(requires Receiver<Data> && Invocable<DDF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&>))
flow_single(Data d, DVF vf, DEF ef, DDF df) flow_single(Data d, DVF vf, DEF ef, DDF df) ->
-> flow_single<Data, DVF, DEF, DDF, passDStpF, passDStrtF>; flow_single<Data, DVF, DEF, DDF, passDStpF, passDStrtF>;
PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF) PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF)
(requires Receiver<Data> && Invocable<DDF&, Data&> && Invocable<DStpF&, Data&>) (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&> PUSHMI_AND defer::Invocable<DStpF&, Data&>))
flow_single(Data d, DVF vf, DEF ef, DDF df, DStpF stpf) flow_single(Data d, DVF vf, DEF ef, DDF df, DStpF stpf) ->
-> flow_single<Data, DVF, DEF, DDF, DStpF, passDStrtF>; flow_single<Data, DVF, DEF, DDF, DStpF, passDStrtF>;
PUSHMI_TEMPLATE( PUSHMI_TEMPLATE(class Data, class DVF, class DEF, class DDF, class DStpF, class DStrtF)
class Data, (requires PUSHMI_EXP(defer::Receiver<Data> PUSHMI_AND defer::Invocable<DDF&, Data&> PUSHMI_AND defer::Invocable<DStpF&, Data&>))
class DVF, flow_single(Data d, DVF vf, DEF ef, DDF df, DStpF stpf, DStrtF strtf) ->
class DEF, flow_single<Data, DVF, DEF, DDF, DStpF, DStrtF>;
class DDF,
class DStpF,
class DStrtF)
(requires Receiver<Data> && Invocable<DDF&, Data&> && Invocable<DStpF&, Data&>)
flow_single(Data d, DVF vf, DEF ef, DDF df, DStpF stpf, DStrtF strtf)
-> flow_single<Data, DVF, DEF, DDF, DStpF, DStrtF>;
#endif #endif
template <class V, class PE = std::exception_ptr, class E = PE> template <class V, class PE = std::exception_ptr, class E = PE>
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment