Line data    Source code

       1             : 
       2             : /* Copyright (c) 2013-2016, EPFL/Blue Brain Project
       3             :  *                          Raphael Dumusc <raphael.dumusc@epfl.ch>
       4             :  *                          Stefan.Eilemann@epfl.ch
       5             :  *
       6             :  * This file is part of Lunchbox <https://github.com/Eyescale/Lunchbox>
       7             :  *
       8             :  * This library is free software; you can redistribute it and/or modify it under
       9             :  * the terms of the GNU Lesser General Public License version 2.1 as published
      10             :  * by the Free Software Foundation.
      11             :  *
      12             :  * This library is distributed in the hope that it will be useful, but WITHOUT
      13             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
      14             :  * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
      15             :  * details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public License
      18             :  * along with this library; if not, write to the Free Software Foundation, Inc.,
      19             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      20             :  */
      21             : 
      22             : #ifndef LUNCHBOX_PLUGINFACTORY_H
      23             : #define LUNCHBOX_PLUGINFACTORY_H
      24             : 
      25             : #include <lunchbox/types.h>
      26             : #include <lunchbox/algorithm.h> // used inline
      27             : #include <lunchbox/debug.h> // LBTHROW
      28             : #include <lunchbox/dso.h> // used inline
      29             : #include <lunchbox/file.h> // searchDirectory() used inline
      30             : #include <servus/uri.h> // Default template type
      31             : 
      32             : #include <unordered_map>
      33             : 
      34             : namespace lunchbox
      35             : {
      36             : 
      37             : /**
      38             :  * Factory for Plugin classes.
      39             :  *
      40             :  * The PluginFactory selects the a plugin for a given T::InitDataT, based on a
      41             :  * plugin's handles() function. In case a InitDataT can be handled by multiple
      42             :  * plugins, which plugin is chosen is undefined.
      43             :  *
      44             :  * This class has been designed as a singleton to allow for link time plugin
      45             :  * registration, but nothing prevents an application from registering new types
      46             :  * at run time.
      47             :  *
      48             :  * To do the registration of a plugin during the static initialization phase
      49             :  * use the PluginRegisterer.
      50             :  *
      51             :  * Example: @include tests/pluginFactory.cpp
      52             :  *
      53             :  * @version 1.11.0
      54             :  */
      55             : template< class T > class PluginFactory
      56             : {
      57             : public:
      58             :     typedef Plugin< T > PluginT;
      59             :     typedef std::vector< PluginT > Plugins;
      60             : 
      61             :     /** Get the single class instance. @version 1.11.0 */
      62             :     static PluginFactory& getInstance();
      63             : 
      64             :     /**
      65             :      * Create a plugin instance.
      66             :      * @param initData The initData passed to the plugin constructor.
      67             :      * @return A new PluginT instance. The user is responsible for deleting
      68             :      *         the returned object.
      69             :      * @throws std::runtime_error if no plugin can handle the initData.
      70             :      * @version 1.11.0
      71             :      */
      72             :     T* create( const typename T::InitDataT& initData );
      73             : 
      74             :     /** Register a plugin type. @version 1.11.0 */
      75             :     void register_( const PluginT& plugin );
      76             : 
      77             :     /** Deregister a plugin type. @version 1.11.0 */
      78             :     bool deregister( const PluginT& plugin );
      79             : 
      80             :     /** Unregister all plugin types. @version 1.11.0 */
      81             :     void deregisterAll();
      82             : 
      83             :     /** @name Automatic loading of plugin DSOs. */
      84             :     //@{
      85             :     /**
      86             :      * Load all compatible plugin libraries from a directory matching a pattern.
      87             :      *
      88             :      * The pattern is the core name of the library, and is extended by the
      89             :      * system-specific shared library suffix and postfix. The plugin has to
      90             :      * implement the C functions 'int LunchboxPluginGetVersion()' and 'bool
      91             :      * LunchboxPluginRegister()'. Only plugins with the same ABI version as the
      92             :      * given one are registered.
      93             :      *
      94             :      * @param version the current ABI version of the application loading the
      95             :      *                plugins.
      96             :      * @param path the directory to search for plugins.
      97             :      * @param pattern the core pattern of plugin names.
      98             :      * @version 1.11.0
      99             :      * @sa getLibraryPath()
     100             :      */
     101             :     void load( const int version, const std::string& path,
     102             :                const std::string& pattern );
     103             :     void load( const int version, const Strings& paths,
     104             :                const std::string& pattern );
     105             :     //@}
     106             : 
     107             : private:
     108           1 :     PluginFactory() {}
     109             :     PluginFactory( const PluginFactory& ) = delete;
     110             :     PluginFactory( PluginFactory&& ) = delete;
     111             :     PluginFactory& operator = ( const PluginFactory& ) = delete;
     112             :     PluginFactory& operator = ( PluginFactory&& ) = delete;
     113             : 
     114             : #pragma warning( disable: 4251 )
     115             :     Plugins _plugins;
     116             :     typedef std::unordered_map< DSO*, PluginT > PluginMap;
     117             :     PluginMap _libraries;
     118             : #pragma warning( default: 4251 )
     119             : 
     120             :     ~PluginFactory();
     121             : };
     122             : 
     123             : }
     124             : 
     125             : #include "pluginFactory.ipp" // template implementation
     126             : 
     127             : #endif // LUNCHBOX_PLUGINFACTORY_H