/** * Set the configItem if found, if not, *CREATE IT* * * @todo Élimier les 45,000 classes qui servent à rien pour Conf. * The true/false logic is useless here. */ void ConfigTree::setConfigTreeItem(const std::string& section, const std::string& itemName, const std::string& value) { SectionMap::iterator iter = sections_.find(section); if (iter == sections_.end()) { // Not found, create section sections_[section] = ItemMap(); iter = sections_.find(section); } ItemMap::iterator iterItem = iter->second.find(itemName); if (iterItem == iter->second.end()) { // If not found, search in our default list to find // something that would fit. std::string defaultValue = getDefaultValue(itemName); addConfigTreeItem(section, ConfigTreeItem(itemName, value, defaultValue)); return; } // Use default value if the value is empty. if (value.empty()) { iterItem->second.setValue(getDefaultValue(itemName)); return; } iterItem->second.setValue(value); return; }
//Parametreler: //parts : formulanın parçaları //partsCount : parts'ın boyutu //opIndex : matematik işlemi bulunduğu index void calcOperand(char parts[][MAX_CHARS],int partsCount,int opIndex){ char operation = *(*(parts+opIndex)); int firstNumberIndex = findNumberIndex(parts,partsCount,-1,opIndex); int secondNumberIndex = findNumberIndex(parts,partsCount,+1,opIndex); int firstNumber ; int secondNumber ; if((*(*(parts+firstNumberIndex)) == '$'))//Tablu dışında firstNumber=getDefaultValue(operation); else firstNumber = atoi(*(parts+firstNumberIndex)); if((*(*(parts+secondNumberIndex)) == '$'))//Tablu dışında secondNumber=getDefaultValue(operation); else secondNumber= atoi(*(parts+secondNumberIndex)); int result = mathCalculate(operation, firstNumber, secondNumber); itoa(result, parts+opIndex, 10); strcpy(parts+firstNumberIndex,"#"); strcpy(parts+secondNumberIndex,"#"); }
const VariableValue & Coupleable::coupledValuePreviousNL(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) return *getDefaultValue(var_name); _c_fe_problem.needsPreviousNewtonIteration(true); coupledCallback(var_name, true); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) { if (_nodal) return var->nodalSlnPreviousNL(); else return var->slnPreviousNL(); } else { if (_nodal) return var->nodalSlnPreviousNLNeighbor(); else return var->slnPreviousNLNeighbor(); } }
const VariableValue & Coupleable::coupledValueOld(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) return *getDefaultValue(var_name); validateExecutionerType(var_name); coupledCallback(var_name, true); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) { if (_nodal) return (_c_is_implicit) ? var->nodalSlnOld() : var->nodalSlnOlder(); else return (_c_is_implicit) ? var->slnOld() : var->slnOlder(); } else { if (_nodal) return (_c_is_implicit) ? var->nodalSlnOldNeighbor() : var->nodalSlnOlderNeighbor(); else return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor(); } }
void OptionWidget::reset() { setValue(getDefaultValue()); if (m_resetButton) { m_resetButton->setEnabled(false); } }
QVariant SettingsManager::getValue(const QString &key, const QUrl &url) { if (!url.isEmpty()) { return QSettings(m_overridePath, QSettings::IniFormat).value((url.isLocalFile() ? QLatin1String("localhost") : url.host()) + QLatin1Char('/') + key, getValue(key)); } return QSettings(m_globalPath, QSettings::IniFormat).value(key, getDefaultValue(key)); }
VariableValue & ScalarCoupleable::coupledScalarValueOld(const std::string & var_name, unsigned int comp) { if (!isCoupledScalar(var_name, comp)) return *getDefaultValue(var_name); MooseVariableScalar * var = getScalarVar(var_name, comp); return (_sc_is_implicit) ? var->slnOld() : var->slnOlder(); }
QVariant Settings::getSettingCached(Settings::SettingsEnum setting) { if (settings_cache.contains(setting)) return settings_cache.value(setting); QSettings settings; QVariant value = settings.value(getSettingPath(setting), getDefaultValue(setting)); settings_cache.insert(setting, value); return value; }
std::string ConfigTree::getConfigTreeItemValue(const std::string& section, const std::string& itemName) const { const ConfigTreeItem* item = getConfigTreeItem(section, itemName); if (item) return item->getValue(); return getDefaultValue(itemName); }
bool Flag::isDefault(const std::string& name) { std::string current_value; if (!__GFLAGS_NAMESPACE::GetCommandLineOption(name.c_str(), ¤t_value)) { return false; } std::string default_value; if (!getDefaultValue(name, default_value).ok()) { return false; } return (default_value == current_value); }
shared_ptr<ScopedVariableContext> ScopedVariableEnvironment::createNewDefaultContext(){ shared_ptr<ScopedVariableContext> new_context = createNewContext(); for(int i = 0; i < variables.getNElements(); i++){ shared_ptr<ScopedVariable> var = variables[i]; auto props = var->getProperties(); new_context->set(var->getContextIndex(), props->getDefaultValue()); } return new_context; }
VariableValue & ScalarCoupleable::coupledScalarValueOlder(const std::string & var_name, unsigned int comp) { checkVar(var_name); if (!isCoupledScalar(var_name, comp)) return *getDefaultValue(var_name); validateExecutionerType(var_name, "coupledScalarValueOlder"); MooseVariableScalar * var = getScalarVar(var_name, comp); if (_sc_is_implicit) return var->slnOlder(); else mooseError("Older values not available for explicit schemes"); }
const VariableValue & Coupleable::coupledNodalValue(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) return *getDefaultValue(var_name); coupledCallback(var_name, false); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) return (_c_is_implicit) ? var->nodalValue() : var->nodalValueOld(); else return (_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor(); }
void Settings::setSetting(Settings::SettingsEnum setting, QVariant value) { bool setting_changed = true; if (settings_cache.contains(setting)) setting_changed = settings_cache.value(setting) != value; else setting_changed = QSettings().value(getSettingPath(setting), getDefaultValue(setting)) != value; if (setting_changed) { QSettings().setValue(getSettingPath(setting), value); settings_cache.clear(); emit settingsChanged(); } }
void Settings::remove(Settings::SettingsEnum setting) { QVariant value = getDefaultValue(setting); bool setting_changed = true; if (settings_cache.contains(setting)) setting_changed = settings_cache.value(setting) != value; else setting_changed = QSettings().value(getSettingPath(setting), value) != value; QSettings().remove(getSettingPath(setting)); if (setting_changed) { settings_cache.clear(); emit settingsChanged(); } }
const VariableValue & Coupleable::coupledValueOlder(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) return *getDefaultValue(var_name); validateExecutionerType(var_name); coupledCallback(var_name, true); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) { if (_nodal) { if (_c_is_implicit) return var->nodalSlnOlder(); else mooseError("Older values not available for explicit schemes"); } else { if (_c_is_implicit) return var->slnOlder(); else mooseError("Older values not available for explicit schemes"); } } else { if (_nodal) { if (_c_is_implicit) return var->nodalSlnOlderNeighbor(); else mooseError("Older values not available for explicit schemes"); } else { if (_c_is_implicit) return var->slnOlderNeighbor(); else mooseError("Older values not available for explicit schemes"); } } }
void TrackingSlider::mousePressEvent(QMouseEvent* event) { if (event->button() == Qt::LeftButton) { if (orientation() == Qt::Vertical) setValue(minimum() + ((maximum()-minimum()) * (height()-event->y())) / height() ) ; else setValue(minimum() + ((maximum()-minimum()) * event->x()) / width() ) ; event->accept(); } QSlider::mousePressEvent(event); if(event->type() == QEvent::MouseButtonDblClick) { setValue(getDefaultValue()); } }
/** * @brief Write the property definition. * @param i The indent level. * @param prop The property to write. * @param object Object containing the properties definitions. * @param pex Binary to decompile. */ void Decompiler::PscCoder::writeProperty(int i, const Pex::Property& prop, const Pex::Object &object, const Pex::Binary& pex) { auto stream = indent(i); auto isAutoReadOnly = !prop.hasAutoVar() && prop.isReadable() && !prop.isWritable() && prop.getReadFunction().getInstructions().size() == 1 && prop.getReadFunction().getInstructions()[0].getOpCode() == Pex::OpCode::RETURN && prop.getReadFunction().getInstructions()[0].getArgs().size() == 1; stream << mapType(prop.getTypeName().asString()) << " Property " << prop.getName(); if (prop.hasAutoVar()) { auto var = object.getVariables().findByName(prop.getAutoVarName()); if (var == nullptr) throw std::runtime_error("Auto variable for property not found"); auto initialValue = var->getDefaultValue(); if (initialValue.getType() != Pex::ValueType::None) stream << " = " << initialValue.toString(); stream << " Auto"; // The flags defined on the variable must be set on the property writeUserFlag(stream, *var, pex); if (var->getConstFlag()) stream << " Const"; } else if (isAutoReadOnly) { stream << " = " << prop.getReadFunction().getInstructions()[0].getArgs()[0].toString(); stream << " AutoReadOnly"; } writeUserFlag(stream, prop, pex); write(stream); writeDocString(i, prop); if (!prop.hasAutoVar() && !isAutoReadOnly) { if (prop.isReadable()) writeFunction(i + 1, prop.getReadFunction(), object, pex, "Get"); if (prop.isWritable()) writeFunction(i + 1, prop.getWriteFunction(), object, pex, "Set"); write(indent(i) << "EndProperty"); } }
/** * Zwraca wartość ustawień odpowiadającą danemu kluczowi. * * @param key klucz ustawień * @return wartość ustawień, lub wartość domyślna (zdefiniowana w tej klasie!) */ QVariant SimpleBirdSettings::value(QString key) const { return QSettings::value(key, getDefaultValue(key)); }
void TNADoubleParam::saveData(TOStream &os) { os << getDefaultValue(); os << getValue(); }
void TBoolParam::saveData(TOStream &os) { os << (int)getDefaultValue() << (int)getValue(); }
void TFilePathParam::saveData(TOStream &os) { os << getDefaultValue(); os << getValue(); }
void TStringParam::saveData(TOStream &os) { os << getDefaultValue(); os << getValue(); }
void SpannerPackedNormalAttribute::read(Bitstream& in, void*& value, bool isLeaf) const { value = getDefaultValue(); in.read(&value, 32); }
QVariant Settings::getSetting(Settings::SettingsEnum setting) const { QSettings settings; return settings.value(getSettingPath(setting), getDefaultValue(setting)); }