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_MAKE_BUFFER_HPP

#ifndef BOOST_CAPY_BUFFERS_MAKE_BUFFER_HPP

#define BOOST_CAPY_BUFFERS_MAKE_BUFFER_HPP

#define BOOST_CAPY_BUFFERS_MAKE_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 <array>

#include <array>

#include <cstdlib>

#include <cstdlib>

#include <iterator>

#include <iterator>

#include <ranges>

#include <ranges>

#include <span>

#include <span>

#include <string>

#include <string>

#include <string_view>

#include <string_view>

#include <type_traits>

#include <type_traits>

#include <vector>

#include <vector>

BOOST_CAPY_MSVC_WARNING_PUSH

BOOST_CAPY_MSVC_WARNING_PUSH

BOOST_CAPY_MSVC_WARNING_DISABLE(4459)

BOOST_CAPY_MSVC_WARNING_DISABLE(4459)

namespace boost {

namespace boost {

namespace capy {

namespace capy {

/** Return a buffer.

/** Return a buffer.

*/

*/

[[nodiscard]] inline

[[nodiscard]] inline

mutable_buffer

mutable_buffer

    mutable_buffer const& b) noexcept

    mutable_buffer const& b) noexcept

{

{

}

}

/** Return a buffer with a maximum size.

/** Return a buffer with a maximum size.

*/

*/

[[nodiscard]] inline

[[nodiscard]] inline

mutable_buffer

mutable_buffer

    mutable_buffer const& b,

    mutable_buffer const& b,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

        b.data(),

        b.data(),

}

}

/** Return a buffer.

/** Return a buffer.

*/

*/

[[nodiscard]] inline

[[nodiscard]] inline

mutable_buffer

mutable_buffer

    void* data,

    void* data,

    std::size_t size) noexcept

    std::size_t size) noexcept

{

{

}

}

/** Return a buffer with a maximum size.

/** Return a buffer with a maximum size.

*/

*/

[[nodiscard]] inline

[[nodiscard]] inline

mutable_buffer

mutable_buffer

    void* data,

    void* data,

    std::size_t size,

    std::size_t size,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

        data,

        data,

}

}

/** Return a buffer.

/** Return a buffer.

*/

*/

[[nodiscard]] inline

[[nodiscard]] inline

const_buffer

const_buffer

    const_buffer const& b) noexcept

    const_buffer const& b) noexcept

{

{

}

}

/** Return a buffer with a maximum size.

/** Return a buffer with a maximum size.

*/

*/

[[nodiscard]] inline

[[nodiscard]] inline

const_buffer

const_buffer

    const_buffer const& b,

    const_buffer const& b,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

        b.data(),

        b.data(),

}

}

/** Return a buffer.

/** Return a buffer.

*/

*/

[[nodiscard]] inline

[[nodiscard]] inline

const_buffer

const_buffer

    void const* data,

    void const* data,

    std::size_t size) noexcept

    std::size_t size) noexcept

{

{

}

}

/** Return a buffer with a maximum size.

/** Return a buffer with a maximum size.

*/

*/

[[nodiscard]] inline

[[nodiscard]] inline

const_buffer

const_buffer

    void const* data,

    void const* data,

    std::size_t size,

    std::size_t size,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

        data,

        data,

}

}

/** Return a buffer from a C-style array.

/** Return a buffer from a C-style array.

*/

*/

template<class T, std::size_t N>

template<class T, std::size_t N>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    T (&data)[N]) noexcept

    T (&data)[N]) noexcept

{

{

}

}

/** Return a buffer from a C-style array with a maximum size.

/** Return a buffer from a C-style array with a maximum size.

*/

*/

template<class T, std::size_t N>

template<class T, std::size_t N>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    T (&data)[N],

    T (&data)[N],

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

        data,

        data,

}

}

/** Return a buffer from a const C-style array.

/** Return a buffer from a const C-style array.

*/

*/

template<class T, std::size_t N>

template<class T, std::size_t N>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    T const (&data)[N]) noexcept

    T const (&data)[N]) noexcept

{

{

}

}

/** Return a buffer from a const C-style array with a maximum size.

/** Return a buffer from a const C-style array with a maximum size.

*/

*/

template<class T, std::size_t N>

template<class T, std::size_t N>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    T const (&data)[N],

    T const (&data)[N],

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

        data,

        data,

}

}

// std::array

// std::array

/** Return a buffer from a std::array.

/** Return a buffer from a std::array.

*/

*/

template<class T, std::size_t N>

template<class T, std::size_t N>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    std::array<T, N>& data) noexcept

    std::array<T, N>& data) noexcept

{

{

}

}

/** Return a buffer from a std::array with a maximum size.

/** Return a buffer from a std::array with a maximum size.

*/

*/

template<class T, std::size_t N>

template<class T, std::size_t N>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    std::array<T, N>& data,

    std::array<T, N>& data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

