void RootManager::uninitializeRootObject() { SLM_TRACE_FUNC(); SLM_WARN_IF("(Hack) Sorry, the OSR must be initialized to uninitialize it. ToDo => transform in assert", ! getDefault()->m_isRootInitialized ); if ( getDefault()->m_isRootInitialized ) { // Setting initialization to false getDefault()->m_isRootInitialized = false ; assert( getDefault()->m_rootObjectConfigurationName.first ) ; // Stop services reported in m_rootObjectConfiguration before stopping everything //::fwServices::stopAndUnregister(getDefault()->m_rootObjectConfiguration) ; getDefault()->m_ctm->stopAndDestroy(); OSLM_WARN_IF("Sorry, few services still exist before erasing root object ( cf debug following message )" << std::endl << ::fwServices::OSR::getRegistryInformation(), ! ::fwServices::OSR::getKSContainer().empty()); //::fwServices::GlobalEventManager::getDefault()->clearMessages(); SLM_TRACE("uninitializeRootObject : Reset the last shared_ptr on root object."); // Reset the root object: involve complete m_container clearing //getDefault()->m_rootObject.reset(); //assert( getDefault()->m_rootObject.use_count() == 0 ); // ::fwRuntime::profile::Profile::sptr profile = ::fwRuntime::profile::getCurrentProfile(); // SLM_TRACE("Stopping Profile"); // profile->stop(); // SLM_TRACE("Profile Stopped"); } }
RenderType intToRenderType(const int mode) { if (mode < 0 || mode >= RENDER_LAST) return getDefault(); if (mode != RENDER_SOFTWARE #if defined(USE_OPENGL) && defined(ANDROID) && defined(USE_SDL2) && mode != RENDER_GLES_OPENGL && mode != RENDER_SDL2_DEFAULT) #elif defined(USE_OPENGL) && defined(ANDROID) && !defined(USE_SDL2) && mode != RENDER_GLES_OPENGL) #elif defined(USE_OPENGL) && !defined(ANDROID) && defined(USE_SDL2) && mode != RENDER_NORMAL_OPENGL && mode != RENDER_MODERN_OPENGL && mode != RENDER_SAFE_OPENGL && mode != RENDER_GLES_OPENGL && mode != RENDER_SDL2_DEFAULT) #elif !defined(USE_OPENGL) && defined(USE_SDL2) && mode != RENDER_SDL2_DEFAULT) #elif !defined(USE_OPENGL) && !defined(USE_SDL2) ) #elif defined(USE_OPENGL) && !defined(ANDROID) && !defined(USE_SDL2) && mode != RENDER_NORMAL_OPENGL && mode != RENDER_MODERN_OPENGL && mode != RENDER_SAFE_OPENGL && mode != RENDER_GLES_OPENGL) #endif { return getDefault(); } return static_cast<RenderType>(mode); }
void RootManager::initializeRootObject() { SLM_ASSERT("Sorry, the OSR is already initialized.", ! getDefault()->m_isRootInitialized ); SLM_ASSERT("Sorry, configuration name parameter is not initialized.", getDefault()->m_rootObjectConfigurationName.first ); SLM_ASSERT("Sorry, configuration file parameter is not initialized.", getDefault()->m_rootObjectConfigurationFile.first ); // ToDo Correct this hack // Load another "pseudo" bundle ::boost::filesystem::path filePath ( getDefault()->m_rootObjectConfigurationFile.second ); SPTR(::fwRuntime::Bundle) configBundle = ::fwRuntime::io::BundleDescriptorReader::createBundleFromXmlPlugin( filePath ); ::fwRuntime::Runtime::getDefault()->addBundle( configBundle ); configBundle->setEnable( true ); // Validate bundle ::fwRuntime::Bundle::ExtensionConstIterator iter = configBundle->extensionsBegin(); while( iter != configBundle->extensionsEnd() ) { ::fwRuntime::Extension::Validity isValid = (*iter)->validate(); OSLM_FATAL_IF("Sorry, extension " << (*iter)->getIdentifier() << " is not valid.", isValid == ::fwRuntime::Extension::Invalid ); iter++; } // Register service config getDefault()->m_ctm = AppConfigManager::New(); ::fwRuntime::ConfigurationElement::csptr config = ::fwServices::registry::AppConfig::getDefault()->getStandardConfig( getDefault()->m_rootObjectConfigurationName.second ); getDefault()->m_ctm->setConfig( ::fwRuntime::ConfigurationElement::constCast( config ) ); getDefault()->m_ctm->launch(); getDefault()->m_isRootInitialized = true; }
void SoTextureCoordinateBindingElement::init(SoState *) // //////////////////////////////////////////////////////////////////////// { data = getDefault(); }
std::string colors::Colors::toString(colors::ColorEnum color) { std::string color_name; switch (color) { case ORANGE: color_name = "ORANGE"; break; case YELLOW: color_name = "YELLOW"; break; case BLUE: color_name = "BLUE"; break; case GREEN: color_name = "GREEN"; break; case RED: color_name = "RED"; break; case BLACK: color_name = "BLACK"; break; case PINK: color_name = "PINK"; break; case PURPLE: color_name = "PURPLE"; break; default: color_name = toString(getDefault()); } return color_name; }
int colors::Colors::toCode(colors::ColorEnum color) { int color_code; switch (color) { case ORANGE: color_code = 0; break; case YELLOW: color_code = 1; break; case BLUE: color_code = 2; break; case GREEN: color_code = 3; break; case RED: color_code = 4; break; case BLACK: color_code = 5; break; case PINK: color_code = 6; break; case PURPLE: color_code = 7; break; default: color_code = toCode(getDefault()); } return color_code; }
bool ParserIntItem::equal(const ParserIntItem& other) const { if (ParserItem::equal(other) && (getDefault() == other.getDefault())) return true; else return false; }
int unifei::expertinos::mrta_vc::tasks::SkillLevels::toCode(unifei::expertinos::mrta_vc::tasks::levels::SkillLevelEnum enumerated) { int code; switch (enumerated) { case unifei::expertinos::mrta_vc::tasks::levels::NONE: code = 0; break; case unifei::expertinos::mrta_vc::tasks::levels::LOW: code = 1; break; case unifei::expertinos::mrta_vc::tasks::levels::MODERATE: code = 2; break; case unifei::expertinos::mrta_vc::tasks::levels::HIGH: code = 3; break; case unifei::expertinos::mrta_vc::tasks::levels::RESOURCEFUL: code = 4; break; default: code = toCode(getDefault()); } return code; }
bool PhpParam::defValueNeedsVariable() const { DataType cppKindOf = kindOf(); if (!hasDefault() || !isIndirectPass()) { return false; } fbstring defVal = getDefault(); if (cppKindOf == KindOfString && ((defVal == "empty_string") || (defVal == "null_string") || (g_knownStringConstants.count(defVal) > 0))) { return false; } if ((cppKindOf == KindOfArray) && (defVal == "null_array")) { return false; } if ((cppKindOf == KindOfObject) && (defVal == "null_object")) { return false; } if ((cppKindOf == KindOfResource) && (defVal == "null_resource")) { return false; } if ((cppKindOf == KindOfAny) && (defVal == "null_variant")) { return false; } return true; }
std::string unifei::expertinos::mrta_vc::tasks::SkillLevels::toString(unifei::expertinos::mrta_vc::tasks::levels::SkillLevelEnum enumerated) { std::string enumerated_name; switch (enumerated) { case unifei::expertinos::mrta_vc::tasks::levels::NONE: enumerated_name = "NONE"; break; case unifei::expertinos::mrta_vc::tasks::levels::LOW: enumerated_name = "LOW"; break; case unifei::expertinos::mrta_vc::tasks::levels::MODERATE: enumerated_name = "MODERATE"; break; case unifei::expertinos::mrta_vc::tasks::levels::HIGH: enumerated_name = "HIGH"; break; case unifei::expertinos::mrta_vc::tasks::levels::RESOURCEFUL: enumerated_name = "RESOURCEFUL"; break; default: enumerated_name = toString(getDefault()); } return enumerated_name; }
U_NAMESPACE_BEGIN UnicodeString& Locale::getDisplayLanguage(UnicodeString& dispLang) const { return this->getDisplayLanguage(getDefault(), dispLang); }
void SoNormalBindingElement::init(SoState *) // //////////////////////////////////////////////////////////////////////// { data = getDefault(); }
unifei::expertinos::mrta_vc::tasks::levels::SkillLevelEnum unifei::expertinos::mrta_vc::tasks::SkillLevels::toEnumerated(int code) { unifei::expertinos::mrta_vc::tasks::levels::SkillLevelEnum enumerated; switch (code) { case 0: enumerated = unifei::expertinos::mrta_vc::tasks::levels::NONE; break; case 1: enumerated = unifei::expertinos::mrta_vc::tasks::levels::LOW; break; case 2: enumerated = unifei::expertinos::mrta_vc::tasks::levels::MODERATE; break; case 3: enumerated = unifei::expertinos::mrta_vc::tasks::levels::HIGH; break; case 4: enumerated = unifei::expertinos::mrta_vc::tasks::levels::RESOURCEFUL; break; default: enumerated = getDefault(); } return enumerated; }
void SoLightAttenuationElement::init(SoState *) // //////////////////////////////////////////////////////////////////////// { attenuation = getDefault(); }
void WebyPlugin::getResults(QList<InputData>* id, QList<CatItem>* results) { if (id->last().hasLabel(HASH_WEBSITE)) { const QString & text = id->last().getText(); // This is a website, create an entry for it results->push_front(CatItem(text + ".weby", text, HASH_WEBY, getIcon())); } if (id->count() > 1 && (unsigned int) id->first().getTopResult().id == HASH_WEBY) { const QString & text = id->last().getText(); // This is user search text, create an entry for it results->push_front(CatItem(text + ".weby", text, HASH_WEBY, getIcon())); } // If we don't have any results, add default if (results->size() == 0 && id->count() <= 1) { const QString & text = id->last().getText(); if (text != "") { QString name = getDefault().name; if (name != "") results->push_back(CatItem(text + ".weby", name, HASH_WEBY, getIcon())); } } }
bool ParserIntItem::equal(const ParserItem& other) const { // cast to a pointer to avoid bad_cast exception const ParserIntItem* rhs = dynamic_cast<const ParserIntItem*>(&other); if (rhs && ParserItem::equal(other) && (getDefault() == rhs->getDefault())) return true; else return false; }
void SoTextureImageElement::init(SoState *state) // //////////////////////////////////////////////////////////////////////// { SoReplacedElement::init(state); bytes = getDefault(size, numComponents); }
std::string ParserDoubleItem::createCode() const { std::stringstream ss; ss << "new ParserDoubleItem(" << "\"" << name() << "\"" << ",Opm::" << ParserItemSizeEnum2String( sizeType() ); if (m_defaultSet) ss << "," << boost::lexical_cast<std::string>(getDefault()); ss << ")"; return ss.str(); }
std::string ParserIntItem::createCode() const { std::stringstream ss; ss << "new ParserIntItem(" << "\"" << name() << "\"" << ",Opm::" << ParserItemSizeEnum2String( sizeType() ); if (m_defaultSet) ss << "," << getDefault(); ss << ")"; return ss.str(); }
const Otype &getOptionParser(const String&name)const { typename OptionMap::const_iterator where=mOptionParsers.find(name); if (where==mOptionParsers.end()) { if (name.length()==0&&getDefault().length()) { return getDefaultOptionParser(); } return mNop; } return where->second; }
void SensorImpl::setEnabled(const bool enabled) { if (enabled == isEnabled() || !isAvailable()) return; if (enabled) { if (ASensorEventQueue_enableSensor(ns_sensorEventQueue, getDefault(m_type)) >= 0) { m_sensor = getDefault(m_type); if (auto rate = ASensor_getMinDelay(m_sensor)) ASensorEventQueue_setEventRate(ns_sensorEventQueue, m_sensor, rate); } } else { ASensorEventQueue_disableSensor(ns_sensorEventQueue, m_sensor); m_sensor = NULL; } }
std::string ExternCompiler::readResult(StructuredLogEntry* log) const { const auto line = readline(m_out); const auto header = folly::parseJson(line); const std::string type = header.getDefault("type", "").asString(); const std::size_t bytes = header.getDefault("bytes", 0).asInt(); const auto logResult = [&] (auto name, auto t) { if (log != nullptr) log->setInt(name, t); FTRACE(2, "{} took {} us\n", name, t); }; if (RuntimeOption::EvalLogExternCompilerPerf) { if (auto parsing_time = header.get_ptr("parsing_time")) { logResult("extern_parsing", parsing_time->asInt()); } if (auto codegen_time = header.get_ptr("codegen_time")) { logResult("extern_codegen", codegen_time->asInt()); } if (auto printing_time = header.get_ptr("printing_time")) { logResult("extern_printing", printing_time->asInt()); } } if (type == "success") { std::string program(bytes, '\0'); if (bytes != 0 && fread(&program[0], bytes, 1, m_out) != 1) { throwErrno("reading input program"); } return program; } else if (type == "error") { // We don't need to restart the pipe -- the compiler just wasn't able to // build this file... throw CompilerFatal( header.getDefault("error", "[no 'error' field]").asString()); } else { throw CompilerFatal("unknown message type, " + type); } not_reached(); }
Format& FormatRegistry::getOrDefault(const std::string& name) { { std::lock_guard<std::mutex> guard(_mutex); for (unsigned int i = 0; i < _formats.size(); i++) { if (_formats[i].name == name) { return _formats[i]; } } } return getDefault(); }
bool ParameterRuleset::matchArguments(list<TokenList*>* arguments) { list<string> parameters = getKeywords(); list<TokenList*>::iterator ait = arguments->begin(); list<string>::iterator pit = parameters.begin(); for(; pit != parameters.end(); pit++) { if (ait != arguments->end()) ait++; else if (getDefault(*pit) == NULL) return false; } return (ait == arguments->end() || unlimitedArguments); }
std::string ExternCompiler::readProgram() const { const auto line = readline(m_out); const auto header = folly::parseJson(line); const std::string type = header.getDefault("type", "").asString(); const std::size_t bytes = header.getDefault("bytes", 0).asInt(); if (type == "hhas") { std::string program(bytes, '\0'); if (fread(&program[0], bytes, 1, m_out) != 1) { throwErrno("reading input program"); } return program; } else if (type == "error") { // We don't need to restart the pipe -- the compiler just wasn't able to // build this file... throw std::runtime_error( header.getDefault("error", "[no 'error' field]").asString()); } else { throw std::runtime_error("unknown message type, " + type); } not_reached(); }
int main(int argc, char* argv[]) try { const auto prm = example::initParam(argc, argv); const auto cellID = prm.getDefault("cell", 0); const auto rset = example::identifyResultSet(prm); const auto init = Opm::ECLInitFileData(rset.initFile()); const auto graph = Opm::ECLGraph::load(rset.gridFile(), init); auto pvtCC = Opm::ECLPVT::ECLPvtCurveCollection(graph, init); if (prm.has("unit")) { pvtCC.setOutputUnits(makeUnits(prm.get<std::string>("unit"), init)); } const auto x = CellState{ graph, rset, cellID }; auto props = std::vector<Property>{}; for (const auto& prop : enumerateProperties()) { if (prm.getDefault(prop.first, false)) { props.push_back(Property{ prop.first, (*prop.second)(pvtCC, x) }); } } if (! props.empty()) { std::cout.precision(16); std::cout.setf(std::ios_base::scientific); writeResults(x, props); } } catch (const std::exception& e) { std::cerr << "Caught Exception: " << e.what() << '\n'; return EXIT_FAILURE; }
bool ParameterRuleset::putArguments(ValueProcessor* valueProcessor, list<TokenList*>* arguments) { list<string> parameters = getKeywords(); list<TokenList*>::iterator ait = arguments->begin(); list<string>::iterator pit = parameters.begin(); TokenList* argsCombined = new TokenList(); TokenList* restVar = NULL; TokenList* variable; if (unlimitedArguments && rest != "") restVar = new TokenList(); // combine with parameter names and add to local scope for(; pit != parameters.end(); pit++) { if (ait != arguments->end()) { valueProcessor->putVariable(*pit, *ait); argsCombined->push((*ait)->clone()); ait++; } else { variable = getDefault(*pit); if (variable == NULL) { delete argsCombined; return false; } valueProcessor->putVariable(*pit, variable->clone()); argsCombined->push(variable->clone()); } argsCombined->push(new Token(" ", Token::WHITESPACE)); } if (argsCombined->size() > 0) delete argsCombined->pop(); if (restVar != NULL) { while (ait != arguments->end()) { restVar->push(*ait); restVar->push(new Token(" ", Token::WHITESPACE)); ait++; } if (restVar->size() > 0) delete restVar->pop(); valueProcessor->putVariable(rest, restVar); } valueProcessor->putVariable("@arguments", argsCombined); return true; }
void SettingRegistry::_loadSettingValues(SettingConfig* config, const rapidjson::GenericValue< rapidjson::UTF8< char > >::ConstMemberIterator& json_object_it, SettingsBase* settings_base) { const rapidjson::Value& data = json_object_it->value; /// Fill the setting config object with data we have in the json file. if (data.HasMember("type") && data["type"].IsString()) { config->setType(data["type"].GetString()); } config->setDefault(getDefault(json_object_it)); if (data.HasMember("unit") && data["unit"].IsString()) { config->setUnit(data["unit"].GetString()); } settings_base->_setSetting(config->getKey(), config->getDefaultValue()); }
std::string sinalization_modes::SinalizationModes::toString(sinalization_modes::SinalizationModeEnum mode) { std::string mode_name; switch (mode) { case BLINK: mode_name = "BLINK"; break; case ALTERNATE: mode_name = "ALTERNATE"; break; case LIGHT: mode_name = "LIGHT"; break; default: mode_name = toString(getDefault()); } return mode_name; }
int sinalization_modes::SinalizationModes::toCode(sinalization_modes::SinalizationModeEnum mode) { int mode_code; switch (mode) { case BLINK: mode_code = 0; break; case ALTERNATE: mode_code = 1; break; case LIGHT: mode_code = 2; break; default: mode_code = toCode(getDefault()); } return mode_code; }