Renaming namespace

Author: stgates

Release/include/cpprest/web_utilities.h

@@ -37,7 +37,7 @@ namespace http { namespace client {
     class http_client_config;
 }}
 
-namespace experimental { namespace web_sockets { namespace client {
+namespace experimental { namespace websockets { namespace client {
     class websocket_client_config;
 }}}
 
@@ -75,7 +75,7 @@ class credentials
 private:
     friend class web::web_proxy;
     friend class web::http::client::http_client_config;
-    friend class web::experimental::web_sockets::client::websocket_client_config;
+    friend class web::experimental::websockets::client::websocket_client_config;
 
     credentials() : m_is_set(false) {}
 

Release/include/cpprest/ws_client.h

@@ -57,7 +57,7 @@ namespace web
 /// WebSocket client is currently in beta.
 namespace experimental 
 {
-namespace web_sockets
+namespace websockets
 {
 /// WebSocket client side library.
 namespace client
@@ -359,29 +359,10 @@ class websocket_client
     _ASYNCRTIMP websocket_client(websocket_client_config client_config);
 
     /// <summary>
+    /// Destructor
     /// </summary>
     ~websocket_client() { }
 
-    /// <summary>
-    /// Move constructor.
-    /// </summary>
-    websocket_client(websocket_client &&other) 
-        : m_client(std::move(other.m_client))
-    {
-    }
-
-    /// <summary>
-    /// Move assignment operator.
-    /// </summary>
-    websocket_client &operator=(websocket_client &&other)
-    {
-        if(this != &other)
-        {
-            m_client = std::move(other.m_client);
-        }
-        return *this;
-    }
-
     /// <summary>
     /// Connects to the remote network destination. The connect method initiates the websocket handshake with the 
     /// remote network destination, takes care of the protocol upgrade request.

Release/include/cpprest/ws_msg.h

@@ -33,7 +33,7 @@
 #include <limits>
 
 #include "cpprest/xxpublic.h"
-#include "cpprest/containerstream.h"
+#include "cpprest/producerconsumerstream.h"
 
 #if _NOT_PHONE8_
 #if defined(_MSC_VER) && (_MSC_VER >= 1800)
@@ -51,7 +51,7 @@ namespace web
 { 
 namespace experimental
 {
-namespace web_sockets
+namespace websockets
 {
 namespace client
 {
@@ -62,7 +62,6 @@ namespace details
     class ws_desktop_client;
 }
 
-
 /// <summary>
 /// The different types of websocket message.
 /// Text type contains UTF-8 encoded data.
@@ -83,47 +82,26 @@ namespace details
 class _websocket_message
 {
 public:
-    _ASYNCRTIMP void set_body(concurrency::streams::istream instream);
 
-    /// <summary>
-    /// Get the streambuf for the message
-    /// </summary>
-    concurrency::streams::streambuf<uint8_t>& streambuf() { return m_buf; }
+    concurrency::streams::streambuf<uint8_t> & body() { return m_buf; }
 
-    /// <summary>
-    /// Set the streambuf for the message
-    /// </summary>
-    void set_streambuf(concurrency::streams::streambuf<uint8_t> buf) { m_buf = buf; }
+    void set_body(const concurrency::streams::streambuf<uint8_t> &buf) { m_buf = buf; }
 
     void set_msg_type(websocket_message_type msg_type) { m_msg_type = msg_type; }
 
     void set_length(size_t len) { m_length = len; }
 
-    size_t length() { return m_length; }
+    size_t length() const { return m_length; }
 
-    websocket_message_type message_type() { return m_msg_type; }
+    websocket_message_type message_type() const { return m_msg_type; }
 
-    pplx::task_completion_event<void> _get_data_available()  { return m_data_available; }
-
-    void _set_data_available() { m_data_available.set(); }
-
-    _ASYNCRTIMP std::string _extract_string();
-
-    /// <summary>
-    /// Prepare the message with an output stream to receive network data
-    /// </summary>
-    _ASYNCRTIMP void _prepare_to_receive_data();
-
-protected:
+private:
 
     concurrency::streams::streambuf<uint8_t> m_buf;
 
     websocket_message_type m_msg_type;
 
     size_t m_length;
-
-    /// <summary> The TCE is used to signal the availability of the message body. </summary>
-    pplx::task_completion_event<void> m_data_available;
 };
 }
 
@@ -133,24 +111,36 @@ class _websocket_message
 class websocket_outgoing_message 
 {
 public:
-    websocket_outgoing_message()
-        : _m_impl(std::make_shared<details::_websocket_message>()) {}
+
+    /// <summary>
+    /// Creates an initially empty message for sending. 
+    /// </summary>
+    websocket_outgoing_message() : _m_impl(std::make_shared<details::_websocket_message>()) {}
 
     /// <summary>
     /// Sets a UTF-8 message as the message body.
     /// </summary>
     /// <param name="data">UTF-8 String containing body of the message.</param>
-    void set_utf8_message(std::string data)
+    void set_utf8_message(std::string &&data)
     {
         this->_set_message(std::move(data), websocket_message_type::text_message);
     }
 
+    /// <summary>
+    /// Sets a UTF-8 message as the message body.
+    /// </summary>
+    /// <param name="data">UTF-8 String containing body of the message.</param>
+    void set_utf8_message(const std::string &data)
+    {
+        this->_set_message(data, websocket_message_type::text_message);
+    }
+
     /// <summary>
     /// Sets a UTF-8 message as the message body.
     /// </summary>
     /// <param name="istream">casablanca input stream representing the body of the message.</param>
     /// <remarks>Upon sending, the entire stream may be buffered to determine the length.</remarks>
-    void set_utf8_message(concurrency::streams::istream istream)
+    void set_utf8_message(const concurrency::streams::istream &istream)
     {
         this->_set_message(istream, SIZE_MAX, websocket_message_type::text_message);
     }
@@ -160,7 +150,7 @@ class websocket_outgoing_message
     /// </summary>
     /// <param name="istream">casablanca input stream representing the body of the message.</param>
     /// <param name="len">number of bytes to send.</param>
-    void set_utf8_message(concurrency::streams::istream istream, size_t len)
+    void set_utf8_message(const concurrency::streams::istream &istream, size_t len)
     {
         this->_set_message(istream, len, websocket_message_type::text_message);
     }
@@ -170,7 +160,7 @@ class websocket_outgoing_message
     /// </summary>
     /// <param name="istream">casablanca input stream representing the body of the message.</param>
     /// <param name="len">number of bytes to send.</param>
-    void set_binary_message(concurrency::streams::istream istream, size_t len)
+    void set_binary_message(const concurrency::streams::istream &istream, size_t len)
     {
         this->_set_message(istream, len, websocket_message_type::binary_message);
     }
@@ -180,7 +170,7 @@ class websocket_outgoing_message
     /// </summary>
     /// <param name="istream">casablanca input stream representing the body of the message.</param>
     /// <remarks>Upon sending, the entire stream may be buffered to determine the length.</remarks>
-    void set_binary_message(concurrency::streams::istream istream)
+    void set_binary_message(const concurrency::streams::istream &istream)
     {
         this->_set_message(istream, SIZE_MAX, websocket_message_type::binary_message);
     }
@@ -192,22 +182,40 @@ class websocket_outgoing_message
 
     std::shared_ptr<details::_websocket_message> _m_impl;
 
-    void _set_message(std::string data, websocket_message_type msg_type)
+    pplx::task_completion_event<void> m_body_sent;
+
+    void signal_body_sent()
+    {
+        m_body_sent.set();
+    }
+
+    void signal_body_sent(const std::exception_ptr &e)
+    {
+        m_body_sent.set_exception(e);
+    }
+
+    pplx::task_completion_event<void> & body_sent() { return m_body_sent; }
+
+    void _set_message(std::string &&data, websocket_message_type msg_type)
     {
         _m_impl->set_msg_type(msg_type);
         _m_impl->set_length(data.length());
-        auto istream = concurrency::streams::bytestream::open_istream<std::string>(std::move(data));
-        _m_impl->set_body(istream);
+        _m_impl->set_body(concurrency::streams::container_buffer<std::string>(std::move(data)));
     }
 
-    void _set_message(concurrency::streams::istream istream, size_t len, websocket_message_type msg_type)
+    void _set_message(const std::string &data, websocket_message_type msg_type)
     {
         _m_impl->set_msg_type(msg_type);
-        _m_impl->set_body(istream);
-        _m_impl->set_length(len);
+        _m_impl->set_length(data.length());
+        _m_impl->set_body(concurrency::streams::container_buffer<std::string>(data));
     }
 
-    pplx::task_completion_event<void> m_send_tce;
+    void _set_message(const concurrency::streams::istream &istream, size_t len, websocket_message_type msg_type)
+    {
+        _m_impl->set_msg_type(msg_type);
+        _m_impl->set_body(istream.streambuf());
+        _m_impl->set_length(len);
+    }
 };
 
 /// <summary>
@@ -216,7 +224,12 @@ class websocket_outgoing_message
 class websocket_incoming_message
 {
 public:
-    websocket_incoming_message(): _m_impl(std::make_shared<details::_websocket_message>()) { }
+    websocket_incoming_message() : _m_impl(std::make_shared<details::_websocket_message>()) 
+    { 
+        // Body defaults to producer_consumer_buffer.
+        // Perhaps in the future options could be exposed to allow the user to set.
+        _m_impl->set_body(concurrency::streams::producer_consumer_buffer<uint8_t>());
+    }
 
     /// <summary>
     /// Extracts the body of the incoming message as a string value, only if the message type is UTF-8.
@@ -235,7 +248,7 @@ class websocket_incoming_message
     /// </remarks>
     concurrency::streams::istream body() const
     {
-        return _m_impl->streambuf().create_istream();
+        return _m_impl->body().create_istream();
     }
 
     /// <summary>