PionPlugin.hpp

// -----------------------------------------------------------------------
// pion-common: a collection of common libraries used by the Pion Platform
// -----------------------------------------------------------------------
// Copyright (C) 2007-2008 Atomic Labs, Inc.  (http://www.atomiclabs.com)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//

#ifndef __PION_PIONPLUGIN_HEADER__
#define __PION_PIONPLUGIN_HEADER__

#include <vector>
#include <string>
#include <map>
#include <list>
#include <boost/thread/mutex.hpp>
#include <boost/filesystem/path.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>


namespace pion {    // begin namespace pion

class PION_COMMON_API PionPlugin {
public:

    class PluginUndefinedException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Plug-in was not loaded properly";
        }
    };
    
    class DirectoryNotFoundException : public PionException {
    public:
        DirectoryNotFoundException(const std::string& dir)
            : PionException("Plug-in directory not found: ", dir) {}
    };

    class PluginNotFoundException : public PionException {
    public:
        PluginNotFoundException(const std::string& file)
            : PionException("Plug-in library not found: ", file) {}
    };
    
    class OpenPluginException : public PionException {
    public:
        OpenPluginException(const std::string& file)
            : PionException("Unable to open plug-in library: ", file) {}
    };
    
    class PluginMissingCreateException : public PionException {
    public:
        PluginMissingCreateException(const std::string& file)
            : PionException("Plug-in library does not include create() symbol: ", file) {}
    };
    
    class PluginMissingDestroyException : public PionException {
    public:
        PluginMissingDestroyException(const std::string& file)
            : PionException("Plug-in library does not include destroy() symbol: ", file) {}
    };

    static inline bool findPluginFile(std::string& path_to_file,
                                      const std::string& name)
    {
        return findFile(path_to_file, name, PION_PLUGIN_EXTENSION);
    }

    static inline bool findConfigFile(std::string& path_to_file,
                                      const std::string& name)
    {
        return findFile(path_to_file, name, PION_CONFIG_EXTENSION);
    }
    
    static bool findStaticEntryPoint(const std::string& plugin_name,
                                     void **create_func,
                                     void **destroy_func);
    
    static void addStaticEntryPoint(const std::string& plugin_name,
                                    void *create_func,
                                    void *destroy_func);
    
    static void checkCygwinPath(boost::filesystem::path& final_path,
                                const std::string& path_string);

    static void addPluginDirectory(const std::string& dir);
    
    static void resetPluginDirectories(void);
    

    // default destructor
    virtual ~PionPlugin() { releaseData(); }
    
    inline bool is_open(void) const { return (m_plugin_data != NULL); }
    
    inline std::string getPluginName(void) const {
        return (is_open() ? m_plugin_data->m_plugin_name : std::string());
    }

    static void getAllPluginNames(std::vector<std::string>& plugin_names);

    void open(const std::string& plugin_name);

    void openFile(const std::string& plugin_file);

    void openStaticLinked(const std::string& plugin_name,
                          void *create_func,
                          void *destroy_func);

    inline void close(void) { releaseData(); }

protected:
    
    struct PionPluginData
    {
        PionPluginData(void)
            : m_lib_handle(NULL), m_create_func(NULL), m_destroy_func(NULL),
            m_references(0)
        {}
        PionPluginData(const std::string& plugin_name)
            : m_lib_handle(NULL), m_create_func(NULL), m_destroy_func(NULL),
            m_plugin_name(plugin_name), m_references(0)
        {}
        PionPluginData(const PionPluginData& p)
            : m_lib_handle(p.m_lib_handle), m_create_func(p.m_create_func),
            m_destroy_func(p.m_destroy_func), m_plugin_name(p.m_plugin_name),
            m_references(p.m_references)
        {}
        
        void *          m_lib_handle;
        
        void *          m_create_func;
        
        void *          m_destroy_func;
        
        std::string     m_plugin_name;
        
        unsigned long   m_references;
    };

    
    PionPlugin(void) : m_plugin_data(NULL) {}
    
    PionPlugin(const PionPlugin& p) : m_plugin_data(NULL) { grabData(p); }

    PionPlugin& operator=(const PionPlugin& p) { grabData(p); return *this; }

    inline void *getCreateFunction(void) {
        return (is_open() ? m_plugin_data->m_create_func : NULL);
    }

    inline void *getDestroyFunction(void) {
        return (is_open() ? m_plugin_data->m_destroy_func : NULL);
    }

    void releaseData(void);
    
    void grabData(const PionPlugin& p);

    
