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/buffers
       8              : //
       9              : 
      10              : #ifndef BOOST_BUFFERS_MAKE_BUFFER_HPP
      11              : #define BOOST_BUFFERS_MAKE_BUFFER_HPP
      12              : 
      13              : #include <boost/buffers/detail/config.hpp>
      14              : #include <boost/buffers/const_buffer.hpp>
      15              : #include <boost/buffers/mutable_buffer.hpp>
      16              : #include <cstdlib>
      17              : #include <type_traits>
      18              : 
      19              : namespace boost {
      20              : namespace buffers {
      21              : 
      22              : /** Return a buffer.
      23              : */
      24              : inline
      25              : mutable_buffer
      26            1 : make_buffer(
      27              :     mutable_buffer const& b) noexcept
      28              : {
      29            1 :     return b;
      30              : }
      31              : 
      32              : /** Return a buffer.
      33              : */
      34              : inline
      35              : mutable_buffer
      36       576961 : make_buffer(
      37              :     void* data,
      38              :     std::size_t size) noexcept
      39              : {
      40       576961 :     return mutable_buffer(data, size);
      41              : }
      42              : 
      43              : /** Return a buffer.
      44              : */
      45              : inline
      46              : const_buffer
      47            1 : make_buffer(
      48              :     const_buffer const& b) noexcept
      49              : {
      50            1 :     return b;
      51              : }
      52              : 
      53              : /** Return a buffer.
      54              : */
      55              : inline
      56              : const_buffer
      57        16419 : make_buffer(
      58              :     void const* data,
      59              :     std::size_t size) noexcept
      60              : {
      61        16419 :     return const_buffer(data, size);
      62              : }
      63              : 
      64              : /** Return a buffer.
      65              : */
      66              : template<
      67              :     class T, std::size_t N
      68              :     , class = typename std::enable_if<
      69              :         std::is_trivially_copyable<T>::value>::type
      70              : >
      71              : mutable_buffer
      72            1 : make_buffer(
      73              :     T (&data)[N]) noexcept
      74              : {
      75            1 :     return mutable_buffer(
      76            1 :         data, N * sizeof(T));
      77              : }
      78              : 
      79              : /** Return a buffer.
      80              : */
      81              : template<
      82              :     class T, std::size_t N
      83              :     , class = typename std::enable_if<
      84              :         std::is_trivially_copyable<T>::value>::type
      85              : >
      86              : const_buffer
      87            1 : make_buffer(
      88              :     T const (&data)[N]) noexcept
      89              : {
      90            1 :     return const_buffer(
      91            1 :         data, N * sizeof(T));
      92              : }
      93              : 
      94              : } // buffers
      95              : } // boost
      96              : 
      97              : #endif