URL Support for wide-character strings

deanberris · deanberris · commit 34197784fcbc · 2011-04-03T00:29:08.000+08:00
This commit finally adds support for wide 
characters in URI's and addresses the final test
errors in the URI implementation. Step after this 
is the refactoring of the Spirit-based grammar to
simplify the URI grammar and reduce the magic that
goes on in the implementation.
diff --git a/boost/network/uri/basic_uri.hpp b/boost/network/uri/basic_uri.hpp
@@ -23,8 +23,10 @@ struct uri_base {
         :
         raw_(uri),
         parts_(),
-        valid_(parse_uri(raw_, parts_))
-    { }
+        valid_(false)
+    {
+        valid_ = parse_uri(raw_, parts_);
+    }
 
     uri_base(const uri_base & other)
         :
@@ -116,8 +118,9 @@ class basic_uri : public uri_base<Tag> {
 
     basic_uri() : uri_base<Tag>() {}
     basic_uri(typename uri_base<Tag>::string_type const & uri) : uri_base<Tag>(uri) {}
+    basic_uri(basic_uri const & other) : uri_base<Tag>(other) {}
 
-    basic_uri & operator= (basic_uri & rhs) {
+    basic_uri & operator= (basic_uri rhs) {
         rhs.swap(*this);
         return *this;
     }
@@ -223,7 +226,7 @@ is_valid(basic_uri<Tag> const & uri) {
 } // namespace network
 } // namespace boost
 
-
+#ifdef BOOST_NETWORK_DEBUG
 // Check that the URI concept is met by the basic_uri type.
 #include <boost/network/uri/uri_concept.hpp>
 #include <boost/network/tags.hpp>
@@ -233,6 +236,7 @@ BOOST_CONCEPT_ASSERT((URI<basic_uri<boost::network::tags::default_wstring> >));
 } // namespace uri
 } // namespace network
 } // namespace boost
+#endif // BOOST_NETWORK_DEBUG
 
 #endif
 
diff --git a/boost/network/uri/detail/impl/parse_uri.ipp b/boost/network/uri/detail/impl/parse_uri.ipp
@@ -131,17 +131,100 @@ struct transform_attribute<
     static void post(optional<Exposed> &, Transformed const &) { }
 };
 #endif
