httprequest.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_HTTP
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/buffer.h>
#include <promeki/url.h>
#include <promeki/hashmap.h>
#include <promeki/sharedptr.h>
#include <promeki/list.h>
#include <promeki/error.h>
#include <promeki/httpmethod.h>
#include <promeki/httpheaders.h>
#include <promeki/json.h>
#include <promeki/function.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class HttpRequest {
                PROMEKI_SHARED_FINAL(HttpRequest)
        public:
                using Ptr = SharedPtr<HttpRequest>;
 
                using List = ::promeki::List<HttpRequest>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                static const String DefaultHttpVersion;
 
                HttpRequest() = default;
 
                const HttpMethod &method() const { return _method; }
 
                void setMethod(const HttpMethod &m) { _method = m; }
 
                const Url &url() const { return _url; }
 
                void setUrl(const Url &u) { _url = u; }
 
                const String &path() const { return _url.path(); }
 
                String queryValue(const String &key, const String &defaultValue = String()) const {
                        return _url.queryValue(key, defaultValue);
                }
 
                const HttpHeaders &headers() const { return _headers; }
 
                HttpHeaders &headers() { return _headers; }
 
                void setHeaders(const HttpHeaders &h) { _headers = h; }
 
                String header(const String &name, const String &defaultValue = String()) const {
                        return _headers.value(name, defaultValue);
                }
 
                const Buffer &body() const { return _body; }
 
                void setBody(const Buffer &body) { _body = body; }
 
                void setBody(const String &text);
 
                String bodyAsString() const;
 
                JsonObject bodyAsJson(Error *err = nullptr) const;
 
                JsonArray bodyAsJsonArray(Error *err = nullptr) const;
 
                void setBody(const JsonObject &obj);
 
                void setBody(const JsonArray &arr);
 
                using BodySink = ::promeki::Function<Error(const void *data, size_t len)>;
 
                using ProgressCallback = ::promeki::Function<bool(int64_t received, int64_t total)>;
 
                const BodySink &bodySink() const { return _bodySink; }
 
                void setBodySink(BodySink sink) { _bodySink = std::move(sink); }
 
                const ProgressCallback &progressCallback() const { return _progressCallback; }
 
                void setProgressCallback(ProgressCallback cb) { _progressCallback = std::move(cb); }
 
                const HashMap<String, String> &pathParams() const { return _pathParams; }
 
                void setPathParams(const HashMap<String, String> &params) { _pathParams = params; }
 
                String pathParam(const String &name, const String &defaultValue = String()) const {
                        return _pathParams.value(name, defaultValue);
                }
 
                const String &httpVersion() const { return _httpVersion; }
 
                void setHttpVersion(const String &v) { _httpVersion = v; }
 
                const String &peerAddress() const { return _peerAddress; }
 
                void setPeerAddress(const String &s) { _peerAddress = s; }
 
                bool operator==(const HttpRequest &other) const;
 
                bool operator!=(const HttpRequest &other) const { return !(*this == other); }
 
        private:
                HttpMethod              _method;
                Url                     _url;
                HttpHeaders             _headers;
                Buffer                  _body;
                HashMap<String, String> _pathParams;
                String                  _httpVersion = DefaultHttpVersion;
                String                  _peerAddress;
                BodySink                _bodySink;
                ProgressCallback        _progressCallback;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_HTTP