Remove pplx::task from product code (#7)

Author: BrennanConroy

include/signalrclient/http_client.h

@@ -32,7 +32,7 @@ namespace signalr
         http_response(http_response&& rhs) noexcept : status_code(rhs.status_code), content(std::move(rhs.content)) {}
         http_response(int code, const std::string& content) : status_code(code), content(content) {}
 
-        http_response& operator=(http_response&& rhs)
+        http_response& operator=(http_response&& rhs) noexcept
         {
             status_code = rhs.status_code;
             content = std::move(rhs.content);
@@ -47,7 +47,7 @@ namespace signalr
     class http_client
     {
     public:
-        virtual void send(std::string url, http_request request, std::function<void(http_response, std::exception_ptr)> callback) = 0;
+        virtual void send(std::string url, const http_request& request, std::function<void(const http_response&, std::exception_ptr)> callback) = 0;
 
         virtual ~http_client() {}
     };

include/signalrclient/websocket_client.h

@@ -13,12 +13,12 @@ namespace signalr
     public:
         virtual ~websocket_client() {};
 
-        virtual void start(std::string url, transfer_format format, std::function<void(std::exception_ptr)> callback) = 0;
+        virtual void start(const std::string& url, transfer_format format, std::function<void(std::exception_ptr)> callback) = 0;
 
         virtual void stop(std::function<void(std::exception_ptr)> callback) = 0;
 
-        virtual void send(std::string payload, std::function<void(std::exception_ptr)> callback) = 0;
+        virtual void send(const std::string& payload, std::function<void(std::exception_ptr)> callback) = 0;
 
-        virtual void receive(std::function<void(std::string, std::exception_ptr)> callback) = 0;
+        virtual void receive(std::function<void(const std::string&, std::exception_ptr)> callback) = 0;
     };
 }

src/signalrclient/CMakeLists.txt

@@ -4,7 +4,6 @@ set (SOURCES
   connection_impl.cpp
   default_http_client.cpp
   default_websocket_client.cpp
-  http_sender.cpp
   hub_connection.cpp
   hub_connection_impl.cpp
   logger.cpp
@@ -15,8 +14,6 @@ set (SOURCES
   transport.cpp
   transport_factory.cpp
   url_builder.cpp
-  web_request.cpp
-  web_request_factory.cpp
   websocket_transport.cpp
 )
 

src/signalrclient/event.h renamed to src/signalrclient/cancellation_token.h

@@ -9,22 +9,21 @@
 
 namespace signalr
 {
-    class event
+    class canceled_exception : public std::exception
     {
-    private:
-        std::mutex m_lock;
-        std::condition_variable m_condition;
-        bool m_signaled;
-    public:
+    };
 
+    class cancellation_token
+    {
+    public:
         static const unsigned int timeout_infinite = 0xFFFFFFFF;
 
-        event() noexcept
+        cancellation_token() noexcept
             : m_signaled(false)
         {
         }
 
-        void set()
+        void cancel()
         {
             std::lock_guard<std::mutex> lock(m_lock);
             m_signaled = true;
@@ -37,10 +36,15 @@ namespace signalr
             m_signaled = false;
         }
 
+        bool is_canceled() const
+        {
+            return m_signaled;
+        }
+
         unsigned int wait(unsigned int timeout)
         {
             std::unique_lock<std::mutex> lock(m_lock);
-            if (timeout == event::timeout_infinite)
+            if (timeout == cancellation_token::timeout_infinite)
             {
                 m_condition.wait(lock, [this]() noexcept { return m_signaled; });
                 return 0;
@@ -51,13 +55,25 @@ namespace signalr
                 const auto status = m_condition.wait_for(lock, period, [this]() noexcept { return m_signaled; });
                 assert(status == m_signaled);
                 // Return 0 if the wait completed as a result of signaling the event. Otherwise, return timeout_infinite
-                return status ? 0 : event::timeout_infinite;
+                return status ? 0 : cancellation_token::timeout_infinite;
             }
         }
 
         unsigned int wait()
         {
-            return wait(event::timeout_infinite);
+            return wait(cancellation_token::timeout_infinite);
+        }
+
+        void throw_if_cancellation_requested() const
+        {
+            if (m_signaled)
+            {
+                throw canceled_exception();
+            }
         }
+    private:
+        std::mutex m_lock;
+        std::condition_variable m_condition;
+        bool m_signaled;
     };
 }

src/signalrclient/case_insensitive_comparison_utils.h

@@ -5,7 +5,6 @@
 
 #include <functional>
 #include <cctype>
-#include "cpprest/details/basic_types.h"
 
 namespace signalr
 {
@@ -21,9 +20,9 @@ namespace signalr
                 return false;
             }
 
-            for (auto s1_iterator = s1.begin(), s2_iterator = s2.begin(); s1_iterator != s1.end(); ++s1_iterator, ++s2_iterator)
+            for (int i = 0; i < s1.size(); ++i)
             {
-                if (std::toupper(*s1_iterator) != std::toupper(*s2_iterator))
+                if (std::toupper(s1[i]) != std::toupper(s2[i]))
                 {
                     return false;
                 }
@@ -39,7 +38,7 @@ namespace signalr
         {
             size_t hash = 0;
             std::hash<size_t> hasher;
-            for (const utility::char_t& c : s)
+            for (const auto& c : s)
             {
                 hash ^= hasher(std::toupper(c)) + (hash << 5) + (hash >> 2);
             }

src/signalrclient/completion_event.h

@@ -0,0 +1,90 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#pragma once
+
+#include <future>
+
+namespace signalr
+{
+    class completion_event_impl : public std::enable_shared_from_this<completion_event_impl>
+    {
+    public:
+        static std::shared_ptr<completion_event_impl> create()
+        {
+            return std::shared_ptr<completion_event_impl>(new completion_event_impl());
+        }
+
+        // no op when already set
+        void set()
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            if (!m_isSet)
+            {
+                m_promise.set_value();
+                m_isSet = true;
+            }
+        }
+
+        // no op when already set
+        void set(const std::exception_ptr& exception)
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            if (!m_isSet)
+            {
+                m_promise.set_exception(exception);
+                m_isSet = true;
+            }
+        }
+
+        // blocks and returns when set or throws when an exception is set
+        void get() const
+        {
+            m_future.get();
+        }
+
+    private:
+        completion_event_impl() : m_isSet(false)
+        {
+            m_future = m_promise.get_future().share();
+        }
+
+        std::promise<void> m_promise;
+        std::shared_future<void> m_future;
+        bool m_isSet;
+        std::mutex m_mutex;
+    };
+
+    class completion_event
+    {
+    public:
+        completion_event() : m_impl(completion_event_impl::create())
+        {
+        }
+
+        completion_event(const completion_event& rhs)
+        {
+            m_impl = rhs.m_impl;
+        }
+
+        // no op when already set
+        void set()
+        {
+            m_impl->set();
+        }
+
+        // no op when already set
+        void set(const std::exception_ptr& exception)
+        {
+            m_impl->set(exception);
+        }
+
+        // blocks and returns when set or throws when an exception is set
+        void get() const
+        {
+            m_impl->get();
+        }
+    private:
+        std::shared_ptr<completion_event_impl> m_impl;
+    };
+}