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

Search this page:

PCMPlugin.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/PCMPlugin.h"

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  Plugin::Plugin(const PluginType & type, const std::string & name, const std::string & filename):
        // Parent initializer 
  DynLoad(filename              /* Plugin file name. */
  ),
        // Parent initializer 
  Name(name                     /* Name of the plugin. */
        )
        // You have to initialize the following attributes:
        // - mPluginType
        // - mInitialized
        // - mNeededLibs
        // - mLastError
  {
        mPluginType = type;
        mInitialized = false;
        mLastError = 0;

        _getNeededLibs();
        _setPluginHandle();
        _setLoggerFunction();

        Logger::getInstance()->log(Logger::NOTICE,
                                 "Plugin `" + mName + "' has been created (`" + mLibraryName + "\').");
  }

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

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

        Logger::getInstance()->log(Logger::NOTICE,
                                 "Plugin `" + mName + "' has been destroyed (`" + mLibraryName + "\').");
  }

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

  //
  // Class methods
  //

  void Plugin::_loggerFunction(const void *handle, const char *message)
  {
        const Plugin *plugin = static_cast < const Plugin * >(handle);

        Logger::getInstance()->log(Logger::NOTICE, "Plugin `" + plugin->getName() + "\' message: " + message);
  }

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

  //
  // Methods
  //

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

        _onLoad();

        // Plugin specific initialization method
        _initializeSpecific();

        mInitialized = true;
        Logger::getInstance()->log(Logger::DEBUG, "Plugin `" + mName + "' has been initialized.");
  }

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

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

        // Plugin specific initialization method
        // TODO: causes pure virtual call in PluginManager::unloadPlugins()
        //_finalizeSpecific();

        _onUnload();

        mInitialized = false;

        Logger::getInstance()->log(Logger::DEBUG, "Plugin `" + mName + "' has been finalized.");
  }

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

  void Plugin::_getNeededLibs()
  {
        // Jump out if no such function
        if(!hasFunction("pcmGetNeededLibs"))
         return;

        pcmGetNeededLibsType pcmGetNeededLibs = (pcmGetNeededLibsType) getFunction("pcmGetNeededLibs");
        const char **neededLibs = pcmGetNeededLibs();

        if(neededLibs)
         for(const char **lib = neededLibs; *lib; lib++)
                mNeededLibs.push_back(*lib);

        Logger::getInstance()->log(Logger::DEBUG, "Needed libraries are retrieved from plugin `" + mName + "\'.");
  }

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

  void Plugin::_setPluginHandle()
  {
        // Jump out if no such function
        if(!hasFunction("pcmSetPluginHandle"))
         return;

        pcmSetPluginHandleType pcmSetPluginHandle = (pcmSetPluginHandleType) getFunction("pcmSetPluginHandle");

        mLastError = pcmSetPluginHandle((void *) this);
        _checkError();

        Logger::getInstance()->log(Logger::DEBUG, "Plugin handle is set for plugin `" + mName + "\'.");
  }

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

  void Plugin::_setLoggerFunction()
  {
        // Jump out if no such function
        if(!hasFunction("pcmSetLoggerFunction"))
         return;

        pcmSetLoggerFunctionType pcmSetLoggerFunction = (pcmSetLoggerFunctionType) getFunction("pcmSetLoggerFunction");

        mLastError = pcmSetLoggerFunction(Plugin::_loggerFunction);
        _checkError();

        Logger::getInstance()->log(Logger::DEBUG, "Logger function is set for plugin `" + mName + "\'.");
  }

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

  void Plugin::_onLoad()
  {
        // Jump out if no such function
        if(!hasFunction("pcmOnLoad"))
         return;

        pcmOnLoadType pcmOnLoad = (pcmOnLoadType) getFunction("pcmOnLoad");

        mLastError = pcmOnLoad();
        _checkError();

        Logger::getInstance()->log(Logger::DEBUG, "pcmLoad event handler is called for plugin `" + mName + "\'.");
  }

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

  void Plugin::_onUnload()
  {
        // Jump out if no such function
        if(!hasFunction("pcmOnLoad"))
         return;

        pcmOnUnloadType pcmOnUnload = (pcmOnUnloadType) getFunction("pcmOnLoad");

        mLastError = pcmOnUnload();
        _checkError();

        Logger::getInstance()->log(Logger::DEBUG, "pcmUnload event handler is called for plugin `" + mName + "\'.");
  }

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

  const char *Plugin::_getErrorMsg()
  {
        // Jump out if no such function
        if(!hasFunction("pcmGetErrorMsg"))
         return 0;

        pcmGetErrorMsgType pcmGetErrorMsg = (pcmGetErrorMsgType) getFunction("pcmGetErrorMsg");

        const char *msg = pcmGetErrorMsg(mLastError);

        Logger::getInstance()->log(Logger::DEBUG, "pcmGetErrorMsg function is called for plugin `" + mName + "\'.");

        return msg;
  }

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

}

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