+
+template <>
+struct transform_attribute<
+    boost::network::uri::detail::uri_parts_wide_base,
+    boost::fusion::tuple<
+        std::wstring &,
+        boost::fusion::tuple<
+            boost::optional<std::wstring>&,
+            boost::optional<std::wstring>&,
+            boost::optional<boost::uint16_t> &,
+            std::wstring &
+            >,
+        optional<std::wstring>&,
+        optional<std::wstring>&
+    >
+#if SPIRIT_VERSION >= 0x2030
+        , boost::spirit::qi::domain
+#endif
+        >
+{
+    typedef
+    boost::fusion::tuple<
+        std::wstring &,
+        boost::fusion::tuple<
+            boost::optional<std::wstring>&,
+            boost::optional<std::wstring>&,
+            boost::optional<boost::uint16_t> &,
+            std::wstring &
+            >,
+        optional<std::wstring>&,
+        optional<std::wstring>&
+    > type;
+
+    static type pre(boost::network::uri::detail::uri_parts_wide_base & parts) {
+        boost::fusion::tuple<
+        boost::optional<std::wstring> &,
+            boost::optional<std::wstring> &,
+            boost::optional<boost::uint16_t> &,
+            std::wstring &
+            > hier_part =
+            boost::fusion::tie(
+                parts.user_info,
+                parts.host,
+                parts.port,
+                parts.path
+                );
+
+    return boost::fusion::tie(
+        parts.scheme,
+        hier_part,
+        parts.query,
+        parts.fragment
+        );
+}
+
+static void post(boost::network::uri::detail::uri_parts_wide_base &, type const &) { }
+
+#if SPIRIT_VERSION >= 0x2030
+static void fail(boost::network::uri::detail::uri_parts_wide_base & val) { }
+#endif
+};
+
 } // namespace traits
 } // namespace spirit
 } // namespace boost
 
 
 namespace boost { namespace network { namespace uri { namespace detail {
+
+template <class String>
+struct unsupported_string;
+
+template <class String, class Dummy = void>
+struct choose_uri_base
+{
+    typedef unsupported_string<String> type;
+};
+
+template <class Dummy>
+struct choose_uri_base<std::string, Dummy>
+{
+    typedef uri_parts_default_base type;
+};
+
+template <class Dummy>
+struct choose_uri_base<std::wstring, Dummy>
+{
+    typedef uri_parts_wide_base type;
+};
     
 namespace qi = boost::spirit::qi;
 
-template <typename Iterator>
-struct uri_grammar_default : qi::grammar<Iterator, uri_parts_default_base()> {
+template <typename Iterator, typename String>
+struct uri_grammar_default : qi::grammar<Iterator, typename choose_uri_base<String>::type()> {
     uri_grammar_default() : uri_grammar_default::base_type(start, "uri") {
         // gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
         gen_delims %= qi::char_(":/?#[]@");
@@ -223,8 +306,8 @@ struct uri_grammar_default : qi::grammar<Iterator, uri_parts_default_base()> {
                 )
             |
             (
-                qi::attr(optional<std::string>())
-                >>  qi::attr(optional<std::string>())
+                qi::attr(optional<String>())
+                >>  qi::attr(optional<String>())
                 >>  qi::attr(optional<boost::uint16_t>())
                 >>  (
                     path_absolute
@@ -242,7 +325,7 @@ struct uri_grammar_default : qi::grammar<Iterator, uri_parts_default_base()> {
         start %= uri.alias();
     }
 
-    typedef std::string string_type;
+    typedef String string_type;
 
     qi::rule<Iterator, typename string_type::value_type()>
     gen_delims, sub_delims, reserved, unreserved;
@@ -268,7 +351,7 @@ struct uri_grammar_default : qi::grammar<Iterator, uri_parts_default_base()> {
                            >()> hier_part;
 
     // start rule of grammar
-    qi::rule<Iterator, uri_parts_default_base()> start;
+    qi::rule<Iterator, typename choose_uri_base<String>::type()> start;
 
     // actual uri parser
     qi::rule<
@@ -290,20 +373,28 @@ struct uri_grammar_default : qi::grammar<Iterator, uri_parts_default_base()> {
 
 BOOST_NETWORK_INLINE bool parse_uri_impl(boost::iterator_range<std::string::const_iterator> & range, uri_parts_default_base & parts, boost::network::tags::default_string) {
     // Qualified boost::begin and boost::end because MSVC complains
-    // of ambiguity on call to begin(range) and end(rand).
+    // of ambiguity on call to begin(range) and end(range).
     std::string::const_iterator start_ = boost::begin(range);
     std::string::const_iterator end_   = boost::end(range);
 
-    static uri_grammar_default<std::string::const_iterator> grammar;
+    static uri_grammar_default<std::string::const_iterator, std::string> grammar;
 
     bool ok = qi::parse(start_, end_, grammar, parts);
 
     return ok && start_ == end_;
 }
 
 BOOST_NETWORK_INLINE bool parse_uri_impl(boost::iterator_range<std::wstring::const_iterator> & range, uri_parts_wide_base & parts, boost::network::tags::default_wstring) {
-    // TODO implement the grammar that supports wide strings
-    return false; // this always fails because it's not supported yet!
+    // Qualified boost::begin and boost::end because MSVC complains
+    // of ambiguity on call to begin(range) and end(range).
+    std::wstring::const_iterator start_ = boost::begin(range);
+    std::wstring::const_iterator end_   = boost::end(range);
+
+    static uri_grammar_default<std::wstring::const_iterator, std::wstring> grammar;
+
+    bool ok = qi::parse(start_, end_, grammar, parts);
+
+    return ok && start_ == end_;
 }
 
 } /* detail */
diff --git a/boost/network/uri/detail/uri_parts.hpp b/boost/network/uri/detail/uri_parts.hpp
@@ -26,6 +26,36 @@ namespace detail {
         string_type path;
         optional<string_type> query;
         optional<string_type> fragment;
+        
+        uri_parts_default_base(uri_parts_default_base const & other)
+        : scheme(other.scheme)
+        , user_info(other.user_info)
+        , host(other.host)
+        , port(other.port)
+        , path(other.path)
+        , query(other.query)
+        , fragment(other.fragment)
+        {}
+        
+        uri_parts_default_base()
+        {}
+        
+        uri_parts_default_base & operator=(uri_parts_default_base rhs)
+        {
+            rhs.swap(*this);
+            return *this;
+        }
+        
+        void swap(uri_parts_default_base & rhs)
+        {
+            std::swap(scheme, rhs.scheme);
+            std::swap(user_info, rhs.user_info);
+            std::swap(host, rhs.host);
+            std::swap(port, rhs.port);
+            std::swap(path, rhs.path);
+            std::swap(query, rhs.query);
+            std::swap(fragment, rhs.fragment);
+        }
     };
 
     struct uri_parts_wide_base {
@@ -37,6 +67,36 @@ namespace detail {
         string_type path;
         optional<string_type> query;
         optional<string_type> fragment;
+        
+        uri_parts_wide_base(uri_parts_wide_base const & other)
+        : scheme(other.scheme) 
+        , user_info(other.user_info)
+        , host(other.host)
+        , port(other.port)
+        , path(other.path)
+        , query(other.query)
+        , fragment(other.fragment)
+        {}
+        
+        uri_parts_wide_base()
+        {}
+        
+        uri_parts_wide_base & operator=(uri_parts_wide_base rhs)
+        {
+            rhs.swap(*this);
+            return *this;
+        }
+        
+        void swap(uri_parts_wide_base & rhs)
+        {
+            std::swap(this->scheme, rhs.scheme);
+            std::swap(this->user_info, rhs.user_info);
+            std::swap(this->host, rhs.host);
+            std::swap(this->port, rhs.port);
+            std::swap(this->path, rhs.path);
+            std::swap(this->query, rhs.query);
+            std::swap(this->fragment, rhs.fragment);
+        }
     };
 
 template <class Tag>
@@ -46,23 +106,21 @@ struct uri_parts :
         , uri_parts_default_base
         , uri_parts_wide_base
     >::type
-{};
-
-template <class Tag>
-struct uri_parts_tuple {
-    typedef typename string<Tag>::type string_type;
-
-    typedef typename boost::fusion::tuple<
-        string_type &,
-        boost::fusion::tuple<
-            optional<string_type> &,
-            optional<string_type> &,
-            optional<boost::uint16_t> &,
-            string_type &
-            >,
-                optional<string_type> &,
-                optional<string_type> &
-                > type;
+{
+    typedef typename mpl::if_<
+        is_default_string<Tag>
+        , uri_parts_default_base
+        , uri_parts_wide_base
+        >::type base_type;
+    uri_parts() : base_type() {}
+    uri_parts(uri_parts const & other)
+    : base_type(other)
+    {}
+    uri_parts & operator=(uri_parts rhs)
+    {
+        swap(*this, rhs);
+        return *this;
+    }
 };
 
 template <class Tag>
@@ -93,8 +151,15 @@ bool operator==(uri_parts<Tag> const & l, uri_parts<Tag> const & r) {
 template <class Tag>
 inline
 bool operator!=(uri_parts<Tag> const & l, uri_parts<Tag> const & r) {
-    return !(l == r);
+    return (l.scheme != r.scheme) &&
+        (l.user_info != r.user_info) &&
+        (l.host != r.host) &&
+        (l.port != r.port) &&
+        (l.path != r.path) &&
+        (l.query != r.query) &&
+        (l.fragment != r.fragment);
 }
+
 } // namespace detail
 } // namespace uri
 } // namespace network
diff --git a/libs/network/test/url_test.cpp b/libs/network/test/url_test.cpp
@@ -212,5 +212,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(assignment_test, T, tag_types) {
     uri_type instance(string_type(boost::begin(url), boost::end(url)));
     uri_type copy;
     copy = instance;
+    BOOST_CHECK(instance.raw() == copy.raw());
     BOOST_CHECK(instance == copy);
 }

Original file line number	Diff line number	Diff line change
`@@ -212,5 +212,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(assignment_test, T, tag_types) {`
`212`	`212`	`uri_type instance(string_type(boost::begin(url), boost::end(url)));`
`213`	`213`	`uri_type copy;`
`214`	`214`	`copy = instance;`
	`215`	`+ BOOST_CHECK(instance.raw() == copy.raw());`
`215`	`216`	`BOOST_CHECK(instance == copy);`
`216`	`217`	`}`