/** Return a buffer from a const std::array.

/** Return a buffer from a const std::array.

*/

*/

template<class T, std::size_t N>

template<class T, std::size_t N>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::array<T, N> const& data) noexcept

    std::array<T, N> const& data) noexcept

{

{

}

}

/** Return a buffer from a const std::array with a maximum size.

/** Return a buffer from a const std::array with a maximum size.

*/

*/

template<class T, std::size_t N>

template<class T, std::size_t N>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::array<T, N> const& data,

    std::array<T, N> const& data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

// std::vector

// std::vector

/** Return a buffer from a std::vector.

/** Return a buffer from a std::vector.

*/

*/

template<class T, class Allocator>

template<class T, class Allocator>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    std::vector<T, Allocator>& data) noexcept

    std::vector<T, Allocator>& data) noexcept

{

{

}

}

/** Return a buffer from a std::vector with a maximum size.

/** Return a buffer from a std::vector with a maximum size.

*/

*/

template<class T, class Allocator>

template<class T, class Allocator>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    std::vector<T, Allocator>& data,

    std::vector<T, Allocator>& data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

/** Return a buffer from a const std::vector.

/** Return a buffer from a const std::vector.

*/

*/

template<class T, class Allocator>

template<class T, class Allocator>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::vector<T, Allocator> const& data) noexcept

    std::vector<T, Allocator> const& data) noexcept

{

{

}

}

/** Return a buffer from a const std::vector with a maximum size.

/** Return a buffer from a const std::vector with a maximum size.

*/

*/

template<class T, class Allocator>

template<class T, class Allocator>

    requires std::is_trivially_copyable_v<T>

    requires std::is_trivially_copyable_v<T>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::vector<T, Allocator> const& data,

    std::vector<T, Allocator> const& data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

// std::basic_string

// std::basic_string

/** Return a buffer from a std::basic_string.

/** Return a buffer from a std::basic_string.

*/

*/

template<class CharT, class Traits, class Allocator>

template<class CharT, class Traits, class Allocator>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    std::basic_string<CharT, Traits, Allocator>& data) noexcept

    std::basic_string<CharT, Traits, Allocator>& data) noexcept

{

{

}

}

/** Return a buffer from a std::basic_string with a maximum size.

/** Return a buffer from a std::basic_string with a maximum size.

*/

*/

template<class CharT, class Traits, class Allocator>

template<class CharT, class Traits, class Allocator>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

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

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

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

/** Return a buffer from a const std::basic_string.

/** Return a buffer from a const std::basic_string.

*/

*/

template<class CharT, class Traits, class Allocator>

template<class CharT, class Traits, class Allocator>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::basic_string<CharT, Traits, Allocator> const& data) noexcept

    std::basic_string<CharT, Traits, Allocator> const& data) noexcept

{

{

}

}

/** Return a buffer from a const std::basic_string with a maximum size.

/** Return a buffer from a const std::basic_string with a maximum size.

*/

*/

template<class CharT, class Traits, class Allocator>

template<class CharT, class Traits, class Allocator>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::basic_string<CharT, Traits, Allocator> const& data,

    std::basic_string<CharT, Traits, Allocator> const& data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

// std::basic_string_view

// std::basic_string_view

/** Return a buffer from a std::basic_string_view.

/** Return a buffer from a std::basic_string_view.

*/

*/

template<class CharT, class Traits>

template<class CharT, class Traits>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::basic_string_view<CharT, Traits> data) noexcept

    std::basic_string_view<CharT, Traits> data) noexcept

{

{

}

}

/** Return a buffer from a std::basic_string_view with a maximum size.

/** Return a buffer from a std::basic_string_view with a maximum size.

*/

*/

template<class CharT, class Traits>

template<class CharT, class Traits>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::basic_string_view<CharT, Traits> data,

    std::basic_string_view<CharT, Traits> data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

// std::span

// std::span

/** Return a buffer from a mutable std::span.

/** Return a buffer from a mutable std::span.

*/

*/

template<class T, std::size_t Extent>

template<class T, std::size_t Extent>

    requires (!std::is_const_v<T> && sizeof(T) == 1)

    requires (!std::is_const_v<T> && sizeof(T) == 1)

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    std::span<T, Extent> data) noexcept

    std::span<T, Extent> data) noexcept

{

{

}

}

/** Return a buffer from a mutable std::span with a maximum size.

/** Return a buffer from a mutable std::span with a maximum size.

*/

*/

template<class T, std::size_t Extent>

template<class T, std::size_t Extent>

    requires (!std::is_const_v<T> && sizeof(T) == 1)

    requires (!std::is_const_v<T> && sizeof(T) == 1)

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

    std::span<T, Extent> data,

    std::span<T, Extent> data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

/** Return a buffer from a const std::span.

/** Return a buffer from a const std::span.

*/

*/

template<class T, std::size_t Extent>

