channel_v2.h

#pragma once
 
namespace resumef
{
#ifndef DOXYGEN_SKIP_PROPERTY
namespace detail
{
    template<class _Ty, class _Opty>
    struct channel_impl_v2;
}   //namespace detail
 
inline namespace channel_v2
{
#endif  //DOXYGEN_SKIP_PROPERTY
 
    template<class _Ty = bool, bool _Optional = !std::is_trivial_v<_Ty>, bool _OptimizationThread = false>
    struct channel_t
    {
        static_assert((std::is_copy_constructible_v<_Ty>&& std::is_copy_assignable_v<_Ty>) ||
            (std::is_move_constructible_v<_Ty> && std::is_move_assignable_v<_Ty>));
 
        struct [[nodiscard]] read_awaiter;
        struct [[nodiscard]] write_awaiter;
 
        channel_t(size_t cache_size = 1);
 
        size_t capacity() const noexcept;
 
        read_awaiter operator co_await() const noexcept;
 
        read_awaiter read() const noexcept;
 
        template<class U
#ifndef DOXYGEN_SKIP_PROPERTY
            COMMA_RESUMEF_ENABLE_IF(std::is_constructible_v<value_type, U&&>)
#endif  //DOXYGEN_SKIP_PROPERTY
        >
#ifndef DOXYGEN_SKIP_PROPERTY
        RESUMEF_REQUIRES(std::is_constructible_v<_Ty, U&&>)
#endif  //DOXYGEN_SKIP_PROPERTY
        write_awaiter operator << (U&& val) const noexcept(std::is_move_constructible_v<U>);
 
        template<class U
#ifndef DOXYGEN_SKIP_PROPERTY
            COMMA_RESUMEF_ENABLE_IF(std::is_constructible_v<value_type, U&&>)
#endif  //DOXYGEN_SKIP_PROPERTY
        >
#ifndef DOXYGEN_SKIP_PROPERTY
        RESUMEF_REQUIRES(std::is_constructible_v<_Ty, U&&>)
#endif  //DOXYGEN_SKIP_PROPERTY
        write_awaiter write(U&& val) const noexcept(std::is_move_constructible_v<U>);
 
 
#ifndef DOXYGEN_SKIP_PROPERTY
        using value_type = _Ty;
 
        static constexpr bool use_optional = _Optional;
        static constexpr bool optimization_for_multithreading = _OptimizationThread;
 
        using optional_type = std::conditional_t<use_optional, std::optional<value_type>, value_type>;
        using channel_type = detail::channel_impl_v2<value_type, optional_type>;
        using lock_type = typename channel_type::lock_type;
 
        channel_t(const channel_t&) = default;
        channel_t(channel_t&&) = default;
        channel_t& operator = (const channel_t&) = default;
        channel_t& operator = (channel_t&&) = default;
    private:
        std::shared_ptr<channel_type> _chan;
#endif  //DOXYGEN_SKIP_PROPERTY
    };
 
 
#ifndef DOXYGEN_SKIP_PROPERTY
    //不支持channel_t<void>
    template<bool _Option, bool _OptimizationThread>
    struct channel_t<void, _Option, _OptimizationThread>
    {
    };
#endif  //DOXYGEN_SKIP_PROPERTY
 
    using semaphore_t = channel_t<bool, false, true>;
 
}   //namespace channel_v2
}   //namespace resumef