#include "settings.h"
#include "irrlichttypes_bloated.h"
#include "exceptions.h"
-#include "jthread/jmutexautolock.h"
-#include "strfnd.h"
+#include "threading/mutex_auto_lock.h"
+#include "util/strfnd.h"
#include <iostream>
#include <fstream>
#include <sstream>
#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)
{
- size_t pos = name.find_first_of("\t\n\v\f\r\b =\"{}#");
- if (pos != std::string::npos) {
- errorstream << "Invalid character '" << name[pos]
- << "' found in setting name" << std::endl;
+ 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;
if (value.substr(0, 3) == "\"\"\"" ||
value.find("\n\"\"\"") != std::string::npos) {
errorstream << "Invalid character sequence '\"\"\"' found in"
- " setting value" << std::endl;
+ " setting value!" << std::endl;
return false;
}
return true;
}
-
-std::string Settings::sanitizeName(const std::string &name)
-{
- 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());
-
- 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();
- it != m_settings.end(); ++it)
+ for (SettingEntries::const_iterator it = m_settings.begin();
+ it != m_settings.end(); ++it)
printEntry(os, it->first, it->second, tab_depth);
}
bool Settings::updateConfigObject(std::istream &is, std::ostream &os,
const std::string &end, u32 tab_depth)
{
- std::map<std::string, SettingsEntry>::const_iterator it;
+ SettingEntries::const_iterator it;
std::set<std::string> present_entries;
std::string line, name, value;
bool was_modified = false;
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;
+ SettingEntries::const_iterator n;
if ((n = m_settings.find(name)) == m_settings.end()) {
if ((n = m_defaults.find(name)) == m_defaults.end())
throw SettingNotFoundException("Setting [" + name + "] not found.");
}
-std::string Settings::get(const std::string &name) const
+const std::string &Settings::get(const std::string &name) const
{
const SettingsEntry &entry = getEntry(name);
if (entry.is_group)
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());
std::vector<std::string> Settings::getNames() const
{
std::vector<std::string> names;
- for (std::map<std::string, SettingsEntry>::const_iterator
- i = m_settings.begin();
- i != m_settings.end(); ++i) {
+ for (SettingEntries::const_iterator i = m_settings.begin();
+ i != m_settings.end(); ++i) {
names.push_back(i->first);
}
return names;
return false;
{
- JMutexAutoLock lock(m_mutex);
+ MutexAutoLock lock(m_mutex);
SettingsEntry &entry = set_default ? m_defaults[name] : m_settings[name];
old_group = entry.group;
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);
+ SettingEntries::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);
-
m_settings[name] = val;
} catch (SettingNotFoundException &e) {
}
if (&other == this)
return;
- JMutexAutoLock lock(m_mutex);
- JMutexAutoLock lock2(other.m_mutex);
+ MutexAutoLock lock(m_mutex);
+ MutexAutoLock lock2(other.m_mutex);
updateNoLock(other);
}
void Settings::clearNoLock()
{
- std::map<std::string, SettingsEntry>::const_iterator it;
- for (it = m_settings.begin(); it != m_settings.end(); ++it)
+
+ for (SettingEntries::const_iterator it = m_settings.begin();
+ it != m_settings.end(); ++it)
delete it->second.group;
m_settings.clear();
- for (it = m_defaults.begin(); it != m_defaults.end(); ++it)
+ clearDefaultsNoLock();
+}
+
+void Settings::clearDefaultsNoLock()
+{
+ for (SettingEntries::const_iterator 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)
+void Settings::registerChangedCallback(const std::string &name,
+ SettingsChangedCallback cbf, void *userdata)
{
- m_callbacks[name].push_back(cbf);
+ MutexAutoLock lock(m_callback_mutex);
+ m_callbacks[name].push_back(std::make_pair(cbf, userdata));
}
-
-void Settings::doCallbacks(const std::string name)
+void Settings::deregisterChangedCallback(const std::string &name,
+ SettingsChangedCallback cbf, void *userdata)
{
- std::vector<setting_changed_callback> tempvector;
- {
- JMutexAutoLock lock(m_mutex);
- if (m_callbacks.find(name) != m_callbacks.end())
- {
- tempvector = m_callbacks[name];
- }
+ MutexAutoLock lock(m_callback_mutex);
+ SettingsCallbackMap::iterator it_cbks = m_callbacks.find(name);
+
+ if (it_cbks != m_callbacks.end()) {
+ SettingsCallbackList &cbks = it_cbks->second;
+
+ SettingsCallbackList::iterator position =
+ std::find(cbks.begin(), cbks.end(), std::make_pair(cbf, userdata));
+
+ if (position != cbks.end())
+ cbks.erase(position);
}
+}
- std::vector<setting_changed_callback>::iterator iter;
- for (iter = tempvector.begin(); iter != tempvector.end(); iter++)
- {
- (*iter)(name);
+void Settings::doCallbacks(const std::string &name) const
+{
+ MutexAutoLock lock(m_callback_mutex);
+
+ SettingsCallbackMap::const_iterator it_cbks = m_callbacks.find(name);
+ if (it_cbks != m_callbacks.end()) {
+ SettingsCallbackList::const_iterator it;
+ for (it = it_cbks->second.begin(); it != it_cbks->second.end(); ++it)
+ (it->first)(name, it->second);
}
}