1   
//
1   
//
2   
// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
2   
// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
3   
//
3   
//
4   
// Distributed under the Boost Software License, Version 1.0. (See accompanying
4   
// Distributed under the Boost Software License, Version 1.0. (See accompanying
5   
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5   
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6   
//
6   
//
7   
// Official repository: https://github.com/cppalliance/capy
7   
// Official repository: https://github.com/cppalliance/capy
8   
//
8   
//
9  
9  
10   
#ifndef BOOST_CAPY_BUFFERS_MAKE_BUFFER_HPP
10   
#ifndef BOOST_CAPY_BUFFERS_MAKE_BUFFER_HPP
11   
#define BOOST_CAPY_BUFFERS_MAKE_BUFFER_HPP
11   
#define BOOST_CAPY_BUFFERS_MAKE_BUFFER_HPP
12  
12  
13   
#include <boost/capy/detail/config.hpp>
13   
#include <boost/capy/detail/config.hpp>
14   
#include <boost/capy/buffers.hpp>
14   
#include <boost/capy/buffers.hpp>
15   
#include <array>
15   
#include <array>
16   
#include <cstdlib>
16   
#include <cstdlib>
17   
#include <iterator>
17   
#include <iterator>
18   
#include <ranges>
18   
#include <ranges>
19   
#include <span>
19   
#include <span>
20   
#include <string>
20   
#include <string>
21   
#include <string_view>
21   
#include <string_view>
22   
#include <type_traits>
22   
#include <type_traits>
23   
#include <vector>
23   
#include <vector>
24  
24  
25 - 
#ifdef _MSC_VER
25 + 
BOOST_CAPY_MSVC_WARNING_PUSH
26 - 
#pragma warning(push)
26 + 
BOOST_CAPY_MSVC_WARNING_DISABLE(4459)
27 - 
#pragma warning(disable: 4459)
 
28 - 
#endif
 
