http_response.h

Go to the documentation of this file.

 
#ifndef CPPSERVER_HTTP_HTTP_RESPONSE_H
#define CPPSERVER_HTTP_HTTP_RESPONSE_H
 
#include "http.h"
 
#include "time/time.h"
 
#include <sstream>
#include <string>
#include <string_view>
#include <tuple>
#include <unordered_map>
#include <vector>
 
namespace CppServer {
namespace HTTP {
 
 
class HTTPResponse
{
    friend class HTTPClient;
    friend class HTTPSClient;
 
public:
    HTTPResponse() { Clear(); }
 
    HTTPResponse(int status, std::string_view protocol = "HTTP/1.1") { SetBegin(status, protocol); }
 
    HTTPResponse(int status, std::string_view status_phrase, std::string_view protocol) { SetBegin(status, status_phrase, protocol); }
    HTTPResponse(const HTTPResponse&) = default;
    HTTPResponse(HTTPResponse&&) = default;
    ~HTTPResponse() = default;
 
    HTTPResponse& operator=(const HTTPResponse&) = default;
    HTTPResponse& operator=(HTTPResponse&&) = default;
 
    bool empty() const noexcept { return _cache.empty(); }
    bool error() const noexcept { return _error; }
 
    int status() const noexcept { return _status; }
    std::string_view status_phrase() const noexcept { return std::string_view(_cache.data() + _status_phrase_index, _status_phrase_size); }
    std::string_view protocol() const noexcept { return std::string_view(_cache.data() + _protocol_index, _protocol_size); }
    size_t headers() const noexcept { return _headers.size(); }
    std::tuple<std::string_view, std::string_view> header(size_t i) const noexcept;
    std::string_view body() const noexcept { return std::string_view(_cache.data() + _body_index, _body_size); }
    size_t body_length() const noexcept { return _body_length; }
 
    const std::string& cache() const noexcept { return _cache; }
 
    std::string string() const { std::stringstream ss; ss << *this; return ss.str(); }
 
    HTTPResponse& Clear();
 
 
    HTTPResponse& SetBegin(int status, std::string_view protocol = "HTTP/1.1");
 
    HTTPResponse& SetBegin(int status, std::string_view status_phrase, std::string_view protocol);
 
    HTTPResponse& SetContentType(std::string_view extension);
 
    HTTPResponse& SetHeader(std::string_view key, std::string_view value);
 
    HTTPResponse& SetCookie(std::string_view name, std::string_view value, size_t max_age = 86400, std::string_view path = "", std::string_view domain = "", bool secure = true, bool strict = true, bool http_only = true);
 
    HTTPResponse& SetBody(std::string_view body = "");
 
    HTTPResponse& SetBodyLength(size_t length);
 
 
    HTTPResponse& MakeOKResponse(int status = 200);
 
    HTTPResponse& MakeErrorResponse(std::string_view content = "", std::string_view content_type = "text/plain; charset=UTF-8") { return MakeErrorResponse(500, content, content_type); }
 
    HTTPResponse& MakeErrorResponse(int status, std::string_view content = "", std::string_view content_type = "text/plain; charset=UTF-8");
 
    HTTPResponse& MakeHeadResponse();
 
    HTTPResponse& MakeGetResponse(std::string_view content = "", std::string_view content_type = "text/plain; charset=UTF-8");
 
    HTTPResponse& MakeOptionsResponse(std::string_view allow = "HEAD,GET,POST,PUT,DELETE,OPTIONS,TRACE");
 
    HTTPResponse& MakeTraceResponse(std::string_view request);
 
    friend std::ostream& operator<<(std::ostream& os, const HTTPResponse& response);
 
    void swap(HTTPResponse& response) noexcept;
    friend void swap(HTTPResponse& response1, HTTPResponse& response2) noexcept { response1.swap(response2); }
 
private:
    // HTTP response error flag
    bool _error;
    // HTTP response status
    int _status;
    // HTTP response status phrase
    size_t _status_phrase_index;
    size_t _status_phrase_size;
    // HTTP response protocol
    size_t _protocol_index;
    size_t _protocol_size;
    // HTTP response headers
    std::vector<std::tuple<size_t, size_t, size_t, size_t>> _headers;
    // HTTP response body
    size_t _body_index;
    size_t _body_size;
    size_t _body_length;
    bool _body_length_provided;
 
    // HTTP response cache
    std::string _cache;
    size_t _cache_size;
 
    // HTTP response mime table
    static const std::unordered_map<std::string, std::string> _mime_table;
 
    // Is pending parts of HTTP response
    bool IsPendingHeader() const;
    bool IsPendingBody() const;
 
    // Receive parts of HTTP response
    bool ReceiveHeader(const void* buffer, size_t size);
    bool ReceiveBody(const void* buffer, size_t size);
 
    // Fast convert integer value to the corresponding string representation
    std::string_view FastConvert(size_t value, char* buffer, size_t size);
};
 
} // namespace HTTP
} // namespace CppServer
 
#include "http_response.inl"
 
#endif // CPPSERVER_HTTP_HTTP_RESPONSE_H