Updating websocketpp to 0.3.0 release.

Author: stgates

Release/libs/websocketpp/Doxyfile

@@ -33,7 +33,7 @@ PROJECT_NAME           = "websocketpp"
 # if some version control system is used.
 
 
-PROJECT_NUMBER         = "0.4.0-dev"
+PROJECT_NUMBER         = "0.3.0"
 
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description

Release/libs/websocketpp/changelog.md

@@ -1,4 +1,6 @@
 HEAD
+
+0.3.0 - 2014-08-10
 - Feature: Adds `start_perpetual` and `stop_perpetual` methods to asio transport
   These may be used to replace manually managed `asio::io_service::work` objects
 - Feature: Allow setting pong and handshake timeouts at runtime.
@@ -17,6 +19,9 @@ HEAD
 - Feature: Adds the ability to specify a maximum message size.
 - Feature: Adds `close::status::get_string(...)` method to look up a human
   readable string given a close code value.
+- Feature: Adds `connection::read_all(...)` method to iostream transport as a
+  convenience method for reading all data into the connection buffer without the
+  end user needing to manually loop on `read_some`.
 - Improvement: Open, close, and pong timeouts can be disabled entirely by
   setting their duration to 0.
 - Improvement: Numerous performance improvements. Including: tuned default

Release/libs/websocketpp/readme.md

@@ -1,4 +1,4 @@
-WebSocket++ (0.3.0-alpha4)
+WebSocket++ (0.3.0)
 ==========================
 
 WebSocket++ is a header only C++ library that implements RFC6455 The WebSocket

Release/libs/websocketpp/test/transport/iostream/connection.cpp

@@ -63,6 +63,7 @@ struct stub_con : public iostream_con {
         // Set the error to a known code that is unused by the library
         // This way we can easily confirm that the handler was run at all.
         , ec(websocketpp::error::make_error_code(websocketpp::error::test))
+        , indef_read_total(0)
     {}
 
     /// Get a shared pointer to this component
@@ -111,7 +112,41 @@ struct stub_con : public iostream_con {
         ec = e;
     }
 
+    void async_read_indef(size_t num_bytes, char *buf, size_t len)
+	{
+        indef_read_size = num_bytes;
+        indef_read_buf = buf;
+        indef_read_len = len;
+        
+        indef_read();
+    }
+
+    void indef_read() {
+        iostream_con::async_read_at_least(
+            indef_read_size,
+            indef_read_buf,
+            indef_read_len,
+            websocketpp::lib::bind(
+                &stub_con::handle_indef,
+                type::get_shared(),
+                websocketpp::lib::placeholders::_1,
+                websocketpp::lib::placeholders::_2
+            )
+        );
+    }
+
+    void handle_indef(websocketpp::lib::error_code const & e, size_t read) {
+        ec = e;
+        indef_read_total += read;
+        
+        indef_read();
+    }
+
     websocketpp::lib::error_code ec;
+    size_t indef_read_size;
+    char * indef_read_buf;
+    size_t indef_read_len;
+    size_t indef_read_total;
 };
 
 // Stubs
@@ -314,6 +349,47 @@ BOOST_AUTO_TEST_CASE( async_read_at_least_read_some ) {
     BOOST_CHECK_EQUAL( std::string(buf,10), "abcdefgxxx" );
 }
 
