http_constants.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_HTTP_CONSTANTS_HPP__
#define NEFORCE_NETWORK_HTTP_HTTP_CONSTANTS_HPP__

 
#include "NeForce/core/exception/system_exception.hpp"
#include "NeForce/core/interface/istringify.hpp"
NEFORCE_BEGIN_NAMESPACE__


NEFORCE_ERROR_BUILD_FINAL_CLASS(http_exception, network_exception, "Http Actions Failed");
 // Exceptions
 
NEFORCE_BEGIN_HTTP__


enum class http_status : uint16_t {
    S1_CONTINUE = 100,

    S1_SWITCHING_PROTOCOLS = 101,

    S2_OK = 200,

    S2_CREATED = 201,

    S2_ACCEPTED = 202,

    S2_NO_CONTENT = 204,

    S2_PARTIAL_CONTENT = 206,

    S3_MOVED_PERMANENT = 301,

    S3_FOUND = 302,

    S3_SEE_OTHER = 303,

    S3_NOT_MODIFIED = 304,

    S3_TEMPORARY_REDIRECT = 307,

    S3_PERMANENT_REDIRECT = 308,

    S4_BAD_REQUEST = 400,

    S4_UNAUTHORIZED = 401,

    S4_FORBIDDEN = 403,

    S4_NOT_FOUND = 404,

    S4_METHOD_NOT_ALLOWED = 405,
    S4_NOT_ACCEPTABLE = 406,

    S4_PROXY_AUTH_REQUIRED = 407,

    S4_REQUEST_TIMEOUT = 408,

    S4_CONFLICT = 409,

    S4_GONE = 410,
    S4_LENGTH_REQUIRED = 411,

    S4_PRECONDITION_FAILED = 412,

    S4_UNSUPPORTED_MEDIA_TYPE = 415,

    S4_RANGE_NOT_SATISFIABLE = 416,
    S4_EXPECTATION_FAILED = 417,

    S4_UNPROCESSABLE_CONTENT = 422,

    S4_UPGRADE_REQUIRED = 426,

    S4_PAYLOAD_TOO_LARGE = 413,

    S4_URI_TOO_LONG = 414,

    S4_TOO_MANY_REQUESTS = 429,
    S4_HEADER_FIELDS_TOO_LARGE = 431,

    S4_UNAVAILABLE_FOR_LEGAL_REASONS = 451,

    S5_INTERNAL_SERVER_ERROR = 500,

    S5_BAD_GATEWAY = 502,

    S5_SERVICE_UNAVAILABLE = 503,

    S5_GATEWAY_TIMEOUT = 504,

    S5_NOT_IMPLEMENTED = 501,

    S5_HTTP_VERSION_NOT_SUPPORTED = 505
};
 
NEFORCE_API string http_status_message(http_status status);
 
NEFORCE_API http_status http_status_from_code(uint16_t code) noexcept;
 

struct NEFORCE_API http_content : istringify<http_content> {
private:
    string content_{"UNKNOWN"}; 
 
public:
    http_content() = default;
    http_content(const http_content&) = default;
    http_content& operator=(const http_content&) = default;

    http_content(http_content&& other) noexcept :
    content_(_NEFORCE move(other.content_)) {}

    http_content& operator=(http_content&& other) noexcept {
        if (addressof(other) == this) {
            return *this;
        }
        content_ = _NEFORCE move(other.content_);
        return *this;
    }

    explicit http_content(string content) :
    content_(move(content)) {}

    http_content& operator=(const string& content) {
        content_ = content;
        return *this;
    }
 
    ~http_content() = default;
 
    static const http_content& HTML_TEXT();  
    static const http_content& XML_TEXT();   
    static const http_content& CSS_TEXT();   
    static const http_content& PLAIN_TEXT(); 
    static const http_content& JSON_APP();   
    static const http_content& FORM_APP();   
    static const http_content& JPEG_IMG();   
    static const http_content& PNG_IMG();    
    static const http_content& BMP_IMG();    
    static const http_content& WEBP_IMG();   
    static const http_content& HTML_MSG();   
 
