/**
* 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));
}
