core.cpp

Go to the documentation of this file.

#include "config.h"
#include "libnebular.hpp"
#include "libnebular-plugin.hpp"
#include "utils.hpp"

#include <list>

#include <loki/Singleton.h>

#if __GNUC__

// Dynamically loaded libraries
#include <dlfcn.h>
// File system directory enumeration
#include <dirent.h>
// Helper @c typedef for FS directory enumeration
#include <sys/types.h>

#else
#error Some code needs to be ported
#endif // __GNUC__

namespace libnebular{
    using namespace std;

    class DLLibWrapper{
#ifdef __GNUC__
    private:
        struct Impl_;
        boost::shared_ptr<Impl_> pimpl_;
        
    public:
        DLLibWrapper(const string &newUrl):
            pimpl_(
                new Impl_(
                    newUrl
                )
            )
        {
        }
        ~DLLibWrapper() {}

        void open(){
            pimpl_->open();
        }
        void close(){
            pimpl_->close();
        }

        template<typename F> F get(const string &symbolName){
            return pimpl_->get<F>(symbolName);
        }

    private:
        // @design Isn't best design, but works OK
        struct Impl_{
            string url;
            void *dlHandle;

            Impl_(const string &newUrl):
                url(newUrl),
                dlHandle(NULL)
            {}

            ~Impl_() {
                if(dlHandle){
                    close();
                }
            }

            void open(){
                if(dlHandle != NULL){
                    return;
                }

                dlHandle = dlopen(
                    url.c_str(),
                    RTLD_NOW |
                    RTLD_GLOBAL
                );
                if(!( dlHandle != NULL )){
                    throw LIBNEBULAR_ERROR(
                        string("Error loading library from \"") + url +"\": " +
                        string(dlerror())
                    );
                }
            }
            void close(){
                bool ok;
                ok = (dlclose(
                    dlHandle
                ) == 0);
                if(!( ok )){
                    Log::warning(
                        string("Error closing library \"") + url +"\": " +
                        string(dlerror())
                    );
                }
            }

            template<typename F> F get(const string &symbolName){
                // Not needed: dlerror(); /* clear error code */
                if(dlHandle == NULL){
                    open();
                }

                F symbol = reinterpret_cast<F>(
                    dlsym(dlHandle, symbolName.c_str())
                );

                char *errorStr;
                if ((errorStr = dlerror()) != NULL) {
                    throw LIBNEBULAR_ERROR(
                        string("Error loading library from \"") + url +"\": " +
                        string(errorStr)
                    );
                }

                return symbol;
            }

        };
#else   // __GNUC__

#error Please provide appropriate DL Library wrapper

#endif
    };

    // @class Core
    // {

    class PicHandlerMgr;

    class Core::Impl_{
    public:
        typedef list< DLLibWrapper > PluginFileList;
        typedef list< boost::shared_ptr<PicHandlerMgr> > PluginList;
        
    private:

        friend class Core;
        Impl_():
            isPluginRegDone_(false),
            pluginDir(".")
        {}

        typedef Loki::SingletonHolder<
            Core
        > CoreHolder;

        bool isPluginRegDone_;
        std::string pluginDir;

        PluginFileList pluginFiles;
        PluginList plugins;

    public:
        ~Impl_() {}

        PluginList::iterator pluginBegin(){
            return plugins.begin();
        }
        PluginList::iterator pluginEnd(){
            return plugins.end();
        }
    };

    // @note Programmer: If i'd make this private, i should specify friend class or fuction which creates, destroys @c Core - but that would be revealing of implementation details.
    Core::Core():
        pimpl_(new Impl_)
    {}

    Core::~Core() {}

