gpucalc::Application Class Reference

Represent application. More...

#include <application.h>

Inheritance diagram for gpucalc::Application:

List of all members.

Public Member Functions
void	addGraphicCore (GraphicCore *Core)
	Add GraphicCore.
void	addShaderSystem (ShaderSystem *System)
	Add ShaderSystem.
void	addTaskManager (TaskManager *TaskMgr)
	Adds TaskManager to our application.
	Application (const InputArguments &InputArgs)
	default constructor
const std::string &	getClassName () const
	Returns name of class of our object.
GraphicCore *	getCompatibleGraphicCore (const ShaderSystem *System=Application::getSingleton().getDefaultShaderSystem())
	Returns GraphicCore compatible with given ShaderSystem.
ShaderSystem *	getCompatibleShaderSystem (const GraphicCore *Core=Application::getSingleton().getDefaultGraphicCore())
	Returns ShaderSystem compatible with given GraphicCore.
GraphicCore *	getDefaultGraphicCore ()
	Returns pointer to default GraphicCore.
ShaderSystem *	getDefaultShaderSystem ()
	Returns pointer to default ShaderSystem.
TaskManager *	getDefaultTaskManager () const
	Gets default TaskManager.
const InputArguments &	getInputArguments () const
const std::string &	getObjectName () const
	Returns name of our object.
void	getSpecificParameter (const std::string &ParameterName, void *ParameterValue)
	Method for obtaining some specific parameters, such as texture specific params, and so on.
TaskManager *	getTaskManager (const std::string &TaskMgrName) const
	Gets TaskManager by name.
void	installPlugin (Plugin *plugin)
	Install selected plugin.
bool	isLocked () const
	returns state of object.
void	loadLibrary (const std::string &LibraryFileName)
	Load dynamic library with selected name.
template<>
Timer *	mSingleton
template<>
Timer *	mSingleton
template<>
Profiler *	mSingleton
template<>
LogManager *	mSingleton
template<>
debugger::Debugger *	mSingleton
template<>
debugger::CommandParser *	mSingleton
template<>
Application *	mSingleton
void	removeGraphicCore (GraphicCore *Core)
	Remove graphic core.
void	removeShaderSystem (ShaderSystem *System)
	Remove shader system.
void	removeTaskManager (TaskManager *TaskMgr)
	Removes TaskManager from our application.
void	setWarningStatus (bool DisableWarning)
	Set warning status.
bool	supressWarnings () const
	If true, WARNING does nothing.
void	uninstallPlugin (Plugin *plugin)
	Uninstall selected plugin.
void	unloadLibrary (const std::string &LibraryFileName)
	~Application ()
	default destructor
Static Public Member Functions
static Application &	getSingleton ()
static Application *	getSingletonPtr ()
Protected Member Functions
void	addSpecificParameter (const std::string &ParameterName, void *ParameterValue, size_t Size)
void	lock ()
void	unlock ()
Static Protected Attributes
static T *	mSingleton
Private Types
typedef std::list< GraphicCore * >	GraphicCoreVector
typedef std::map< std::string, Library * >	LibraryMap
typedef std::map< std::string, Plugin * >	PluginMap
typedef std::list< ShaderSystem * >	ShaderSystemVector
typedef std::map< std::string, TaskManager * >	TaskManagerMap
Private Member Functions
void	applyInputArguments ()
void	automaticUninstallPlugins ()
void	automaticUnloadLibraries ()
Private Attributes
debugger::Debugger *	mDebugger
GraphicCore *	mDefaultGraphicCore
ShaderSystem *	mDefaultShaderSystem
TaskManager *	mDefaultTaskManager
GraphicCoreVector	mGraphicCoreVector
InputArguments	mInputArguments
LibraryMap	mLibraryMap
LogManager *	mLogManager
PluginMap	mPluginMap
Profiler *	mProfiler
ShaderSystemVector	mShaderSystemVector
bool	mSupressWarnings
TaskManagerMap	mTaskManagerMap
Timer *	mTimer

---

Detailed Description

Represent application.

This class can load and unload plugins, also gets pointers to some useful objects

See also:

GraphicCore and

ShaderSystem