    // TODO: application/problem+json — RFC 9457 Problem Details MIME type for standardized API error responses
    // TODO: application/octet-stream — generic binary data MIME type for file downloads
    // TODO: multipart/form-data — MIME type constant for form upload content negotiation
 
    NEFORCE_NODISCARD bool is_html_text() const { return content_ == HTML_TEXT().content_; }
    NEFORCE_NODISCARD bool is_xml_text() const { return content_ == XML_TEXT().content_; }
    NEFORCE_NODISCARD bool is_css_text() const { return content_ == CSS_TEXT().content_; }
    NEFORCE_NODISCARD bool is_plain_text() const { return content_ == PLAIN_TEXT().content_; }
    NEFORCE_NODISCARD bool is_json_app() const { return content_ == JSON_APP().content_; }
    NEFORCE_NODISCARD bool is_form_app() const { return content_ == FORM_APP().content_; }
    NEFORCE_NODISCARD bool is_jpeg_img() const { return content_ == JPEG_IMG().content_; }
    NEFORCE_NODISCARD bool is_png_img() const { return content_ == PNG_IMG().content_; }
    NEFORCE_NODISCARD bool is_bmp_img() const { return content_ == BMP_IMG().content_; }
    NEFORCE_NODISCARD bool is_webp_img() const { return content_ == WEBP_IMG().content_; }
    NEFORCE_NODISCARD bool is_html_msg() const { return content_ == HTML_MSG().content_; }
 
    NEFORCE_NODISCARD static bool is_html_text(const string_view view) { return view == HTML_TEXT().content_; }
    NEFORCE_NODISCARD static bool is_xml_text(const string_view view) { return view == XML_TEXT().content_; }
    NEFORCE_NODISCARD static bool is_css_text(const string_view view) { return view == CSS_TEXT().content_; }
    NEFORCE_NODISCARD static bool is_plain_text(const string_view view) { return view == PLAIN_TEXT().content_; }
    NEFORCE_NODISCARD static bool is_json_app(const string_view view) { return view == JSON_APP().content_; }
    NEFORCE_NODISCARD static bool is_form_app(const string_view view) { return view == FORM_APP().content_; }
    NEFORCE_NODISCARD static bool is_jpeg_img(const string_view view) { return view == JPEG_IMG().content_; }
    NEFORCE_NODISCARD static bool is_png_img(const string_view view) { return view == PNG_IMG().content_; }
    NEFORCE_NODISCARD static bool is_bmp_img(const string_view view) { return view == BMP_IMG().content_; }
    NEFORCE_NODISCARD static bool is_webp_img(const string_view view) { return view == WEBP_IMG().content_; }
    NEFORCE_NODISCARD static bool is_html_msg(const string_view view) { return view == HTML_MSG().content_; }

    NEFORCE_NODISCARD const string& content() const& noexcept { return content_; }

    NEFORCE_NODISCARD string content() && noexcept { return _NEFORCE move(content_); }

    NEFORCE_NODISCARD string to_string() const { return content_; }

    NEFORCE_NODISCARD http_content with_charset(string charset) const {
        return http_content(content_ + "; charset=" + move(charset));
    }
};
 
 
#ifdef DELETE
#    undef DELETE
#endif

struct NEFORCE_API http_method : istringify<http_method> {
private:
    string method_{"UNKNOWN"}; 
 
public:
    http_method() = default;
    http_method(const http_method&) = default;
    http_method& operator=(const http_method&) = default;

    http_method(http_method&& other) noexcept :
    method_(_NEFORCE move(other.method_)) {}

    http_method& operator=(http_method&& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        method_ = _NEFORCE move(other.method_);
        return *this;
    }

    explicit http_method(const string& method) :
    method_(method) {}

    http_method& operator=(const string& method) {
        method_ = method;
        return *this;
    }

    explicit http_method(string&& method) :
    method_(_NEFORCE move(method)) {}

    http_method& operator=(string&& method) {
        method_ = _NEFORCE move(method);
        return *this;
    }
 
    ~http_method() = default;
 