    void Core::registerPlugins(){
        struct PluginFileEnum{
            string dirName;

            int numFiles;

            static int isPluginFile(const struct ::dirent *aDirEnt){
                const string fileName = aDirEnt->d_name;
                const string prefix = "libnebular-plugin-";
                const string suffix = ".so";

                if(
                    fileName.length() > prefix.length() + suffix.length() &&
                    fileName.substr(0, prefix.length()) == prefix &&
                    fileName.substr(fileName.length() - suffix.length()) == suffix
                ){
                    return int(true);
                }
                return int(false);
            }

            void enumerate(list<string> &newList){
#if __GNUC__
                // Cleanup
                newList = list<string>();

                struct ::dirent **dirEntriesRaw;
                numFiles = ::scandir(
                    dirName.c_str(),
                    &dirEntriesRaw,
                    isPluginFile,
                    ::alphasort
                );
                boost::shared_ptr<
                    struct ::dirent *
                > dirEntries(
                    dirEntriesRaw,
                    CArrayOfArrayDeleter(numFiles)
                );

                const string dirFileSep = "/";
                if(numFiles >= 0){
                    for(int idxFile = 0; idxFile < numFiles; idxFile++){
                        newList.push_back(
                            dirName + dirFileSep  + dirEntries.get()[idxFile]->d_name
                        );
                    }
                }else{
                    throw LIBNEBULAR_ERROR("At plugin directory file enumeration");
                }
#endif // __GNUC__
            }

            PluginFileEnum(const string &newDirName):
                dirName(newDirName)
            {}

            ~PluginFileEnum() {}
        } pluginFileEnum(
            pimpl_->pluginDir
        );

        list<string> pluginFile;
        pluginFileEnum.enumerate(pluginFile);

        // Cleanup
        pimpl_->plugins = Impl_::PluginList();
        pimpl_->pluginFiles = Impl_::PluginFileList();

        for(
            list<string>::iterator curPluginFile = pluginFile.begin();
            curPluginFile != pluginFile.end();
            curPluginFile++
        ){
            DLLibWrapper pluginLib(*curPluginFile);

            pimpl_->pluginFiles.push_back(
                pluginLib
            );

            pluginLib.open();
            typedef boost::shared_ptr<PicHandlerMgr> (*GetPicHandlerMgrPtr)();
            GetPicHandlerMgrPtr getNewCurrPicHandlerMgr =
                pluginLib.get<GetPicHandlerMgrPtr>(
                    "getNewCurrPicHandlerMgr"
                );

            pimpl_->plugins.push_back(
                getNewCurrPicHandlerMgr()
            );
        }

        if(pimpl_->pluginFiles.empty()){
            Log::warning("No plugins found");
        }

        pimpl_->isPluginRegDone_ = true;
    }

    void Core::makePluginsRegistered(){
        if(!isPluginRegDone()){
            registerPlugins();
        }
    }

    bool Core::isPluginRegDone() const{
        return pimpl_->isPluginRegDone_;
    }

    void Core::setPluginDir(const std::string &newPluginDir){
        pimpl_->pluginDir = newPluginDir;
    }

    Core &Core::get(){
        return Impl_::CoreHolder::Instance();
    }

    // class PluginIterator
    // {

    class PluginIteratorImpl_{
    private:
        friend class PluginIterator;

        typedef Core::Impl_::PluginList::iterator BaseIterator;
        BaseIterator i;

    public:

        static PluginIterator toPluginIterator(
            BaseIterator newPluginListI
        ){
            PluginIterator newPluginI;
            newPluginI.pimpl_->i = newPluginListI;
            return newPluginI;
        }
    };

    // @note Language: Exception-safety is weak here, heh (at @c PluginIterator::PluginIterator)
    PluginIterator::PluginIterator():
        pimpl_(new Impl_)
    {}
    PluginIterator::~PluginIterator() {}

    PluginIterator::PluginIterator(
        const PluginIterator &src
    ):
        pimpl_(new Impl_)
    {
        (*this) = src;
    }
    PluginIterator& PluginIterator::operator=(
        const PluginIterator &src
    ){
        (pimpl_->i) = (src.pimpl_->i);
        return *this;
    }

    PluginIterator &PluginIterator::operator++(){
        ++( pimpl_->i );
        return *this;
    }
    PluginIterator PluginIterator::operator++(int){
        PluginIterator prev = *this;
        ( pimpl_->i++ );
        return prev;
    }
    bool PluginIterator::operator!=(const PluginIterator &b) const{
        return ( pimpl_->i != b.pimpl_->i );
    }
    bool PluginIterator::operator==(const PluginIterator &b) const{
        return ( pimpl_->i == b.pimpl_->i );
    }
    PluginIterator::value_type& PluginIterator::operator*(){
        return *( *( pimpl_->i ) );
    }
    PluginIterator::value_type* PluginIterator::operator->(){
        return ( *( pimpl_->i ) ).get();
    }

    //}
    PluginIterator pluginBegin(){
        return PluginIteratorImpl_::toPluginIterator(
            Core::get().pimpl_->pluginBegin()
        );
    }
    PluginIterator pluginEnd(){
        return PluginIteratorImpl_::toPluginIterator(
            Core::get().pimpl_->pluginEnd()
        );
    }

    //}

}

---