plugin.h

//                                                                             
//  Copyright (C) 2008-2016  Artyom Beilis (Tonkikh) <artyomtnk@yahoo.com>     
//                                                                             
//  See accompanying file COPYING.TXT file for licensing details.
//
#ifndef CPPCMS_PLUGIN_H
#define CPPCMS_PLUGIN_H
#include <cppcms/defs.h>
#include <cppcms/cppcms_error.h>
#include <booster/callback.h>
#include <booster/hold_ptr.h>
#include <string>
#include <set>

namespace booster { class shared_object; }

namespace cppcms {
namespace json { class value; }
namespace plugin {

class CPPCMS_API signature_error : public booster::bad_cast {
public:
        signature_error(std::string const &msg);
        ~signature_error() throw();
        virtual char const *what() const throw();
private:
        std::string msg_;
};


class CPPCMS_API scope {
        scope(scope const &);
        void operator=(scope const &);
public:
        scope();
        ~scope();

        scope(int argc,char **argv);
        scope(json::value const &value);

        void paths(std::vector<std::string> const &paths);
        void shared_object_pattern(std::string const &pattern);

        void load(std::string const &module);

        static bool is_loaded(std::string const &module);

        booster::shared_object const &get(std::string const &module) const;

        bool is_loaded_by_this_scope(std::string const &module) const;
private:
        void init(json::value const &config);
        struct _class_data;
        static _class_data &class_data();

        struct _data;
        booster::hold_ptr<_data> d;
};


class CPPCMS_API manager {
public:
        static manager &instance();

        typedef booster::intrusive_ptr<booster::refcounted> refcounted_ptr;
        typedef refcounted_ptr (*entry_point_type)();

        template<typename Signature>
        booster::callback<Signature>
        entry(std::string const &plugin_name,std::string const &entry_name)
        {
                typedef booster::callback<Signature> callback_type;
                typedef typename callback_type::callable_type callable_type;
                typedef typename callback_type::pointer_type pointer_type;

                entry_point_type plugin_call = instance().get_entry(plugin_name,entry_name);
                if(!plugin_call)
                        throw cppcms_error("Could not find entry `" + entry_name + "' in plugin `" + plugin_name + "'");
                refcounted_ptr call = plugin_call();
                if(!call)
                        throw cppcms_error("Failed to create callback from plugin `"+plugin_name+"':entry `" + entry_name + "'");

                callable_type *real_call = dynamic_cast<callable_type *>(call.get());
                if(!real_call) {
                        throw signature_error("Invalid signature request in plugin `"+ plugin_name +"':entry `"+entry_name+"', expected following signaure `" + instance().signature(plugin_name,entry_name) + "'");
                }
                pointer_type ptr(real_call);
                callback_type result(ptr);
                return result;
        }

        template<typename Signature>
        bool has_entry(std::string const &plugin,std::string const &name)
        {
                typedef booster::callback<Signature> callback_type;

                entry_point_type plugin_call = get_entry(plugin,name);
                if(!plugin_call)
                        return false;
                return dynamic_cast<callback_type *>(plugin_call().get())!=0;
        }

        entry_point_type get_entry(std::string const &plugin,std::string const &name);
        std::string signature(std::string const &plugin,std::string const &name);

        void add_entry(char const *plugin_name,char const *entry_name,entry_point_type entry,char const *signature);
        void remove_entry(entry_point_type entry);

        std::set<std::string> plugins();
        std::set<std::string> entries(std::string const &plugin);

        bool has_plugin(std::string const &name);

private:
        manager();
        ~manager();
        manager(manager const &);
        void operator=(manager const &);

        struct _data;
        struct entry_type;
        booster::hold_ptr<_data> d;
};

#define CPPCMS_PLUGIN_CONCAT(x,y) x ## y
#define CPPCMS_PLUGIN_CONCAT2(x,y) CPPCMS_PLUGIN_CONCAT(x,y)

#define CPPCMS_FULL_PLUGIN_ENTRY(plugin_name,entry_name,call,type)                      \
namespace {                                                                             \
        struct CPPCMS_PLUGIN_CONCAT2(stpg_ , __LINE__) {                                \
                static booster::intrusive_ptr<booster::refcounted> entry()              \
                {                                                                       \
                        typedef booster::callback<type> ct;                             \
                        ct cb = call;                                                   \
                        booster::refcounted *tmp = cb.get_pointer().get();              \
                        booster::intrusive_ptr<booster::refcounted> ptr(tmp);           \
                        return ptr;                                                     \
                }                                                                       \
                CPPCMS_PLUGIN_CONCAT2(stpg_,__LINE__) () {                              \
                        cppcms::plugin::manager::instance().add_entry(                  \
                                plugin_name,entry_name,&entry,#type                     \
                        );                                                              \
                                                                                        \
                }                                                                       \
                ~CPPCMS_PLUGIN_CONCAT2(stpg_,__LINE__)() {                              \
                        cppcms::plugin::manager::instance().remove_entry(&entry);       \
                }                                                                       \
        } CPPCMS_PLUGIN_CONCAT2(instance_of_stpg_,__LINE__);                            \
} 


#define CPPCMS_PLUGIN_ENTRY(name,call,type) CPPCMS_FULL_PLUGIN_ENTRY(#name,#call,& name :: call,type)

#define CPPCMS_NAMED_PLUGIN_ENTRY(name,entry,call,type) CPPCMS_FULL_PLUGIN_ENTRY(#name,#entry,& name :: call,type)


} // plugin
} // cppcms

#endif