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_BUFFER_COPY_HPP
      11                 : #define BOOST_CAPY_BUFFERS_BUFFER_COPY_HPP
      12                 : 
      13                 : #include <boost/capy/detail/config.hpp>
      14                 : #include <boost/capy/buffers.hpp>
      15                 : #include <cstring>
      16                 : #include <utility>
      17                 : 
      18                 : namespace boost {
      19                 : namespace capy {
      20                 : 
      21                 : /** Copy the contents of a buffer sequence into another buffer sequence.
      22                 : 
      23                 :     @functionobject
      24                 : */
      25                 : constexpr struct
      26                 : {
      27                 :     /** Copy the contents of a buffer sequence into another buffer sequence.
      28                 : 
      29                 :         Copies bytes from the constant buffer sequence `src` into the
      30                 :         mutable buffer sequence `dest`, stopping when any limit is
      31                 :         reached.
      32                 : 
      33                 :         @param dest The destination buffer sequence.
      34                 : 
      35                 :         @param src The source buffer sequence.
      36                 : 
      37                 :         @param at_most The maximum bytes to copy. Default copies all
      38                 :         available.
      39                 : 
      40                 :         @return The number of bytes copied, equal to
      41                 :         `std::min(size(dest), size(src), at_most)`.
      42                 :     */
      43                 :     template<
      44                 :         MutableBufferSequence MB,
      45                 :         ConstBufferSequence CB>
      46                 :     std::size_t
      47 HIT       12256 :     operator()(
      48                 :         MB const& dest,
      49                 :         CB const& src,
      50                 :         std::size_t at_most = std::size_t(-1)) const noexcept
      51                 :     {
      52           12256 :         std::size_t total = 0;
      53           12256 :         std::size_t pos0 = 0;
      54           12256 :         std::size_t pos1 = 0;
      55           12256 :         auto const end0 = end(src);
      56           12256 :         auto const end1 = end(dest);
      57           12256 :         auto it0 = begin(src);
      58           12256 :         auto it1 = begin(dest);
      59           12256 :         while(
      60           38002 :             total < at_most &&
      61           54380 :             it0 != end0 &&
      62            9402 :             it1 != end1)
      63                 :         {
      64           19805 :             const_buffer b0 = *it0;
      65           19805 :             mutable_buffer b1 = *it1;
      66           19805 :             b0 += pos0;
      67           19805 :             b1 += pos1;
      68                 :             std::size_t const amount =
      69           59415 :             [&]
      70                 :             {
      71           19805 :                 std::size_t n = b0.size();
      72           19805 :                 if( n > b1.size())
      73            5750 :                     n = b1.size();
      74           19805 :                 if( n > at_most - total)
      75            4902 :                     n = at_most - total;
      76           19805 :                 if(n != 0)
      77           18953 :                     std::memcpy(
      78                 :                         b1.data(),
      79                 :                         b0.data(),
      80                 :                         n);
      81           19805 :                 return n;
      82           19805 :             }();
      83           19805 :             total += amount;
      84           19805 :             if(amount == b1.size())
      85                 :             {
      86            7301 :                 ++it1;
      87            7301 :                 pos1 = 0;
      88                 :             }
      89                 :             else
      90                 :             {
      91           12504 :                 pos1 += amount;
      92                 :             }
      93           19805 :             if(amount == b0.size())
      94                 :             {
      95           10569 :                 ++it0;
      96           10569 :                 pos0 = 0;
      97                 :             }
      98                 :             else
      99                 :             {
     100            9236 :                 pos0 += amount;
     101                 :             }
     102                 :         }
     103           12256 :         return total;
     104                 :     }
     105                 : } buffer_copy {};
     106                 : 
     107                 : } // capy
     108                 : } // boost
     109                 : 
     110                 : #endif