Definition at line 54 of file application.h.

---

Member Typedef Documentation

typedef std::list<GraphicCore *> gpucalc::Application::GraphicCoreVector [private]

Definition at line 245 of file application.h.

typedef std::map<std::string, Library *> gpucalc::Application::LibraryMap [private]

Definition at line 263 of file application.h.

typedef std::map<std::string, Plugin *> gpucalc::Application::PluginMap [private]

Definition at line 259 of file application.h.

typedef std::list<ShaderSystem *> gpucalc::Application::ShaderSystemVector [private]

Definition at line 250 of file application.h.

typedef std::map<std::string, TaskManager *> gpucalc::Application::TaskManagerMap [private]

Definition at line 255 of file application.h.

---

Constructor & Destructor Documentation

gpucalc::Application::Application

(

const InputArguments &

InputArgs

)

default constructor

Creates instance of our application, creates log file, parse arguments and config file

Definition at line 59 of file application.cpp.

                                                            :
        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();
    }

gpucalc::Application::~Application

(

)

default destructor

deletes instance of our application, deletes singletons and unloads all plugins and libraries, registered earlier

See also:

unloadLibrary, uninstallPlugin

Definition at line 82 of file application.cpp.

    {
        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;
    }

---

Member Function Documentation

void gpucalc::Application::addGraphicCore

(

GraphicCore *

Core

)

Add GraphicCore.

Also this method set Core as default GraphicCore pointer

See also:

Application::getGraphicCore

Definition at line 100 of file application.cpp.

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

void gpucalc::Application::addShaderSystem

(

ShaderSystem *

System

)

Add ShaderSystem.

Also this method set shadersystem as default ShaderSystem pointer

See also:

Application::getShaderSystem

Definition at line 142 of file application.cpp.

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

void gpucalc::Object::addSpecificParameter	(	const std::string &	ParameterName,
		void *	ParameterValue,
		size_t	Size
	)			[inline, protected, inherited]

Definition at line 254 of file object.h.

   {
    SpecificParametersMap::iterator i = mSpecificParameters.find(ParameterName);
    if (i != mSpecificParameters.end())
    {
     mSpecificParameters.erase(i);
    }
    mSpecificParameters[ParameterName] = Any(ParameterValue, Size);
   }

void gpucalc::Application::addTaskManager

(

TaskManager *

TaskMgr

)

Adds TaskManager to our application.

Definition at line 182 of file application.cpp.

 {
  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;
  }
 }

void gpucalc::Application::applyInputArguments

(

)

[private]

Definition at line 326 of file application.cpp.

    {
        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));
        }
    }

void gpucalc::Application::automaticUninstallPlugins

(

)

[private]

Definition at line 308 of file application.cpp.

 {
  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 gpucalc::Application::automaticUnloadLibraries

(

)

[private]

Definition at line 289 of file application.cpp.

 {
  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();
  }
 }

const std::string& gpucalc::Object::getClassName

(

)

const [inline, inherited]

Returns name of class of our object.

Definition at line 92 of file object.h.

   {
    return mClassName;
   }

GraphicCore * gpucalc::Application::getCompatibleGraphicCore

(

const ShaderSystem *

System = Application::getSingleton().getDefaultShaderSystem()

)

Returns GraphicCore compatible with given ShaderSystem.

Note:

This method sets GraphicCore and ShaderSystem as default.

Set this GraphicCore as a default

Definition at line 108 of file application.cpp.

    {
        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;
    }

ShaderSystem * gpucalc::Application::getCompatibleShaderSystem

(

const GraphicCore *

Core = Application::getSingleton().getDefaultGraphicCore()

)

Returns ShaderSystem compatible with given GraphicCore.

Note:

This method sets ShaderSystem and GraphicCore as default.

Definition at line 150 of file application.cpp.

 {
  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;
 }

GraphicCore* gpucalc::Application::getDefaultGraphicCore

(

)

[inline]

Returns pointer to default GraphicCore.

Definition at line 115 of file application.h.

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

ShaderSystem* gpucalc::Application::getDefaultShaderSystem

(

)

[inline]

Returns pointer to default ShaderSystem.

