Cleaned up further the implementation of the URI parts and parser.

Author: glynos

boost/network/protocol/http/impl/request.hpp

@@ -17,6 +17,7 @@
 
 #include <boost/network/uri/uri.hpp>
 #include <boost/network/traits/vector.hpp>
+#include <boost/network/constants.hpp>
 
 #include <boost/network/protocol/http/message/async_message.hpp>
 #include <boost/network/support/is_async.hpp>

boost/network/uri/detail/uri_parts.hpp

@@ -7,38 +7,48 @@
 # define BOOST_NETWORK_URL_DETAIL_URL_PARTS_HPP_
 
 
-# include <utility>
+# include <boost/range/iterator_range.hpp>
 
 
 namespace boost {
 namespace network {
 namespace uri {
 namespace detail {
 template <
-    class String
+    class FwdIter
     >
-struct iterator_range
-    : std::pair<
-      typename String::const_iterator
-    , typename String::const_iterator> {
+struct hierarchical_part {
+    iterator_range<FwdIter> user_info, host, port, path;
 
-};
+    hierarchical_part()
+    {}
 
-template <
-    class String
-    >
-struct hierarchical_part {
-    iterator_range<String> user_info, host, port, path;
+    hierarchical_part(FwdIter begin, FwdIter end)
+        : user_info(begin, end)
+        , host(begin, end)
+        , port(begin, end)
+        , path(begin, end)
+    { }
 };
 
 template <
-    class String
+    class FwdIter
     >
 struct uri_parts {
-    iterator_range<String> scheme;
-    hierarchical_part<String> hier_part;
-    iterator_range<String> query;
-    iterator_range<String> fragment;
+    iterator_range<FwdIter> scheme;
+    hierarchical_part<FwdIter> hier_part;
+    iterator_range<FwdIter> query;
+    iterator_range<FwdIter> fragment;
+
+    uri_parts()
+    {}
+
+    uri_parts(FwdIter begin, FwdIter end)
+        : scheme(begin, end)
+        , hier_part(begin, end)
+        , query(begin, end)
+        , fragment(begin, end)
+    { }
 };
 } // namespace detail
 } // namespace uri

boost/network/uri/uri.hpp

@@ -7,12 +7,7 @@
 #ifndef __BOOST_NETWORK_URI_INC__
 # define __BOOST_NETWORK_URI_INC__
 
-
-# include <boost/network/traits/string.hpp>
-# include <boost/network/constants.hpp>
 # include <boost/network/uri/detail/uri_parts.hpp>
-# include <boost/algorithm/string.hpp>
-# include <boost/range/iterator_range.hpp>
 # include <boost/operators.hpp>
 # include <boost/utility/swap.hpp>
 # include <boost/lexical_cast.hpp>
@@ -26,7 +21,7 @@ namespace uri {
 namespace detail {
 bool parse(std::string::const_iterator first,
            std::string::const_iterator last,
-           uri_parts<std::string> &parts);
+           uri_parts<std::string::const_iterator> &parts);
 } // namespace detail
 
 
@@ -50,7 +45,7 @@ class uri
         class FwdIter
         >
     uri(const FwdIter &first, const FwdIter &last)
-        : uri_(first, last), is_valid_(false) {
+        : uri_(first, last), uri_parts_(first, first), is_valid_(false) {
         parse();
     }
 
@@ -103,38 +98,31 @@ class uri
     }
 
     const_range_type scheme_range() const {
-        return const_range_type(uri_parts_.scheme.first,
-                                uri_parts_.scheme.second);
+        return uri_parts_.scheme;
     }
 
     const_range_type user_info_range() const {
-        return const_range_type(uri_parts_.hier_part.user_info.first,
-                                uri_parts_.hier_part.user_info.second);
+        return uri_parts_.hier_part.user_info;
     }
 
     const_range_type host_range() const {
-        return const_range_type(uri_parts_.hier_part.host.first,
-                                uri_parts_.hier_part.host.second);
+        return uri_parts_.hier_part.host;
     }
 
     const_range_type port_range() const {
-        return const_range_type(uri_parts_.hier_part.port.first,
-                                uri_parts_.hier_part.port.second);
+        return uri_parts_.hier_part.port;
     }
 
     const_range_type path_range() const {
-        return const_range_type(uri_parts_.hier_part.path.first,
-                                uri_parts_.hier_part.path.second);
+        return uri_parts_.hier_part.path;
     }
 
     const_range_type query_range() const {
-        return const_range_type(uri_parts_.query.first,
-                                uri_parts_.query.second);
+        return uri_parts_.query;
     }
 
     const_range_type fragment_range() const {
-        return const_range_type(uri_parts_.fragment.first,
-                                uri_parts_.fragment.second);
+        return uri_parts_.fragment;
     }
 
     string_type scheme() const {
@@ -198,7 +186,7 @@ class uri
     void parse();
 
     string_type uri_;
-    detail::uri_parts<std::string> uri_parts_;
+    detail::uri_parts<std::string::const_iterator> uri_parts_;
     bool is_valid_;
 
 };

libs/network/src/uri/parse.cpp

@@ -6,57 +6,46 @@
 
 #include <boost/network/uri/detail/uri_parts.hpp>
 #include <boost/config/warning_disable.hpp>
-#include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/version.hpp>
-#include <boost/spirit/repository/include/qi_iter_pos.hpp>
+#include <boost/spirit/home/qi.hpp>
 #include <boost/fusion/adapted/struct/adapt_struct.hpp>
 
-
-BOOST_FUSION_ADAPT_TPL_STRUCT
-(
-    (String),
-    (boost::network::uri::detail::iterator_range)(String),
-    (typename String::const_iterator, first)
-    (typename String::const_iterator, second)
-    );
-
 BOOST_FUSION_ADAPT_TPL_STRUCT
 (
-    (String),
-    (boost::network::uri::detail::hierarchical_part)(String),
-    (boost::network::uri::detail::iterator_range<String>, user_info)
-    (boost::network::uri::detail::iterator_range<String>, host)
-    (boost::network::uri::detail::iterator_range<String>, port)
-    (boost::network::uri::detail::iterator_range<String>, path)
+    (FwdIter),
+    (boost::network::uri::detail::hierarchical_part)(FwdIter),
+    (boost::iterator_range<FwdIter>, user_info)
+    (boost::iterator_range<FwdIter>, host)
+    (boost::iterator_range<FwdIter>, port)
+    (boost::iterator_range<FwdIter>, path)
     );
 
 BOOST_FUSION_ADAPT_TPL_STRUCT
 (
-    (String),
-    (boost::network::uri::detail::uri_parts)(String),
-    (boost::network::uri::detail::iterator_range<String>, scheme)
-    (boost::network::uri::detail::hierarchical_part<String>, hier_part)
-    (boost::network::uri::detail::iterator_range<String>, query)
-    (boost::network::uri::detail::iterator_range<String>, fragment)
+    (FwdIter),
+    (boost::network::uri::detail::uri_parts)(FwdIter),
+    (boost::iterator_range<FwdIter>, scheme)
+    (boost::network::uri::detail::hierarchical_part<FwdIter>, hier_part)
+    (boost::iterator_range<FwdIter>, query)
+    (boost::iterator_range<FwdIter>, fragment)
     );
 
-
 namespace boost {
 namespace network {
 namespace uri {
 namespace detail {
 namespace qi = boost::spirit::qi;
 
 template <
-    class String,
-    typename Iterator
+    class String
     >
-struct uri_grammar : qi::grammar<Iterator, detail::uri_parts<String>()> {
+struct uri_grammar : qi::grammar<
+    typename String::const_iterator
+  , detail::uri_parts<typename String::const_iterator>()> {
 
-    uri_grammar() : uri_grammar::base_type(start, "uri") {
-        using boost::spirit::repository::qi::iter_pos;
+    typedef String string_type;
+    typedef typename String::const_iterator const_iterator;
 
+    uri_grammar() : uri_grammar::base_type(start, "uri") {
         // gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
         gen_delims %= qi::char_(":/?#[]@");
         // sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
@@ -83,46 +72,34 @@ struct uri_grammar : qi::grammar<Iterator, detail::uri_parts<String>()> {
             ];
         // path-abempty  = *( "/" segment )
         path_abempty %=
-               iter_pos
-            >> qi::omit[qi::raw[*(qi::char_("/") >> segment)]]
-            >> iter_pos
+            qi::raw[qi::raw[*(qi::char_("/") >> segment)]]
             ;
         // path-absolute = "/" [ segment-nz *( "/" segment ) ]
         path_absolute %=
-               iter_pos
-            >> qi::omit[qi::raw[
+            qi::raw[qi::raw[
                                 qi::char_("/")
                                 >>  -(segment_nz >> *(qi::char_("/") >> segment))
                                 ]]
-            >> iter_pos
             ;
         // path-rootless = segment-nz *( "/" segment )
         path_rootless %=
-               iter_pos
-            >> qi::omit[qi::raw[
+            qi::raw[qi::raw[
                                 segment_nz >> *(qi::char_("/") >> segment)
                                 ]]
-            >> iter_pos
             ;
         // path-empty = 0<pchar>
         path_empty %=
-               iter_pos
-            >> qi::omit[qi::eps]
-            >> iter_pos
+            qi::raw[qi::eps]
             ;
 
         // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
         scheme %=
-               iter_pos
-            >> qi::omit[qi::alpha >> *(qi::alnum | qi::char_("+.-"))]
-            >> iter_pos
+            qi::raw[qi::alpha >> *(qi::alnum | qi::char_("+.-"))]
             ;
 
         // user_info = *( unreserved / pct-encoded / sub-delims / ":" )
         user_info %=
-               iter_pos
-            >> qi::omit[qi::raw[*(unreserved | pct_encoded | sub_delims | qi::char_(":"))]]
-            >> iter_pos
+            qi::raw[qi::raw[*(unreserved | pct_encoded | sub_delims | qi::char_(":"))]]
             ;
 
         ip_literal %=
@@ -173,30 +150,22 @@ struct uri_grammar : qi::grammar<Iterator, detail::uri_parts<String>()> {
 
         // TODO, host = IP-literal / IPv4address / reg-name
         host %=
-               iter_pos
-            >> qi::omit[ip_literal | ipv4address | reg_name]
-            >> iter_pos
+            qi::raw[ip_literal | ipv4address | reg_name]
             ;
 
         // port %= qi::ushort_;
         port %=
-               iter_pos
-            >> qi::omit[*qi::digit]
-            >> iter_pos
+            qi::raw[*qi::digit]
             ;
 
         // query = *( pchar / "/" / "?" )
         query %=
-               iter_pos
-            >> qi::omit[qi::raw[*(pchar | qi::char_("/?"))]]
-            >> iter_pos
+            qi::raw[qi::raw[*(pchar | qi::char_("/?"))]]
             ;
 
         // fragment = *( pchar / "/" / "?" )
         fragment %=
-               iter_pos
-            >> qi::omit[qi::raw[*(pchar | qi::char_("/?"))]]
-            >> iter_pos
+            qi::raw[qi::raw[*(pchar | qi::char_("/?"))]]
             ;
 
         // hier-part = "//" authority path-abempty / path-absolute / path-rootless / path-empty
@@ -211,9 +180,9 @@ struct uri_grammar : qi::grammar<Iterator, detail::uri_parts<String>()> {
                 )
             |
             (
-                    qi::attr(iterator_range<String>())
-                >>  qi::attr(iterator_range<String>())
-                >>  qi::attr(iterator_range<String>())
+                    qi::attr(iterator_range<const_iterator>())
+                >>  qi::attr(iterator_range<const_iterator>())
+                >>  qi::attr(iterator_range<const_iterator>())
                 >>  (
                     path_absolute
                     |   path_rootless
@@ -230,41 +199,41 @@ struct uri_grammar : qi::grammar<Iterator, detail::uri_parts<String>()> {
             ;
     }
 
-    qi::rule<Iterator, typename String::value_type()>
+    qi::rule<const_iterator, typename string_type::value_type()>
     gen_delims, sub_delims, reserved, unreserved;
-    qi::rule<Iterator, String()>
+    qi::rule<const_iterator, string_type()>
     pct_encoded, pchar;
 
-    qi::rule<Iterator, String()>
+    qi::rule<const_iterator, string_type()>
     segment, segment_nz, segment_nz_nc;
-    qi::rule<Iterator, iterator_range<String>()>
+    qi::rule<const_iterator, iterator_range<const_iterator>()>
     path_abempty, path_absolute, path_rootless, path_empty;
 
-    qi::rule<Iterator, String()>
+    qi::rule<const_iterator, string_type()>
     dec_octet, ipv4address, reg_name, ipv6address, ipvfuture, ip_literal;
 
-    qi::rule<Iterator, String()>
+    qi::rule<const_iterator, string_type()>
     h16, ls32;
 
-    qi::rule<Iterator, iterator_range<String>()>
+    qi::rule<const_iterator, iterator_range<const_iterator>()>
     host, port;
 
-    qi::rule<Iterator, iterator_range<String>()>
+    qi::rule<const_iterator, iterator_range<const_iterator>()>
     scheme, user_info, query, fragment;
 
-    qi::rule<Iterator, hierarchical_part<String>()>
+    qi::rule<const_iterator, hierarchical_part<const_iterator>()>
     hier_part;
 
     // actual uri parser
-    qi::rule<Iterator, uri_parts<String>()> start;
+    qi::rule<const_iterator, uri_parts<const_iterator>()> start;
 
 };
 
 bool parse(std::string::const_iterator first,
            std::string::const_iterator last,
-           uri_parts<std::string> &parts) {
+           uri_parts<std::string::const_iterator> &parts) {
     namespace qi = boost::spirit::qi;
-    static detail::uri_grammar<std::string, std::string::const_iterator> grammar;
+    static detail::uri_grammar<std::string> grammar;
     bool is_valid = qi::parse(first, last, grammar, parts);
     return is_valid && (first == last);
 }