add callback param to request_builder

headers/curly.hpp/curly.hpp

@@ -18,6 +18,7 @@
 #include <string>
 #include <vector>
 #include <stdexcept>
+#include <functional>
 
 namespace curly_hpp
 {
@@ -48,6 +49,9 @@ namespace curly_hpp
     using time_ms_t = std::chrono::milliseconds;
     using time_point_t = std::chrono::steady_clock::time_point;
 
+    class request;
+    using callback_t = std::function<void(request)>;
+
     class upload_handler {
     public:
         virtual ~upload_handler() {}
@@ -176,6 +180,7 @@ namespace curly_hpp
 
         request_builder& content(std::string_view b);
         request_builder& content(content_t b) noexcept;
+        request_builder& callback(callback_t c) noexcept;
         request_builder& uploader(uploader_uptr u) noexcept;
         request_builder& downloader(downloader_uptr d) noexcept;
 
@@ -193,6 +198,9 @@ namespace curly_hpp
         content_t& content() noexcept;
         const content_t& content() const noexcept;
 
+        callback_t& callback() noexcept;
+        const callback_t& callback() const noexcept;
+
         uploader_uptr& uploader() noexcept;
         const uploader_uptr& uploader() const noexcept;
 
@@ -201,16 +209,22 @@ namespace curly_hpp
 
         request send();
 
+        template < typename Callback >
+        request_builder& callback(Callback&& f) {
+            static_assert(std::is_convertible_v<Callback, callback_t>);
+            return callback(callback_t(std::forward<Callback>(f)));
+        }
+
         template < typename Uploader, typename... Args >
         request_builder& uploader(Args&&... args) {
-            return uploader(std::make_unique<Uploader>(
-                std::forward<Args>(args)...));
+            static_assert(std::is_base_of_v<upload_handler, Uploader>);
+            return uploader(std::make_unique<Uploader>(std::forward<Args>(args)...));
         }
 
         template < typename Downloader, typename... Args >
         request_builder& downloader(Args&&... args) {
-            return downloader(std::make_unique<Downloader>(
-                std::forward<Args>(args)...));
+            static_assert(std::is_base_of_v<download_handler, Downloader>);
+            return downloader(std::make_unique<Downloader>(std::forward<Args>(args)...));
         }
     private:
         std::string url_;
@@ -224,6 +238,7 @@ namespace curly_hpp
         time_sec_t connection_timeout_{20u};
     private:
         content_t content_;
+        callback_t callback_;
         uploader_uptr uploader_;
         downloader_uptr downloader_;
     };

sources/curly.cpp

@@ -13,7 +13,6 @@
 #include <mutex>
 #include <queue>
 #include <algorithm>
-#include <functional>
 #include <condition_variable>
 
 #ifndef NOMINMAX
@@ -759,6 +758,11 @@ namespace curly_hpp
         return *this;
     }
 
+    request_builder& request_builder::callback(callback_t c) noexcept {
+        callback_ = std::move(c);
+        return *this;
+    }
+
     request_builder& request_builder::uploader(uploader_uptr u) noexcept {
         uploader_ = std::move(u);
         return *this;
@@ -813,6 +817,14 @@ namespace curly_hpp
         return content_;
     }
 
+    callback_t& request_builder::callback() noexcept {
+        return callback_;
+    }
+
+    const callback_t& request_builder::callback() const noexcept {
+        return callback_;
+    }
+
     uploader_uptr& request_builder::uploader() noexcept {
         return uploader_;
     }