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