async_stream.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_ASYNC_STREAM_HPP__
#define NEFORCE_CORE_ASYNC_ASYNC_STREAM_HPP__

 
#include "NeForce/core/async/cancellation_slot.hpp"
#include "NeForce/core/async/use_awaitable.hpp"
#include "NeForce/core/async/io_context.hpp"
#include "NeForce/core/memory/buffer.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API async_stream {
public:
    virtual ~async_stream() = default;

    virtual void async_read(io_context& ctx, memory_view<char> buffer, function<void(error_code, size_t)> handler) = 0;

    virtual void async_read(io_context& ctx, memory_view<char> buffer, cancellation_slot& slot,
                            function<void(error_code, size_t)> handler) = 0;

    virtual void async_write(io_context& ctx, memory_view<const char> buffer,
                             function<void(error_code, size_t)> handler) = 0;

    virtual void async_write(io_context& ctx, memory_view<const char> buffer, cancellation_slot& slot,
                             function<void(error_code, size_t)> handler) = 0;

    template <typename Token, enable_if_t<!is_same_v<decay_t<Token>, function<void(error_code, size_t)>>, int> = 0>
    void async_read(io_context& ctx, memory_view<char> buffer, Token&& token) {
        async_read(ctx, buffer, function<void(error_code, size_t)>(forward<Token>(token)));
    }

    auto async_read(io_context& ctx, memory_view<char> buffer, use_future_t /*unused*/) {
        async_result<use_future_t, void(error_code, size_t)> result(use_future);
        async_read(ctx, buffer, function<void(error_code, size_t)>(result.get_handler()));
        return result.get();
    }

    void async_read(io_context& ctx, memory_view<char> buffer, detached_t /*unused*/) {
        async_read(ctx, buffer, function<void(error_code, size_t)>([](error_code, size_t) {}));
    }
 
#ifdef NEFORCE_STANDARD_20
    auto async_read(io_context& ctx, memory_view<char> buffer, use_awaitable_t /*unused*/) {
        async_result<use_awaitable_t, void(error_code, size_t)> result(use_awaitable);
        async_read(ctx, buffer, function<void(error_code, size_t)>(result.get_handler()));
        return result.get();
    }
#endif

    template <typename Token, enable_if_t<!is_same_v<decay_t<Token>, function<void(error_code, size_t)>>, int> = 0>
    void async_write(io_context& ctx, memory_view<const char> buffer, Token&& token) {
        async_write(ctx, buffer, function<void(error_code, size_t)>(forward<Token>(token)));
    }

    auto async_write(io_context& ctx, memory_view<const char> buffer, use_future_t /*unused*/) {
        async_result<use_future_t, void(error_code, size_t)> result(use_future);
        async_write(ctx, buffer, function<void(error_code, size_t)>(result.get_handler()));
        return result.get();
    }

    void async_write(io_context& ctx, memory_view<const char> buffer, detached_t /*unused*/) {
        async_write(ctx, buffer, function<void(error_code, size_t)>([](error_code, size_t) {}));
    }
 
#ifdef NEFORCE_STANDARD_20
    auto async_write(io_context& ctx, memory_view<const char> buffer, use_awaitable_t /*unused*/) {
        async_result<use_awaitable_t, void(error_code, size_t)> result(use_awaitable);
        async_write(ctx, buffer, function<void(error_code, size_t)>(result.get_handler()));
        return result.get();
    }
#endif

    void async_read(io_context& ctx, mutable_buffers& bufs, function<void(error_code, size_t)> handler);

    void async_write(io_context& ctx, const_buffers& bufs, function<void(error_code, size_t)> handler);

    void async_read(io_context& ctx, dynamic_buffer& buf, size_t n, function<void(error_code, size_t)> handler) {
        auto region = buf.prepare(n);
        async_read(ctx, region, [&buf, h = move(handler)](error_code ec, size_t bytes) mutable {
            if (!ec) {
                buf.commit(bytes);
            }
            h(ec, bytes);
        });
    }
};
 // AsyncStream
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_ASYNC_STREAM_HPP__