void CLI::Add(const std::string& path, const std::string& description, const std::string& alias, bool required) { po::options_description& desc = CLI::GetSingleton().desc; // Must make use of boost syntax here. std::string progOptId = alias.length() ? path + "," + alias : path; // Add the alias, if necessary AddAlias(alias, path); // Add the option to boost program_options. desc.add_options()(progOptId.c_str(), po::value<T>(), description.c_str()); // Make sure the appropriate metadata is inserted into gmap. gmap_t& gmap = GetSingleton().globalValues; ParamData data; T tmp = T(); data.desc = description; data.name = path; data.tname = TYPENAME(T); data.value = boost::any(tmp); data.wasPassed = false; gmap[path] = data; // If the option is required, add it to the required options list. if (required) GetSingleton().requiredOptions.push_front(path); }
T& CLI::GetParam(const std::string& identifier) { // Used to ensure we have a valid value. T tmp = T(); // Used to index into the globalValues map. std::string key = std::string(identifier); gmap_t& gmap = GetSingleton().globalValues; // Now check if we have an alias. amap_t& amap = GetSingleton().aliasValues; if (amap.count(key)) key = amap[key]; // What if we don't actually have any value? if (!gmap.count(key)) { gmap[key] = ParamData(); gmap[key].value = boost::any(tmp); *boost::any_cast<T>(&gmap[key].value) = tmp; } // What if we have meta-data, but no data? boost::any val = gmap[key].value; if (val.empty()) gmap[key].value = boost::any(tmp); return *boost::any_cast<T>(&gmap[key].value); }
T& CLI::GetParam(const std::string& identifier) { // Only use the alias if the parameter does not exist as given. std::string key = (GetSingleton().parameters.count(identifier) == 0 && identifier.length() == 1 && GetSingleton().aliases.count(identifier[0])) ? GetSingleton().aliases[identifier[0]] : identifier; if (GetSingleton().parameters.count(key) == 0) Log::Fatal << "Parameter --" << key << " does not exist in this program!" << std::endl; util::ParamData& d = GetSingleton().parameters[key]; // Make sure the types are correct. if (TYPENAME(T) != d.tname) Log::Fatal << "Attempted to access parameter --" << key << " as type " << TYPENAME(T) << ", but its true type is " << d.tname << "!" << std::endl; // We already know that required options have been passed, so we have a valid // value to return. Because the parameters held are sometimes different types // than what the user wants, we must pass through a utility function. typename util::ParameterType<T>::type& v = *boost::any_cast<typename util::ParameterType<T>::type>(&d.value); return util::HandleParameter<T>(v, d); }
void CLogger::SetFileName( String const & logFilePath, ELogType logLevel ) { if ( GetSingleton()._impl ) { GetSingleton().DoSetFileName( logFilePath, logLevel ); } }
void CLogger::Initialise( CLogger * logger ) { _counter++; #if defined( _WIN32 ) if ( _singleton ) { _counter--; PARSER_EXCEPT( EShaderParserExceptionCodes_InternalError, ERROR_DB_LOGGER_ALREADY_INITIALISED ); } else { _ownInstance = false; CLogger & mylogger = GetSingleton(); delete mylogger._impl; mylogger._impl = logger->_impl; for ( int i = 0; i < ELogType_COUNT; i++ ) { mylogger._headers[i] = logger->_headers[i]; } mylogger._logLevel = logger->_logLevel; mylogger.DoInitialiseThread(); } #endif }
void ezToolsProject::BroadcastSaveAll() { ezToolsProjectEvent e; e.m_pProject = GetSingleton(); e.m_Type = ezToolsProjectEvent::Type::SaveAll; s_Events.Broadcast(e); }
void ezToolsProject::BroadcastConfigChanged() { ezToolsProjectEvent e; e.m_pProject = GetSingleton(); e.m_Type = ezToolsProjectEvent::Type::ProjectConfigChanged; s_Events.Broadcast(e); }
gameEngine::gameEngine() : m_bQuit(true) { if (GetSingleton() == 0) gameEngine::ge_ptr = this; else { } gi_ptr = 0; }
void ezToolsProject::CloseProject() { if (GetSingleton()) { GetSingleton()->m_bIsClosing = true; ezToolsProjectEvent e; e.m_pProject = GetSingleton(); e.m_Type = ezToolsProjectEvent::Type::ProjectClosing; s_Events.Broadcast(e); ezDocumentManager::CloseAllDocuments(); delete GetSingleton(); e.m_Type = ezToolsProjectEvent::Type::ProjectClosed; s_Events.Broadcast(e); } }
static void kill() { if (_singleton != NULL) { GetSingleton()->clear(); delete _singleton; _singleton = NULL; C_Log::GetSingleton()->AddMessage("Singleton Resource killed."); } }
void CLogger::Cleanup() { GetSingleton().DoCleanupThread(); if ( _counter > 0 ) { _counter--; delete _singleton; _singleton = NULL; } }
typename util::ParameterType<T>::type& CLI::GetUnmappedParam( const std::string& identifier) { std::string key = (identifier.length() == 1 && GetSingleton().aliases.count(identifier[0])) ? GetSingleton().aliases[identifier[0]] : identifier; if (GetSingleton().parameters.count(key) == 0) Log::Fatal << "Parameter --" << key << " does not exist in this program!" << std::endl; util::ParamData& d = GetSingleton().parameters[key]; // Make sure the types are correct. if (TYPENAME(T) != d.tname) Log::Fatal << "Attempted to access parameter --" << key << " as type " << TYPENAME(T) << ", but its true type is " << d.tname << "!" << std::endl; return *boost::any_cast<typename util::ParameterType<T>::type>(&d.value); }
bool ezToolsProject::CanCloseProject() { if (GetSingleton() == nullptr) return true; ezToolsProjectRequest e; e.m_Type = ezToolsProjectRequest::Type::CanCloseProject; e.m_bCanClose = true; s_Requests.Broadcast(e, 1); // when the save dialog pops up and the user presses 'Save' we need to allow one more recursion return e.m_bCanClose; }
ezStatus ezToolsProject::CreateOrOpenProject(const char* szProjectPath, bool bCreate) { CloseProject(); new ezToolsProject(szProjectPath); ezStatus ret; if (bCreate) ret = GetSingleton()->Create(); else ret = GetSingleton()->Open(); if (ret.m_Result.Failed()) { delete GetSingleton(); return ret; } return ezStatus(EZ_SUCCESS); }
bool ezToolsProject::CanCloseDocuments(ezArrayPtr<ezDocument*> documents) { if (GetSingleton() == nullptr) return true; ezToolsProjectRequest e; e.m_Type = ezToolsProjectRequest::Type::CanCloseDocuments; e.m_bCanClose = true; e.m_Documents = documents; s_Requests.Broadcast(e); return e.m_bCanClose; }
LRESULT CALLBACK EventSystem::KeyboardHook( int nCode, WPARAM wParam, LPARAM lParam ) { if ( nCode >= HC_ACTION ) { KBDLLHOOKSTRUCT* Message = reinterpret_cast< KBDLLHOOKSTRUCT* >( lParam ); switch ( wParam ) { case WM_KEYDOWN: case WM_SYSKEYDOWN: GetSingleton( )->DispatchKeyPressEvents( Message->vkCode ); break; case WM_KEYUP: case WM_SYSKEYUP: GetSingleton( )->DispatchKeyReleaseEvents( Message->vkCode ); break; default: break; } } return CallNextHookEx( GetSingleton( )->KeyboardHookObject, nCode, wParam, lParam ); }
Component* ActorFactory::CreateComponent(const tinyxml2::XMLElement* i_pNode, const char* i_pActorName) { if(i_pNode) { const char* pComponentID = i_pNode->Value(); Component* pComponent = GetSingleton().m_Factory.Create(ObjectId(pComponentID), i_pActorName); if (pComponent) { if (pComponent->SetupFromXml(i_pNode)) { return pComponent; } } delete(pComponent); MGD_LOG::LOGManager::GetSingleton().WriteLog(MGD_LOG::MGD_ERROR, ACTOR_FACTORY_CONTEXT, "Component failed to initialize: %s", pComponentID); } return NULL; }
void CLogger::Initialise( ELogType logLevel ) { _counter++; if ( _singleton ) { PARSER_EXCEPT( EShaderParserExceptionCodes_InternalError, ERROR_DB_LOGGER_ALREADY_INITIALISED ); } else { _ownInstance = true; CLogger & logger = GetSingleton(); delete logger._impl; logger._impl = new CLoggerImpl; logger._impl->Initialise( logger ); logger._logLevel = logLevel; logger.DoInitialiseThread(); } }
LRESULT CALLBACK EventSystem::MouseHook( int nCode, WPARAM wParam, LPARAM lParam ) { if ( nCode >= HC_ACTION ) { MSLLHOOKSTRUCT* Message = reinterpret_cast< MSLLHOOKSTRUCT* >( lParam ); switch( wParam ) { case WM_LBUTTONDOWN: GetSingleton( )->DispatchMouseDownEvents( Message->pt, MouseButton::MOUSE_LEFT ); break; case WM_MBUTTONDOWN: GetSingleton( )->DispatchMouseDownEvents( Message->pt, MouseButton::MOUSE_MIDDLE ); break; case WM_RBUTTONDOWN: GetSingleton( )->DispatchMouseDownEvents( Message->pt, MouseButton::MOUSE_RIGHT ); break; case WM_LBUTTONUP: GetSingleton( )->DispatchMouseUpEvents( Message->pt, MouseButton::MOUSE_LEFT ); break; case WM_MBUTTONUP: GetSingleton( )->DispatchMouseUpEvents( Message->pt, MouseButton::MOUSE_MIDDLE ); break; case WM_RBUTTONUP: GetSingleton( )->DispatchMouseUpEvents( Message->pt, MouseButton::MOUSE_RIGHT ); break; case WM_MOUSEMOVE: GetSingleton( )->DispatchMouseMoveEvents( Message->pt, MouseButton::MOUSE_NONE ); // TODO: Add button states to callback break; default: break; } } return CallNextHookEx( GetSingleton( )->MouseHookObject, nCode, wParam, lParam ); }
void ActorFactory::CreateActorFromTemplate(const char* i_pTemplateActorName, const char* i_pActorName) { if (i_pTemplateActorName && strlen(i_pTemplateActorName) > 0 && i_pActorName && strlen(i_pActorName) > 0) { MGDVector<Component*> pTemplateComponents; SystemManager::GetSingleton().GetComponentsFromTemplate(ObjectId(i_pTemplateActorName), pTemplateComponents); MGDVector<Component*> pNewComponents; for (uint32 uiIndex = 0; uiIndex < pTemplateComponents.size(); ++uiIndex) { Component* pComponent = GetSingleton().m_Factory.Create(pTemplateComponents[uiIndex]->GetID(), i_pActorName, true); if (pComponent) { pComponent->CreateFromTemplate(pTemplateComponents[uiIndex], ObjectId(i_pActorName)); SystemManager::GetSingleton().AddComponent(pComponent, ObjectId(i_pActorName)); pNewComponents.push_back(pComponent); } } InitComponents(pNewComponents); } }
bool ImageBridgeChild::IsCreated() { return GetSingleton() != nullptr; }
CLogger * CLogger::GetSingletonPtr() { return &GetSingleton(); }
void CLogger::LogError( std::wstring const & msg ) { GetSingleton().DoPushMessage( ELogType_ERROR, msg ); }
void CLogger::LogWarning( std::wstring const & msg ) { GetSingleton().DoPushMessage( ELogType_WARNING, msg ); }
void CLogger::LogInfo( std::wstring const & msg ) { GetSingleton().DoPushMessage( ELogType_INFO, msg ); }
void CLogger::LogDebug( std::wstring const & msg ) { GetSingleton().DoPushMessage( ELogType_DEBUG, msg ); }
void CLogger::SetLevel( ELogType logLevel ) { GetSingleton()._logLevel = logLevel; }
void CLI::Add(const std::string& identifier, const std::string& description, const std::string& alias, const bool required, const bool input) { // Temporarily define color code escape sequences. #ifndef _WIN32 #define BASH_RED "\033[0;31m" #define BASH_CLEAR "\033[0m" #else #define BASH_RED "" #define BASH_CLEAR "" #endif // Temporary outstream object for detecting duplicate identifiers. util::PrefixedOutStream outstr(std::cerr, BASH_RED "[FATAL] " BASH_CLEAR, false, true /* fatal */); #undef BASH_RED #undef BASH_CLEAR // Define identifier and alias maps. gmap_t& gmap = GetSingleton().globalValues; amap_t& amap = GetSingleton().aliasValues; // If found in current map, print fatal error and terminate the program. if (gmap.count(identifier)) outstr << "Parameter --" << identifier << "(-" << alias << ") " << "is defined multiple times with same identifiers." << std::endl; if (amap.count(alias)) outstr << "Parameter --" << identifier << "(-" << alias << ") " << "is defined multiple times with same alias." << std::endl; po::options_description& desc = CLI::GetSingleton().desc; // Must make use of boost syntax here. std::string progOptId = alias.length() ? identifier + "," + alias : identifier; // Add the alias, if necessary AddAlias(alias, identifier); // Add the option to boost program_options. desc.add_options()(progOptId.c_str(), po::value<T>(), description.c_str()); // Make sure the appropriate metadata is inserted into gmap. ParamData data; T tmp = T(); data.desc = description; data.name = identifier; data.tname = TYPENAME(T); data.value = boost::any(tmp); data.wasPassed = false; gmap[identifier] = data; // If the option is required, add it to the required options list. if (required) GetSingleton().requiredOptions.push_front(identifier); // Depending on whether or not the option is input or output, add it to the // appropriate list. if (input) GetSingleton().inputOptions.push_front(identifier); else GetSingleton().outputOptions.push_front(identifier); }
CDatabase* CDatabase::GetSingletonPtr ( ) { return &GetSingleton (); }
void CompositorLRU::Init() { unused << GetSingleton(); }