I/O Streams

template<typename T>
concept ReadStream = requires(T& stream, MutableBufferSequence auto buffers)
{
    { stream.read_some(buffers) } -> IoAwaitable;
    // Returns io_result<std::size_t>
};

template<typename T>
concept WriteStream = requires(T& stream, ConstBufferSequence auto buffers)
{
    { stream.write_some(buffers) } -> IoAwaitable;
    // Returns io_result<std::size_t>
};

template<typename T>
concept ReadSource = requires(T& source, MutableBufferSequence auto buffers)
{
    { source.read(buffers) } -> IoAwaitable;
    // Returns io_result<std::size_t>
};

template<typename T>
concept WriteSink = requires(T& sink, ConstBufferSequence auto buffers, bool eof)
{
    { sink.write(buffers) } -> IoAwaitable;        // Write all bytes
    { sink.write(buffers, eof) } -> IoAwaitable;   // Write + optional EOF
    { sink.write_eof() } -> IoAwaitable;           // Signal end of data
};

template<typename T>
concept BufferSource = requires(T& src, const_buffer* arr, std::size_t max_count)
{
    { src.pull(arr, max_count) } -> IoAwaitable;
    // Returns io_result<std::size_t> where size_t is buffer count
};

template<typename T>
concept BufferSink = requires(T& sink, mutable_buffer* arr, std::size_t max_count,
                              std::size_t n, bool eof)
{
    { sink.prepare(arr, max_count) } -> std::convertible_to<std::size_t>;  // Sync
    { sink.commit(n) } -> IoAwaitable;           // Commit n bytes
    { sink.commit(n, eof) } -> IoAwaitable;      // Commit + optional EOF
    { sink.commit_eof() } -> IoAwaitable;        // Signal end of data
};

#include <boost/capy/read.hpp>

// Read into fixed buffers (loops read_some until full)
auto [ec, n] = co_await read(stream, buffers);

// Read into dynamic buffer (loops until EOF)
auto [ec, n] = co_await read(source, dynamic_buffer);

#include <boost/capy/write.hpp>

// Write all data (loops write_some until empty)
auto [ec, n] = co_await write(stream, buffers);

#include <boost/capy/io/push_to.hpp>

// BufferSource to WriteSink (complete transfer with EOF)
auto [ec, n] = co_await push_to(buffer_source, write_sink);

// BufferSource to WriteStream (streaming transfer)
auto [ec, n] = co_await push_to(buffer_source, write_stream);

#include <boost/capy/io/pull_from.hpp>

// ReadSource to BufferSink (complete reads)
auto [ec, n] = co_await pull_from(read_source, buffer_sink);

// ReadStream to BufferSink (streaming with partial reads)
auto [ec, n] = co_await pull_from(read_stream, buffer_sink);

#include <boost/capy/io/any_stream.hpp>

task<> echo(any_stream& stream)
{
    char buffer[4096];
    for (;;)
    {
        auto [ec, n] = co_await stream.read_some(make_buffer(buffer));
        if (ec == cond::eof)
            break;
        if (ec.failed())
            co_return;

        auto [wec, wn] = co_await write(stream, make_buffer(buffer, n));
        if (wec.failed())
            co_return;
    }
}

// Works with any bidirectional stream
task<> handle_tcp(tcp_socket& sock)
{
    any_stream stream(sock);
    co_await echo(stream);
}

task<> handle_tls(tls_stream& tls)
{
    any_stream stream(tls);
    co_await echo(stream);
}

#include <boost/capy/io/owning.hpp>

// Create an owning wrapper
owning<any_buffer_source, my_source> src(constructor_arg1, constructor_arg2);

// src IS-A any_buffer_source
any_buffer_source& ref = src;

// Access the owned object
my_source& s = src.get();

// Factory function returning owned source
owning<any_buffer_source, file_source> make_file_source(std::string_view path)
{
    return owning<any_buffer_source, file_source>(path);
}

task<> process_file(std::string_view path)
{
    auto src = make_file_source(path);

    // Use as any_buffer_source
    auto [ec, n] = co_await push_to(src, some_sink);
}

task<> echo_server(any_stream& stream)
{
    char buffer[4096];
    for (;;)
    {
        // Partial read: get whatever is available
        auto [ec, n] = co_await stream.read_some(make_buffer(buffer));
        if (ec == cond::eof)
            break;
        if (ec.failed())
            co_return;

        // Complete write: send all bytes
        auto [wec, _] = co_await write(stream, make_buffer(buffer, n));
        if (wec.failed())
            co_return;
    }
}

task<> send_response_body(any_write_sink& body, std::string_view content)
{
    // Write all content and signal EOF
    auto [ec, n] = co_await body.write(make_buffer(content), true);
    if (ec.failed())
    {
        // Handle error
    }
}

// Library code - transport independent
class protocol_handler
{
    any_stream& stream_;

public:
    explicit protocol_handler(any_stream& s)
        : stream_(s)
    {
    }

    task<> run()
    {
        // Works with any stream type
        auto [ec, n] = co_await stream_.read_some(/*...*/);
        // ...
    }
};

// Application code - concrete transport
task<> handle_client(tcp_socket& sock)
{
    any_stream stream(sock);
    protocol_handler handler(stream);
    co_await handler.run();
}