29  
27  
30   
namespace boost {
28   
namespace boost {
31   
namespace capy {
29   
namespace capy {
32  
30  
33   
/** Return a buffer.
31   
/** Return a buffer.
34   
*/
32   
*/
35   
[[nodiscard]] inline
33   
[[nodiscard]] inline
36   
mutable_buffer
34   
mutable_buffer
37   
make_buffer(
35   
make_buffer(
38   
    mutable_buffer const& b) noexcept
36   
    mutable_buffer const& b) noexcept
39   
{
37   
{
40   
    return b;
38   
    return b;
41   
}
39   
}
42  
40  
43   
/** Return a buffer with a maximum size.
41   
/** Return a buffer with a maximum size.
44   
*/
42   
*/
45   
[[nodiscard]] inline
43   
[[nodiscard]] inline
46   
mutable_buffer
44   
mutable_buffer
47   
make_buffer(
45   
make_buffer(
48   
    mutable_buffer const& b,
46   
    mutable_buffer const& b,
49   
    std::size_t max_size) noexcept
47   
    std::size_t max_size) noexcept
50   
{
48   
{
51   
    return mutable_buffer(
49   
    return mutable_buffer(
52   
        b.data(),
50   
        b.data(),
53   
        b.size() < max_size ? b.size() : max_size);
51   
        b.size() < max_size ? b.size() : max_size);
54   
}
52   
}
55  
53  
56   
/** Return a buffer.
54   
/** Return a buffer.
57   
*/
55   
*/
58   
[[nodiscard]] inline
56   
[[nodiscard]] inline
59   
mutable_buffer
57   
mutable_buffer
60   
make_buffer(
58   
make_buffer(
61   
    void* data,
59   
    void* data,
62   
    std::size_t size) noexcept
60   
    std::size_t size) noexcept
63   
{
61   
{
64   
    return mutable_buffer(data, size);
62   
    return mutable_buffer(data, size);
65   
}
63   
}
66  
64  
67   
/** Return a buffer with a maximum size.
65   
/** Return a buffer with a maximum size.
68   
*/
66   
*/
69   
[[nodiscard]] inline
67   
[[nodiscard]] inline
70   
mutable_buffer
68   
mutable_buffer
71   
make_buffer(
69   
make_buffer(
72   
    void* data,
70   
    void* data,
73   
    std::size_t size,
71   
    std::size_t size,
74   
    std::size_t max_size) noexcept
72   
    std::size_t max_size) noexcept
75   
{
73   
{
76   
    return mutable_buffer(
74   
    return mutable_buffer(
77   
        data,
75   
        data,
78   
        size < max_size ? size : max_size);
76   
        size < max_size ? size : max_size);
79   
}
77   
}
80  
78  
81   
/** Return a buffer.
79   
/** Return a buffer.
82   
*/
80   
*/
83   
[[nodiscard]] inline
81   
[[nodiscard]] inline
84   
const_buffer
82   
const_buffer
85   
make_buffer(
83   
make_buffer(
86   
    const_buffer const& b) noexcept
84   
    const_buffer const& b) noexcept
87   
{
85   
{
88   
    return b;
86   
    return b;
89   
}
87   
}
90  
88  
91   
/** Return a buffer with a maximum size.
89   
/** Return a buffer with a maximum size.
92   
*/
90   
*/
93   
[[nodiscard]] inline
91   
[[nodiscard]] inline
94   
const_buffer
92   
const_buffer
95   
make_buffer(
93   
make_buffer(
96   
    const_buffer const& b,
94   
    const_buffer const& b,
97   
    std::size_t max_size) noexcept
95   
    std::size_t max_size) noexcept
98   
{
96   
{
99   
    return const_buffer(
97   
    return const_buffer(
100   
        b.data(),
98   
        b.data(),
101   
        b.size() < max_size ? b.size() : max_size);
99   
        b.size() < max_size ? b.size() : max_size);
102   
}
100   
}
103  
101  
104   
/** Return a buffer.
102   
/** Return a buffer.
105   
*/
103   
*/
106   
[[nodiscard]] inline
104   
[[nodiscard]] inline
107   
const_buffer
105   
const_buffer
108   
make_buffer(
106   
make_buffer(
109   
    void const* data,
107   
    void const* data,
110   
    std::size_t size) noexcept
108   
    std::size_t size) noexcept
111   
{
109   
{
112   
    return const_buffer(data, size);
110   
    return const_buffer(data, size);
113   
}
111   
}
114  
112  
115   
/** Return a buffer with a maximum size.
113   
/** Return a buffer with a maximum size.
116   
*/
114   
*/
117   
[[nodiscard]] inline
115   
[[nodiscard]] inline
118   
const_buffer
116   
const_buffer
119   
make_buffer(
117   
make_buffer(
120   
    void const* data,
118   
    void const* data,
121   
    std::size_t size,
119   
    std::size_t size,
122   
    std::size_t max_size) noexcept
120   
    std::size_t max_size) noexcept
123   
{
121   
{
124   
    return const_buffer(
122   
    return const_buffer(
125   
        data,
123   
        data,
126   
        size < max_size ? size : max_size);
124   
        size < max_size ? size : max_size);
127   
}
125   
}
128  
126  
129   
/** Return a buffer from a C-style array.
127   
/** Return a buffer from a C-style array.
130   
*/
128   
*/
131   
template<class T, std::size_t N>
129   
template<class T, std::size_t N>
132   
    requires std::is_trivially_copyable_v<T>
130   
    requires std::is_trivially_copyable_v<T>
133   
[[nodiscard]]
131   
[[nodiscard]]
134   
mutable_buffer
132   
mutable_buffer
135   
make_buffer(
133   
make_buffer(
136   
    T (&data)[N]) noexcept
134   
    T (&data)[N]) noexcept
137   
{
135   
{
138   
    return mutable_buffer(
136   
    return mutable_buffer(
139   
        data, N * sizeof(T));
137   
        data, N * sizeof(T));
140   
}
138   
}
141  
139  
142   
/** Return a buffer from a C-style array with a maximum size.
140   
/** Return a buffer from a C-style array with a maximum size.
143   
*/
141   
*/
144   
template<class T, std::size_t N>
142   
template<class T, std::size_t N>
145   
    requires std::is_trivially_copyable_v<T>
143   
    requires std::is_trivially_copyable_v<T>
146   
[[nodiscard]]
144   
[[nodiscard]]
147   
mutable_buffer
145   
mutable_buffer
148   
make_buffer(
146   
make_buffer(
149   
    T (&data)[N],
147   
    T (&data)[N],
150   
    std::size_t max_size) noexcept
148   
    std::size_t max_size) noexcept
151   
{
149   
{
152   
    return mutable_buffer(
150   
    return mutable_buffer(
153   
        data,
151   
        data,
154   
        N * sizeof(T) < max_size ? N * sizeof(T) : max_size);
152   
        N * sizeof(T) < max_size ? N * sizeof(T) : max_size);
155   
}
153   
}
156  
154  
157   
/** Return a buffer from a const C-style array.
155   
/** Return a buffer from a const C-style array.
158   
*/
156   
*/
159   
template<class T, std::size_t N>
157   
template<class T, std::size_t N>
160   
    requires std::is_trivially_copyable_v<T>
158   
    requires std::is_trivially_copyable_v<T>
161   
[[nodiscard]]
159   
[[nodiscard]]
162   
const_buffer
160   
const_buffer
163   
make_buffer(
161   
make_buffer(
164   
    T const (&data)[N]) noexcept
162   
    T const (&data)[N]) noexcept
165   
{
163   
{
166   
    return const_buffer(
164   
    return const_buffer(
167   
        data, N * sizeof(T));
165   
        data, N * sizeof(T));
168   
}
166   
}
169  
167  
170   
/** Return a buffer from a const C-style array with a maximum size.
168   
/** Return a buffer from a const C-style array with a maximum size.
171   
*/
169   
*/
172   
template<class T, std::size_t N>
170   
template<class T, std::size_t N>
173   
    requires std::is_trivially_copyable_v<T>
171   
    requires std::is_trivially_copyable_v<T>
174   
[[nodiscard]]
172   
[[nodiscard]]
175   
const_buffer
173   
const_buffer
176   
make_buffer(
174   
make_buffer(
177   
    T const (&data)[N],
175   
    T const (&data)[N],
178   
    std::size_t max_size) noexcept
176   
    std::size_t max_size) noexcept
179   
{
177   
{
180   
    return const_buffer(
178   
    return const_buffer(
181   
        data,
179   
        data,
182   
        N * sizeof(T) < max_size ? N * sizeof(T) : max_size);
180   
        N * sizeof(T) < max_size ? N * sizeof(T) : max_size);
183   
}
181   
}
184  
182  
185   
// std::array
183   
// std::array
186  
184  
187   
/** Return a buffer from a std::array.
185   
/** Return a buffer from a std::array.
188   
*/
186   
*/
189   
template<class T, std::size_t N>
187   
template<class T, std::size_t N>
190   
    requires std::is_trivially_copyable_v<T>
188   
    requires std::is_trivially_copyable_v<T>
191   
[[nodiscard]]
189   
[[nodiscard]]
192   
mutable_buffer
190   
mutable_buffer
193   
make_buffer(
191   
make_buffer(
194   
    std::array<T, N>& data) noexcept
192   
    std::array<T, N>& data) noexcept
195   
{
193   
{
196   
    return mutable_buffer(
194   
    return mutable_buffer(
197   
        data.data(), data.size() * sizeof(T));
195   
        data.data(), data.size() * sizeof(T));
198   
}
196   
}
199  
197  
200   
/** Return a buffer from a std::array with a maximum size.
198   
/** Return a buffer from a std::array with a maximum size.
201   
*/
199   
*/
202   
template<class T, std::size_t N>
200   
template<class T, std::size_t N>
203   
    requires std::is_trivially_copyable_v<T>
201   
    requires std::is_trivially_copyable_v<T>
204   
[[nodiscard]]
202   
[[nodiscard]]
205   
mutable_buffer
203   
mutable_buffer
206   
make_buffer(
204   
make_buffer(
207   
    std::array<T, N>& data,
205   
    std::array<T, N>& data,
208   
    std::size_t max_size) noexcept
206   
    std::size_t max_size) noexcept
209   
{
207   
{
210   
    return mutable_buffer(
208   
    return mutable_buffer(
211   
        data.data(),
209   
        data.data(),
212   
        data.size() * sizeof(T) < max_size
210   
        data.size() * sizeof(T) < max_size
213   
            ? data.size() * sizeof(T) : max_size);
211   
            ? data.size() * sizeof(T) : max_size);
214   
}
212   
}
215  
213  
216   
/** Return a buffer from a const std::array.
214   
/** Return a buffer from a const std::array.
217   
*/
215   
*/
218   
template<class T, std::size_t N>
216   
template<class T, std::size_t N>
219   
    requires std::is_trivially_copyable_v<T>
217   
    requires std::is_trivially_copyable_v<T>
220   
[[nodiscard]]
218   
[[nodiscard]]
221   
const_buffer
219   
const_buffer
222   
make_buffer(
220   
make_buffer(
223   
    std::array<T, N> const& data) noexcept
221   
    std::array<T, N> const& data) noexcept
224   
{
222   
{
225   
    return const_buffer(
223   
    return const_buffer(
226   
        data.data(), data.size() * sizeof(T));
224   
        data.data(), data.size() * sizeof(T));
227   
}
225   
}
228  
226  
229   
/** Return a buffer from a const std::array with a maximum size.
227   
/** Return a buffer from a const std::array with a maximum size.
230   
*/
228   
*/
231   
template<class T, std::size_t N>
229   
template<class T, std::size_t N>
232   
    requires std::is_trivially_copyable_v<T>
230   
    requires std::is_trivially_copyable_v<T>
233   
[[nodiscard]]
231   
[[nodiscard]]
234   
const_buffer
232   
const_buffer
235   
make_buffer(
233   
make_buffer(
236   
    std::array<T, N> const& data,
234   
    std::array<T, N> const& data,
237   
    std::size_t max_size) noexcept
235   
    std::size_t max_size) noexcept
238   
{
236   
{
239   
    return const_buffer(
237   
    return const_buffer(
240   
        data.data(),
238   
        data.data(),
241   
        data.size() * sizeof(T) < max_size
239   
        data.size() * sizeof(T) < max_size
242   
            ? data.size() * sizeof(T) : max_size);
240   
            ? data.size() * sizeof(T) : max_size);
243   
}
241   
}
244  
242  
245   
// std::vector
243   
// std::vector
246  
244  
247   
/** Return a buffer from a std::vector.
245   
/** Return a buffer from a std::vector.
248   
*/
246   
*/
249   
template<class T, class Allocator>
247   
template<class T, class Allocator>
250   
    requires std::is_trivially_copyable_v<T>
248   
    requires std::is_trivially_copyable_v<T>
251   
[[nodiscard]]
249   
[[nodiscard]]
252   
mutable_buffer
250   
mutable_buffer
253   
make_buffer(
251   
make_buffer(
254   
    std::vector<T, Allocator>& data) noexcept
252   
    std::vector<T, Allocator>& data) noexcept
255   
{
253   
{
256   
    return mutable_buffer(
254   
    return mutable_buffer(
257   
        data.size() ? data.data() : nullptr,
255   
        data.size() ? data.data() : nullptr,
258   
        data.size() * sizeof(T));
256   
        data.size() * sizeof(T));
259   
}
257   
}
260  
258  
261   
/** Return a buffer from a std::vector with a maximum size.
259   
/** Return a buffer from a std::vector with a maximum size.
262   
*/
260   
*/
263   
template<class T, class Allocator>
261   
template<class T, class Allocator>
264   
    requires std::is_trivially_copyable_v<T>
262   
    requires std::is_trivially_copyable_v<T>
265   
[[nodiscard]]
263   
[[nodiscard]]
266   
mutable_buffer
264   
mutable_buffer
267   
make_buffer(
265   
make_buffer(
268   
    std::vector<T, Allocator>& data,
266   
    std::vector<T, Allocator>& data,
269   
    std::size_t max_size) noexcept
267   
    std::size_t max_size) noexcept
270   
{
268   
{
271   
    return mutable_buffer(
269   
    return mutable_buffer(
272   
        data.size() ? data.data() : nullptr,
270   
        data.size() ? data.data() : nullptr,
273   
        data.size() * sizeof(T) < max_size
271   
        data.size() * sizeof(T) < max_size
274   
            ? data.size() * sizeof(T) : max_size);
272   
            ? data.size() * sizeof(T) : max_size);
275   
}
273   
}
276  
274  
277   
/** Return a buffer from a const std::vector.
275   
/** Return a buffer from a const std::vector.
278   
*/
276   
*/
279   
template<class T, class Allocator>
277   
template<class T, class Allocator>
280   
    requires std::is_trivially_copyable_v<T>
278   
    requires std::is_trivially_copyable_v<T>
281   
[[nodiscard]]
279   
[[nodiscard]]
282   
const_buffer
280   
const_buffer
283   
make_buffer(
281   
make_buffer(
284   
    std::vector<T, Allocator> const& data) noexcept
282   
    std::vector<T, Allocator> const& data) noexcept
285   
{
283   
{
286   
    return const_buffer(
284   
    return const_buffer(
287   
        data.size() ? data.data() : nullptr,
285   
        data.size() ? data.data() : nullptr,
288   
        data.size() * sizeof(T));
286   
        data.size() * sizeof(T));
289   
}
287   
}
290  
288  
291   
/** Return a buffer from a const std::vector with a maximum size.
289   
/** Return a buffer from a const std::vector with a maximum size.
292   
*/
290   
*/
293   
template<class T, class Allocator>
291   
template<class T, class Allocator>
294   
    requires std::is_trivially_copyable_v<T>
292   
    requires std::is_trivially_copyable_v<T>
295   
[[nodiscard]]
293   
[[nodiscard]]
296   
const_buffer
294   
const_buffer
297   
make_buffer(
295   
make_buffer(
298   
    std::vector<T, Allocator> const& data,
296   
    std::vector<T, Allocator> const& data,
299   
    std::size_t max_size) noexcept
297   
    std::size_t max_size) noexcept
300   
{
298   
{
301   
    return const_buffer(
299   
    return const_buffer(
302   
        data.size() ? data.data() : nullptr,
300   
        data.size() ? data.data() : nullptr,
303   
        data.size() * sizeof(T) < max_size
301   
        data.size() * sizeof(T) < max_size
304   
            ? data.size() * sizeof(T) : max_size);
302   
            ? data.size() * sizeof(T) : max_size);
305   
}
303   
}
306  
304  
307   
// std::basic_string
305   
// std::basic_string
308  
306  
309   
/** Return a buffer from a std::basic_string.
307   
/** Return a buffer from a std::basic_string.
310   
*/
308   
*/
311   
template<class CharT, class Traits, class Allocator>
309   
template<class CharT, class Traits, class Allocator>
312   
[[nodiscard]]
310   
[[nodiscard]]
313   
mutable_buffer
311   
mutable_buffer
314   
make_buffer(
312   
make_buffer(
315   
    std::basic_string<CharT, Traits, Allocator>& data) noexcept
313   
    std::basic_string<CharT, Traits, Allocator>& data) noexcept
316   
{
314   
{
317   
    return mutable_buffer(
315   
    return mutable_buffer(
318   
        data.size() ? &data[0] : nullptr,
316   
        data.size() ? &data[0] : nullptr,
319   
        data.size() * sizeof(CharT));
317   
        data.size() * sizeof(CharT));
320   
}
318   
}
321  
319  
322   
/** Return a buffer from a std::basic_string with a maximum size.
320   
/** Return a buffer from a std::basic_string with a maximum size.
323   
*/
321   
*/
324   
template<class CharT, class Traits, class Allocator>
322   
template<class CharT, class Traits, class Allocator>
325   
[[nodiscard]]
323   
[[nodiscard]]
326   
mutable_buffer
324   
mutable_buffer
327   
make_buffer(
325   
make_buffer(
328   
    std::basic_string<CharT, Traits, Allocator>& data,
326   
    std::basic_string<CharT, Traits, Allocator>& data,
329   
    std::size_t max_size) noexcept
327   
    std::size_t max_size) noexcept
330   
{
328   
{
331   
    return mutable_buffer(
329   
    return mutable_buffer(
332   
        data.size() ? &data[0] : nullptr,
330   
        data.size() ? &data[0] : nullptr,
333   
        data.size() * sizeof(CharT) < max_size
331   
        data.size() * sizeof(CharT) < max_size
334   
            ? data.size() * sizeof(CharT) : max_size);
332   
            ? data.size() * sizeof(CharT) : max_size);
335   
}
333   
}
336  
334  
337   
/** Return a buffer from a const std::basic_string.
335   
/** Return a buffer from a const std::basic_string.
338   
*/
336   
*/
339   
template<class CharT, class Traits, class Allocator>
337   
template<class CharT, class Traits, class Allocator>
340   
[[nodiscard]]
338   
[[nodiscard]]
341   
const_buffer
339   
const_buffer
342   
make_buffer(
340   
make_buffer(
343   
    std::basic_string<CharT, Traits, Allocator> const& data) noexcept
341   
    std::basic_string<CharT, Traits, Allocator> const& data) noexcept
344   
{
342   
{
345   
    return const_buffer(
343   
    return const_buffer(
346   
        data.data(),
344   
        data.data(),
347   
        data.size() * sizeof(CharT));
345   
        data.size() * sizeof(CharT));
348   
}
346   
}
349  
347  
350   
/** Return a buffer from a const std::basic_string with a maximum size.
348   
/** Return a buffer from a const std::basic_string with a maximum size.
351   
*/
349   
*/
352   
template<class CharT, class Traits, class Allocator>
350   
template<class CharT, class Traits, class Allocator>
353   
[[nodiscard]]
351   
[[nodiscard]]
354   
const_buffer
352   
const_buffer
355   
make_buffer(
353   
make_buffer(
356   
    std::basic_string<CharT, Traits, Allocator> const& data,
354   
    std::basic_string<CharT, Traits, Allocator> const& data,
357   
    std::size_t max_size) noexcept
355   
    std::size_t max_size) noexcept
358   
{
356   
{
359   
    return const_buffer(
357   
    return const_buffer(
360   
        data.data(),
358   
        data.data(),
361   
        data.size() * sizeof(CharT) < max_size
359   
        data.size() * sizeof(CharT) < max_size
362   
            ? data.size() * sizeof(CharT) : max_size);
360   
            ? data.size() * sizeof(CharT) : max_size);
363   
}
361   
}
364  
362  
365   
// std::basic_string_view
363   
// std::basic_string_view
366  
364  
367   
/** Return a buffer from a std::basic_string_view.
365   
/** Return a buffer from a std::basic_string_view.
368   
*/
366   
*/
369   
template<class CharT, class Traits>
367   
template<class CharT, class Traits>
370   
[[nodiscard]]
368   
[[nodiscard]]
371   
const_buffer
369   
const_buffer
372   
make_buffer(
370   
make_buffer(
373   
    std::basic_string_view<CharT, Traits> data) noexcept
371   
    std::basic_string_view<CharT, Traits> data) noexcept
374   
{
372   
{
375   
    return const_buffer(
373   
    return const_buffer(
376   
        data.size() ? data.data() : nullptr,
374   
        data.size() ? data.data() : nullptr,
377   
        data.size() * sizeof(CharT));
375   
        data.size() * sizeof(CharT));
378   
}
376   
}
379  
377  
380   
/** Return a buffer from a std::basic_string_view with a maximum size.
378   
/** Return a buffer from a std::basic_string_view with a maximum size.
381   
*/
379   
*/
382   
template<class CharT, class Traits>
380   
template<class CharT, class Traits>
383   
[[nodiscard]]
381   
[[nodiscard]]
384   
const_buffer
382   
const_buffer
385   
make_buffer(
383   
make_buffer(
386   
    std::basic_string_view<CharT, Traits> data,
384   
    std::basic_string_view<CharT, Traits> data,
387   
    std::size_t max_size) noexcept
385   
    std::size_t max_size) noexcept
388   
{
386   
{
389   
    return const_buffer(
387   
    return const_buffer(
390   
        data.size() ? data.data() : nullptr,
388   
        data.size() ? data.data() : nullptr,
391   
        data.size() * sizeof(CharT) < max_size
389   
        data.size() * sizeof(CharT) < max_size
392   
            ? data.size() * sizeof(CharT) : max_size);
390   
            ? data.size() * sizeof(CharT) : max_size);
393   
}
391   
}
394  
392  
395   
// std::span
393   
// std::span
396  
394  
397   
/** Return a buffer from a mutable std::span.
395   
/** Return a buffer from a mutable std::span.
398   
*/
396   
*/
399   
template<class T, std::size_t Extent>
397   
template<class T, std::size_t Extent>
400   
    requires (!std::is_const_v<T> && sizeof(T) == 1)
398   
    requires (!std::is_const_v<T> && sizeof(T) == 1)
401   
[[nodiscard]]
399   
[[nodiscard]]
402   
mutable_buffer
400   
mutable_buffer
403   
make_buffer(
401   
make_buffer(
404   
    std::span<T, Extent> data) noexcept
402   
    std::span<T, Extent> data) noexcept
405   
{
403   
{
406   
    return mutable_buffer(data.data(), data.size());
404   
    return mutable_buffer(data.data(), data.size());
407   
}
405   
}
408  
406  
409   
/** Return a buffer from a mutable std::span with a maximum size.
407   
/** Return a buffer from a mutable std::span with a maximum size.
410   
*/
408   
*/
411   
template<class T, std::size_t Extent>
409   
template<class T, std::size_t Extent>
412   
    requires (!std::is_const_v<T> && sizeof(T) == 1)
410   
    requires (!std::is_const_v<T> && sizeof(T) == 1)
413   
[[nodiscard]]
411   
[[nodiscard]]
414   
mutable_buffer
412   
mutable_buffer
415   
make_buffer(
413   
make_buffer(
416   
    std::span<T, Extent> data,
414   
    std::span<T, Extent> data,
417   
    std::size_t max_size) noexcept
415   
    std::size_t max_size) noexcept
418   
{
416   
{
419   
    return mutable_buffer(
417   
    return mutable_buffer(
420   
        data.data(),
418   
        data.data(),
421   
        data.size() < max_size ? data.size() : max_size);
419   
        data.size() < max_size ? data.size() : max_size);
422   
}
420   
}
423  
421  
424   
/** Return a buffer from a const std::span.
422   
/** Return a buffer from a const std::span.
425   
*/
423   
*/
426   
template<class T, std::size_t Extent>
424   
template<class T, std::size_t Extent>
427   
    requires (sizeof(T) == 1)
425   
    requires (sizeof(T) == 1)
428   
[[nodiscard]]
426   
[[nodiscard]]
429   
const_buffer
427   
const_buffer
430   
make_buffer(
428   
make_buffer(
431   
    std::span<T const, Extent> data) noexcept
429   
    std::span<T const, Extent> data) noexcept
432   
{
430   
{
433   
    return const_buffer(data.data(), data.size());
431   
    return const_buffer(data.data(), data.size());
434   
}
432   
}
435  
433  
436   
/** Return a buffer from a const std::span with a maximum size.
434   
/** Return a buffer from a const std::span with a maximum size.
437   
*/
435   
*/
438   
template<class T, std::size_t Extent>
436   
template<class T, std::size_t Extent>
439   
    requires (sizeof(T) == 1)
437   
    requires (sizeof(T) == 1)
440   
[[nodiscard]]
438   
[[nodiscard]]
441   
const_buffer
439   
const_buffer
442   
make_buffer(
440   
make_buffer(
443   
    std::span<T const, Extent> data,
441   
    std::span<T const, Extent> data,
444   
    std::size_t max_size) noexcept
442   
    std::size_t max_size) noexcept
445   
{
443   
{
446   
    return const_buffer(
444   
    return const_buffer(
447   
        data.data(),
445   
        data.data(),
448   
        data.size() < max_size ? data.size() : max_size);
446   
        data.size() < max_size ? data.size() : max_size);
449   
}
447   
}
450  
448  
451   
// Contiguous ranges
449   
// Contiguous ranges
452  
450  
453   
namespace detail {
451   
namespace detail {
454  
452  
455   
template<class T>
453   
template<class T>
456   
concept non_buffer_contiguous_range =
454   
concept non_buffer_contiguous_range =
457   
    std::ranges::contiguous_range<T> &&
455   
    std::ranges::contiguous_range<T> &&
458   
    std::ranges::sized_range<T> &&
456   
    std::ranges::sized_range<T> &&
459   
    !std::convertible_to<T, const_buffer> &&
457   
    !std::convertible_to<T, const_buffer> &&
460   
    !std::convertible_to<T, mutable_buffer> &&
458   
    !std::convertible_to<T, mutable_buffer> &&
461   
    std::is_trivially_copyable_v<std::ranges::range_value_t<T>>;
459   
    std::is_trivially_copyable_v<std::ranges::range_value_t<T>>;
462  
460  
463   
template<class T>
461   
template<class T>
464   
concept mutable_contiguous_range =
462   
concept mutable_contiguous_range =
465   
    non_buffer_contiguous_range<T> &&
463   
    non_buffer_contiguous_range<T> &&
466   
    !std::is_const_v<std::remove_reference_t<
464   
    !std::is_const_v<std::remove_reference_t<
467   
        std::ranges::range_reference_t<T>>>;
465   
        std::ranges::range_reference_t<T>>>;
468  
466  
469   
template<class T>
467   
template<class T>
470   
concept const_contiguous_range =
468   
concept const_contiguous_range =
471   
    non_buffer_contiguous_range<T> &&
469   
    non_buffer_contiguous_range<T> &&
472   
    std::is_const_v<std::remove_reference_t<
470   
    std::is_const_v<std::remove_reference_t<
473   
        std::ranges::range_reference_t<T>>>;
471   
        std::ranges::range_reference_t<T>>>;
474  
472  
475   
} // detail
473   
} // detail
476  
474  
477   
/** Return a buffer from a mutable contiguous range.
475   
/** Return a buffer from a mutable contiguous range.
478   
*/
476   
*/
479   
template<detail::mutable_contiguous_range T>
477   
template<detail::mutable_contiguous_range T>
480   
[[nodiscard]]
478   
[[nodiscard]]
481   
mutable_buffer
479   
mutable_buffer
482   
make_buffer(T& data) noexcept
480   
make_buffer(T& data) noexcept
483   
{
481   
{
484   
    return mutable_buffer(
482   
    return mutable_buffer(
485   
        std::ranges::size(data) ? std::ranges::data(data) : nullptr,
483   
        std::ranges::size(data) ? std::ranges::data(data) : nullptr,
486   
        std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>));
484   
        std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>));
487   
}
485   
}
488  
486  
489   
/** Return a buffer from a mutable contiguous range with a maximum size.
487   
/** Return a buffer from a mutable contiguous range with a maximum size.
490   
*/
488   
*/
491   
template<detail::mutable_contiguous_range T>
489   
template<detail::mutable_contiguous_range T>
492   
[[nodiscard]]
490   
[[nodiscard]]
493   
mutable_buffer
491   
mutable_buffer
494   
make_buffer(
492   
make_buffer(
495   
    T& data,
493   
    T& data,
496   
    std::size_t max_size) noexcept
494   
    std::size_t max_size) noexcept
497   
{
495   
{
498   
    auto const n = std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>);
496   
    auto const n = std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>);
499   
    return mutable_buffer(
497   
    return mutable_buffer(
500   
        std::ranges::size(data) ? std::ranges::data(data) : nullptr,
498   
        std::ranges::size(data) ? std::ranges::data(data) : nullptr,
501   
        n < max_size ? n : max_size);
499   
        n < max_size ? n : max_size);
502   
}
500   
}
503  
501  
504   
/** Return a buffer from a const contiguous range.
502   
/** Return a buffer from a const contiguous range.
505   
*/
503   
*/
506   
template<detail::non_buffer_contiguous_range T>
504   
template<detail::non_buffer_contiguous_range T>
507   
[[nodiscard]]
505   
[[nodiscard]]
508   
const_buffer
506   
const_buffer
509   
make_buffer(T const& data) noexcept
507   
make_buffer(T const& data) noexcept
510   
{
508   
{
511   
    return const_buffer(
509   
    return const_buffer(
512   
        std::ranges::size(data) ? std::ranges::data(data) : nullptr,
510   
        std::ranges::size(data) ? std::ranges::data(data) : nullptr,
513   
        std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>));
511   
        std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>));
