application.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Kutumov Alexey                                  *
 *   ru.pixel@gmail.com                                                    *
 *                                                                         *
 *   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.             *
 ***************************************************************************/

#include "gpucalc/application.h"
#include "gpucalc/gpucalc.h"
#include "gpucalc/simple_task_manager.h"


namespace gpucalc
{
    typedef void (*DLL_START_PLUGIN)();
    typedef void (*DLL_STOP_PLUGIN)();


    template<> Application * Singleton<Application>::mSingleton = 0;

    Application * Application::getSingletonPtr()
    {
        return mSingleton;
    }


    Application & Application::getSingleton()
    {
        assert(mSingleton);
        return(* mSingleton);
    }


    Application::Application(const InputArguments & InputArgs):
        Singleton<Application>(_ApplicationClassName), mLogManager(new LogManager()), mTimer(new Timer), mProfiler(new Profiler),
        mDefaultGraphicCore(0), mGraphicCoreVector(), mDefaultShaderSystem(0), mShaderSystemVector(),
        mDefaultTaskManager(0), mTaskManagerMap(), mPluginMap(), mLibraryMap(), mSupressWarnings(false), mInputArguments(InputArgs)
    {
  mLogManager->createLog(InputArgs.getLogFile(), true, 15, 20, true);
  mLogManager->setLogDetail(mInputArguments.getLoggingLevel());
        applyInputArguments();

        LogManager::getSingleton().logMessage(this, "---===========================================---");
        LogManager::getSingleton().logMessage(this, "---===         Application created         ===---");
        LogManager::getSingleton().logMessage(this, std::string("---===Using \"gpucalc\" library version ") + gpucalc_version + "===---");
        LogManager::getSingleton().logMessage(this, "---===========================================---");

        LogManager::getSingleton().logMessage(this, "Application name is \"" + InputArgs.getApplicationName() + "\"");
        LogManager::getSingleton().logMessage(this, "Configuration file name is \"" + InputArgs.getConfigFile() + "\"");

        addTaskManager(new SimpleTaskManager());

        mDebugger = new debugger::Debugger();
    }


    Application::~Application()
    {
        automaticUnloadLibraries();
        automaticUninstallPlugins();

        clearContainer(mGraphicCoreVector);
        clearContainer(mShaderSystemVector);
        clearContainer(mTaskManagerMap);

        delete mDebugger;

        LogManager::getSingleton().logMessage(this, "---===========================================---");
        LogManager::getSingleton().logMessage(this, "---===         Application deleted         ===---");
        LogManager::getSingleton().logMessage(this, "---===========================================---");
        delete mLogManager;
    }


    void Application::addGraphicCore(GraphicCore * Core)
    {
        assert(Core && "adding non initialized GraphicCore pointer is not allowed");
        addToContainer(Core, mGraphicCoreVector);
        mDefaultGraphicCore = Core;
    }


    GraphicCore * Application::getCompatibleGraphicCore(const ShaderSystem * System)
    {
        for (GraphicCoreVector::iterator i = mGraphicCoreVector.begin(); i != mGraphicCoreVector.end(); ++i)
        {
            if ((*i)->isAcceptSystem(System))
            {
            mDefaultGraphicCore = *i;
            //mDefaultShaderSystem = System;
            return mDefaultGraphicCore;
            }
        }
        Except<ERR_ITEM_NOT_FOUND>(this, "Cannot find valid acceptable GraphicCore.", "Application::getGraphicCore", __FILE__, __LINE__);
        return 0;
    }


 void Application::removeGraphicCore(GraphicCore * Core)
 {
  removeFromContainer(Core, mGraphicCoreVector);
  if (Core == mDefaultGraphicCore)
  {
   if (mGraphicCoreVector.empty())
   {
    mDefaultGraphicCore = 0;
   }
   else
   {
    mDefaultGraphicCore = (*mGraphicCoreVector.begin());
   }
  }
 }


 void Application::addShaderSystem(ShaderSystem * System)
 {
  assert(System && "adding non initialized ShaderSystem pointer is not allowed.");
  addToContainer(System, mShaderSystemVector);
  mDefaultShaderSystem = System;
 }


 ShaderSystem * Application::getCompatibleShaderSystem(const GraphicCore * Core)
 {
  for (ShaderSystemVector::iterator i = mShaderSystemVector.begin(); i != mShaderSystemVector.end(); ++i)
  {
   if ((*i)->isAcceptCore(Core))
   {
    mDefaultShaderSystem = *i;
    return mDefaultShaderSystem;
   }
  }
  Except<ERR_ITEM_NOT_FOUND>(this, "Cannot find valid acceptable ShaderSystem.", "Application::getShaderSystem()", __FILE__, __LINE__);
  return 0;
 }


 void Application::removeShaderSystem(ShaderSystem * System)
 {
  removeFromContainer(System, mShaderSystemVector);
  if (System == mDefaultShaderSystem)
  {
   if (mShaderSystemVector.empty())
   {
    mDefaultShaderSystem = 0;
   }
   else
   {
    mDefaultShaderSystem = (*mShaderSystemVector.begin());
   }
  }
 }


 void Application::addTaskManager(TaskManager * TaskMgr)
 {
  if (!addToContainer(TaskMgr, TaskMgr->getObjectName(), mTaskManagerMap))
  {
   Warning<ERR_DUPLICATE_ITEM>(this, "TaskManager \"" + TaskMgr->getObjectName() + "\" already exists!!! Nothing added.",
    "Application::addTaskManager()", __FILE__, __LINE__);
  }
  else
  {
   mDefaultTaskManager = TaskMgr;
  }
 }


 TaskManager * Application::getDefaultTaskManager() const
 {
  return mDefaultTaskManager;
 }