Definition at line 151 of file application.h.

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

TaskManager * gpucalc::Application::getDefaultTaskManager

(

)

const

Gets default TaskManager.

Definition at line 196 of file application.cpp.

 {
  return mDefaultTaskManager;
 }

const InputArguments& gpucalc::Application::getInputArguments

(

)

const [inline]

Definition at line 219 of file application.h.

            {
                return mInputArguments;
            }

const std::string& gpucalc::Object::getObjectName

(

)

const [inline, inherited]

Returns name of our object.

Definition at line 101 of file object.h.

   {
    return mObjectName;
   }

Application & gpucalc::Application::getSingleton

(

)

[static]

Override standard Singleton retrieval.

Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll.

This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors.

Reimplemented from gpucalc::Singleton< T >.

Definition at line 52 of file application.cpp.

    {
        assert(mSingleton);
        return(* mSingleton);
    }

Application * gpucalc::Application::getSingletonPtr

(

)

[static]

Override standard Singleton retrieval.

Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll.

This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors.

Reimplemented from gpucalc::Singleton< T >.

Definition at line 46 of file application.cpp.

    {
        return mSingleton;
    }

void gpucalc::Object::getSpecificParameter	(	const std::string &	ParameterName,
		void *	ParameterValue
	)			[inline, inherited]

Method for obtaining some specific parameters, such as texture specific params, and so on.

Parameters:

	ParameterName	- name of parameter, usually it similar to specific method of some object (for example, GLTextureID)
	ParameterValue	- contain value of named parameter, it must be allocated and have sufficient size.

Todo:

Think for better realization.

Definition at line 128 of file object.h.

   {
    SpecificParametersMap::iterator i = mSpecificParameters.find(ParameterName);
    if (i != mSpecificParameters.end())
    {
     i->second.copyValue(ParameterValue);
    }
    else
    {
     Except<ERR_ITEM_NOT_FOUND>(this, "Parameter \"" + ParameterName + "\" does not exists.", "Object::getSpecificParameter()", __FILE__, __LINE__);
    }
   }

TaskManager * gpucalc::Application::getTaskManager

(

const std::string &

TaskMgrName

)

const

Gets TaskManager by name.

Definition at line 202 of file application.cpp.

 {
  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 gpucalc::Application::installPlugin

(

Plugin *

plugin

)

Install selected plugin.

if plugin has already installed, does nothing

Definition at line 228 of file application.cpp.

 {
  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__);
  }
 }

bool gpucalc::Object::isLocked

(

)

const [inline, inherited]

returns state of object.

If object is locked then we cannot change some state of it, because object is used in computation. If object is unlocked then we can change some state of it, object is not in computation.

Definition at line 113 of file object.h.

   {
    return mIsLocked;
   }

void gpucalc::Application::loadLibrary

(

const std::string &

LibraryFileName

)

Load dynamic library with selected name.

if Library has already loaded, does nothing

