Change setCompletionStatus to convertCompletionStatus

So async and sync uses of Request only set the status code in one
place, change setCompletionStatus to convertCompletionStatus and
use the result of the function to set the status in either
onComplete (async) or Perform (sync).

inc/lift/EventLoop.h

@@ -271,16 +271,16 @@ class EventLoop {
     /**
      * @param event_loop Reference to the EventLoop that is calling onComplete (so requests that have
      *          response wait times can be removed from the multiset of ResponseWaitTimeWrapper)
+     * @param completion_status RequestStatus enum indicating the status of the lift Request when it has completed
+     *                          (Success, error, etc.).
      * @param shared_request Shared pointer to the SharedRequest that owns this Request, so it can be used to create
-     *          a RequestHandle and return the Request to the RequestPool if necessary.
-     * @param response_wait_time_timeout Bool indicating whether or not onComplete was called because
-     *          a response wait time was exceeded (true) or not (false)
-     * @param finish_time Optional that will contain a uint64_t indicating the timepoint when
-     *                    the request was timed out while waiting for the response time.
-     *                    If the request received a response or timed out via cURL, this will be
-     *                    empty and we'll get the total time from the cURL handle.
+     *                       a RequestHandle and return the Request to the RequestPool if necessary.
+     * @param finish_time Optional that will contain a uint64_t indicating the timepoint when request was timed out
+     *                    while waiting for the response time.  If the request received a response or timed out via
+     *                    cURL, this will be empty and we'll get the total time from the cURL handle.
+     *                    Default is an empty optional.
      */
-    friend auto Request::onComplete(EventLoop& event_loop, std::shared_ptr<SharedRequest> shared_request, std::optional<uint64_t> finish_time) -> void;
+    friend auto Request::onComplete(EventLoop& event_loop, RequestStatus completion_status, std::shared_ptr<SharedRequest> shared_request, std::optional<uint64_t> finish_time) -> void;
 };
 
 } // lift

inc/lift/Request.h

@@ -415,21 +415,23 @@ class Request {
     /**
      * Converts a CURLcode into a RequestStatus.
      * @param curl_code The CURLcode to convert.
+     * @return The lift RequestStatus that corresponds to the CURLcode
      */
-    auto setCompletionStatus(
-        CURLcode curl_code) -> void;
+    auto convertCompletionStatus(CURLcode curl_code) -> RequestStatus;
 
     /**
      * @param event_loop Reference to the EventLoop that is calling onComplete (so requests that have
      *          response wait times can be removed from the multiset of ResponseWaitTimeWrapper)
+     * @param completion_status RequestStatus enum indicating the status of the lift Request when it has completed
+     *                          (Success, error, etc.).
      * @param shared_request Shared pointer to the SharedRequest that owns this Request, so it can be used to create
      *                       a RequestHandle and return the Request to the RequestPool if necessary.
      * @param finish_time Optional that will contain a uint64_t indicating the timepoint when request was timed out 
      *                    while waiting for the response time.  If the request received a response or timed out via 
      *                    cURL, this will be empty and we'll get the total time from the cURL handle.
      *                    Default is an empty optional.
      */
-    auto onComplete(EventLoop& event_loop, std::shared_ptr<SharedRequest> shared_request, std::optional<uint64_t> finish_time = std::nullopt) -> void;
+    auto onComplete(EventLoop& event_loop, RequestStatus completion_status, std::shared_ptr<SharedRequest> shared_request, std::optional<uint64_t> finish_time = std::nullopt) -> void;
 
     /**
      * Helper function to find how many bytes are left to be downloaded for a request

src/EventLoop.cpp

@@ -220,7 +220,7 @@ auto EventLoop::stopTimedOutRequests() -> void
 
         // Call onComplete on the underlying Request object, copying in the shared_pointer
         // so we get a correct reference count.
-        shared_request->GetAsReference().onComplete(*this, shared_request, now);
+        shared_request->GetAsReference().onComplete(*this, RequestStatus::RESPONSE_WAIT_TIME_TIMEOUT, shared_request, now);
     }
 
     // If there are still items in the multiset, get the first item and use its time to reset the request timer.
@@ -294,8 +294,7 @@ auto EventLoop::checkActions(
                 auto shared_request_ptr = *shared_request_ptr_pointer;
                 auto& shared_request_ref = shared_request_ptr->GetAsReference();
 
-                shared_request_ref.setCompletionStatus(easy_result);
-                shared_request_ref.onComplete(*this, shared_request_ptr);
+                shared_request_ref.onComplete(*this, shared_request_ref.convertCompletionStatus(easy_result), shared_request_ptr);
 
                 --m_active_request_count;
             }
@@ -495,14 +494,11 @@ auto requests_accept_async(uv_async_t* handle) -> void
 
         if(curl_code != CURLM_OK && curl_code != CURLM_CALL_MULTI_PERFORM)
         {
-            /**
-             * If curl_multi_add_handle fails then notify the user that the request failed to start
-             * immediately.
+            /*
+             * If curl_multi_add_handle fails then notify the user that the request failed to start immediately.
+             * If we are calling onComplete now, move the shared_ptr into the method so it cleans itself up correctly.
              */
-            request_handle->setCompletionStatus(CURLcode::CURLE_SEND_ERROR);
-
-            // If we are calling onComplete now, move the shared_ptr into the method so it cleans itself up correctly.
-            request_handle->onComplete(*event_loop, *shared_request_on_heap);
+            request_handle->onComplete(*event_loop, RequestStatus::ERROR_FAILED_TO_START, *shared_request_on_heap);
         }
         else
         {

src/Request.cpp

@@ -324,7 +324,7 @@ auto Request::Perform() -> bool
 {
     prepareForPerform();
     auto curl_error_code = curl_easy_perform(m_curl_handle);
-    setCompletionStatus(curl_error_code);
+    m_status_code = convertCompletionStatus(curl_error_code);
     return (m_status_code == RequestStatus::SUCCESS);
 }
 
@@ -451,52 +451,41 @@ auto Request::clearResponseBuffers() -> void
     m_response_data.clear();
 }
 
