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