application.h

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.             *
 ***************************************************************************/

#ifndef __application__header__
#define __application__header__

#include "gpucalc/singleton.h"

#include "gpucalc/input_argument_parser.h"

namespace gpucalc
{


 const char _ApplicationClassName [] = "Application";


 class _GpuCalcExport Application: public Singleton<Application>
 {

  OBJ_DISABLE_COPY(Application)
  
  
  public:
   Application(const InputArguments & InputArgs);


   ~Application();


   void loadLibrary(const std::string & LibraryFileName);


   void unloadLibrary(const std::string & LibraryFileName);


   void installPlugin(Plugin * plugin);


   void uninstallPlugin(Plugin * plugin);


   void addGraphicCore(GraphicCore * Core);


   GraphicCore * getDefaultGraphicCore()
   {
    assert(mDefaultGraphicCore && "Default GraphicCore does not exists!!!");
    return mDefaultGraphicCore;
   }


   GraphicCore * getCompatibleGraphicCore(const ShaderSystem * System = Application::getSingleton().getDefaultShaderSystem());


   void removeGraphicCore(GraphicCore * Core);


   void addShaderSystem(ShaderSystem * System);


   ShaderSystem * getDefaultShaderSystem()
   {
    assert(mDefaultGraphicCore && "Default ShaderSystem does not exists!!!");
    return mDefaultShaderSystem;
   }


   ShaderSystem * getCompatibleShaderSystem(const GraphicCore * Core = Application::getSingleton().getDefaultGraphicCore());


   void removeShaderSystem(ShaderSystem * System);


   void addTaskManager(TaskManager * TaskMgr);


   TaskManager * getDefaultTaskManager() const;


   TaskManager * getTaskManager(const std::string & TaskMgrName) const;


   void removeTaskManager(TaskManager * TaskMgr);


   bool supressWarnings() const
   {
    return mSupressWarnings;
   }


   void setWarningStatus(bool DisableWarning)
   {
    mSupressWarnings = DisableWarning;
   }


            const InputArguments & getInputArguments() const
            {
                return mInputArguments;
            }


   static Application * getSingletonPtr();


   static Application & getSingleton();


  private:
   LogManager * mLogManager;
   Timer * mTimer;
   Profiler * mProfiler;
   debugger::Debugger * mDebugger;


   GraphicCore * mDefaultGraphicCore;
   typedef std::list<GraphicCore *> GraphicCoreVector;
   GraphicCoreVector mGraphicCoreVector;


   ShaderSystem * mDefaultShaderSystem;
   typedef std::list<ShaderSystem *> ShaderSystemVector;
   ShaderSystemVector mShaderSystemVector;


   TaskManager * mDefaultTaskManager;
   typedef std::map<std::string, TaskManager *> TaskManagerMap;
   TaskManagerMap mTaskManagerMap;


   typedef std::map<std::string, Plugin *> PluginMap;
   PluginMap mPluginMap;


   typedef std::map<std::string, Library *>LibraryMap;
   LibraryMap mLibraryMap;


   bool mSupressWarnings;

            InputArguments mInputArguments;


   void automaticUnloadLibraries();
   void automaticUninstallPlugins();

            void applyInputArguments();
 };
}

#endif