Line data    Source code

       1             : //
       2             : // Copyright (c) 2019 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/boostorg/url
       8             : //
       9             : 
      10             : #ifndef BOOST_URL_DETAIL_PATH_HPP
      11             : #define BOOST_URL_DETAIL_PATH_HPP
      12             : 
      13             : #include <boost/core/detail/string_view.hpp>
      14             : 
      15             : namespace boost {
      16             : namespace urls {
      17             : namespace detail {
      18             : 
      19             : // Return the number of characters at
      20             : // the front of the path that are reserved
      21             : inline
      22             : std::size_t
      23        4181 : path_prefix(
      24             :     char const* p,
      25             :     std::size_t n) noexcept
      26             : {
      27        4181 :     switch(n)
      28             :     {
      29         316 :     case 0:
      30         316 :         return 0;
      31             : 
      32         247 :     case 1:
      33         247 :         if(p[0] == '/')
      34         162 :             return 1;
      35          85 :         return 0;
      36             : 
      37         184 :     case 2:
      38         184 :         if(p[0] == '/')
      39          83 :             return 1;
      40         101 :         if( p[0] == '.' &&
      41          86 :             p[1] == '/')
      42          57 :             return 2;
      43          44 :         return 0;
      44             : 
      45        3434 :     default:
      46        3434 :         if(p[0] == '/')
      47             :         {
      48        1823 :             if( p[1] == '.' &&
      49         433 :                 p[2] == '/')
      50         234 :                 return 3;
      51        1589 :             return 1;
      52             :         }
      53        1611 :         if( p[0] == '.' &&
      54         622 :             p[1] == '/')
      55         351 :             return 2;
      56        1260 :         break;
      57             :     }
      58        1260 :     return 0;
      59             : }
      60             : 
      61             : // VFALCO DEPRECATED
      62             : inline
      63             : std::size_t
      64        4181 : path_prefix(
      65             :     core::string_view s) noexcept
      66             : {
      67        4181 :     return path_prefix(
      68        4181 :         s.data(), s.size());
      69             : }
      70             : 
      71             : // returns the number of adjusted
      72             : // segments based on the malleable prefix.
      73             : inline
      74             : std::size_t
      75        3640 : path_segments(
      76             :     core::string_view s,
      77             :     std::size_t nseg) noexcept
      78             : {
      79        3640 :     switch(s.size())
      80             :     {
      81        1109 :     case 0:
      82        1109 :         BOOST_ASSERT(nseg == 0);
      83        1109 :         return 0;
      84             : 
      85         552 :     case 1:
      86         552 :         BOOST_ASSERT(nseg == 1);
      87         552 :         if(s[0] == '/')
      88         492 :             return 0;
      89          60 :         return 1;
      90             : 
      91         166 :     case 2:
      92         166 :         if(s[0] == '/')
      93         124 :             return nseg;
      94          66 :         if( s[0] == '.' &&
      95          24 :             s[1] == '/')
      96             :         {
      97          14 :             BOOST_ASSERT(nseg > 1);
      98          14 :             return nseg - 1;
      99             :         }
     100          28 :         return nseg;
     101             : 
     102        1813 :     default:
     103        1813 :         if(s[0] == '/')
     104             :         {
     105         964 :             if( s[1] == '.' &&
     106          66 :                 s[2] == '/')
     107             :             {
     108          44 :                 BOOST_ASSERT(nseg > 1);
     109          44 :                 return nseg - 1;
     110             :             }
     111         854 :             return nseg;
     112             :         }
     113         983 :         if( s[0] == '.' &&
     114          68 :             s[1] == '/')
     115             :         {
     116          39 :             BOOST_ASSERT(nseg > 1);
     117          39 :             return nseg - 1;
     118             :         }
     119         876 :         break;
     120             :     }
     121         876 :     return nseg;
     122             : }
     123             : 
     124             : // Trim reserved characters from
     125             : // the front of the path.
     126             : inline
     127             : core::string_view
     128             : clean_path(
     129             :     core::string_view s) noexcept
     130             : {
     131             :     s.remove_prefix(
     132             :         path_prefix(s));
     133             :     return s;
     134             : }
     135             : 
     136             : } // detail
     137             : } // urls
     138             : } // boost
     139             : 
     140             : #endif