private:

    class StaticEntryPoint
    {
    public:
        StaticEntryPoint(const std::string& name, void *create, void *destroy)
            : m_plugin_name(name), m_create_func(create), m_destroy_func(destroy)
            {}
        std::string  m_plugin_name;
        void *       m_create_func;
        void *       m_destroy_func;
    };

    typedef std::list<StaticEntryPoint>     StaticEntryPointList;
    
    typedef std::map<std::string, PionPluginData*>  PluginMap;

    
    static bool findFile(std::string& path_to_file, const std::string& name,                             
                         const std::string& extension);
    
    static bool checkForFile(std::string& final_path, const std::string& start_path,
                             const std::string& name, const std::string& extension);
    
    static void openPlugin(const std::string& plugin_file,
                           PionPluginData& plugin_data);

    static std::string getPluginName(const std::string& plugin_file);
    
    static void *loadDynamicLibrary(const std::string& plugin_file);
    
    static void closeDynamicLibrary(void *lib_handle);
    
    static void *getLibrarySymbol(void *lib_handle, const std::string& symbol);
    
    
    static const std::string            PION_PLUGIN_CREATE;
    
    static const std::string            PION_PLUGIN_DESTROY;
    
    static const std::string            PION_PLUGIN_EXTENSION;
    
    static const std::string            PION_CONFIG_EXTENSION;
    
    static std::vector<std::string>     m_plugin_dirs;
    
    static PluginMap                    m_plugin_map;
    
    static boost::mutex                 m_plugin_mutex;

    static StaticEntryPointList         *m_entry_points_ptr;

    PionPluginData *                    m_plugin_data;
};


template <typename InterfaceClassType>
class PionPluginPtr :
    public PionPlugin
{
protected:
    
    typedef InterfaceClassType* CreateObjectFunction(void);
    
    typedef void DestroyObjectFunction(InterfaceClassType*);

    
public:

    PionPluginPtr(void) : PionPlugin() {}
    virtual ~PionPluginPtr() {}
    
    PionPluginPtr(const PionPluginPtr& p) : PionPlugin(p) {}

    PionPluginPtr& operator=(const PionPluginPtr& p) { grabData(p); return *this; }

    inline InterfaceClassType *create(void) {
        CreateObjectFunction *create_func =
            (CreateObjectFunction*)(getCreateFunction());
        if (create_func == NULL)
            throw PluginUndefinedException();
        return create_func();
    }
    
    inline void destroy(InterfaceClassType *object_ptr) {
        DestroyObjectFunction *destroy_func =
            (DestroyObjectFunction*)(getDestroyFunction());
        if (destroy_func == NULL)
            throw PluginUndefinedException();
        destroy_func(object_ptr);
    }
};


#ifdef PION_STATIC_LINKING

#define PION_DECLARE_PLUGIN(plugin_name)    \
    class plugin_name;                      \
    extern "C" plugin_name *pion_create_##plugin_name(void); \
    extern "C" void pion_destroy_##plugin_name(plugin_name *plugin_ptr); \
    static pion::StaticEntryPointHelper helper_##plugin_name(#plugin_name, pion_create_##plugin_name, pion_destroy_##plugin_name);

class StaticEntryPointHelper {
public:
    StaticEntryPointHelper(const std::string& name, void *create, void *destroy)
    {
        pion::PionPlugin::addStaticEntryPoint(name, create, destroy);
    }
};

#else

#define PION_DECLARE_PLUGIN(plugin_name)

#endif

}   // end namespace pion

#endif