Definition at line 253 of file application.cpp.

 {
        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 gpucalc::Object::lock

(

)

[inline, protected, inherited]

Definition at line 265 of file object.h.

   {
    mIsLocked = true;
   }

template<>

Timer * gpucalc::Singleton< Timer >::mSingleton

(

)

[inline, inherited]

Definition at line 42 of file win32_timer_impl.cpp.

template<>

Timer * gpucalc::Singleton< Timer >::mSingleton

(

)

[inline, inherited]

Definition at line 45 of file unix_timer_impl.cpp.

template<>

Profiler * gpucalc::Singleton< Profiler >::mSingleton

(

)

[inline, inherited]

Definition at line 39 of file profiler.cpp.

template<>

LogManager * gpucalc::Singleton< LogManager >::mSingleton

(

)

[inline, inherited]

Definition at line 38 of file log_manager.cpp.

template<>

debugger::Debugger * gpucalc::Singleton< debugger::Debugger >::mSingleton

(

)

[inline, inherited]

Definition at line 42 of file debugger.cpp.

template<>

debugger::CommandParser * gpucalc::Singleton< debugger::CommandParser >::mSingleton

(

)

[inline, inherited]

Definition at line 41 of file command_parser.cpp.

template<>

Application * gpucalc::Singleton< Application >::mSingleton

(

)

[inline, inherited]

Definition at line 44 of file application.cpp.

void gpucalc::Application::removeGraphicCore

(

GraphicCore *

Core

)

Remove graphic core.

This method does not delete GraphicCore, but erases it from list of registered GraphicCore s. This object deleted in corresponding Plugin class

Definition at line 125 of file application.cpp.

 {
  removeFromContainer(Core, mGraphicCoreVector);
  if (Core == mDefaultGraphicCore)
  {
   if (mGraphicCoreVector.empty())
   {
    mDefaultGraphicCore = 0;
   }
   else
   {
    mDefaultGraphicCore = (*mGraphicCoreVector.begin());
   }
  }
 }

void gpucalc::Application::removeShaderSystem

(

ShaderSystem *

System

)

Remove shader system.

This method does not delete ShaderSystem, but erases it from list of registered ShaderSystems. This object deleted in corresponding Plugin class

Definition at line 165 of file application.cpp.

 {
  removeFromContainer(System, mShaderSystemVector);
  if (System == mDefaultShaderSystem)
  {
   if (mShaderSystemVector.empty())
   {
    mDefaultShaderSystem = 0;
   }
   else
   {
    mDefaultShaderSystem = (*mShaderSystemVector.begin());
   }
  }
 }

void gpucalc::Application::removeTaskManager

(

TaskManager *

TaskMgr

)

Removes TaskManager from our application.

Definition at line 217 of file application.cpp.

 {
  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 gpucalc::Application::setWarningStatus

(

bool

DisableWarning

)

[inline]

Set warning status.

Definition at line 213 of file application.h.

   {
    mSupressWarnings = DisableWarning;
   }

bool gpucalc::Application::supressWarnings

(

)

const [inline]

If true, WARNING does nothing.

See also:

exception.h

Definition at line 204 of file application.h.

   {
    return mSupressWarnings;
   }

void gpucalc::Application::uninstallPlugin

(

Plugin *

plugin

)

Uninstall selected plugin.

Definition at line 242 of file application.cpp.

 {
  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 gpucalc::Application::unloadLibrary

(

const std::string &

LibraryFileName

)

Definition at line 275 of file application.cpp.

 {
  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 gpucalc::Object::unlock

(

)

[inline, protected, inherited]

Definition at line 271 of file object.h.

   {
    mIsLocked = false;
   }

---

Member Data Documentation

debugger::Debugger* gpucalc::Application::mDebugger [private]

Definition at line 241 of file application.h.

GraphicCore* gpucalc::Application::mDefaultGraphicCore [private]

Definition at line 244 of file application.h.

ShaderSystem* gpucalc::Application::mDefaultShaderSystem [private]

Definition at line 249 of file application.h.

TaskManager* gpucalc::Application::mDefaultTaskManager [private]

Definition at line 254 of file application.h.

GraphicCoreVector gpucalc::Application::mGraphicCoreVector [private]

Definition at line 246 of file application.h.

InputArguments gpucalc::Application::mInputArguments [private]

Definition at line 269 of file application.h.

LibraryMap gpucalc::Application::mLibraryMap [private]

Definition at line 264 of file application.h.

LogManager* gpucalc::Application::mLogManager [private]

Definition at line 238 of file application.h.

PluginMap gpucalc::Application::mPluginMap [private]

Definition at line 260 of file application.h.

Profiler* gpucalc::Application::mProfiler [private]

Definition at line 240 of file application.h.

ShaderSystemVector gpucalc::Application::mShaderSystemVector [private]

Definition at line 251 of file application.h.

template<typename T>

T* gpucalc::Singleton< T >::mSingleton [static, protected, inherited]

Definition at line 108 of file singleton.h.

bool gpucalc::Application::mSupressWarnings [private]

Definition at line 267 of file application.h.

TaskManagerMap gpucalc::Application::mTaskManagerMap [private]

Definition at line 256 of file application.h.

Timer* gpucalc::Application::mTimer [private]

Definition at line 239 of file application.h.

---

The documentation for this class was generated from the following files:

• gpucalc/application.h
• gpucalc/application.cpp