applications_pool.h

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

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

#include <booster/auto_ptr_inc.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 aio {
                class io_service;
        }
}

namespace cppcms {

        class service;
        class mount_point;
        class application_specific_pool;
        class applications_pool;
        namespace http {
                class context;
        }

        namespace app {
                static const int synchronous    = 0x0000; 
                static const int asynchronous   = 0x0001; 

                static const int op_mode_mask   = 0x000F; 

                static const int thread_specific= 0x0010; 
                static const int prepopulated   = 0x0020; 
                static const int content_filter = 0x0040; 
                static const int legacy         = 0x8000; 
        }

        class CPPCMS_API application_specific_pool : 
                public booster::noncopyable,
                public booster::enable_shared_from_this<application_specific_pool>
        {
        public:
                application_specific_pool();
                virtual ~application_specific_pool();

                booster::intrusive_ptr<application> asynchronous_application_by_io_service(booster::aio::io_service &io_srv,cppcms::service &srv);
                booster::intrusive_ptr<application> asynchronous_application_by_io_service(booster::aio::io_service &io_srv);

        protected:
                virtual application *new_application(service &srv) = 0;
        private:
                int flags();
                void flags(int f);

                void prepopulate(cppcms::service &srv);
                void application_requested(cppcms::service &srv);
                friend class applications_pool;
                friend class application;
                friend class http::context;
                friend void booster::intrusive_ptr_release(cppcms::application *app);

                application *get_new(service &srv);

                void size(size_t n);
                booster::intrusive_ptr<application> get(service &);
                void put(application *app);

                struct _data;
                class _policy;
                class _tls_policy;
                class _pool_policy;
                class _async_policy;
                class _async_legacy_policy;
                class _legacy_pool_policy;
                booster::hold_ptr<_data> d;
        };

        class CPPCMS_API applications_pool {
        public:

                struct factory : public booster::noncopyable {
                        virtual std::auto_ptr<application> operator()(service &) const = 0;
                        virtual ~factory(){}
                };

                void mount(std::auto_ptr<factory> aps);
                
                void mount(std::auto_ptr<factory> aps,mount_point const &point);

                void mount(booster::intrusive_ptr<application> app);
                void mount(booster::intrusive_ptr<application> app,mount_point const &point);

                void mount(booster::shared_ptr<application_specific_pool> gen,int application_options = 0);

                void mount(booster::shared_ptr<application_specific_pool> gen,mount_point const &point,int application_options = 0);


                void unmount(booster::weak_ptr<application_specific_pool> gen);



                booster::intrusive_ptr<application> 
                get(char const *h,char const *s,char const *path_info,std::string &match);

                booster::shared_ptr<application_specific_pool> 
                get_application_specific_pool(char const *h,char const *s,char const *path_info,std::string &match);

                // put is not in use any more
                void put(application *app);
                applications_pool(service &srv,int unused);
                ~applications_pool();


        private:
                struct _data;
                service *srv_;
                booster::hold_ptr<_data> d;
        };

        namespace details {
                template<typename T>
                struct simple_factory0 : public applications_pool::factory
                {
                        std::auto_ptr<application> operator()(service &s) const
                        {
                                std::auto_ptr<application> app(new T(s));
                                return app;
                        }
                };
                template<typename T,typename P1>
                struct simple_factory1 : public applications_pool::factory
                {
                        simple_factory1(P1 p1) : p1_(p1) {}
                        P1 p1_;
                        std::auto_ptr<application> operator()(service &s) const
                        {
                                std::auto_ptr<application> app(new T(s,p1_));
                                return app;
                        }
                };
                template<typename T,typename P1,typename P2>
                struct simple_factory2 : public applications_pool::factory 
                {
                        simple_factory2(P1 p1,P2 p2) : p1_(p1),p2_(p2) {}
                        P1 p1_;
                        P2 p2_;
                        std::auto_ptr<application> operator()(service &s) const
                        {
                                std::auto_ptr<application> app(new T(s,p1_,p2_));
                                return app;
                        }
                };
        } // details


        template<typename T>
        std::auto_ptr<applications_pool::factory> applications_factory()
        {
                std::auto_ptr<applications_pool::factory> f(new details::simple_factory0<T>);
                return f;
        }
        
        template<typename T,typename P1>
        std::auto_ptr<applications_pool::factory> applications_factory(P1 p1)
        {
                std::auto_ptr<applications_pool::factory> f(new details::simple_factory1<T,P1>(p1));
                return f;
        }
        
        template<typename T,typename P1,typename P2>
        std::auto_ptr<applications_pool::factory> applications_factory(P1 p1,P2 p2)
        {
                std::auto_ptr<applications_pool::factory> f(new details::simple_factory2<T,P1,P2>(p1,p2));
                return f;
        }

        namespace details {
                template<typename T>
                struct simple_application_specific_pool0 : public application_specific_pool
                {
                        T *new_application(service &s) 
                        {
                                return new T(s);
                        }
                };
                template<typename T,typename P1>
                struct simple_application_specific_pool1 : public application_specific_pool
                {
                        simple_application_specific_pool1(P1 p1) : p1_(p1) {}
                        P1 p1_;
                        T *new_application(service &s)
                        {
                                return new T(s,p1_);
                        }
                };
                template<typename T,typename P1,typename P2>
                struct simple_application_specific_pool2 : public application_specific_pool 
                {
                        simple_application_specific_pool2(P1 p1,P2 p2) : p1_(p1),p2_(p2) {}
                        P1 p1_;
                        P2 p2_;
                        T *new_application(service &s)
                        {
                                return new T(s,p1_,p2_);
                        }
                };
        } // details


        template<typename T>
        booster::shared_ptr<application_specific_pool> create_pool()
        {
                booster::shared_ptr<application_specific_pool> f(new details::simple_application_specific_pool0<T>);
                return f;
        }
        
        template<typename T,typename P1>
        booster::shared_ptr<application_specific_pool> create_pool(P1 p1)
        {
                booster::shared_ptr<application_specific_pool> f(new details::simple_application_specific_pool1<T,P1>(p1));
                return f;
        }
        
        template<typename T,typename P1,typename P2>
        booster::shared_ptr<application_specific_pool> create_pool(P1 p1,P2 p2)
        {
                booster::shared_ptr<application_specific_pool> f(new details::simple_application_specific_pool2<T,P1,P2>(p1,p2));
                return f;
        }

} // cppcms



#endif