URI no longer uses ranges internally, but strings because of inconsistencies in the parser that I couldn't solve.

Author: glynos

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

@@ -96,7 +96,7 @@ namespace http {
             if (!port)
             {
                 typedef constants<Tag> consts;
-                return boost::iequals(uri_.scheme_range(),
+                return boost::iequals(uri_.scheme(),
                                       string_type(consts::https()))? 443 : 80;
             }
             return *port;

boost/network/uri/accessors.hpp

@@ -45,53 +45,53 @@ template <
     >
 inline
 Map &query_map(const uri &uri_, Map &map) {
-    uri::const_range_type range = uri_.query_range();
+    std::string range = uri_.query();
     details::key_value_sequence<Map> parser;
     spirit::qi::parse(boost::begin(range), boost::end(range), parser, map);
     return map;
 }
 
 std::string username(const uri &uri_) {
-    uri::const_range_type user_info_range = uri_.user_info_range();
-    uri::const_iterator it(boost::begin(user_info_range)), end(boost::end(user_info_range));
+    std::string user_info = uri_.user_info();
+    uri::const_iterator it(boost::begin(user_info)), end(boost::end(user_info));
     for (; it != end; ++it) {
         if (*it == ':') {
             break;
         }
     }
-    return std::string(boost::begin(user_info_range), it);
+    return std::string(boost::begin(user_info), it);
 }
 
 std::string password(const uri &uri_) {
-    uri::const_range_type user_info_range = uri_.user_info_range();
-    uri::const_iterator it(boost::begin(user_info_range)), end(boost::end(user_info_range));
+    std::string user_info = uri_.user_info();
+    uri::const_iterator it(boost::begin(user_info)), end(boost::end(user_info));
     for (; it != end; ++it) {
         if (*it == ':') {
             ++it;
             break;
         }
     }
-    return std::string(it, boost::end(user_info_range));
+    return std::string(it, boost::end(user_info));
 }
 
 std::string decoded_path(const uri &uri_) {
-    uri::const_range_type path_range = uri_.path_range();
+    std::string path = uri_.path();
     std::string decoded_path;
-    decode(path_range, std::back_inserter(decoded_path));
+    decode(path, std::back_inserter(decoded_path));
     return decoded_path;
 }
 
 std::string decoded_query(const uri &uri_) {
-    uri::const_range_type query_range = uri_.query_range();
+    std::string query = uri_.query();
     std::string decoded_query;
-    decode(query_range, std::back_inserter(decoded_query));
+    decode(query, std::back_inserter(decoded_query));
     return decoded_query;
 }
 
 std::string decoded_fragment(const uri &uri_) {
-    uri::const_range_type fragment_range = uri_.fragment_range();
+    std::string fragment = uri_.fragment();
     std::string decoded_fragment;
-    decode(fragment_range, std::back_inserter(decoded_fragment));
+    decode(fragment, std::back_inserter(decoded_fragment));
     return decoded_fragment;
 }
 } // namespace uri

boost/network/uri/detail/uri_parts.hpp

@@ -7,48 +7,36 @@
 # define BOOST_NETWORK_URL_DETAIL_URL_PARTS_HPP_
 
 
-# include <boost/range/iterator_range.hpp>
+# include <string>
 
 
 namespace boost {
 namespace network {
 namespace uri {
 namespace detail {
-template <
-    class FwdIter
-    >
 struct hierarchical_part {
-    iterator_range<FwdIter> user_info, host, port, path;
-
-    hierarchical_part()
-    {}
-
-    hierarchical_part(FwdIter begin, FwdIter end)
-        : user_info(begin, end)
-        , host(begin, end)
-        , port(begin, end)
-        , path(begin, end)
-    { }
+    std::string user_info, host, port, path;
+
+    void clear() {
+        user_info.clear();
+        host.clear();
+        port.clear();
+        path.clear();
+    }
 };
 
-template <
-    class FwdIter
-    >
 struct uri_parts {
-    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)
-    { }
+    std::string scheme;
+    hierarchical_part hier_part;
+    std::string query;
+    std::string fragment;
+
+    void clear() {
+        scheme.clear();
+        hier_part.clear();
+        query.clear();
+        fragment.clear();
+    }
 };
 } // namespace detail
 } // namespace uri

boost/network/uri/directives/query.hpp

@@ -44,7 +44,7 @@ struct query_key_query_directive {
         >
     void operator () (Uri &uri) const {
         std::string encoded_key, encoded_query;
-        if (!uri.query_range())
+        if (boost::empty(uri.query()))
         {
             uri.append("?");
         }

boost/network/uri/uri.hpp

@@ -10,6 +10,7 @@
 # include <boost/network/uri/detail/uri_parts.hpp>
 # include <boost/operators.hpp>
 # include <boost/utility/swap.hpp>
+# include <boost/range/iterator_range.hpp>
 # include <boost/lexical_cast.hpp>
 # include <boost/optional.hpp>
 # include <algorithm>
@@ -21,7 +22,7 @@ namespace uri {
 namespace detail {
 bool parse(std::string::const_iterator first,
            std::string::const_iterator last,
-           uri_parts<std::string::const_iterator> &parts);
+           uri_parts &parts);
 } // namespace detail
 
 
@@ -32,9 +33,7 @@ class uri
 
     typedef std::string string_type;
     typedef string_type::iterator iterator;
-    typedef boost::iterator_range<iterator> range_type;
     typedef string_type::const_iterator const_iterator;
-    typedef boost::iterator_range<const_iterator> const_range_type;
 
     uri()
         : is_valid_(false) {
@@ -45,7 +44,7 @@ class uri
         class FwdIter
         >
     uri(const FwdIter &first, const FwdIter &last)
-        : uri_(first, last), uri_parts_(first, first), is_valid_(false) {
+        : uri_(first, last), is_valid_(false) {
         parse();
     }
 
@@ -97,67 +96,32 @@ class uri
         return uri_.end();
     }
 
-    const_range_type scheme_range() const {
-        return uri_parts_.scheme;
-    }
-
-    const_range_type user_info_range() const {
-        return uri_parts_.hier_part.user_info;
-    }
-
-    const_range_type host_range() const {
-        return uri_parts_.hier_part.host;
-    }
-
-    const_range_type port_range() const {
-        return uri_parts_.hier_part.port;
-    }
-
-    const_range_type path_range() const {
-        return uri_parts_.hier_part.path;
-    }
-
-    const_range_type query_range() const {
-        return uri_parts_.query;
-    }
-
-    const_range_type fragment_range() const {
-        return uri_parts_.fragment;
-    }
-
     string_type scheme() const {
-        const_range_type range = scheme_range();
-        return string_type(boost::begin(range), boost::end(range));
+        return uri_parts_.scheme;
     }
 
     string_type user_info() const {
-        const_range_type range = user_info_range();
-        return string_type(boost::begin(range), boost::end(range));
+        return uri_parts_.hier_part.user_info;
     }
 
     string_type host() const {
-        const_range_type range = host_range();
-        return string_type(boost::begin(range), boost::end(range));
+        return uri_parts_.hier_part.host;
     }
 
     string_type port() const {
-        const_range_type range = port_range();
-        return string_type(boost::begin(range), boost::end(range));
+        return uri_parts_.hier_part.port;
     }
 
     string_type path() const {
-        const_range_type range = path_range();
-        return string_type(boost::begin(range), boost::end(range));
+        return uri_parts_.hier_part.path;
     }
 
     string_type query() const {
-        const_range_type range = query_range();
-        return string_type(boost::begin(range), boost::end(range));
+        return uri_parts_.query;
     }
 
     string_type fragment() const {
-        const_range_type range = fragment_range();
-        return string_type(boost::begin(range), boost::end(range));
+        return uri_parts_.fragment;
     }
 
     string_type string() const {
@@ -186,13 +150,14 @@ class uri
     void parse();
 
     string_type uri_;
-    detail::uri_parts<std::string::const_iterator> uri_parts_;
+    detail::uri_parts uri_parts_;
     bool is_valid_;
 
 };
 
 inline
 void uri::parse() {
+    uri_parts_.clear();
     const_iterator first(boost::begin(uri_)), last(boost::end(uri_));
     is_valid_ = detail::parse(first, last, uri_parts_);
 }
@@ -242,14 +207,25 @@ std::string fragment(const uri &uri_) {
 
 inline
 std::string authority(const uri &uri_) {
-    uri::const_range_type user_info(uri_.user_info_range());
-    uri::const_range_type port(uri_.port_range());
-    return std::string(user_info.begin(), port.end());
-}
-
-inline
-std::string netloc(const uri &uri_) {
-    return authority(uri_);
+    std::string user_info(uri_.user_info());
+	std::string host(uri_.host());
+    std::string port(uri_.port());
+	std::string authority;
+	if (!boost::empty(user_info))
+	{
+		std::copy(boost::begin(user_info), boost::end(user_info), std::back_inserter(authority));
+		authority.push_back('@');
+	}
+	if (!boost::empty(host))
+	{
+		std::copy(boost::begin(host), boost::end(host), std::back_inserter(authority));
+	}
+	if (!boost::empty(port))
+	{
+		authority.push_back(':');
+		std::copy(boost::begin(port), boost::end(port), std::back_inserter(authority));
+	}
+	return authority;
 }
 
 inline