+BOOST_AUTO_TEST_CASE( async_read_at_least_read_some_indef ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[20];
+    memset(buf,'x',20);
+
+    con->async_read_indef(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+
+    // here we expect to return early from read some because the outstanding
+    // read was for 5 bytes and we were called with 10.
+    char input[11] = "aaaaabbbbb";
+    BOOST_CHECK_EQUAL(con->read_some(input,10), 5);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "aaaaaxxxxx" );
+    BOOST_CHECK_EQUAL( con->indef_read_total, 5 );
+    
+    // A subsequent read should read 5 more because the indef read refreshes
+    // itself. The new read will start again at the beginning of the buffer.
+    BOOST_CHECK_EQUAL(con->read_some(input+5,5), 5);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "bbbbbxxxxx" );
+    BOOST_CHECK_EQUAL( con->indef_read_total, 10 );
+}
+
+BOOST_AUTO_TEST_CASE( async_read_at_least_read_all ) {
+    stub_con::ptr con(new stub_con(true,alogger,elogger));
+
+    char buf[20];
+    memset(buf,'x',20);
+
+    con->async_read_indef(5,buf,5);
+    BOOST_CHECK( con->ec == make_error_code(websocketpp::error::test) );
+
+    char input[11] = "aaaaabbbbb";
+    BOOST_CHECK_EQUAL(con->read_all(input,10), 10);
+    BOOST_CHECK( !con->ec );
+    BOOST_CHECK_EQUAL( std::string(buf,10), "bbbbbxxxxx" );
+    BOOST_CHECK_EQUAL( con->indef_read_total, 10 );
+}
+
 BOOST_AUTO_TEST_CASE( eof_flag ) {
     stub_con::ptr con(new stub_con(true,alogger,elogger));
     char buf[10];

Release/libs/websocketpp/websocketpp/close.hpp

@@ -204,7 +204,7 @@ namespace status {
     /**
      * See https://tools.ietf.org/html/rfc6455#section-7.4 for more details.
      *
-     * @since 0.4.0-beta1
+     * @since 0.3.0
      *
      * @param [in] code The code to look up.
      * @return A human readable interpretation of the code.

Release/libs/websocketpp/websocketpp/concurrency/none.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Peter Thorson. All rights reserved.
+ * Copyright (c) 2014, Peter Thorson. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -29,26 +29,48 @@
 #define WEBSOCKETPP_CONCURRENCY_NONE_HPP
 
 namespace websocketpp {
+
+/// Concurrency handling support
 namespace concurrency {
 
+/// Implementation for no-op locking primitives
 namespace none_impl {
+/// A fake mutex implementation that does nothing
 class fake_mutex {
 public:
     fake_mutex() {}
     ~fake_mutex() {}
 };
 
+/// A fake lock guard implementation that does nothing
 class fake_lock_guard {
 public:
     explicit fake_lock_guard(fake_mutex foo) {}
     ~fake_lock_guard() {}
 };
 } // namespace none_impl
 
-/// Stub Concurrency policy to remove locking in single threaded projects
+/// Stub concurrency policy that implements the interface using no-ops.
+/**
+ * This policy documents the concurrency policy interface using no-ops. It can
+ * be used as a reference or base for building a new concurrency policy. It can
+ * also be used as is to disable all locking for endpoints used in purely single
+ * threaded programs.
+ */
 class none {
 public:
+    /// The type of a mutex primitive
+    /**
+     * std::mutex is an example.
+     */
     typedef none_impl::fake_mutex mutex_type;
+
+    /// The type of a scoped/RAII lock primitive.
+    /**
+     * The scoped lock constructor should take a mutex_type as a parameter,
+     * acquire that lock, and release it in its destructor. std::lock_guard is
+     * an example.
+     */
     typedef none_impl::fake_lock_guard scoped_lock_type;
 };
 

Release/libs/websocketpp/websocketpp/config/core.hpp

@@ -223,7 +223,7 @@ struct core {
      *
      * The default is 32MB
      *
-     * @since 0.4.0-alpha1
+     * @since 0.3.0
      */
     static const size_t max_message_size = 32000000;
 

Release/libs/websocketpp/websocketpp/config/core_client.hpp

@@ -232,7 +232,7 @@ struct core_client {
      *
      * The default is 32MB
      *
-     * @since 0.4.0-alpha1
+     * @since 0.3.0
      */
     static const size_t max_message_size = 32000000;
 

Release/libs/websocketpp/websocketpp/config/debug.hpp

@@ -224,7 +224,7 @@ struct debug_core {
      *
      * The default is 32MB
      *
-     * @since 0.4.0-alpha1
+     * @since 0.3.0
      */
     static const size_t max_message_size = 32000000;
 

Release/libs/websocketpp/websocketpp/connection.hpp

@@ -538,7 +538,7 @@ class connection
      *
      * The default is set by the endpoint that creates the connection.
      *
-     * @since 0.4.0-alpha1
+     * @since 0.3.0
      */
     size_t get_max_message_size() const {
         return m_max_message_size;
@@ -552,7 +552,7 @@ class connection
      *
      * The default is set by the endpoint that creates the connection.
      *
-     * @since 0.4.0-alpha1
+     * @since 0.3.0
      *
      * @param new_value The value to set as the maximum message size.
      */