request.hpp

Go to the documentation of this file.

#pragma once
 
#include "instance.hpp"
#include "response.hpp"
#include "source.hpp"
 
#include <cstdint>
#include <boost/beast/http/field.hpp>
#include <curl/curl.h>
#ifdef ROAR_ENABLE_NLOHMANN_JSON
#    include <nlohmann/json.hpp>
#endif
 
#include <chrono>
#include <cstddef>
#include <filesystem>
#include <functional>
#include <iosfwd>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace Roar::Curl
{
    class Sink;
 
    struct VerboseLogEntry
    {
        curl_infotype type;
        std::string data;
    };
 
    class Request
    {
      public:
        using LogsType = std::vector<VerboseLogEntry>;
 
        Request();
 
        Request& basicAuth(std::string const& name, std::string const& password);
 
        Request& bearerAuth(std::string const& bearerToken);
 
        Request& acceptEncoding(std::string const& encoding);
 
        Request& followRedirects(bool doFollow);
 
        Request& maxRedirects(std::size_t maxRedirects);
 
        Request& autoReferer(bool doAutoRefer);
 
        Request& setHeaderFields(std::unordered_map<std::string, std::string> const& fields);
 
        Request& setHeader(std::string const& key, std::string const& value);
 
        Request& setHeader(boost::beast::http::field key, std::string const& value);
 
        Request& verifyPeer(bool verify = true);
 
        Request& verifyHost(bool verify = true);
 
        Request& expect100Continue();
 
        Request& connectTimeout(std::chrono::milliseconds timeout);
 
        Request& transferTimeout(std::chrono::milliseconds timeout);
 
        Request& useSignals(bool useSignal);
 
        Request& sink(
            std::function<void(char const*, std::size_t)> const& sinkFunction,
            std::function<void()> onComplete = []() {})
        {
            sinks_.emplace_back(
                std::pair<std::function<void(char*, std::size_t)>, std::function<void()>>(sinkFunction, onComplete));
            return *this;
        }
 
#ifdef ROAR_ENABLE_NLOHMANN_JSON
        Request& sink(nlohmann::json& json);
#endif
 
        Request& sink(std::string& str);
 
        Request& sink(std::ostream& stream);
 
        Request& sink(std::filesystem::path const& path);
 
        Request& sink(Sink& customSink);
 
        Request& addLibcurlDefaultSink();
 
        Request& proxy(std::string const& url);
 
        Request& tunnel(std::string const& url);
 
        Request& unixSocket(std::filesystem::path const& path);
 
        Request& contentType(std::string const& type);
 
        Request& verbose(bool enable = true);
 
        Request& verbose(LogsType& logs);
 
        Request& onHeaderValue(std::function<void(std::string const&, std::string const&)> const& headerReceiver);
 
        Request& headerSink(std::unordered_map<std::string, std::string>& headers);
 
        template <typename SourceT, typename... Args>
        Request& emplaceSource(Args&&... args)
        {
            source_ = std::make_unique<SourceT>(std::forward<Args>(args)...);
            setupSource(source_->isChunked());
            return *this;
        }
 
        Request& source(char const* str);
 
        Request& method(std::string const& method);
 
        Request& verb(std::string const& verb);
 
        Request& source(std::string str);
 
        Request& source(std::filesystem::path path);
 
        Response get(std::string const& url);
 
        Response put(std::string const& url);
 
        Response post(std::string const& url);
 
        Response delete_(std::string const& url);
 
        Response options(std::string const& url);
 
        Response head(std::string const& url);
 
        Response patch(std::string const& url);
 
        Response custom(std::string const& request, std::string const& url);
 
        Instance& instance();
 
        Request& url(std::string const& url);
 
        Response perform();
 
      private:
        void check(CURLcode code);
        void setupSource(bool chunked);
        void setupSinks();
 
      private:
        Instance instance_;
        std::function<void(char*, std::size_t)> sink_;
        std::vector<std::pair<std::function<void(char*, std::size_t)>, std::function<void()>>> sinks_;
        std::unique_ptr<Source> source_;
        std::vector<std::function<void(std::string const&, std::string const&)>> headerReceivers_;
        std::unordered_map<std::string, std::string> headerFields_;
    };
 
    std::ostream& operator<<(std::ostream& stream, Request::LogsType const& logs);
}