plugin.h

Go to the documentation of this file.

/*
        plugin.h

        Copyright 2012 - 2016 Brenton Ross

This file is part of VICI.

VICI is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

VICI is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with VICI. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CFI_PLUGIN_H
#define CFI_PLUGIN_H

#include "stringy.h"
#include <map>
#include <list>
#include <memory>
#include <iostream>

extern "C"
{

        void initViciPlugin();


        void closeViciPlugin();
}

#define VICI_PLUGIN_VERSION "0.1"

namespace VICI
{
namespace cfi
{

class PlugInLib;

typedef std::shared_ptr<PlugInLib> PlugInLibPtr;


class PlugIn
{
private:
        friend class PlugInMgr;
        void setLib( PlugInLibPtr L);
private:
        PlugInLibPtr lib;
public:
        virtual ~PlugIn();
};


class AutoRunPlugIn : public PlugIn
{
public:
        virtual void execute() = 0;
};

typedef std::unique_ptr< AutoRunPlugIn > AutoRunPlugInPtr;


class PlugInFactory
{
public:
        virtual ~PlugInFactory(){}


        virtual PlugIn * make() = 0;
};


template < class F >
class PlugInFamilyFactoryT : public PlugInFactory
{
public:
        virtual F * make() = 0;
};



template < class F, class P >
class PlugInFactoryT : public PlugInFamilyFactoryT<F>
{
public:
        virtual ~PlugInFactoryT(){}
        virtual F * make() { return new P; }
};

struct PlugInDescriptor
{
        std::string pluginFamily;               
        std::string name;                               
        std::string description;                
        std::string version;                    
        VICI::Path library;                             
        bool onDemand;                                  
        bool autoRun;                                   
};

struct PlugInDetails : public PlugInDescriptor
{
        PlugInFactory *factory;                 
        bool loadable;                                  

        PlugInDetails();
};


class PlugInLib
{
public:
        enum Mode{
                AutoRun,                
                OnDemand,               
                StayResident    
        };

private:
        void * libHandle;
        VICI::Path path;
        int usageCounter;
        Mode mode;

        bool initLib();
        void closeLib();
public:

        PlugInLib( const Path & libPath );

        ~PlugInLib();


        void setMode( Mode m);


        Mode getMode() { return mode; }


        bool loaded();

        void startUsage();

        void endUsage();


        bool inUse() { return usageCounter > 0; }


        const VICI::Path & getPath() { return path; }
};


class PlugInMgr
{
private:
        // created with load(), removed when mgr destroyed
        std::map< std::string,  PlugInDetails > plugins;        // owned

        // mode == autorun ==> created by load, removed by load
        // mode == demand ==> created by getPlugin, removed when no longer needed
        // mode == load ==> created by load, removed when mgr destroyed
        std::map< Path, std::shared_ptr< PlugInLib > > libs;    // owned

        // libs wait here while unused
        std::list< PlugInLib * > pending;               // references

        bool loadLibrary( const Path &, PlugInLib::Mode );
        void getDetails(csr);
public:
        static PlugInMgr & instance();


        void load(csr prog);

        void regn( const PlugInDetails & details );

        void getDetails( std::vector< PlugInDescriptor > & plugins );

        void release( PlugInLib * );

        void shutdown();

        template < class PlugInFamily >
        std::unique_ptr< PlugInFamily > getPlugin( csr name )
        {
                // make sure we know the name
                auto P = plugins.find( name );
                if ( P == plugins.end() ) return nullptr;
                if ( ! P->second.loadable ) return nullptr;

                // if necessary load the library
                auto L = libs.find(P->second.library);
                if ( L == libs.end() || ! L->second->loaded())
                {
                        // std::cout << "Loading library " << name << std::endl;
                        PlugInLib::Mode mode = PlugInLib::StayResident;
                        if( P->second.autoRun) mode = PlugInLib::AutoRun;
                        else if ( P->second.onDemand ) mode = PlugInLib::OnDemand;

                        if ( ! loadLibrary( P->second.library, mode ) )
                        {
                                P->second.loadable = false;
                                // std::cout << "Unable to load library" << std::endl;
                                return nullptr;
                        }
                        L = libs.find(P->second.library);
                }
                // std::cout << "Loaded library" << std::endl;

                // get the factory from the library
                PlugInFamilyFactoryT<PlugInFamily> *pif
                                = dynamic_cast< PlugInFamilyFactoryT<PlugInFamily> * >( P->second.factory );
                if ( pif == 0) return nullptr;
                // std::cout << "Got the factory" << std::endl;

                // construct the object
                std::unique_ptr<PlugInFamily> up(pif->make() );
                up->setLib(L->second);
                return up;
        }
};


}  // namespace cfi
}  // namespace VICI


#endif /* INCLUDE_PLUGIN_H_ */