• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMPluginManager.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program 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 2
// of the License, or (at your option) any later version.
// 
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

//
// Inner includes
//

#include "../include/PCMPluginManager.h"

#include "../include/PCMFileSystemManager.h"

#include "../include/PCMStringConverter.h"

#include "../include/PCMRendererPlugin.h"

//
// Outer includes
//

#include <iostream>
#include <fstream>

namespace ParCompMark
{

  // Inherited static attribute initialization
  template <> PluginManager * Singleton < PluginManager >::mInstance = 0;

  //
  // Constructors & destructor
  //

  PluginManager::PluginManager(const std::string & pluginDirectory, const std::string & iniFile)
        // You have to initialize the following attributes:
        // - mPlugins
        // - mPluginDirectory
        // - mPluginIniFile
        // - mInitialized
  {
        mPlugins = new Container < Plugin, Mutex > ();
        mPluginDirectory = pluginDirectory;
        mPluginIniFile = iniFile;
        mInitialized = false;

        Logger::getInstance()->log(Logger::NOTICE, "Plugin manager has been created.");
  }

 /*----------------------------------------------------------------------*/

  PluginManager::~PluginManager()
  {
        if(mInitialized)
         finalize();

        Logger::getInstance()->log(Logger::NOTICE, "Plugin manager has been destroyed.");
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  void PluginManager::initialize()
  {
        Assert(!mInitialized, INVALID_OPERATION_ERROR, "PluginManager::initialize()");

        loadPlugins();

        mInitialized = true;

        Logger::getInstance()->log(Logger::DEBUG, "Plugin manager has been initialized.");
  }

 /*----------------------------------------------------------------------*/

  void PluginManager::finalize()
  {
        Assert(mInitialized, INVALID_OPERATION_ERROR, "PluginManager::finalize()");

        unloadPlugins();

        mInitialized = false;

        Logger::getInstance()->log(Logger::DEBUG, "Plugin manager has been finalized.");
  }

 /*----------------------------------------------------------------------*/

  void PluginManager::loadPlugins()
  {
        // Load renderer plugins
        std::list < std::string > plugins = FileSystemManager::getInstance()->listDataDirectory("plugins/renderers/");
        for(std::list < std::string >::iterator plugini = plugins.begin(); plugini != plugins.end(); plugini++)
        {
         if(plugini->find(".so") == std::string::npos)
                continue;

         // Load plugin
         Plugin::Pointer plugin(_loadPlugin(Plugin::RENDERER_PLUGIN, *plugini));

         // Check libraries for the plugin
         _checkNeededLibs(plugin);

         // Initialize the plugin
         plugin->initialize();
        }

        Logger::getInstance()->log(Logger::NOTICE, "All plugins has been loaded.");
  }

 /*----------------------------------------------------------------------*/

  void PluginManager::loadPlugins_old()
  {
        FileSystemManager::CppFilePointer fp(FileSystemManager::getInstance()->
                                          openDataFileCpp(mPluginDirectory + mPluginIniFile,
                                                          FileSystemManager::READ));

        const u32 lineBufSize = 1024;
        char lineBuf[lineBufSize];

        std::string line = "";

        while(!fp->eof())
        {
         // Read line, trim, and test comment
         fp->getline(lineBuf, lineBufSize);

         line = lineBuf;
         StringConverter::trim(line);
         if(!line.length() || line[0] == '#')
                continue;

         // Plugin name and option
         std::string filename;
         std::string option;

         // Look for option
         if(line.find('[') != std::string::npos)
         {
                filename = line.substr(0, line.find('['));
                StringConverter::trim(filename);

                option = line.substr(line.find('[')).substr(0, line.find(']'));
                StringConverter::trim(option);
         }

         else
                filename = line;

         // Test filename
         Assert(filename.length(), INVALID_NAME_ERROR, "PluginManager::loadPlugins()");

         // Convert option string to plugin type
         Plugin::PluginType pluginType = Plugin::BASIC_PLUGIN;
         if(option == "[renderer]")
                pluginType = Plugin::RENDERER_PLUGIN;
         else if(option.length())
                Except(INVALID_ENUM_ERROR, "PluginManager::loadPlugins()",
                   "Unknown option `" + option + "\' for plugin `" + filename + "\'");

         // Load plugin
         Plugin::Pointer plugin(_loadPlugin(pluginType, filename));

         // Check libraries for the plugin
         _checkNeededLibs(plugin);

         // Initialize the plugin
         plugin->initialize();
        }

        FileSystemManager::getInstance()->closeFile(fp);

        Logger::getInstance()->log(Logger::NOTICE, "All plugins has been loaded.");
  }

 /*----------------------------------------------------------------------*/

  void PluginManager::unloadPlugins()
  {
        mPlugins.kill();

        Logger::getInstance()->log(Logger::NOTICE, "All plugins has been unloaded.");
  }

 /*----------------------------------------------------------------------*/

  Plugin::Pointer PluginManager::getPlugin(const std::string & name)
  {
        Assert(mInitialized, INVALID_OPERATION_ERROR, "PluginManager::getPlugin()");

        mPlugins.lock();
        Plugin::Pointer plugin = mPlugins->get(name);
        mPlugins.unlock();

        return plugin;
  }

 /*----------------------------------------------------------------------*/

  Plugin::Pointer PluginManager::_loadPlugin(const Plugin::PluginType & type,
                                           const std::string & filename)
  {
        std::string name = filename.substr(filename.rfind('/') + 1);
        //std::string _filename = FileSystemManager::getInstance()->getPathDataFile(mPluginDirectory + filename);
        std::string _filename = FileSystemManager::getInstance()->getPathDataFile(filename);

        Plugin::Pointer plugin;

        switch (type)
        {
         case Plugin::RENDERER_PLUGIN:
                plugin = new RendererPlugin(type, name, _filename);
                break;
         default:
                Except(INVALID_ENUM_ERROR, "PluginManager::_loadPlugin()",
                   "Cannot create instance from basic plugin `" + filename + "\'.");
        }

        mPlugins.lock();
        mPlugins->add(name, plugin);
        mPlugins.unlock();

        Logger::getInstance()->log(Logger::DEBUG, "Plugin `" + filename + "\' has been loaded.");

        return plugin;
  }

 /*----------------------------------------------------------------------*/

  void PluginManager::_checkNeededLibs(Plugin::Pointer & plugin)
  {
        // TODO: implement

        Logger::getInstance()->log(Logger::DEBUG,
                                 "Every library needed by plugin `" + plugin->getName() +
                                 "\' is linked to parcompmark.");
  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team