514   
}
512   
}
515  
513  
516   
/** Return a buffer from a const contiguous range with a maximum size.
514   
/** Return a buffer from a const contiguous range with a maximum size.
517   
*/
515   
*/
518   
template<detail::non_buffer_contiguous_range T>
516   
template<detail::non_buffer_contiguous_range T>
519   
[[nodiscard]]
517   
[[nodiscard]]
520   
const_buffer
518   
const_buffer
521   
make_buffer(
519   
make_buffer(
522   
    T const& data,
520   
    T const& data,
523   
    std::size_t max_size) noexcept
521   
    std::size_t max_size) noexcept
524   
{
522   
{
525   
    auto const n = std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>);
523   
    auto const n = std::ranges::size(data) * sizeof(std::ranges::range_value_t<T>);
526   
    return const_buffer(
524   
    return const_buffer(
527   
        std::ranges::size(data) ? std::ranges::data(data) : nullptr,
525   
        std::ranges::size(data) ? std::ranges::data(data) : nullptr,
528   
        n < max_size ? n : max_size);
526   
        n < max_size ? n : max_size);
529   
}
527   
}
530  
528  
531   
} // capy
529   
} // capy
532   
} // boost
530   
} // boost
533  
531  
534 - 
#ifdef _MSC_VER
532 + 
BOOST_CAPY_MSVC_WARNING_POP
535 - 
#pragma warning(pop)
 
536 - 
#endif
 
537  
533  
538   
#endif
534   
#endif