#include "settings.h"
#include "irrlichttypes_bloated.h"
#include "exceptions.h"
-#include "jthread/jmutexautolock.h"
+#include "threading/mutex_auto_lock.h"
#include "strfnd.h"
#include <iostream>
#include <fstream>
#include <cctype>
#include <algorithm>
+static Settings main_settings;
+Settings *g_settings = &main_settings;
+std::string g_settings_path;
Settings::~Settings()
{
if (&other == this)
return *this;
- JMutexAutoLock lock(m_mutex);
- JMutexAutoLock lock2(other.m_mutex);
+ MutexAutoLock lock(m_mutex);
+ MutexAutoLock lock2(other.m_mutex);
clearNoLock();
updateNoLock(other);
}
+bool Settings::checkNameValid(const std::string &name)
+{
+ bool valid = name.find_first_of("=\"{}#") == std::string::npos;
+ if (valid) valid = trim(name) == name;
+ if (!valid) {
+ errorstream << "Invalid setting name \"" << name << "\""
+ << std::endl;
+ return false;
+ }
+ return true;
+}
+
+
+bool Settings::checkValueValid(const std::string &value)
+{
+ if (value.substr(0, 3) == "\"\"\"" ||
+ value.find("\n\"\"\"") != std::string::npos) {
+ errorstream << "Invalid character sequence '\"\"\"' found in"
+ " setting value!" << std::endl;
+ return false;
+ }
+ return true;
+}
+
+
+std::string Settings::sanitizeName(const std::string &name)
+{
+ std::string n = trim(name);
+
+ for (const char *s = "=\"{}#"; *s; s++)
+ n.erase(std::remove(n.begin(), n.end(), *s), n.end());
+
+ return n;
+}
+
+
+std::string Settings::sanitizeValue(const std::string &value)
+{
+ std::string v(value);
+ size_t p = 0;
+
+ if (v.substr(0, 3) == "\"\"\"")
+ v.erase(0, 3);
+
+ while ((p = v.find("\n\"\"\"")) != std::string::npos)
+ v.erase(p, 4);
+
+ return v;
+}
+
+
std::string Settings::getMultiline(std::istream &is, size_t *num_lines)
{
size_t lines = 1;
bool Settings::parseConfigLines(std::istream &is, const std::string &end)
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
std::string line, name, value;
void Settings::writeLines(std::ostream &os, u32 tab_depth) const
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
for (std::map<std::string, SettingsEntry>::const_iterator
it = m_settings.begin();
printEntry(os, name, it->second, tab_depth);
was_modified = true;
} else {
- assert(it->second.group == NULL);
os << line << "\n";
if (event == SPE_MULTILINE)
os << value << "\n\"\"\"\n";
it = m_settings.find(name);
if (it != m_settings.end() && it->second.is_group) {
os << line << "\n";
- assert(it->second.group != NULL);
+ sanity_check(it->second.group != NULL);
was_modified |= it->second.group->updateConfigObject(is, os,
"}", tab_depth + 1);
} else {
bool Settings::updateConfigFile(const char *filename)
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
std::ifstream is(filename);
std::ostringstream os(std::ios_base::binary);
const SettingsEntry &Settings::getEntry(const std::string &name) const
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
std::map<std::string, SettingsEntry>::const_iterator n;
if ((n = m_settings.find(name)) == m_settings.end()) {
bool Settings::exists(const std::string &name) const
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
return (m_settings.find(name) != m_settings.end() ||
m_defaults.find(name) != m_defaults.end());
* Setters *
***********/
-void Settings::setEntry(const std::string &name, const void *data,
+bool Settings::setEntry(const std::string &name, const void *data,
bool set_group, bool set_default)
{
Settings *old_group = NULL;
- // Strip any potentially dangerous characters from the name (note the value
- // has no such restrictions)
- std::string n(name);
- for (const char *s = "\t\n\v\f\r\b =\""; *s; s++)
- n.erase(std::remove(n.begin(), n.end(), *s), n.end());
+ if (!checkNameValid(name))
+ return false;
+ if (!set_group && !checkValueValid(*(const std::string *)data))
+ return false;
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
- SettingsEntry &entry = set_default ? m_defaults[n] : m_settings[n];
+ SettingsEntry &entry = set_default ? m_defaults[name] : m_settings[name];
old_group = entry.group;
entry.value = set_group ? "" : *(const std::string *)data;
}
delete old_group;
+
+ return true;
}
-void Settings::set(const std::string &name, const std::string &value)
+bool Settings::set(const std::string &name, const std::string &value)
{
- setEntry(name, &value, false, false);
+ if (!setEntry(name, &value, false, false))
+ return false;
doCallbacks(name);
+ return true;
}
-void Settings::setDefault(const std::string &name, const std::string &value)
+bool Settings::setDefault(const std::string &name, const std::string &value)
{
- setEntry(name, &value, false, true);
+ return setEntry(name, &value, false, true);
}
-void Settings::setGroup(const std::string &name, Settings *group)
+bool Settings::setGroup(const std::string &name, Settings *group)
{
- setEntry(name, &group, true, false);
+ return setEntry(name, &group, true, false);
}
-void Settings::setGroupDefault(const std::string &name, Settings *group)
+bool Settings::setGroupDefault(const std::string &name, Settings *group)
{
- setEntry(name, &group, true, true);
+ return setEntry(name, &group, true, true);
}
-void Settings::setBool(const std::string &name, bool value)
+bool Settings::setBool(const std::string &name, bool value)
{
- set(name, value ? "true" : "false");
+ return set(name, value ? "true" : "false");
}
-void Settings::setS16(const std::string &name, s16 value)
+bool Settings::setS16(const std::string &name, s16 value)
{
- set(name, itos(value));
+ return set(name, itos(value));
}
-void Settings::setU16(const std::string &name, u16 value)
+bool Settings::setU16(const std::string &name, u16 value)
{
- set(name, itos(value));
+ return set(name, itos(value));
}
-void Settings::setS32(const std::string &name, s32 value)
+bool Settings::setS32(const std::string &name, s32 value)
{
- set(name, itos(value));
+ return set(name, itos(value));
}
-void Settings::setU64(const std::string &name, u64 value)
+bool Settings::setU64(const std::string &name, u64 value)
{
std::ostringstream os;
os << value;
- set(name, os.str());
+ return set(name, os.str());
}
-void Settings::setFloat(const std::string &name, float value)
+bool Settings::setFloat(const std::string &name, float value)
{
- set(name, ftos(value));
+ return set(name, ftos(value));
}
-void Settings::setV2F(const std::string &name, v2f value)
+bool Settings::setV2F(const std::string &name, v2f value)
{
std::ostringstream os;
os << "(" << value.X << "," << value.Y << ")";
- set(name, os.str());
+ return set(name, os.str());
}
-void Settings::setV3F(const std::string &name, v3f value)
+bool Settings::setV3F(const std::string &name, v3f value)
{
std::ostringstream os;
os << "(" << value.X << "," << value.Y << "," << value.Z << ")";
- set(name, os.str());
+ return set(name, os.str());
}
-void Settings::setFlagStr(const std::string &name, u32 flags,
+bool Settings::setFlagStr(const std::string &name, u32 flags,
const FlagDesc *flagdesc, u32 flagmask)
{
- set(name, writeFlagString(flags, flagdesc, flagmask));
+ return set(name, writeFlagString(flags, flagdesc, flagmask));
}
if (!serializeStructToString(&structstr, format, value))
return false;
- set(name, structstr);
- return true;
+ return set(name, structstr);
}
-void Settings::setNoiseParams(const std::string &name,
+bool Settings::setNoiseParams(const std::string &name,
const NoiseParams &np, bool set_default)
{
Settings *group = new Settings;
group->setFloat("lacunarity", np.lacunarity);
group->setFlagStr("flags", np.flags, flagdesc_noiseparams, np.flags);
- setEntry(name, &group, true, set_default);
+ return setEntry(name, &group, true, set_default);
}
bool Settings::remove(const std::string &name)
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
- delete m_settings[name].group;
- return m_settings.erase(name);
+ std::map<std::string, SettingsEntry>::iterator it = m_settings.find(name);
+ if (it != m_settings.end()) {
+ delete it->second.group;
+ m_settings.erase(it);
+ return true;
+ } else {
+ return false;
+ }
}
void Settings::clear()
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
clearNoLock();
}
+void Settings::clearDefaults()
+{
+ MutexAutoLock lock(m_mutex);
+ clearDefaultsNoLock();
+}
void Settings::updateValue(const Settings &other, const std::string &name)
{
if (&other == this)
return;
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
try {
std::string val = other.get(name);
if (&other == this)
return;
- JMutexAutoLock lock(m_mutex);
- JMutexAutoLock lock2(other.m_mutex);
+ MutexAutoLock lock(m_mutex);
+ MutexAutoLock lock2(other.m_mutex);
updateNoLock(other);
}
delete it->second.group;
m_settings.clear();
+ clearDefaultsNoLock();
+}
+
+void Settings::clearDefaultsNoLock()
+{
+ std::map<std::string, SettingsEntry>::const_iterator it;
for (it = m_defaults.begin(); it != m_defaults.end(); ++it)
delete it->second.group;
m_defaults.clear();
void Settings::registerChangedCallback(std::string name,
- setting_changed_callback cbf)
+ setting_changed_callback cbf, void *userdata)
{
- m_callbacks[name].push_back(cbf);
+ MutexAutoLock lock(m_callbackMutex);
+ m_callbacks[name].push_back(std::make_pair(cbf, userdata));
}
+void Settings::deregisterChangedCallback(std::string name, setting_changed_callback cbf, void *userdata)
+{
+ MutexAutoLock lock(m_callbackMutex);
+ std::map<std::string, std::vector<std::pair<setting_changed_callback, void*> > >::iterator iterToVector = m_callbacks.find(name);
+ if (iterToVector != m_callbacks.end())
+ {
+ std::vector<std::pair<setting_changed_callback, void*> > &vector = iterToVector->second;
+
+ std::vector<std::pair<setting_changed_callback, void*> >::iterator position =
+ std::find(vector.begin(), vector.end(), std::make_pair(cbf, userdata));
+
+ if (position != vector.end())
+ vector.erase(position);
+ }
+}
void Settings::doCallbacks(const std::string name)
{
- std::vector<setting_changed_callback> tempvector;
+ MutexAutoLock lock(m_callbackMutex);
+ std::map<std::string, std::vector<std::pair<setting_changed_callback, void*> > >::iterator iterToVector = m_callbacks.find(name);
+ if (iterToVector != m_callbacks.end())
{
- JMutexAutoLock lock(m_mutex);
- if (m_callbacks.find(name) != m_callbacks.end())
+ std::vector<std::pair<setting_changed_callback, void*> >::iterator iter;
+ for (iter = iterToVector->second.begin(); iter != iterToVector->second.end(); ++iter)
{
- tempvector = m_callbacks[name];
+ (iter->first)(name, iter->second);
}
}
-
- std::vector<setting_changed_callback>::iterator iter;
- for (iter = tempvector.begin(); iter != tempvector.end(); iter++)
- {
- (*iter)(name);
- }
}
projects / dragonfireclient.git / blobdiff