http_context.h

//                                                                             
//  Copyright (C) 2008-2012  Artyom Beilis (Tonkikh) <artyomtnk@yahoo.com>     
//                                                                             
//  See accompanying file COPYING.TXT file for licensing details.
//
#ifndef CPPCMS_HTTP_CONTEXT_H
#define CPPCMS_HTTP_CONTEXT_H

#include <cppcms/defs.h>
#include <booster/hold_ptr.h>
#include <booster/intrusive_ptr.h>
#include <booster/shared_ptr.h>
#include <booster/enable_shared_from_this.h>
#include <booster/callback.h>
#include <booster/noncopyable.h>
#include <locale>

namespace cppcms {

        class service;
        class application;
        class application_specific_pool;
        class cache_interface;
        class session_interface;
        namespace json { class value; }
        namespace impl { namespace cgi { class connection; } }

        namespace http {
                class request;
                class response;
                class file;

                
                class CPPCMS_API context : 
                        public booster::noncopyable,
                        public booster::enable_shared_from_this<context>
                {
                public:

                        context(booster::shared_ptr<impl::cgi::connection> conn);
                        ~context();
                        impl::cgi::connection &connection();
                        void run();


                        http::request &request();

                        http::response &response();

                        json::value const &settings();

                        cache_interface &cache();

                        session_interface &session();

                        std::locale locale();

                        void locale(std::locale const &new_locale);

                        void locale(std::string const &name);
                        
                        cppcms::service &service();

                        std::string skin();

                        void skin(std::string const &name);


                        typedef enum {
                                operation_completed, 
                                operation_aborted    
                        } completion_type; 

                        typedef booster::callback<void(completion_type)> handler;

                        void complete_response();

                        void async_complete_response();
                        

                        void async_flush_output(handler const &h);

                        void async_on_peer_reset(booster::callback<void()> const &h);
                        void submit_to_pool(booster::shared_ptr<application_specific_pool> pool,std::string const &matched_url); 
                        void submit_to_asynchronous_application(booster::intrusive_ptr<application> app,std::string const &matched_url);

                private:
                        struct holder { virtual ~holder() {} };
                        template<typename T>
                        struct specific_holder : public holder {
                                specific_holder(T *ptr) : p(ptr) {}
                                virtual ~specific_holder() {}
                                booster::hold_ptr<T> p;
                        };
                public:
                        template<typename T>
                        T *get_specific()
                        {
                                specific_holder<T> *sh=dynamic_cast<specific_holder<T> *>(get_holder());
                                if(!sh)
                                        return 0;
                                return sh->p.get();
                        }
                        template<typename T>
                        void reset_specific(T *ptr = 0)
                        {
                                if(ptr == 0) {
                                        set_holder(0);
                                        return;
                                }
                                specific_holder<T> *sh=dynamic_cast<specific_holder<T> *>(get_holder());
                                if(sh) {
                                        sh->p.reset(ptr);
                                }
                                else {
                                        specific_holder<T> *sh = new specific_holder<T>(ptr);
                                        set_holder(sh);
                                }
                        }
                        template<typename T>
                        T *release_specific()
                        {
                                T *r = 0;
                                specific_holder<T> *sh=dynamic_cast<specific_holder<T> *>(get_holder());
                                if(sh) {
                                        r = sh->p.release();
                                }
                                set_holder(0);
                                return r;
                        }
                private:

                        void set_holder(holder *p);
                        holder *get_holder();
                        
                        friend class impl::cgi::connection;
                        int on_content_progress(size_t n);
                        int on_headers_ready();
                        int translate_exception();
                        void make_error_message(std::exception const &e);
                        void on_request_ready(bool error);
                        void submit_to_pool_internal(booster::shared_ptr<application_specific_pool> pool,std::string const &matched,bool now);
                        static void dispatch(booster::shared_ptr<application_specific_pool> const &pool,booster::shared_ptr<context> const &self,std::string const &url);
                        static void dispatch(booster::intrusive_ptr<application> const &app,std::string const &url,bool syncronous);
                        void try_restart(bool e);
                        booster::shared_ptr<context> self();

                        struct _data;
                        booster::hold_ptr<_data> d;
                        booster::shared_ptr<impl::cgi::connection> conn_;
                };

        }

};

#endif