http_reply.hpp

Go to the documentation of this file.

#ifndef CPP_WEB_SERVER_HTTP_REPLY_HPP
#define CPP_WEB_SERVER_HTTP_REPLY_HPP
 
#include "async_web_server_cpp/http_connection.hpp"
#include "async_web_server_cpp/http_header.hpp"
#include "async_web_server_cpp/http_request_handler.hpp"
 
#include <boost/asio.hpp>
#include <boost/filesystem.hpp>
 
#include <string>
#include <vector>
 
namespace async_web_server_cpp
{
 
class ReplyBuilder;
 
struct HttpReply
{
    enum status_type
    {
        switching_protocols = 101,
        ok = 200,
        created = 201,
        accepted = 202,
        no_content = 204,
        multiple_choices = 300,
        moved_permanently = 301,
        moved_temporarily = 302,
        not_modified = 304,
        bad_request = 400,
        unauthorized = 401,
        forbidden = 403,
        not_found = 404,
        internal_server_error = 500,
        not_implemented = 501,
        bad_gateway = 502,
        service_unavailable = 503
    } status;
 
    static std::vector<boost::asio::const_buffer>
    to_buffers(const std::vector<HttpHeader>& headers);
 
    static HttpServerRequestHandler stock_reply(status_type status);
 
    static HttpServerRequestHandler
    from_file(HttpReply::status_type status, const std::string& content_type,
              const std::string& filename,
              const std::vector<HttpHeader>& additional_headers =
                  std::vector<HttpHeader>());
 
    static HttpServerRequestHandler
    from_filesystem(HttpReply::status_type status, const std::string& path_root,
                    const std::string& filesystem_root, bool list_directories,
                    const std::vector<HttpHeader>& additional_headers =
                        std::vector<HttpHeader>());
 
    static HttpServerRequestHandler
    static_reply(status_type status, const std::string& content_type,
                 const std::string& content,
                 const std::vector<HttpHeader>& additional_headers =
                     std::vector<HttpHeader>());
 
    static ReplyBuilder builder(status_type status);
};
 
class ReplyBuilder
{
public:
    ReplyBuilder(HttpReply::status_type status);
 
    ReplyBuilder& header(const std::string& name, const std::string& value);
 
    ReplyBuilder& header(const HttpHeader& header);
 
    ReplyBuilder& headers(const std::vector<HttpHeader>& headers);
 
    void write(HttpConnectionPtr connection);
 
private:
    HttpReply::status_type status_;
    boost::shared_ptr<std::vector<HttpHeader>> headers_;
};
 
class StaticHttpRequestHandler
{
public:
    StaticHttpRequestHandler(HttpReply::status_type status,
                             const std::vector<HttpHeader>& headers,
                             const std::string& content);
 
    bool operator()(const HttpRequest&, boost::shared_ptr<HttpConnection>,
                    const char* begin, const char* end);
 
private:
    ReplyBuilder reply_builder_;
    const std::string content_string_;
};
 
class FileHttpRequestHandler
{
public:
    FileHttpRequestHandler(HttpReply::status_type status,
                           const std::string& filename,
                           const std::vector<HttpHeader>& headers);
 
    bool operator()(const HttpRequest&, boost::shared_ptr<HttpConnection>,
                    const char* begin, const char* end);
 
private:
    HttpReply::status_type status_;
    std::vector<HttpHeader> headers_;
    std::string filename_;
};
 
class FilesystemHttpRequestHandler
{
public:
    FilesystemHttpRequestHandler(HttpReply::status_type status,
                                 const std::string& path_root,
                                 const std::string& filesystem_root,
                                 bool list_directories,
                                 const std::vector<HttpHeader>& headers);
 
    bool operator()(const HttpRequest&, boost::shared_ptr<HttpConnection>,
                    const char* begin, const char* end);
 
private:
    HttpReply::status_type status_;
    std::vector<HttpHeader> headers_;
    std::string path_root_;
    boost::filesystem::path filesystem_root_;
    bool list_directories_;
};
 
}  // namespace async_web_server_cpp
 
#endif