 TaskManager * Application::getTaskManager(const std::string & TaskMgrName) const
 {
  TaskManagerMap::const_iterator i = mTaskManagerMap.find(TaskMgrName);
  if (i != mTaskManagerMap.end())
  {
   return i->second;
  }
  else
  {
   Except<ERR_ITEM_NOT_FOUND>(this, "TaskManager \"" + TaskMgrName + "\" cannot be found.", "Application::getTaskManager()", __FILE__, __LINE__);
   return 0;
  }
 }


 void Application::removeTaskManager(TaskManager * TaskMgr)
 {
  if (!removeFromContainer(TaskMgr->getObjectName(), mTaskManagerMap))
  {
   Warning<ERR_ITEM_NOT_FOUND>(this, "TaskManager \"" + TaskMgr->getObjectName() + "\" cannot be found!!! Deleting anyway.",
    "Application::removeTaskManager()", __FILE__, __LINE__);
  }
  delete TaskMgr;
 }


 void Application::installPlugin(Plugin * plugin)
 {
  if (addToContainer(plugin, plugin->getObjectName(), mPluginMap))
  {
   plugin->install();
  }
  else
  {
   Warning<ERR_DUPLICATE_ITEM>(this, "Plugin \"" + plugin->getObjectName() + "\" already exists!!! Nothing added.",
    "Application::installPlugin()", __FILE__, __LINE__);
  }
 }


 void Application::uninstallPlugin(Plugin * plugin)
 {
  if (!removeFromContainer(plugin->getObjectName(), mPluginMap))
  {
   Warning<ERR_ITEM_NOT_FOUND>(this, "Plugin \"" + plugin->getObjectName() + "\" cannot be found!!! Uninstalling anyway.",
    "Application::uninstallPLugin()", __FILE__, __LINE__);
  }
  plugin->uninstall();
 }


 void Application::loadLibrary(const std::string & LibraryFileName)
 {
        LibraryMap::iterator i = mLibraryMap.find(LibraryFileName);
        if (i == mLibraryMap.end())
        {
            LogManager::getSingleton().logMessage(this, "Loading \"" + LibraryFileName + "\"...");
            Library * lib = new Library(LibraryFileName);
   lib->load();
   addToContainer(lib, LibraryFileName, mLibraryMap);

   DLL_START_PLUGIN pFunc = (DLL_START_PLUGIN)lib->getSymbol("dllStartPlugin");
   if (!pFunc)
   {
    Except<ERR_FILE_NOT_FOUND>(this, "Entry point in plugin \"" +  LibraryFileName + "\" cannot be found",
     "Application::loadPlugin", __FILE__, __LINE__);
   }
   pFunc();
   LogManager::getSingleton().logMessage(this, "Library \"" + LibraryFileName + "\" successfully loaded");
  }
 }


 void Application::unloadLibrary(const std::string & LibraryFileName)
 {
  LibraryMap::iterator i = mLibraryMap.find(LibraryFileName);
  if (i != mLibraryMap.end())
  {
   DLL_STOP_PLUGIN pFunc = (DLL_STOP_PLUGIN)i->second->getSymbol("dllStopPlugin");
   pFunc();
   delete i->second;
   mLibraryMap.erase(i);
   LogManager::getSingleton().logMessage(this, "Library \"" + LibraryFileName + "\" successfully unloaded");
  }
 }


 void Application::automaticUnloadLibraries()
 {
  if (!mLibraryMap.empty())
  {
   Warning<ERR_INVALID_STATE>(this, "Called automatic unloading libraries.\
    It is preferred to unload its manualy by calling method Application::unloadLibrary()",
    "Application::AutomaticUnloadLibraries()", __FILE__, __LINE__);
   for (LibraryMap::iterator i = mLibraryMap.begin(); i != mLibraryMap.end(); ++i)
   {
    DLL_STOP_PLUGIN pFunc = (DLL_STOP_PLUGIN)i->second->getSymbol("dllStopPlugin");
    pFunc();
    delete i->second;
    LogManager::getSingleton().logMessage(this, "Library \"" + i->first + "\" successfully unloaded");
   }
   mLibraryMap.clear();
  }
 }


 void Application::automaticUninstallPlugins()
 {
  if (!mPluginMap.empty())
  {
   Warning<ERR_INVALID_STATE>(this, "Called automatic plugins uninstalling.\
    It is preferred to uninstall its manualy by calling method Application::uninstallPLugin",
    "Application::AutomaticuninstallPlugins", __FILE__, __LINE__);
   for (PluginMap::iterator i = mPluginMap.begin(); i != mPluginMap.end(); ++i)
   {
    i->second->uninstall();
    delete i->second;
    LogManager::getSingleton().logMessage(this, "Plugin \"" + i->first + "\" successfully uninstalled");
   }
   mPluginMap.clear();
  }
 }


    void Application::applyInputArguments()
    {
        const StringList & pluginList = mInputArguments.getPluginList();
        for (StringList::const_iterator i = pluginList.begin(); i != pluginList.end(); ++i)
        {
            try
            {
                loadLibrary(*i);
            }
            catch(const Exception & e)
            {
                // does nothing
            }
        }

        // assume that our graphic core and shader system are compatible
        mDefaultGraphicCore->start(mInputArguments.getArgc(), mInputArguments.getArgv());
        mDefaultShaderSystem->start();


        const StringMap & shaders = mInputArguments.getShaders();
        for (StringMap::const_iterator i = shaders.begin(); i != shaders.end(); ++i)
        {
            mDefaultShaderSystem->preCompile(i->first, auxillary::TextFileLoader::load(i->second));
        }
    }
}