Diff coverage report for

//

//

// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)

// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.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_BUFFERS_STRING_DYNAMIC_BUFFER_HPP

#ifndef BOOST_CAPY_BUFFERS_STRING_DYNAMIC_BUFFER_HPP

#define BOOST_CAPY_BUFFERS_STRING_DYNAMIC_BUFFER_HPP

#define BOOST_CAPY_BUFFERS_STRING_DYNAMIC_BUFFER_HPP

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

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

#include <boost/capy/buffers.hpp>

#include <boost/capy/buffers.hpp>

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

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

#include <string>

#include <string>

namespace boost {

namespace boost {

namespace capy {

namespace capy {

/** A dynamic buffer backed by a `std::basic_string`.

/** A dynamic buffer backed by a `std::basic_string`.

    This adapter wraps an externally-owned string and

    This adapter wraps an externally-owned string and

    exposes it through the @ref DynamicBuffer interface.

    exposes it through the @ref DynamicBuffer interface.

    Readable bytes occupy the front of the string; writable

    Readable bytes occupy the front of the string; writable

    bytes are appended by `prepare` and made readable by

    bytes are appended by `prepare` and made readable by

    `commit`.

    `commit`.

    @note The wrapped string must outlive this adapter.

    @note The wrapped string must outlive this adapter.

        Calls to `prepare`, `commit`, and `consume`

        Calls to `prepare`, `commit`, and `consume`

        invalidate previously returned buffer views.

        invalidate previously returned buffer views.

    @par Thread Safety

    @par Thread Safety

    Distinct objects: Safe.

    Distinct objects: Safe.

    Shared objects: Unsafe.

    Shared objects: Unsafe.

    @par Example

    @par Example

    @code

    @code

    std::string s;

    std::string s;

    auto buf = dynamic_buffer( s, 4096 );

    auto buf = dynamic_buffer( s, 4096 );

    auto mb = buf.prepare( 100 );

    auto mb = buf.prepare( 100 );

    // fill mb with data...

    // fill mb with data...

    buf.commit( 100 );

    buf.commit( 100 );

    // buf.data() now has 100 readable bytes

    // buf.data() now has 100 readable bytes

    buf.consume( 50 );

    buf.consume( 50 );

    @endcode

    @endcode

    @tparam CharT The character type.

    @tparam CharT The character type.

    @tparam Traits The character traits type.

    @tparam Traits The character traits type.

    @tparam Allocator The allocator type.

    @tparam Allocator The allocator type.

    @see DynamicBuffer, string_dynamic_buffer, dynamic_buffer

    @see DynamicBuffer, string_dynamic_buffer, dynamic_buffer

*/

*/

template<

template<

    class CharT,

    class CharT,

    class Traits = std::char_traits<CharT>,

    class Traits = std::char_traits<CharT>,

    class Allocator = std::allocator<CharT>>

    class Allocator = std::allocator<CharT>>

class basic_string_dynamic_buffer

class basic_string_dynamic_buffer

{

{

    std::basic_string<

    std::basic_string<

        CharT, Traits, Allocator>* s_;

        CharT, Traits, Allocator>* s_;

    std::size_t max_size_;

    std::size_t max_size_;

    std::size_t in_size_ = 0;

    std::size_t in_size_ = 0;

    std::size_t out_size_ = 0;

    std::size_t out_size_ = 0;

public:

public:

    /// Indicates this is a DynamicBuffer adapter over external storage.

    /// Indicates this is a DynamicBuffer adapter over external storage.

    using is_dynamic_buffer_adapter = void;

    using is_dynamic_buffer_adapter = void;

    /// The underlying string type.

    /// The underlying string type.

    using string_type = std::basic_string<

    using string_type = std::basic_string<

        CharT, Traits, Allocator>;

        CharT, Traits, Allocator>;

    /// The ConstBufferSequence type for readable bytes.

    /// The ConstBufferSequence type for readable bytes.

    using const_buffers_type = const_buffer;

    using const_buffers_type = const_buffer;

    /// The MutableBufferSequence type for writable bytes.

    /// The MutableBufferSequence type for writable bytes.

    using mutable_buffers_type = mutable_buffer;

    using mutable_buffers_type = mutable_buffer;

    /// Destroy the buffer.

    /// Destroy the buffer.

    ~basic_string_dynamic_buffer() = default;

    ~basic_string_dynamic_buffer() = default;

    /// Construct by moving from another buffer.

    /// Construct by moving from another buffer.

        basic_string_dynamic_buffer&& other) noexcept

