http.hpp

Go to the documentation of this file.

#pragma once
#include <format>
#include <string>
#include <vector>
#include <sstream>
#include <limits>
#include <ios>
#include <algorithm>
 
#include "http_codes.hpp"
#include "http_headers.hpp"
#include "http_method.hpp"
#include "url.hpp"
 
namespace dcn::http
{
    class MessageBase
    {
        public:
            //ctor
            MessageBase();
 
            //move
            MessageBase(MessageBase && other) = default;
            MessageBase & operator=(MessageBase && other) = default;
 
            //copy
            MessageBase(const MessageBase & other) = delete;
            MessageBase & operator=(const MessageBase & other) = delete;
 
            //dtor
            virtual ~MessageBase() = default;
            
            MessageBase& setVersion(const std::string & version);
 
            MessageBase& setBody(const std::string & body);
 
            MessageBase& setBodyWithContentLength(const std::string & body);
 
            MessageBase& addHeader(Header header, const std::string & value);
            
            MessageBase& setHeader(Header header, const std::string & value);
 
            std::vector<std::string> getHeader(Header header) const;
 
            const std::string & getVersion() const;
 
            const HeadersList & getHeaders() const;
 
            const std::string & getBody() const;
        
        private:
            std::string _version;
            HeadersList _headers;
            std::string _body;
    };
 
    class Request : public MessageBase
    {
        public:
            // ctor
            Request() = default;
 
            //move
            Request(Request && other) = default;
            Request & operator=(Request && other) = default;
 
            //copy
            Request(const Request & other) = delete;
            Request & operator=(const Request & other) = delete;
 
            // dtor
            ~Request() = default;
 
            Request& setMethod(const Method & method);
 
            Request& setPath(URL path);
 
            const Method & getMethod() const;
 
            const URL & getPath() const;
 
        private:
            Method _method;
            URL _path;
    };
 
    class Response : public MessageBase
    {
        public:
            // ctor
            Response() = default;
 
            //move
            Response(Response && other) = default;
            Response & operator=(Response && other) = default;
 
            //copy
            Response(const Response & other) = delete;
            Response & operator=(const Response & other) = delete;
 
            // dtor
            ~Response() = default;
 
            Response& setCode(Code code);
 
            const Code & getCode() const;
            
        private:
            Code _code;
    };
}
 
namespace dcn::parse
{
    http::Request parseRequestFromString(const std::string & request);
}
 
template <>
struct std::formatter<dcn::http::Response> : std::formatter<std::string> {
  auto format(const dcn::http::Response & res, format_context& ctx) const {
    return formatter<string>::format(
      std::format("{} {}\n{}\r\n{}", res.getVersion(), res.getCode(), res.getHeaders(), res.getBody()), ctx);
  }
};
 
template <>
struct std::formatter<dcn::http::Request> : std::formatter<std::string> {
 
  auto format(const dcn::http::Request & req, format_context& ctx) const {
    return formatter<string>::format(
      std::format("{} {} {}\n{}\r\n{}", req.getVersion(), req.getMethod(), req.getPath(), req.getHeaders(), req.getBody()), ctx);
  }
};