transport.hpp

Go to the documentation of this file.

// Copyright 2026 Aniket Kulkarni
// SPDX-License-Identifier: Apache-2.0
 
 
#pragma once
 
#include "neuralplus/export.hpp"
#include "neuralplus/types.hpp"
 
#include <chrono>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace neuralplus {
 
enum class HttpMethod {
    get,
    post,
    put,
    patch,
    delete_,
};
 
struct HttpHeader {
    std::string name;
 
    std::string value;
 
    bool sensitive{false};
};
 
struct HttpRequest {
    HttpMethod method{HttpMethod::post};
 
    std::string url;
 
    std::vector<HttpHeader> headers;
 
    std::string body;
 
    std::chrono::milliseconds timeout{60000};
};
 
struct NEURALPLUS_API HttpResponse {
    int status{0};
 
    std::vector<HttpHeader> headers;
 
    std::string body;
 
    [[nodiscard]] std::optional<std::string> header(std::string_view name) const;
};
 
class NEURALPLUS_API HttpTransport {
public:
    virtual ~HttpTransport();
 
    virtual HttpResponse send(const HttpRequest& request) = 0;
 
protected:
    HttpTransport() = default;
 
private:
    HttpTransport(const HttpTransport&) = delete;
    HttpTransport& operator=(const HttpTransport&) = delete;
};
 
struct HttpTransportOptions {
    std::chrono::milliseconds connect_timeout{10000};
 
    bool verify_tls{true};
 
    std::string proxy;
 
    std::string user_agent{"NeuralPlus"};
 
    std::size_t max_response_body_bytes{16U * 1024U * 1024U};
 
    std::size_t max_response_header_bytes{256U * 1024U};
};
 
class NEURALPLUS_API CurlHttpTransport final : public HttpTransport {
public:
    explicit CurlHttpTransport(HttpTransportOptions options = {});
    ~CurlHttpTransport() override;
 
    HttpResponse send(const HttpRequest& request) override;
 
private:
    CurlHttpTransport(const CurlHttpTransport&) = delete;
    CurlHttpTransport& operator=(const CurlHttpTransport&) = delete;
 
    class Impl;
    std::unique_ptr<Impl> impl_;
};
 
[[nodiscard]] NEURALPLUS_API std::shared_ptr<HttpTransport>
make_default_http_transport(HttpTransportOptions options = {});
 
class NEURALPLUS_API MockHttpTransport final : public HttpTransport {
public:
    using Handler = std::function<HttpResponse(const HttpRequest&)>;
 
    explicit MockHttpTransport(Handler handler);
    ~MockHttpTransport() override;
 
    HttpResponse send(const HttpRequest& request) override;
 
    [[nodiscard]] std::vector<HttpRequest> requests() const;
 
    void clear_requests();
 
private:
    MockHttpTransport(const MockHttpTransport&) = delete;
    MockHttpTransport& operator=(const MockHttpTransport&) = delete;
 
    Handler handler_;
    mutable std::mutex mutex_;
    std::vector<HttpRequest> requests_;
};
 
}  // namespace neuralplus