sender_operations.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "condy/concepts.hpp"
#include "condy/senders.hpp"
#include <stdexcept>
 
namespace condy {
 
template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler>
auto build_op_sender(PrepFunc &&prep_func, CQEHandler &&cqe_handler) {
    return OpSender<std::decay_t<PrepFunc>, std::decay_t<CQEHandler>>(
        std::forward<PrepFunc>(prep_func),
        std::forward<CQEHandler>(cqe_handler));
}
 
template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler,
          typename MultiShotFunc>
auto build_multishot_op_sender(PrepFunc &&func, CQEHandler &&cqe_handler,
                               MultiShotFunc &&multishot_func) {
    return MultiShotOpSender<std::decay_t<PrepFunc>, std::decay_t<CQEHandler>,
                             std::decay_t<MultiShotFunc>>(
        std::forward<PrepFunc>(func), std::forward<CQEHandler>(cqe_handler),
        std::forward<MultiShotFunc>(multishot_func));
}
 
template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler, typename FreeFunc>
auto build_zero_copy_op_sender(PrepFunc &&func, CQEHandler &&cqe_handler,
                               FreeFunc &&free_func) {
    return ZeroCopyOpSender<std::decay_t<PrepFunc>, std::decay_t<CQEHandler>,
                            std::decay_t<FreeFunc>>(
        std::forward<PrepFunc>(func), std::forward<CQEHandler>(cqe_handler),
        std::forward<FreeFunc>(free_func));
}

template <unsigned int Flags, typename Sender> auto flag(Sender &&sender) {
    return FlaggedOpSender<Flags, std::decay_t<Sender>>(
        std::forward<Sender>(sender));
}

template <typename Sender> auto drain(Sender &&sender) {
    return flag<IOSQE_IO_DRAIN>(std::forward<Sender>(sender));
}

template <typename Sender> auto always_async(Sender &&sender) {
    return flag<IOSQE_ASYNC>(std::forward<Sender>(sender));
}

template <template <typename... Senders> typename SenderType,
          typename... Senders>
auto parallel(Senders &&...senders) {
    return SenderType<std::decay_t<Senders>...>(
        std::forward<Senders>(senders)...);
}

template <template <typename Sender> typename RangedSenderType,
          std::ranges::range Range>
auto parallel(Range &&range) {
    using SenderType = typename std::remove_cvref_t<Range>::value_type;
    auto begin = std::make_move_iterator(std::begin(range));
    auto end = std::make_move_iterator(std::end(range));
    std::vector<SenderType> senders(begin, end);
    return RangedSenderType<SenderType>(std::move(senders));
}

template <typename... Senders> auto when_all(Senders &&...senders) {
    return parallel<WhenAllSender>(std::forward<Senders>(senders)...);
}

template <std::ranges::range Range> auto when_all(Range &&range) {
    return parallel<RangedWhenAllSender>(std::forward<Range>(range));
}

template <typename... Senders> auto when_any(Senders &&...senders) {
    static_assert(sizeof...(Senders) > 0,
                  "when_any requires at least one sender");
    return parallel<WhenAnySender>(std::forward<Senders>(senders)...);
}

template <std::ranges::range Range> auto when_any(Range &&range) {
    if (std::ranges::empty(range)) {
        throw std::invalid_argument("when_any requires at least one sender");
    }
    return parallel<RangedWhenAnySender>(std::forward<Range>(range));
}

template <typename... Senders> auto link(Senders &&...senders) {
    return parallel<LinkSender>(std::forward<Senders>(senders)...);
}

template <std::ranges::range Range> auto link(Range &&range) {
    return parallel<RangedLinkSender>(std::forward<Range>(range));
}

template <typename... Senders> auto hard_link(Senders &&...senders) {
    return parallel<HardLinkSender>(std::forward<Senders>(senders)...);
}

template <std::ranges::range Range> auto hard_link(Range &&range) {
    return parallel<RangedHardLinkSender>(std::forward<Range>(range));
}

namespace operators {

template <typename Sender1, typename Sender2>
auto operator&&(Sender1 s1, Sender2 s2) {
    return when_all(std::move(s1), std::move(s2));
}

template <typename S, typename... Ss>
auto operator&&(WhenAllSender<Ss...> aws, S sender) {
    return WhenAllSender<Ss..., std::decay_t<S>>(std::move(aws),
                                                 std::move(sender));
}

template <typename Sender1, typename Sender2>
auto operator||(Sender1 s1, Sender2 s2) {
    return when_any(std::move(s1), std::move(s2));
}

template <typename S, typename... Ss>
auto operator||(WhenAnySender<Ss...> aws, S sender) {
    return WhenAnySender<Ss..., std::decay_t<S>>(std::move(aws),
                                                 std::move(sender));
}

template <typename Sender1, typename Sender2>
auto operator>>(Sender1 s1, Sender2 s2) {
    return link(std::move(s1), std::move(s2));
}

template <typename S, typename... Ss>
auto operator>>(LinkSender<Ss...> aws, S sender) {
    return LinkSender<Ss..., std::decay_t<S>>(std::move(aws),
                                              std::move(sender));
}
 
} // namespace operators
 
} // namespace condy