-auto Request::setCompletionStatus(
-    CURLcode curl_code) -> void
+auto Request::convertCompletionStatus(CURLcode curl_code) -> RequestStatus
 {
-
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch-enum"
     switch (curl_code) {
     case CURLcode::CURLE_OK:
-        m_status_code = RequestStatus::SUCCESS;
-        break;
+        return RequestStatus::SUCCESS;
     case CURLcode::CURLE_GOT_NOTHING:
-        m_status_code = RequestStatus::RESPONSE_EMPTY;
-        break;
+        return RequestStatus::RESPONSE_EMPTY;
     case CURLcode::CURLE_OPERATION_TIMEDOUT:
-        m_status_code = RequestStatus::TIMEOUT;
-        break;
+        return RequestStatus::TIMEOUT;
     case CURLcode::CURLE_COULDNT_CONNECT:
-        m_status_code = RequestStatus::CONNECT_ERROR;
-        break;
+        return RequestStatus::CONNECT_ERROR;
     case CURLcode::CURLE_COULDNT_RESOLVE_HOST:
-        m_status_code = RequestStatus::CONNECT_DNS_ERROR;
-        break;
+        return RequestStatus::CONNECT_DNS_ERROR;
     case CURLcode::CURLE_SSL_CONNECT_ERROR:
-        m_status_code = RequestStatus::CONNECT_SSL_ERROR;
-        break;
+        return RequestStatus::CONNECT_SSL_ERROR;
     case CURLcode::CURLE_WRITE_ERROR:
         /**
          * If there is a cURL write error, but the maximum number of bytes has been written,
          * then we intentionally aborted, so let's set this to success.
          * Otherwise, there was an error in the CURL write callback.
          */
-        m_status_code = (getRemainingDownloadBytes() == 0)
+        return (getRemainingDownloadBytes() == 0)
             ? RequestStatus::SUCCESS
             : RequestStatus::DOWNLOAD_ERROR;
-        break;
     case CURLcode::CURLE_SEND_ERROR:
-        m_status_code = RequestStatus::ERROR_FAILED_TO_START;
-        break;
+        return RequestStatus::ERROR_FAILED_TO_START;
     default:
-        m_status_code = RequestStatus::ERROR;
-        break;
+        return RequestStatus::ERROR;
     }
 #pragma GCC diagnostic pop
 }
 
-auto Request::onComplete(EventLoop& event_loop, std::shared_ptr<SharedRequest> shared_request, std::optional<uint64_t> finish_time) -> void
+auto Request::onComplete(EventLoop& event_loop, RequestStatus completion_status, std::shared_ptr<SharedRequest> shared_request, std::optional<uint64_t> finish_time) -> void
 {
     auto request_handle_ptr = RequestHandle(std::move(shared_request));
 
@@ -510,6 +499,7 @@ auto Request::onComplete(EventLoop& event_loop, std::shared_ptr<SharedRequest> s
         }
 
         setTotalTime(finish_time);
+        m_status_code = completion_status;
 
         if (m_on_complete_handler != nullptr)
         {