Diff coverage report for

//

//

// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)

// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/cppalliance/capy

// Official repository: https://github.com/cppalliance/capy

//

//

#ifndef BOOST_CAPY_IO_ANY_STREAM_HPP

#ifndef BOOST_CAPY_IO_ANY_STREAM_HPP

#define BOOST_CAPY_IO_ANY_STREAM_HPP

#define BOOST_CAPY_IO_ANY_STREAM_HPP

#include <boost/capy/detail/config.hpp>

#include <boost/capy/detail/config.hpp>

#include <boost/capy/concept/read_stream.hpp>

#include <boost/capy/concept/read_stream.hpp>

#include <boost/capy/concept/write_stream.hpp>

#include <boost/capy/concept/write_stream.hpp>

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

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

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

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

#include <concepts>

#include <concepts>

namespace boost {

namespace boost {

namespace capy {

namespace capy {

/** Type-erased wrapper for bidirectional streams.

/** Type-erased wrapper for bidirectional streams.

    This class provides type erasure for any type satisfying both

    This class provides type erasure for any type satisfying both

    the @ref ReadStream and @ref WriteStream concepts, enabling

    the @ref ReadStream and @ref WriteStream concepts, enabling

    runtime polymorphism for bidirectional I/O operations.

    runtime polymorphism for bidirectional I/O operations.

    Inherits from both @ref any_read_stream and @ref any_write_stream,

    Inherits from both @ref any_read_stream and @ref any_write_stream,

    providing `read_some` and `write_some` operations. Each base

    providing `read_some` and `write_some` operations. Each base

    maintains its own cached awaitable storage, allowing concurrent

    maintains its own cached awaitable storage, allowing concurrent

    read and write operations.

    read and write operations.

    The wrapper supports two construction modes:

    The wrapper supports two construction modes:

    - **Owning**: Pass by value to transfer ownership. The wrapper

    - **Owning**: Pass by value to transfer ownership. The wrapper

      allocates storage and owns the stream.

      allocates storage and owns the stream.

    - **Reference**: Pass a pointer to wrap without ownership. The

    - **Reference**: Pass a pointer to wrap without ownership. The

      pointed-to stream must outlive this wrapper.

      pointed-to stream must outlive this wrapper.

    @par Implicit Conversion

    @par Implicit Conversion

    This class implicitly converts to `any_read_stream&` or

    This class implicitly converts to `any_read_stream&` or

    `any_write_stream&`, allowing it to be passed to functions

    `any_write_stream&`, allowing it to be passed to functions

    that accept only one capability. However, do not move through

    that accept only one capability. However, do not move through

    a base reference as this would leave the other base in an

    a base reference as this would leave the other base in an

    invalid state.

    invalid state.

    @par Thread Safety

    @par Thread Safety

    Not thread-safe. Concurrent operations of the same type

    Not thread-safe. Concurrent operations of the same type

    (two reads or two writes) are undefined behavior. One read

    (two reads or two writes) are undefined behavior. One read

    and one write may be in flight simultaneously.

    and one write may be in flight simultaneously.

    @par Example

    @par Example

    @code

    @code

    // Owning - takes ownership of the stream

    // Owning - takes ownership of the stream

    any_stream stream(socket{ioc});

    any_stream stream(socket{ioc});

    // Reference - wraps without ownership

    // Reference - wraps without ownership

    socket sock(ioc);

    socket sock(ioc);

    any_stream stream(&sock);

    any_stream stream(&sock);

    // Use read_some from any_read_stream base

    // Use read_some from any_read_stream base

    mutable_buffer rbuf(rdata, rsize);

    mutable_buffer rbuf(rdata, rsize);

    auto [ec1, n1] = co_await stream.read_some(std::span(&rbuf, 1));

    auto [ec1, n1] = co_await stream.read_some(std::span(&rbuf, 1));

    // Use write_some from any_write_stream base

    // Use write_some from any_write_stream base

    const_buffer wbuf(wdata, wsize);

    const_buffer wbuf(wdata, wsize);

    auto [ec2, n2] = co_await stream.write_some(std::span(&wbuf, 1));

    auto [ec2, n2] = co_await stream.write_some(std::span(&wbuf, 1));

    // Pass to functions expecting one capability

    // Pass to functions expecting one capability

    void reader(any_read_stream&);

    void reader(any_read_stream&);

    void writer(any_write_stream&);

    void writer(any_write_stream&);

    reader(stream);  // Implicit upcast

    reader(stream);  // Implicit upcast

    writer(stream);  // Implicit upcast

    writer(stream);  // Implicit upcast

    @endcode

    @endcode

    @see any_read_stream, any_write_stream, ReadStream, WriteStream

    @see any_read_stream, any_write_stream, ReadStream, WriteStream

*/

*/

class any_stream

class any_stream

    : public any_read_stream

    : public any_read_stream

    , public any_write_stream

