root/http/response.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_HTTP_RESPONSE_HH
#define GUARD_HTTP_RESPONSE_HH

#include "session.hh"

#include <boost/asio.hpp>
#include <vector>

namespace http
{
        class connection;
        class request;
        class response : private boost::noncopyable
        {
        public:
                class factory
                {
                        boost::shared_ptr<connection> conn;
                        bool v11;
                        bool close;
                        bool no_body;
                public:
                        factory(boost::shared_ptr<connection> conn)
                                : conn(conn), v11(true), close(true),
                                  no_body(false)
                                {}
                        void set_v11(bool val) { v11 = val; }
                        void set_close(bool val) { close = val; }
                        void set_no_body(bool val) { no_body = val; }

                        boost::shared_ptr<response> operator()(std::string s)
                                const {
                                boost::shared_ptr<response> rv
                                        (new response(conn, v11, close, 
                                                      no_body, s));
                                return rv;
                        }
                };
                typedef boost::asio::const_buffers_1
                const_buffer_sequence;

                std::ostream &body(std::string content_type);
                std::string logbit() const { return logline; }

                void complete();

                const_buffer_sequence get_buffer() const {
                        assert(completed);
                        return boost::asio::buffer(buffer.data(),
                                                   buffer.size());
                }

                std::string get_string() const {
                        assert(completed);
                        return std::string(buffer.begin(), buffer.end());
                }

                bool get_close() const { return close; }
                void add_header(std::string name, std::string body) {
                        hdrs << name << ": " << body << "\r\n";
                }
                void set_session(boost::shared_ptr<request> req,
                                 boost::shared_ptr<session>);
        private:
                boost::shared_ptr<connection> conn;
                std::ostringstream hdrs;
                std::ostringstream bdy;
                const bool close;
                const bool no_body;

                // constructed by get_buffer
                std::vector<char> buffer;
                bool completed;

                std::string logline;

                response(boost::shared_ptr<connection> conn,
                         bool v11, bool close, bool no_body,
                         std::string respline);
        };
}

#endif /* GUARD_HTTP_RESPONSE_HH */