Line data    Source code

       1             : //
       2             : // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot 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             : 
      11             : #include <boost/url/detail/config.hpp>
      12             : #include <boost/url/rfc/absolute_uri_rule.hpp>
      13             : #include <boost/url/grammar/delim_rule.hpp>
      14             : #include <boost/url/grammar/tuple_rule.hpp>
      15             : #include <boost/url/grammar/optional_rule.hpp>
      16             : #include <boost/url/grammar/parse.hpp>
      17             : #include "detail/hier_part_rule.hpp"
      18             : #include "detail/query_part_rule.hpp"
      19             : #include "detail/scheme_rule.hpp"
      20             : #include <utility>
      21             : 
      22             : namespace boost {
      23             : namespace urls {
      24             : 
      25             : auto
      26          28 : absolute_uri_rule_t::
      27             : parse(
      28             :     char const*& it,
      29             :     char const* const end
      30             :         ) const noexcept ->
      31             :     system::result<value_type>
      32             : {
      33          28 :     detail::url_impl u(detail::url_impl::from::string);
      34          28 :     u.cs_ = it;
      35             : 
      36             :     // scheme
      37             :     {
      38             :         auto rv = grammar::parse(
      39             :             it, end,
      40          28 :             grammar::tuple_rule(
      41          28 :                 detail::scheme_rule(),
      42          28 :                 grammar::squelch(
      43          28 :                     grammar::delim_rule(':'))));
      44          28 :         if(! rv)
      45           3 :             return rv.error();
      46          25 :         u.apply_scheme(rv->scheme);
      47             :     }
      48             : 
      49             :     // hier_part
      50             :     {
      51             :         auto rv = grammar::parse(
      52          25 :             it, end, detail::hier_part_rule);
      53          25 :         if(! rv)
      54           1 :             return rv.error();
      55          24 :         if(rv->has_authority)
      56          18 :             u.apply_authority(rv->authority);
      57          24 :         u.apply_path(
      58          24 :             rv->path,
      59          24 :             rv->segment_count);
      60             :     }
      61             : 
      62             :     // [ "?" query ]
      63             :     {
      64             :         auto rv = grammar::parse(
      65          24 :             it, end, detail::query_part_rule);
      66          24 :         if(! rv)
      67           1 :             return rv.error();
      68          23 :         if(rv->has_query)
      69             :         {
      70             :             // map "?" to { {} }
      71          11 :             u.apply_query(
      72          11 :                 rv->query,
      73          11 :                 rv->count +
      74          11 :                     rv->query.empty());
      75             :         }
      76             :     }
      77             : 
      78          23 :     return u.construct();
      79             : }
      80             : 
      81             : } // urls
      82             : } // boost
      83             :