response.h

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef SERVLET_RESPONSE_H
#define SERVLET_RESPONSE_H

#include <ostream>
#include <chrono>
#include <experimental/string_view>

#include <servlet/cookie.h>
#include <servlet/lib/io.h>
#include <servlet/lib/io_filter.h>
#include <servlet/lib/optional.h>

namespace servlet
{

using std::experimental::string_view;

class http_response
{
public:
    virtual ~http_response() noexcept {}

    virtual void add_cookie(const cookie& c) = 0;

    virtual void add_header(const std::string &name, const std::string &value) = 0;

    template<typename Clock, typename Dur>
    void add_date_header(const std::string &name, const std::chrono::time_point<Clock, Dur> &date)
    {
        add_date_header(name, std::chrono::duration_cast<std::chrono::seconds>(date.time_since_epoch()).count());
    }

    virtual void add_date_header(const std::string &name, long timeSec) = 0;

    virtual void set_header(const std::string &name, const std::string &value) = 0;

    template<typename Clock, typename Dur>
    void set_date_header(const std::string &name, const std::chrono::time_point<Clock, Dur> &date)
    {
        set_date_header(name, std::chrono::duration_cast<std::chrono::seconds>(date.time_since_epoch()).count());
    }
    virtual void set_date_header(const std::string &name, long date) = 0;

    virtual bool contains_header(const std::string &name) const = 0;

    virtual string_view get_header(const std::string& name) const = 0;

    virtual long get_date_header(const std::string& name) const = 0;

    virtual void get_headers(const std::string& name, std::vector<std::string>& headers) const = 0;

    virtual void get_headers(std::vector<std::pair<std::string, std::string>>& headers) const = 0;

    virtual string_view get_content_type() const = 0;

    virtual void set_content_type(const std::string &type) = 0;


    virtual void set_content_length(std::size_t len) = 0;

    virtual void send_redirect(const std::string &redirectURL) = 0;

    virtual void set_status(int sc) = 0;

    virtual int get_status() const = 0;

    virtual std::ostream& get_output_stream() = 0;

    /*
     * Server status codes; see RFC 2068.
     */

    static constexpr int SC_CONTINUE                        = 100;

    static constexpr int SC_SWITCHING_PROTOCOLS             = 101;


    static constexpr int SC_OK                              = 200;

    static constexpr int SC_CREATED                         = 201;

    static constexpr int SC_ACCEPTED                        = 202;

    static constexpr int SC_NON_AUTHORITATIVE_INFORMATION   = 203;

    static constexpr int SC_NO_CONTENT                      = 204;

    static constexpr int SC_RESET_CONTENT                   = 205;

    static constexpr int SC_PARTIAL_CONTENT                 = 206;


    static constexpr int SC_MULTIPLE_CHOICES                = 300;

    static constexpr int SC_MOVED_PERMANENTLY               = 301;

    static constexpr int SC_MOVED_TEMPORARILY               = 302;

    static constexpr int SC_FOUND                           = 302;

    static constexpr int SC_SEE_OTHER                       = 303;

    static constexpr int SC_NOT_MODIFIED                    = 304;

    static constexpr int SC_USE_PROXY                       = 305;

    static constexpr int SC_TEMPORARY_REDIRECT              = 307;


    static constexpr int SC_BAD_REQUEST                     = 400;

    static constexpr int SC_UNAUTHORIZED                    = 401;

    static constexpr int SC_PAYMENT_REQUIRED                = 402;

    static constexpr int SC_FORBIDDEN                       = 403;

    static constexpr int SC_NOT_FOUND                       = 404;

    static constexpr int SC_METHOD_NOT_ALLOWED              = 405;

    static constexpr int SC_NOT_ACCEPTABLE                  = 406;

    static constexpr int SC_PROXY_AUTHENTICATION_REQUIRED   = 407;

    static constexpr int SC_REQUEST_TIMEOUT                 = 408;

    static constexpr int SC_CONFLICT                        = 409;

    static constexpr int SC_GONE                            = 410;

    static constexpr int SC_LENGTH_REQUIRED                 = 411;

    static constexpr int SC_PRECONDITION_FAILED             = 412;

    static constexpr int SC_REQUEST_ENTITY_TOO_LARGE        = 413;

    static constexpr int SC_REQUEST_URI_TOO_LONG            = 414;

    static constexpr int SC_UNSUPPORTED_MEDIA_TYPE          = 415;

    static constexpr int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;

    static constexpr int SC_EXPECTATION_FAILED              = 417;


    static constexpr int SC_INTERNAL_SERVER_ERROR           = 500;

    static constexpr int SC_NOT_IMPLEMENTED                 = 501;

    static constexpr int SC_BAD_GATEWAY                     = 502;

    static constexpr int SC_SERVICE_UNAVAILABLE             = 503;

    static constexpr int SC_GATEWAY_TIMEOUT                 = 504;

    static constexpr int SC_HTTP_VERSION_NOT_SUPPORTED      = 505;
};

class http_response_wrapper : public http_response
{
public:

    http_response_wrapper(http_response&resp) : _resp{resp} {}
    ~http_response_wrapper() override {}

    http_response& get_wrapped_request() { return _resp; }
    const http_response& get_wrapped_request() const { return _resp; }

    void add_cookie(const cookie& c) override { _resp.add_cookie(c); }
    void add_header(const std::string &name, const std::string &value) override { _resp.add_header(name, value); }
    void add_date_header(const std::string &name, long timeSec) override { _resp.add_date_header(name, timeSec); }
    void set_header(const std::string &name, const std::string &value) override { _resp.set_header(name, value); }
    void set_date_header(const std::string &name, long timeSec) override { _resp.set_date_header(name, timeSec); }
    bool contains_header(const std::string &name) const override { return _resp.contains_header(name); }

    string_view get_header(const std::string& name) const override { return _resp.get_header(name); }
    long get_date_header(const std::string& name) const override { return _resp.get_date_header(name); }
    void get_headers(const std::string& name, std::vector<std::string>& headers) const override
    { _resp.get_headers(name, headers); }
    void get_headers(std::vector<std::pair<std::string, std::string>>& headers) const override
    { _resp.get_headers(headers); }

    string_view get_content_type() const override { return _resp.get_content_type(); }
    void set_content_type(const std::string &content_type) override { _resp.set_content_type(content_type); }
    void set_content_length(std::size_t content_length) override { _resp.set_content_length(content_length); }

    void send_redirect(const std::string &redirectURL) override { _resp.send_redirect(redirectURL); }

    void set_status(int sc) override { _resp.set_status(sc); }
    int get_status() const override { return _resp.get_status(); }

    std::ostream& get_output_stream() override;
protected:

    virtual out_filter *filter() { return nullptr; }

private:
    http_response& _resp;
    optional_ptr<std::ostream> _out;
};

} // end of servlet namespace

#endif // SERVLET_RESPONSE_H