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/uri_rule.hpp>
      13             : #include <boost/url/rfc/query_rule.hpp>
      14             : #include "detail/fragment_part_rule.hpp"
      15             : #include "detail/hier_part_rule.hpp"
      16             : #include "detail/query_part_rule.hpp"
      17             : #include "detail/scheme_rule.hpp"
      18             : #include <boost/url/grammar/delim_rule.hpp>
      19             : #include <boost/url/grammar/tuple_rule.hpp>
      20             : #include <boost/url/grammar/optional_rule.hpp>
      21             : #include <boost/url/grammar/parse.hpp>
      22             : 
      23             : namespace boost {
      24             : namespace urls {
      25             : 
      26             : auto
      27        3383 : uri_rule_t::
      28             : parse(
      29             :     char const*& it,
      30             :     char const* const end
      31             :         ) const noexcept ->
      32             :     system::result<value_type>
      33             : {
      34        3383 :     detail::url_impl u(detail::url_impl::from::string);
      35        3383 :     u.cs_ = it;
      36             : 
      37             :     // scheme
      38             :     {
      39             :         auto rv = grammar::parse(
      40             :             it, end,
      41        3383 :             grammar::tuple_rule(
      42        3383 :                 detail::scheme_rule(),
      43        3383 :                 grammar::squelch(
      44        3383 :                     grammar::delim_rule(':'))));
      45        3383 :         if(! rv)
      46        1159 :             return rv.error();
      47        2224 :         u.apply_scheme(rv->scheme);
      48             :     }
      49             : 
      50             :     // hier_part
      51             :     {
      52             :         auto rv = grammar::parse(
      53             :             it, end,
      54        2224 :             detail::hier_part_rule);
      55        2224 :         if(! rv)
      56          35 :             return rv.error();
      57        2189 :         if(rv->has_authority)
      58        1420 :             u.apply_authority(rv->authority);
      59        2189 :         u.apply_path(
      60        2189 :             rv->path,
      61        2189 :             rv->segment_count);
      62             :     }
      63             : 
      64             :     // [ "?" query ]
      65             :     {
      66             :         auto rv = grammar::parse(
      67        2189 :             it, end, detail::query_part_rule);
      68        2189 :         if(! rv)
      69           1 :             return rv.error();
      70        2188 :         if(rv->has_query)
      71             :         {
      72             :             // map "?" to { {} }
      73         192 :             u.apply_query(
      74         192 :                 rv->query,
      75         192 :                 rv->count +
      76         192 :                     rv->query.empty());
      77             :         }
      78             :     }
      79             : 
      80             :     // [ "#" fragment ]
      81             :     {
      82             :         auto rv = grammar::parse(
      83        2188 :             it, end, detail::fragment_part_rule);
      84        2188 :         if(! rv)
      85           1 :             return rv.error();
      86        2187 :         if(rv->has_fragment)
      87         151 :             u.apply_frag(rv->fragment);
      88             :     }
      89             : 
      90        2187 :     return u.construct();
      91             : }
      92             : 
      93             : } // urls
      94             : } // boost
      95             :