onDataReceived method has been added

Author: leventkaragol

README.md

@@ -29,6 +29,7 @@ Modern, non-blocking and exception free HTTP Client library for C++ (17+)
 * [Setting the User Agent](#setting-the-user-agent)
 * [How can I limit download and upload bandwidth?](#how-can-i-limit-download-and-upload-bandwidth)
 * [How do I get the request as a curl command?](#how-do-i-get-the-request-as-a-curl-command)
+* [How to stream data?](#how-to-stream-data)
 * [Semantic Versioning](#semantic-versioning)
 * [Full function list](#full-function-list)
 * [License](#license)
@@ -518,6 +519,39 @@ int main() {
 ```
 
 
+## How to stream data?
+
+Instead of receiving the data all at once, you can also receive it in parts using the **"onDataReceived"** callback method.
+
+```cpp
+#include <fstream>
+#include "libcpp-http-client.hpp"
+
+using namespace lklibs;
+
+int main() {
+    
+    HttpRequest httpRequest("https://api.myproject.com/image/5000");
+
+    // You can stream the data by onDataReceived methods
+    httpRequest.onDataReceived([&](const unsigned char* chunk, const size_t dataLength)
+    {
+        std::cout << "Received chunk of size: " << dataLength << std::endl;
+    });
+
+    auto response = httpRequest
+            .returnAsBinary()
+            .send()
+            .get();
+    
+    std::cout << "Succeed: " << response.succeed << std::endl;
+    std::cout << "Http Status Code: " << response.statusCode << std::endl;
+
+    return 0;
+}
+```
+
+
 ## Semantic Versioning
 
 Versioning of the library is done using conventional semantic versioning. Accordingly, 

examples/main.cpp

@@ -265,39 +265,60 @@ void getCurlCommand()
     std::cout << "Curl Command: " << response.toCurlCommand() << std::endl;
 }
 
-int main()
+void streamData()
 {
-    simpleGet();
-
-    nonBlockingGet();
-
-    receiveBinaryData();
-
-    receiveError();
-
-    sendingHttpHeaders();
-
-    simplePostWithFormData();
-
-    simplePostWithJSONData();
-
-    simplePutWithFormData();
-
-    simpleDeleteWithFormData();
-
-    simplePatch();
-
-    ignoreSslErrors();
+    HttpRequest httpRequest("https://httpbun.com/bytes/5000");
 
-    setTLSVersion();
+    // You can stream the data by onDataReceived methods
+    httpRequest.onDataReceived([&](const unsigned char* chunk, const size_t dataLength)
+    {
+        std::cout << "Received chunk of size: " << dataLength << std::endl;
+    });
 
-    setUserAgent();
-
-    setTimeout();
+    auto response = httpRequest
+                    .returnAsBinary()
+                    .send()
+                    .get();
 
-    setDownloadAndUploadBandwidthLimit();
+    std::cout << "Succeed: " << response.succeed << std::endl;
+    std::cout << "Http Status Code: " << response.statusCode << std::endl;
+}
 
-    getCurlCommand();
+int main()
+{
+    // simpleGet();
+    //
+    // nonBlockingGet();
+    //
+    // receiveBinaryData();
+    //
+    // receiveError();
+    //
+    // sendingHttpHeaders();
+    //
+    // simplePostWithFormData();
+    //
+    // simplePostWithJSONData();
+    //
+    // simplePutWithFormData();
+    //
+    // simpleDeleteWithFormData();
+    //
+    // simplePatch();
+    //
+    // ignoreSslErrors();
+    //
+    // setTLSVersion();
+    //
+    // setUserAgent();
+    //
+    // setTimeout();
+    //
+    // setDownloadAndUploadBandwidthLimit();
+    //
+    // getCurlCommand();
+
+    streamData();
 
     return 0;
 }

src/libcpp-http-client.hpp

@@ -1,7 +1,7 @@
 /*
 
 Modern, non-blocking and exception free HTTP Client library for C++ (17+)
-version 1.4.0
+version 1.5.0
 https://github.com/leventkaragol/libcpp-http-client
 
 If you encounter any issues, please submit a ticket at https://github.com/leventkaragol/libcpp-http-client/issues
@@ -134,7 +134,6 @@ namespace lklibs
                 {
                     initialized = true;
 
-                    // Cleanup is called at program exit.
                     std::atexit(cleanup);
                 }
             }
@@ -303,6 +302,18 @@ namespace lklibs
             return *this;
         }
 
+        /**
+         * @brief The callback that will be triggered when each piece (chunk) of incoming data is processed
+         *
+         * @param callback: Callback function that will be called with the data and its length
+        */
+        HttpRequest& onDataReceived(std::function<void(const unsigned char* data, size_t dataLength)> callback) noexcept
+        {
+            dataCallback = std::move(callback);
+
+            return *this;
+        }
+
         /**
          * @brief Convert the request to a cURL command string
          * This can be useful for debugging or logging purposes
@@ -394,7 +405,7 @@ namespace lklibs
 
         struct CurlDeleter
         {
-            void operator()(CURL* ptr)
+            void operator()(CURL* ptr) const
             {
                 if (ptr)
                 {
@@ -405,7 +416,7 @@ namespace lklibs
 
         struct CurlSlistDeleter
         {
-            void operator()(curl_slist* ptr)
+            void operator()(curl_slist* ptr) const
             {
                 if (ptr)
                 {
@@ -414,6 +425,8 @@ namespace lklibs
             }
         };
 
+        std::function<void(const unsigned char* data, size_t dataLength)> dataCallback;
+
         std::future<HttpResult> sendRequest() noexcept
         {
             return std::async(std::launch::async, [this]() -> HttpResult
@@ -436,17 +449,17 @@ namespace lklibs
 
                 std::string stringBuffer;
                 std::vector<unsigned char> binaryBuffer;
-                int statusCode = 0;
+                long statusCode = 0;
 
                 curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, headerList.get());
                 curl_easy_setopt(curl.get(), CURLOPT_URL, this->url.c_str());
                 curl_easy_setopt(curl.get(), CURLOPT_CUSTOMREQUEST, this->method.c_str());
                 curl_easy_setopt(curl.get(), CURLOPT_SSL_VERIFYPEER, this->sslErrorsWillBeIgnored ? 0L : 1L);
                 curl_easy_setopt(curl.get(), CURLOPT_SSL_VERIFYHOST, this->sslErrorsWillBeIgnored ? 0L : 1L);
-                curl_easy_setopt(curl.get(), CURLOPT_SSLVERSION, static_cast<int>(this->tlsVersion));
+                curl_easy_setopt(curl.get(), CURLOPT_SSLVERSION, static_cast<long>(this->tlsVersion));
                 curl_easy_setopt(curl.get(), CURLOPT_TIMEOUT, this->timeout);
-                curl_easy_setopt(curl.get(), CURLOPT_MAX_SEND_SPEED_LARGE, this->uploadBandwidthLimit);
-                curl_easy_setopt(curl.get(), CURLOPT_MAX_RECV_SPEED_LARGE, this->downloadBandwidthLimit);
+                curl_easy_setopt(curl.get(), CURLOPT_MAX_SEND_SPEED_LARGE, static_cast<curl_off_t>(this->uploadBandwidthLimit));
+                curl_easy_setopt(curl.get(), CURLOPT_MAX_RECV_SPEED_LARGE, static_cast<curl_off_t>(this->downloadBandwidthLimit));
 
                 if (!this->userAgent.empty())
                 {
@@ -458,7 +471,12 @@ namespace lklibs
                     curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, this->payload.c_str());
                 }
 
-                if (this->returnFormat == ReturnFormat::BINARY)
+                if (dataCallback)
+                {
+                    curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, streamingWriteCallback);
+                    curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, this);
+                }
+                else if (this->returnFormat == ReturnFormat::BINARY)
                 {
                     curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, binaryWriteCallback);
                     curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &binaryBuffer);
@@ -469,35 +487,58 @@ namespace lklibs
                     curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &stringBuffer);
                 }
 
-                CURLcode res = curl_easy_perform(curl.get());
+                const auto res = curl_easy_perform(curl.get());
                 curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &statusCode);
 
                 if (res == CURLE_OK && statusCode >= 200 && statusCode < 300)
                 {
-                    return {true, stringBuffer, binaryBuffer, statusCode, ""};
+                    return {
+                        true,
+                        std::move(stringBuffer),
+                        std::move(binaryBuffer),
+                        static_cast<int>(statusCode),
+                        ""
+                    };
                 }
                 else
                 {
-                    std::string errorMessage = curl_easy_strerror(res);
-
+                    std::string err = curl_easy_strerror(res);
                     if (res == CURLE_OK)
                     {
-                        errorMessage = "HTTP Error: " + std::to_string(statusCode);
+                        err = "HTTP Error: " + std::to_string(statusCode);
                     }
-
-                    return {false, stringBuffer, binaryBuffer, statusCode, errorMessage};
+                    return {
+                        false,
+                        std::move(stringBuffer),
+                        std::move(binaryBuffer),
+                        static_cast<int>(statusCode),
+                        std::move(err)
+                    };
                 }
             });
         }
 
-        static size_t textWriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
+        static size_t streamingWriteCallback(const void* contents, const size_t size, size_t nmemb, void* userp)
+        {
+            const auto* self = static_cast<HttpRequest*>(userp);
+
+            const size_t total = size * nmemb;
+
+            const auto* data = static_cast<const unsigned char*>(contents);
+
+            self->dataCallback(data, total);
+
+            return total;
+        }
+
+        static size_t textWriteCallback(void* contents, const size_t size, size_t nmemb, void* userp)
         {
-            ((std::string*)userp)->append((char*)contents, size * nmemb);
+            static_cast<std::string*>(userp)->append(static_cast<char*>(contents), size * nmemb);
 
             return size * nmemb;
         }
 
-        static size_t binaryWriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
+        static size_t binaryWriteCallback(void* contents, const size_t size, size_t nmemb, void* userp)
         {
             auto& buffer = *static_cast<std::vector<unsigned char>*>(userp);
 

test/test.cpp

@@ -841,6 +841,24 @@ TEST(CurlCommandTest, CurlCommandCanBeGet)
     ASSERT_EQ(response.toCurlCommand(), "curl -X POST -H \"Content-Type: application/json\" -A \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 Edg/124.0.0.0\" --max-time 3 --limit-rate 10240 --data '{\"param1\": 7, \"param2\": \"test\"}' \"https://httpbun.com/post\"") << "Curl command is invalid";
 }
 
+TEST(StreamData, ResponseCanBeStreamedByOnDataReceivedCallback)
+{
+    HttpRequest httpRequest("https://httpbun.com/bytes/5000");
+
+    httpRequest.onDataReceived([&](const unsigned char* chunk, const size_t dataLength)
+    {
+        ASSERT_TRUE(dataLength > 0) << "Binary data length is invalid";
+    });
+
+    auto response = httpRequest
+                    .returnAsBinary()
+                    .send()
+                    .get();
+
+    ASSERT_TRUE(response.succeed) << "HTTP Request failed";
+    ASSERT_EQ(response.statusCode, 200) << "HTTP Status Code is not 200";
+}
+
 int main(int argc, char** argv)
 {
     testing::InitGoogleTest(&argc, argv);