    static const http_method& GET();     
    static const http_method& POST();    
    static const http_method& HEAD();    
    static const http_method& PUT();     
    static const http_method& DELETE();  
    static const http_method& OPTIONS(); 
    static const http_method& TRACE();   
    static const http_method& CONNECT(); 
    static const http_method& PATCH();   
    static const http_method& DEFAULT(); 

    NEFORCE_NODISCARD const string& method() const& noexcept { return method_; }

    NEFORCE_NODISCARD string method() && noexcept { return _NEFORCE move(method_); }

    NEFORCE_NODISCARD http_method operator&(const http_method& rhs) const& {
        return http_method(method_ + ", " + rhs.method_);
    }
 
    NEFORCE_NODISCARD http_method operator&(http_method&& rhs) const& {
        return http_method(method_ + ", " + _NEFORCE move(rhs.method_));
    }
 
    NEFORCE_NODISCARD http_method operator&(const http_method& rhs) && {
        return http_method(_NEFORCE move(method_) + ", " + rhs.method_);
    }
 
    NEFORCE_NODISCARD http_method operator&(http_method&& rhs) && {
        return http_method(_NEFORCE move(method_) + ", " + _NEFORCE move(rhs.method_));
    }
 
    NEFORCE_NODISCARD bool is_get() const { return method_ == GET().method_; }
    NEFORCE_NODISCARD bool is_post() const { return method_ == POST().method_; }
    NEFORCE_NODISCARD bool is_head() const { return method_ == HEAD().method_; }
    NEFORCE_NODISCARD bool is_put() const { return method_ == PUT().method_; }
    NEFORCE_NODISCARD bool is_delete() const { return method_ == DELETE().method_; }
    NEFORCE_NODISCARD bool is_options() const { return method_ == OPTIONS().method_; }
    NEFORCE_NODISCARD bool is_trace() const { return method_ == TRACE().method_; }
    NEFORCE_NODISCARD bool is_connect() const { return method_ == CONNECT().method_; }
    NEFORCE_NODISCARD bool is_patch() const { return method_ == PATCH().method_; }

    NEFORCE_NODISCARD string to_string() const { return method_; }
};
 

struct NEFORCE_API http_cookie_name : istringify<http_cookie_name> {
private:
    string cookie_{"UNKNOWN"}; 
 
public:
    http_cookie_name() = default;
    http_cookie_name(const http_cookie_name&) = default;
    http_cookie_name& operator=(const http_cookie_name&) = default;

    http_cookie_name(http_cookie_name&& other) noexcept :
    cookie_(_NEFORCE move(other.cookie_)) {}

    http_cookie_name& operator=(http_cookie_name&& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        cookie_ = _NEFORCE move(other.cookie_);
        return *this;
    }

    explicit http_cookie_name(string cookie) :
    cookie_(move(cookie)) {}

    http_cookie_name& operator=(const string& cookie) {
        cookie_ = cookie;
        return *this;
    }
 
    ~http_cookie_name() = default;
 
    static const http_cookie_name& JSESSIONID();   
    static const http_cookie_name& SESSIONID();    
    static const http_cookie_name& PHPSESSID();    
    static const http_cookie_name& ASPSESSIONID(); 

    NEFORCE_NODISCARD const string& cookie_name() const& noexcept { return cookie_; }

    NEFORCE_NODISCARD string cookie_name() && noexcept { return _NEFORCE move(cookie_); }

    NEFORCE_NODISCARD string to_string() const { return cookie_; }
};
 
 
struct NEFORCE_API http_key {
    static const string& Access_Control_Allow_Credentials();
    static const string& Access_Control_Allow_Headers();
    static const string& Access_Control_Allow_Methods();
    static const string& Access_Control_Allow_Origin();
    static const string& Access_Control_Max_Age();
    static const string& Connection();
    static const string& Content_Length();
    static const string& Content_Type();
    static const string& Lax();
    static const string& Strict();
    static const string& X_Forwarded_Proto();
 
    static const string& Strict_Transport_Security();
    static const string& X_Frame_Options();
    static const string& X_Content_Type_Options();
    static const string& Content_Security_Policy();
    static const string& X_XSS_Protection();
    static const string& Referrer_Policy();
    static const string& Permissions_Policy();
};
 // Http
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_HTTP_CONSTANTS_HPP__