generator.hpp

#pragma once
 
#include "response.hpp"
#include "request.hpp"
#include "type_traits.hpp"
#include "types.hpp"
#include "utils.hpp"
 
#include <filesystem>
#include <string_view>
#include <variant>
 
namespace malloy::http
{

    class generator
    {
        using file_response = std::variant<response<boost::beast::http::file_body>, response<boost::beast::http::string_body>>;
 
    public:
        generator() = default;
 
        generator(const generator& other) = delete;
        generator(generator&& other) = delete;

        virtual
        ~generator() = default;
 
        // Operators
        generator& operator=(const generator& rhs) = delete;
        generator& operator=(generator&& rhs) = delete;

        [[nodiscard]]
        static
        response<>
        ok();

        [[nodiscard]]
        static
        response<>
        redirect(status code, std::string_view location);

        [[nodiscard]]
        static
        response<>
        bad_request(std::string_view reason);

        [[nodiscard]]
        static
        response<>
        not_found(std::string_view resource);

        [[nodiscard]]
        static
        response<>
        server_error(std::string_view what);

        template<malloy::http::concepts::body Body>
        [[nodiscard]]
        static
        file_response
        file(const request<Body>& req, const std::filesystem::path& storage_base_path)
        {
            return file(storage_base_path, malloy::http::resource_string(req));
        }

        [[nodiscard]]
        static
        file_response
        file(const std::filesystem::path& storage_path, std::string_view rel_path);
    };
 
}