    , public any_write_stream

{

{

    void* storage_ = nullptr;

    void* storage_ = nullptr;

    void* stream_ptr_ = nullptr;

    void* stream_ptr_ = nullptr;

    void (*destroy_)(void*) noexcept = nullptr;

    void (*destroy_)(void*) noexcept = nullptr;

public:

public:

    /** Destructor.

    /** Destructor.

        Destroys the owned stream (if any). Base class destructors

        Destroys the owned stream (if any). Base class destructors

        handle their cached awaitable storage.

        handle their cached awaitable storage.

    */

    */

    {

    {

        {

        {

        }

        }

    /** Default constructor.

    /** Default constructor.

        Constructs an empty wrapper. Operations on a default-constructed

        Constructs an empty wrapper. Operations on a default-constructed

        wrapper result in undefined behavior.

        wrapper result in undefined behavior.

    */

    */

    any_stream() = default;

    any_stream() = default;

    /** Non-copyable.

    /** Non-copyable.

        The awaitable caches are per-instance and cannot be shared.

        The awaitable caches are per-instance and cannot be shared.

    */

    */

    any_stream(any_stream const&) = delete;

    any_stream(any_stream const&) = delete;

    any_stream& operator=(any_stream const&) = delete;

    any_stream& operator=(any_stream const&) = delete;

    /** Move constructor.

    /** Move constructor.

        Transfers ownership from both bases and the owned stream (if any).

        Transfers ownership from both bases and the owned stream (if any).

        @param other The wrapper to move from.

        @param other The wrapper to move from.

    */

    */

    {

    {

    /** Move assignment operator.

    /** Move assignment operator.

        Destroys any owned stream and releases existing resources,

        Destroys any owned stream and releases existing resources,

        then transfers ownership from `other`.

        then transfers ownership from `other`.

        @param other The wrapper to move from.

        @param other The wrapper to move from.

        @return Reference to this wrapper.

        @return Reference to this wrapper.

    */

    */

    any_stream&

    any_stream&

    {

    {

        {

        {

            {

            {

            }

            }

            static_cast<any_read_stream&>(*this) =

            static_cast<any_read_stream&>(*this) =

            static_cast<any_write_stream&>(*this) =

            static_cast<any_write_stream&>(*this) =

        }

        }

    }

    }

    /** Construct by taking ownership of a bidirectional stream.

    /** Construct by taking ownership of a bidirectional stream.

        Allocates storage and moves the stream into this wrapper.

        Allocates storage and moves the stream into this wrapper.

        The wrapper owns the stream and will destroy it.

        The wrapper owns the stream and will destroy it.

        @param s The stream to take ownership of. Must satisfy both

        @param s The stream to take ownership of. Must satisfy both

            ReadStream and WriteStream concepts.

            ReadStream and WriteStream concepts.

    */

    */

    template<class S>

    template<class S>

        requires ReadStream<S> && WriteStream<S> &&

        requires ReadStream<S> && WriteStream<S> &&

            (!std::same_as<std::decay_t<S>, any_stream>)

            (!std::same_as<std::decay_t<S>, any_stream>)

        struct guard {

        struct guard {

            any_stream* self;

            any_stream* self;

            void* ptr = nullptr;

            void* ptr = nullptr;

            bool committed = false;

            bool committed = false;

                }

                }

        // Initialize bases with pointer (reference semantics)

        // Initialize bases with pointer (reference semantics)

    /** Construct by wrapping a bidirectional stream without ownership.

    /** Construct by wrapping a bidirectional stream without ownership.

        Wraps the given stream by pointer. The stream must remain

        Wraps the given stream by pointer. The stream must remain

        valid for the lifetime of this wrapper.

        valid for the lifetime of this wrapper.

        @param s Pointer to the stream to wrap. Must satisfy both

        @param s Pointer to the stream to wrap. Must satisfy both

            ReadStream and WriteStream concepts.

            ReadStream and WriteStream concepts.

    */

    */

    template<class S>

    template<class S>

        requires ReadStream<S> && WriteStream<S>

        requires ReadStream<S> && WriteStream<S>

        : any_read_stream(s)

        : any_read_stream(s)

    {

    {

        // storage_ remains nullptr - no ownership

        // storage_ remains nullptr - no ownership

    /** Check if the wrapper contains a valid stream.

    /** Check if the wrapper contains a valid stream.

        Both bases must be valid for the wrapper to be valid.

        Both bases must be valid for the wrapper to be valid.

        @return `true` if wrapping a stream, `false` if default-constructed

        @return `true` if wrapping a stream, `false` if default-constructed

            or moved-from.

            or moved-from.

    */

    */

    bool

    bool

    {

    {

    }

    }

    /** Check if the wrapper contains a valid stream.

    /** Check if the wrapper contains a valid stream.

        Both bases must be valid for the wrapper to be valid.

        Both bases must be valid for the wrapper to be valid.

        @return `true` if wrapping a stream, `false` if default-constructed

        @return `true` if wrapping a stream, `false` if default-constructed

            or moved-from.

            or moved-from.

    */

    */

    explicit

    explicit

    {

    {

    }

    }

};

};

} // namespace capy

} // namespace capy

} // namespace boost

} // namespace boost

#endif

#endif