Merge branch 'development' of https://git01.codeplex.com/casablanca into websocket_tls

Conflicts:
	Release/include/cpprest/ws_msg.h

Author: stgates

CONTRIBUTORS.txt

@@ -11,4 +11,5 @@ Michael M (M1xa)
 Matt Peterson (MattPeterson1)
 Dmitry Kolomiets (kolomiets)
 
-
+Illumina Inc.
+Gery Vessere ([email protected])

Release/include/cpprest/base_uri.h

@@ -40,14 +40,61 @@
 namespace web {
     namespace details
     {
-        struct _uri_components
+        struct uri_components
         {
-            _uri_components()
+            uri_components() : m_path(_XPLATSTR("/")), m_port(-1)
+            {}
+
+            uri_components(const uri_components &other) :
+                m_scheme(other.m_scheme),
+                m_host(other.m_host),
+                m_user_info(other.m_user_info),
+                m_path(other.m_path),
+                m_query(other.m_query),
+                m_fragment(other.m_fragment),
+                m_port(other.m_port)
+            {}
+
+            uri_components & operator=(const uri_components &other)
             {
-                m_path = _XPLATSTR("/");
-                m_port = -1;
+                if (this != &other)
+                {
+                    m_scheme = other.m_scheme;
+                    m_host = other.m_host;
+                    m_user_info = other.m_user_info;
+                    m_path = other.m_path;
+                    m_query = other.m_query;
+                    m_fragment = other.m_fragment;
+                    m_port = other.m_port;
+                }
+                return *this;
             }
 
+            uri_components(uri_components &&other) _noexcept :
+                m_scheme(std::move(other.m_scheme)),
+                m_host(std::move(other.m_host)),
+                m_user_info(std::move(other.m_user_info)),
+                m_path(std::move(other.m_path)),
+                m_query(std::move(other.m_query)),
+                m_fragment(std::move(other.m_fragment)),
+                m_port(other.m_port)
+            {}
+
+            uri_components & operator=(uri_components &&other) _noexcept
+            {
+                if (this != &other)
+                {
+                    m_scheme = std::move(other.m_scheme);
+                    m_host = std::move(other.m_host);
+                    m_user_info = std::move(other.m_user_info);
+                    m_path = std::move(other.m_path);
+                    m_query = std::move(other.m_query);
+                    m_fragment = std::move(other.m_fragment);
+                    m_port = other.m_port;
+                }
+                return *this;
+            }
+            
             _ASYNCRTIMP utility::string_t join();
 
             utility::string_t m_scheme;
@@ -81,25 +128,25 @@ namespace web {
     };
 
     /// <summary>
-    /// A flexible, protocol independent uri implementation.
+    /// A flexible, protocol independent URI implementation.
     ///
-    /// URI instances are immutable. Querying the various fields on an emtpy uri will return empty strings. Querying
-    /// various diagnostic members on an empty uri will return false.
+    /// URI instances are immutable. Querying the various fields on an emtpy URI will return empty strings. Querying
+    /// various diagnostic members on an empty URI will return false.
     /// </summary>
     /// <remarks>
-    /// This implementation accepts both uris ('http://msn.com/path') and uri relative-references
+    /// This implementation accepts both URIs ('http://msn.com/path') and URI relative-references
     /// ('/path?query#frag').
     ///
     /// This implementation does not provide any scheme-specific handling -- an example of this
-    /// would be the following: 'http://path1/path'. This is a valid uri, but it's not a valid 
+    /// would be the following: 'http://path1/path'. This is a valid URI, but it's not a valid 
     /// http-uri -- that is, it's syntactically correct but does not conform to the requirements 
     /// of the http scheme (http requires a host). 
     /// We could provide this by allowing a pluggable 'scheme' policy-class, which would provide 
-    /// extra capability for validating and canonicalizing a uri according to scheme, and would 
-    /// introduce a layer of type-safety for uris of differing schemes, and thus differing semantics.
+    /// extra capability for validating and canonicalizing a URI according to scheme, and would 
+    /// introduce a layer of type-safety for URIs of differing schemes, and thus differing semantics.
     ///
-    /// One issue with implementing a scheme-independent uri facility is that of comparing for equality.
-    /// For instance, these uris are considered equal 'http://msn.com', 'http://msn.com:80'. That is --
+    /// One issue with implementing a scheme-independent URI facility is that of comparing for equality.
+    /// For instance, these URIs are considered equal 'http://msn.com', 'http://msn.com:80'. That is --
     /// the 'default' port can be either omitted or explicit. Since we don't have a way to map a scheme
     /// to it's default port, we don't have a way to know these are equal. This is just one of a class of
     /// issues with regard to scheme-specific behavior.
@@ -168,9 +215,9 @@ namespace web {
         _ASYNCRTIMP static std::map<utility::string_t, utility::string_t> __cdecl split_query(const utility::string_t &query);
 
         /// <summary>
-        /// Validates a string as a uri.
+        /// Validates a string as a URI.
         /// </summary>
-        /// <param name="uri_string">The uri string to be validated.</param>
+        /// <param name="uri_string">The URI string to be validated.</param>
         /// <returns><c>true</c> if the given string represents a valid URI, <c>false</c> otherwise.</returns>
         _ASYNCRTIMP static bool __cdecl validate(const utility::string_t &uri_string);
 
@@ -180,19 +227,61 @@ namespace web {
         uri() { m_uri = _XPLATSTR("/");};
 
         /// <summary>
-        /// Creates a uri from the given encoded string. This will throw an exception if the string 
-        /// does not contain a valid uri. Use uri::validate if processing user-input.
+        /// Creates a URI from the given encoded string. This will throw an exception if the string 
+        /// does not contain a valid URI. Use uri::validate if processing user-input.
         /// </summary>
         /// <param name="uri_string">A pointer to an encoded string to create the URI instance.</param>
         _ASYNCRTIMP uri(const utility::char_t *uri_string);
 
         /// <summary>
-        /// Creates a uri from the given encoded string. This will throw an exception if the string 
-        /// does not contain a valid uri. Use uri::validate if processing user-input.
+        /// Creates a URI from the given encoded string. This will throw an exception if the string 
+        /// does not contain a valid URI. Use uri::validate if processing user-input.
         /// </summary>
-        /// <param name="uri_string">An encoded uri string to create the URI instance.</param>
+        /// <param name="uri_string">An encoded URI string to create the URI instance.</param>
         _ASYNCRTIMP uri(const utility::string_t &uri_string);
 
+        /// <summary>
+        /// Copy constructor.
+        /// </summary>
+        uri(const uri &other) :
+            m_uri(other.m_uri),
+            m_components(other.m_components)
+        {}
+
+        /// <summary>
+        /// Copy assignment operator.
+        /// </summary>
+        uri & operator=(const uri &other)
+        {
+            if (this != &other)
+            {
+                m_uri = other.m_uri;
+                m_components = other.m_components;
+            }
+            return *this;
+        }
+
+        /// <summary>
+        /// Move constructor.
+        /// </summary>
+        uri(uri &&other) _noexcept :
+            m_uri(std::move(other.m_uri)),
+            m_components(std::move(other.m_components))
+        {}
+
+        /// <summary>
+        /// Move assignment operator
+        /// </summary>
+        uri & operator=(uri &&other) _noexcept
+        {
+            if (this != &other)
+            {
+                m_uri = std::move(other.m_uri);
+                m_components = std::move(other.m_components);
+            }
+            return *this;
+        }
+
         /// <summary>
         /// Get the scheme component of the URI as an encoded string.
         /// </summary>
@@ -244,11 +333,11 @@ namespace web {
         /// <summary>
         /// Gets the path, query, and fragment portion of this uri, which may be empty.
         /// </summary>
-        /// <returns>The new uri object with the path, query and fragment portion of this uri.</returns>
+        /// <returns>The new URI object with the path, query and fragment portion of this URI.</returns>
         _ASYNCRTIMP uri resource() const;
 
         /// <summary>
-        /// An empty uri specifies no components, and serves as a default value
+        /// An empty URI specifies no components, and serves as a default value
         /// </summary>
         bool is_empty() const
         {
@@ -303,37 +392,37 @@ namespace web {
         }
 
         /// <summary>
-        /// An "authority" uri is one with only a scheme, optional userinfo, hostname, and (optional) port.
+        /// An "authority" URI is one with only a scheme, optional userinfo, hostname, and (optional) port.
         /// </summary>
-        /// <returns><c>true</c> if this is an "authority" uri, <c>false</c> otherwise.</returns>
+        /// <returns><c>true</c> if this is an "authority" URI, <c>false</c> otherwise.</returns>
         bool is_authority() const
         {
             return !is_empty() && is_path_empty() && query().empty() && fragment().empty();
         }
 
         /// <summary>
-        /// Returns whether the other uri has the same authority as this one
+        /// Returns whether the other URI has the same authority as this one
         /// </summary>
-        /// <param name="other">The uri to compare the authority with.</param>
-        /// <returns><c>true</c> if both the uri's have the same authority, <c>false</c> otherwise.</returns>
+        /// <param name="other">The URI to compare the authority with.</param>
+        /// <returns><c>true</c> if both the URI's have the same authority, <c>false</c> otherwise.</returns>
         bool has_same_authority(const uri &other) const
         {
             return !is_empty() && this->authority() == other.authority();
         }
 
         /// <summary>
-        /// Returns whether the path portion of this uri is empty
+        /// Returns whether the path portion of this URI is empty
         /// </summary>
-        /// <returns><c>true</c> if the path portion of this uri is empty, <c>false</c> otherwise.</returns>
+        /// <returns><c>true</c> if the path portion of this URI is empty, <c>false</c> otherwise.</returns>
         bool is_path_empty() const
         {
             return path().empty() || path() == _XPLATSTR("/");
         }
 
         /// <summary>
-        /// Returns the full (encoded) uri as a string.
+        /// Returns the full (encoded) URI as a string.
         /// </summary>
-         /// <returns>The full encoded uri string.</returns>
+         /// <returns>The full encoded URI string.</returns>
         utility::string_t to_string() const
         {
             return m_uri;
@@ -358,7 +447,7 @@ namespace web {
         static utility::string_t encode_impl(const utility::string_t &raw, const std::function<bool(int)>& should_encode);
 
         utility::string_t m_uri;
-        details::_uri_components m_components;
+        details::uri_components m_components;
     };
 
 } // namespace web

Release/include/cpprest/http_client.h

@@ -163,9 +163,9 @@ class http_client_config
     /// Set the web proxy object
     /// </summary>
     /// <param name="proxy">A reference to the web proxy object.</param>
-    void set_proxy(const web_proxy& proxy)
+    void set_proxy(web_proxy proxy)
     {
-        m_proxy = proxy;
+        m_proxy = std::move(proxy);
     }
 
     /// <summary>
@@ -377,10 +377,7 @@ class http_client
     /// <returns>
     /// A base uri initialized in constructor
     /// </return>
-    const uri& base_uri() const
-    {
-        return _base_uri;
-    }
+    _ASYNCRTIMP const uri& base_uri() const;
 
     /// <summary>
     /// Get client configuration object
@@ -394,7 +391,7 @@ class http_client
     /// <param name="handler">A function object representing the pipeline stage.</param>
     void add_handler(std::function<pplx::task<http_response>(http_request, std::shared_ptr<http::http_pipeline_stage>)> handler)
     {
-        m_pipeline->append(std::make_shared< ::web::http::details::function_pipeline_wrapper>(handler));
+        m_pipeline->append(std::make_shared<::web::http::details::function_pipeline_wrapper>(handler));
     }
 
     /// <summary>
@@ -593,8 +590,6 @@ class http_client
     void build_pipeline(uri base_uri, http_client_config client_config);
 
     std::shared_ptr<::web::http::http_pipeline> m_pipeline;
-
-    uri _base_uri;
 };
 
 }}} // namespaces

Release/include/cpprest/http_client_impl.h

@@ -299,6 +299,11 @@ class _http_client_communicator
         return m_client_config;
     }
 
+    const uri & base_uri() const
+    {
+        return m_uri;
+    }
+
 protected:
     _http_client_communicator(http::uri address, http_client_config client_config)
         : m_uri(std::move(address)), m_client_config(std::move(client_config)), m_opened(false), m_scheduled(0)
@@ -437,15 +442,13 @@ void verify_uri(const uri &uri)
 } // namespace details
 
 http_client::http_client(uri base_uri)
-    :_base_uri(std::move(base_uri))
 {
-    build_pipeline(_base_uri, http_client_config());
+    build_pipeline(std::move(base_uri), http_client_config());
 }
 
 http_client::http_client(uri base_uri, http_client_config client_config)
-    :_base_uri(std::move(base_uri))
 {
-    build_pipeline(_base_uri, std::move(client_config));
+    build_pipeline(std::move(base_uri), std::move(client_config));
 }
 
 void http_client::build_pipeline(uri base_uri, http_client_config client_config)
@@ -458,26 +461,27 @@ void http_client::build_pipeline(uri base_uri, http_client_config client_config)
     }
     details::verify_uri(base_uri);
 
