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