TLA  Line data    Source code

       1                 : //
       2                 : // Copyright (c) 2025 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/http
       8                 : //
       9                 : 
      10                 : #ifndef BOOST_HTTP_SERVER_DETAIL_STABLE_STRING_HPP
      11                 : #define BOOST_HTTP_SERVER_DETAIL_STABLE_STRING_HPP
      12                 : 
      13                 : #include <boost/http/detail/config.hpp>
      14                 : #include <cstdint>
      15                 : #include <cstdlib>
      16                 : 
      17                 : namespace boost {
      18                 : namespace http {
      19                 : namespace detail {
      20                 : 
      21                 : // avoids SBO
      22                 : class stable_string
      23                 : {
      24                 :     char const* p_ = 0;
      25                 :     std::size_t n_ = 0;
      26                 : 
      27                 : public:
      28 HIT         832 :     ~stable_string()
      29                 :     {
      30             832 :         if(p_)
      31             192 :             delete[] p_;
      32             832 :     }
      33                 : 
      34                 :     stable_string() = default;
      35                 : 
      36             640 :     stable_string(
      37                 :         stable_string&& other) noexcept
      38             640 :         : p_(other.p_)
      39             640 :         , n_(other.n_)
      40                 :     {
      41             640 :         other.p_ = nullptr;
      42             640 :         other.n_ = 0;
      43             640 :     }
      44                 : 
      45                 :     stable_string& operator=(
      46                 :         stable_string&& other) noexcept
      47                 :     {
      48                 :         auto p = p_;
      49                 :         auto n = n_;
      50                 :         p_ = other.p_;
      51                 :         n_ = other.n_;
      52                 :         other.p_ = p;
      53                 :         other.n_ = n;
      54                 :         return *this;
      55                 :     }
      56                 : 
      57                 :     explicit
      58             192 :     stable_string(
      59                 :         std::string_view s)
      60             384 :         : p_(
      61             576 :             [&]
      62                 :             {
      63             192 :                 auto p =new char[s.size()];
      64             192 :                 std::memcpy(p, s.data(), s.size());
      65             192 :                 return p;
      66             192 :             }())
      67             192 :         , n_(s.size())
      68                 :     {
      69             192 :     }
      70                 : 
      71                 :     stable_string(
      72                 :         char const* it, char const* end)
      73                 :         : stable_string(std::string_view(it, end))
      74                 :     {
      75                 :     }
      76                 : 
      77             136 :     char const* data() const noexcept
      78                 :     {
      79             136 :         return p_;
      80                 :     }
      81                 : 
      82             136 :     std::size_t size() const noexcept
      83                 :     {
      84             136 :         return n_;
      85                 :     }
      86                 : 
      87             136 :     operator core::string_view() const noexcept
      88                 :     {
      89             136 :         return { data(), size() };
      90                 :     }
      91                 : 
      92                 :     operator std::string_view() const noexcept
      93                 :     {
      94                 :         return { data(), size() };
      95                 :     }
      96                 : };
      97                 : 
      98                 : } // detail
      99                 : } // http
     100                 : } // boost
     101                 : 
     102                 : #endif