application.h

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

#include <cppcms/defs.h>
#include <booster/noncopyable.h>
#include <booster/hold_ptr.h>
#include <booster/atomic_counter.h>
#include <booster/intrusive_ptr.h>
#include <booster/shared_ptr.h>
#include <string>

namespace cppcms {
        class application;
}

namespace booster {
        void CPPCMS_API intrusive_ptr_add_ref(cppcms::application *p);
        void CPPCMS_API intrusive_ptr_release(cppcms::application *p);
}


namespace cppcms {

        class service;
        class url_dispatcher;
        class url_mapper;
        class applications_pool;
        class application_specific_pool;
        class application;
        class base_content;
        class cache_interface;
        class session_interface;

        namespace http {
                class request;
                class response;
                class context;
        }
        namespace json {
                class value;
        }
        namespace filters {
                class streamable;
        }



        class CPPCMS_API application : public booster::noncopyable {
        public:
                application(cppcms::service &srv);

                virtual ~application();

                cppcms::service &service();
                
                json::value const &settings();

                http::context &context();

                http::request &request();

                http::response &response();

                url_dispatcher &dispatcher();

                url_mapper &mapper();

                cache_interface &cache();
                
                session_interface &session();

                void render(std::string template_name,base_content &content);
                void render(std::string skin,std::string template_name,base_content &content);

                void render(std::string template_name,std::ostream &out,base_content &content);

                void render(std::string skin,std::string template_name,std::ostream &out,base_content &content);

                void add(application &app);

                void add(application &app,std::string const &regex,int part);

                void add(application &app,std::string const &name,std::string const &url,std::string const &regex,int part);
                void add(application &app,std::string const &name,std::string const &url);

                void attach(application *app);
                void attach(application *app,std::string const &regex,int part);
                void attach(application *app,std::string const &name,std::string const &url);
                void attach(application *app,std::string const &name,std::string const &url,std::string const &regex,int part);

                application *parent();

                application *root();

                booster::shared_ptr<http::context> release_context();

                booster::shared_ptr<http::context> get_context();

                void assign_context(booster::shared_ptr<http::context> conn);

                void add_context(http::context &conn);

                void remove_context();

                bool is_asynchronous();

                bool has_context();
                
                bool owns_context();


                virtual void main(std::string url);

                virtual void init();

                virtual void clear();

                std::string translate(char const *context,char const *message);
                std::string translate(char const *message);
                std::string translate(char const *context,char const *single,char const *plural,int n);
                std::string translate(char const *single,char const *plural,int n);


                std::string url(std::string const &key);

                std::string url(std::string const &key,
                                filters::streamable const &p1);

                std::string url(std::string const &key,
                                filters::streamable const &p1,
                                filters::streamable const &p2);

                std::string url(std::string const &key,
                                filters::streamable const &p1,
                                filters::streamable const &p2,
                                filters::streamable const &p3);

                std::string url(std::string const &key,
                                filters::streamable const &p1,
                                filters::streamable const &p2,
                                filters::streamable const &p3,
                                filters::streamable const &p4);
                std::string url(std::string const &key,
                                filters::streamable const &p1,
                                filters::streamable const &p2,
                                filters::streamable const &p3,
                                filters::streamable const &p4,
                                filters::streamable const &p5);
                std::string url(std::string const &key,
                                filters::streamable const &p1,
                                filters::streamable const &p2,
                                filters::streamable const &p3,
                                filters::streamable const &p4,
                                filters::streamable const &p5,
                                filters::streamable const &p6);

        private:

                void recycle();
                void parent(application *parent);

                booster::weak_ptr<application_specific_pool> get_pool();
                void set_pool(booster::weak_ptr<application_specific_pool> pool);


                struct _data; // future use
                booster::hold_ptr<_data> d;

                application *parent_;
                application *root_;

                booster::atomic_counter refs_;
                friend class applications_pool;
                friend class application_specific_pool;
                friend void booster::intrusive_ptr_add_ref(application *p);
                friend void booster::intrusive_ptr_release(application *p);
        };

} // cppcms

#endif