-    std::vector<std::shared_ptr<http::http_pipeline_stage> > extra_handlers;
+    m_pipeline = ::web::http::http_pipeline::create_pipeline(std::make_shared<details::http_network_handler>(std::move(base_uri), std::move(client_config)));
 
 #if !defined(CPPREST_TARGET_XP) && !defined(_PHONE8_)
-    extra_handlers.push_back(std::make_shared<oauth1::details::oauth1_handler>(client_config.oauth1()));
+    add_handler(std::static_pointer_cast<http::http_pipeline_stage>(
+        std::make_shared<oauth1::details::oauth1_handler>(this->client_config().oauth1())));
 #endif // !defined(CPPREST_TARGET_XP) && !defined(_PHONE8_)
 
-    extra_handlers.push_back(std::make_shared<oauth2::details::oauth2_handler>(client_config.oauth2()));
-
-    m_pipeline = ::web::http::http_pipeline::create_pipeline(std::make_shared<details::http_network_handler>(std::move(base_uri), std::move(client_config)));
-
-    for (auto& handler : extra_handlers)
-    {
-        add_handler(handler);
-    }
+    add_handler(std::static_pointer_cast<http::http_pipeline_stage>(
+        std::make_shared<oauth2::details::oauth2_handler>(this->client_config().oauth2())));
 }
 
-const http_client_config& http_client::client_config() const
+const http_client_config & http_client::client_config() const
 {
-    auto* ph = static_cast<details::http_network_handler*>(m_pipeline->last_stage().get());
+    auto ph = std::static_pointer_cast<details::http_network_handler>(m_pipeline->last_stage());
     return ph->http_client_impl()->client_config();
 }
 
+const uri & http_client::base_uri() const
+{
+    auto ph = std::static_pointer_cast<details::http_network_handler>(m_pipeline->last_stage());
+    return ph->http_client_impl()->base_uri();
+}
+
 }}} // namespaces