template<class T, std::size_t Extent>

    requires (sizeof(T) == 1)

    requires (sizeof(T) == 1)

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::span<T const, Extent> data) noexcept

    std::span<T const, Extent> data) noexcept

{

{

}

}

/** Return a buffer from a const std::span with a maximum size.

/** Return a buffer from a const std::span with a maximum size.

*/

*/

template<class T, std::size_t Extent>

template<class T, std::size_t Extent>

    requires (sizeof(T) == 1)

    requires (sizeof(T) == 1)

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

    std::span<T const, Extent> data,

    std::span<T const, Extent> data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

}

}

// Contiguous ranges

// Contiguous ranges

namespace detail {

namespace detail {

template<class T>

template<class T>

concept non_buffer_contiguous_range =

concept non_buffer_contiguous_range =

    std::ranges::contiguous_range<T> &&

    std::ranges::contiguous_range<T> &&

    std::ranges::sized_range<T> &&

    std::ranges::sized_range<T> &&

    !std::convertible_to<T, const_buffer> &&

    !std::convertible_to<T, const_buffer> &&

    !std::convertible_to<T, mutable_buffer> &&

    !std::convertible_to<T, mutable_buffer> &&

    std::is_trivially_copyable_v<std::ranges::range_value_t<T>>;

    std::is_trivially_copyable_v<std::ranges::range_value_t<T>>;

template<class T>

template<class T>

concept mutable_contiguous_range =

concept mutable_contiguous_range =

    non_buffer_contiguous_range<T> &&

    non_buffer_contiguous_range<T> &&

    !std::is_const_v<std::remove_reference_t<

    !std::is_const_v<std::remove_reference_t<

        std::ranges::range_reference_t<T>>>;

        std::ranges::range_reference_t<T>>>;

template<class T>

template<class T>

concept const_contiguous_range =

concept const_contiguous_range =

    non_buffer_contiguous_range<T> &&

    non_buffer_contiguous_range<T> &&

    std::is_const_v<std::remove_reference_t<

    std::is_const_v<std::remove_reference_t<

        std::ranges::range_reference_t<T>>>;

        std::ranges::range_reference_t<T>>>;

} // detail

} // detail

/** Return a buffer from a mutable contiguous range.

/** Return a buffer from a mutable contiguous range.

*/

*/

template<detail::mutable_contiguous_range T>

template<detail::mutable_contiguous_range T>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

make_buffer(T& data) noexcept

make_buffer(T& data) noexcept

{

{

    return mutable_buffer(

    return mutable_buffer(

        std::ranges::size(data) ? std::ranges::data(data) : nullptr,

        std::ranges::size(data) ? std::ranges::data(data) : nullptr,

        std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>));

        std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>));

}

}

/** Return a buffer from a mutable contiguous range with a maximum size.

/** Return a buffer from a mutable contiguous range with a maximum size.

*/

*/

template<detail::mutable_contiguous_range T>

template<detail::mutable_contiguous_range T>

[[nodiscard]]

[[nodiscard]]

mutable_buffer

mutable_buffer

make_buffer(

make_buffer(

    T& data,

    T& data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

    auto const n = std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>);

    auto const n = std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>);

    return mutable_buffer(

    return mutable_buffer(

        std::ranges::size(data) ? std::ranges::data(data) : nullptr,

        std::ranges::size(data) ? std::ranges::data(data) : nullptr,

        n < max_size ? n : max_size);

        n < max_size ? n : max_size);

}

}

/** Return a buffer from a const contiguous range.

/** Return a buffer from a const contiguous range.

*/

*/

template<detail::non_buffer_contiguous_range T>

template<detail::non_buffer_contiguous_range T>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

make_buffer(T const& data) noexcept

make_buffer(T const& data) noexcept

{

{

    return const_buffer(

    return const_buffer(

        std::ranges::size(data) ? std::ranges::data(data) : nullptr,

        std::ranges::size(data) ? std::ranges::data(data) : nullptr,

        std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>));

        std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>));

}

}

/** Return a buffer from a const contiguous range with a maximum size.

/** Return a buffer from a const contiguous range with a maximum size.

*/

*/

template<detail::non_buffer_contiguous_range T>

template<detail::non_buffer_contiguous_range T>

[[nodiscard]]

[[nodiscard]]

const_buffer

const_buffer

make_buffer(

make_buffer(

    T const& data,

    T const& data,

    std::size_t max_size) noexcept

    std::size_t max_size) noexcept

{

{

    auto const n = std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>);

    auto const n = std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>);

    return const_buffer(

    return const_buffer(

        std::ranges::size(data) ? std::ranges::data(data) : nullptr,

        std::ranges::size(data) ? std::ranges::data(data) : nullptr,

        n < max_size ? n : max_size);

        n < max_size ? n : max_size);

}

}

} // capy

} // capy

} // boost

} // boost

BOOST_CAPY_MSVC_WARNING_POP

BOOST_CAPY_MSVC_WARNING_POP