        basic_string_dynamic_buffer&& other) noexcept

    {

    {

    /** Construct from an existing string.

    /** Construct from an existing string.

        @param s Pointer to the string to wrap. Must

        @param s Pointer to the string to wrap. Must

            remain valid for the lifetime of this object.

            remain valid for the lifetime of this object.

        @param max_size Optional upper bound on the number

        @param max_size Optional upper bound on the number

            of bytes the buffer may hold.

            of bytes the buffer may hold.

    */

    */

    explicit

    explicit

        string_type* s,

        string_type* s,

        std::size_t max_size =

        std::size_t max_size =

            std::size_t(-1)) noexcept

            std::size_t(-1)) noexcept

    {

    {

    /// Copy assignment is deleted.

    /// Copy assignment is deleted.

    basic_string_dynamic_buffer& operator=(

    basic_string_dynamic_buffer& operator=(

        basic_string_dynamic_buffer const&) = delete;

        basic_string_dynamic_buffer const&) = delete;

    /// Return the number of readable bytes.

    /// Return the number of readable bytes.

    std::size_t

    std::size_t

    {

    {

    }

    }

    /// Return the maximum number of bytes the buffer can hold.

    /// Return the maximum number of bytes the buffer can hold.

    std::size_t

    std::size_t

    {

    {

    }

    }

    /// Return the number of writable bytes without reallocation.

    /// Return the number of writable bytes without reallocation.

    std::size_t

    std::size_t

    {

    {

    }

    }

    /// Return a buffer sequence representing the readable bytes.

    /// Return a buffer sequence representing the readable bytes.

    const_buffers_type

    const_buffers_type

    {

    {

    }

    }

    /** Prepare writable space of at least `n` bytes.

    /** Prepare writable space of at least `n` bytes.

        Invalidates iterators and references returned by

        Invalidates iterators and references returned by

        previous calls to `data` and `prepare`.

        previous calls to `data` and `prepare`.

        @throws std::invalid_argument if `n` exceeds

        @throws std::invalid_argument if `n` exceeds

            available space.

            available space.

        @param n The number of bytes to prepare.

        @param n The number of bytes to prepare.

        @return A mutable buffer of exactly `n` bytes.

        @return A mutable buffer of exactly `n` bytes.

    */

    */

    mutable_buffers_type

    mutable_buffers_type

    {

    {

        // n exceeds available space

        // n exceeds available space

    }

    }

    /** Move bytes from the writable to the readable area.

    /** Move bytes from the writable to the readable area.

        Invalidates iterators and references returned by

        Invalidates iterators and references returned by

        previous calls to `data` and `prepare`.

        previous calls to `data` and `prepare`.

        @param n The number of bytes to commit. Clamped

        @param n The number of bytes to commit. Clamped

            to the size of the writable area.

            to the size of the writable area.

    */

    */

    {

    {

        else

        else

    /** Remove bytes from the beginning of the readable area.

    /** Remove bytes from the beginning of the readable area.

        Invalidates iterators and references returned by

        Invalidates iterators and references returned by

        previous calls to `data` and `prepare`.

        previous calls to `data` and `prepare`.

        @param n The number of bytes to consume. Clamped

        @param n The number of bytes to consume. Clamped

            to the number of readable bytes.

            to the number of readable bytes.

    */

    */

    {

    {

        {

        {

        }

        }

        else

        else

        {

        {

        }

        }

};

};

/// A dynamic buffer using `std::string`.

/// A dynamic buffer using `std::string`.

using string_dynamic_buffer = basic_string_dynamic_buffer<char>;

using string_dynamic_buffer = basic_string_dynamic_buffer<char>;

/** Create a dynamic buffer from a string.

/** Create a dynamic buffer from a string.

    @param s The string to wrap.

    @param s The string to wrap.

    @param max_size Optional maximum size limit.

    @param max_size Optional maximum size limit.

    @return A string_dynamic_buffer wrapping the string.

    @return A string_dynamic_buffer wrapping the string.

*/

*/

template<class CharT, class Traits, class Allocator>

template<class CharT, class Traits, class Allocator>

basic_string_dynamic_buffer<CharT, Traits, Allocator>

basic_string_dynamic_buffer<CharT, Traits, Allocator>

    std::basic_string<CharT, Traits, Allocator>& s,

    std::basic_string<CharT, Traits, Allocator>& s,

    std::size_t max_size = std::size_t(-1))

    std::size_t max_size = std::size_t(-1))

{

{

}

}

} // capy

} // capy

} // boost

} // boost

#endif

#endif