response.hpp

#pragma once
 
#include "types.hpp"
#include "cookie.hpp"
#include "../utils.hpp"
 
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/version.hpp>
 
#include <filesystem>
 
namespace malloy::http
{

    template<typename Body = boost::beast::http::string_body, typename Fields = boost::beast::http::fields>
    class response :
        public boost::beast::http::response<Body, Fields>
    {
        using msg_t = boost::beast::http::response<Body, Fields>;
 
    public:
        response() = default;

        explicit
        response(msg_t&& msg)
        {
            msg_t::operator=(std::move(msg));
        }

        explicit
        response(const boost::beast::http::response_header<Fields>& header) :
            msg_t{ header }
        {
        }

        explicit
        response(boost::beast::http::response_header<Fields>&& header) :
            msg_t{ std::move(header) }
        {
        }

        explicit
        response(const status& status_)
        {
            msg_t::result(status_);
        }

        response(const response& other) = default;

        response(response&& other) noexcept = default;

        virtual
        ~response() = default;

        response&
        operator=(const response& rhs) = default;

        response&
        operator=(response&& rhs) noexcept = default;

        void
        set_status(http::status status) { msg_t::result(status); }

        [[nodiscard]]
        http::status
        status() const { return msg_t::result(); }

        void
        add_cookie(const cookie& c)
        {
            msg_t::insert(malloy::http::field::set_cookie, c.to_string());
        }
    };
 
}
 
#include <sstream>
 
namespace malloy
{
 
    template<typename Body, typename Fields>
    [[nodiscard]]
    std::string
    to_string(const http::response<Body, Fields>& r)
    {
        std::ostringstream ss;
        ss << r;
 
        return ss.str();
    }
 
}