Settings: Make setting entry group and values mutually exclusive

This greatly reduces the complexity of Settings code.
Additionally, several memory leaks were fixed.
master
kwolekr 2014-12-09 23:22:38 -05:00
parent 2f8fbdb9f5
commit f2c18511a4
3 changed files with 112 additions and 209 deletions

View File

@ -36,9 +36,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
Settings::~Settings() Settings::~Settings()
{ {
std::map<std::string, SettingsEntry>::const_iterator it; clear();
for (it = m_settings.begin(); it != m_settings.end(); ++it)
delete it->second.group;
} }
@ -101,6 +99,16 @@ std::string Settings::getMultiline(std::istream &is, size_t *num_lines)
} }
bool Settings::readConfigFile(const char *filename)
{
std::ifstream is(filename);
if (!is.good())
return false;
return parseConfigLines(is, "");
}
bool Settings::parseConfigLines(std::istream &is, const std::string &end) bool Settings::parseConfigLines(std::istream &is, const std::string &end)
{ {
JMutexAutoLock lock(m_mutex); JMutexAutoLock lock(m_mutex);
@ -122,11 +130,12 @@ bool Settings::parseConfigLines(std::istream &is, const std::string &end)
case SPE_END: case SPE_END:
return true; return true;
case SPE_GROUP: { case SPE_GROUP: {
Settings *branch = new Settings; Settings *group = new Settings;
if (!branch->parseConfigLines(is, "}")) if (!group->parseConfigLines(is, "}")) {
delete group;
return false; return false;
}
m_settings[name] = SettingsEntry(branch); m_settings[name] = SettingsEntry(group);
break; break;
} }
case SPE_MULTILINE: case SPE_MULTILINE:
@ -139,16 +148,6 @@ bool Settings::parseConfigLines(std::istream &is, const std::string &end)
} }
bool Settings::readConfigFile(const char *filename)
{
std::ifstream is(filename);
if (!is.good())
return false;
return parseConfigLines(is, "");
}
void Settings::writeLines(std::ostream &os, u32 tab_depth) const void Settings::writeLines(std::ostream &os, u32 tab_depth) const
{ {
JMutexAutoLock lock(m_mutex); JMutexAutoLock lock(m_mutex);
@ -160,99 +159,28 @@ void Settings::writeLines(std::ostream &os, u32 tab_depth) const
} }
bool Settings::printEntry(std::ostream &os, const std::string &name, void Settings::printEntry(std::ostream &os, const std::string &name,
const SettingsEntry &entry, u32 tab_depth) const SettingsEntry &entry, u32 tab_depth)
{ {
bool printed = false;
if (!entry.group || entry.value != "") {
printValue(os, name, entry.value, tab_depth);
printed = true;
}
if (entry.group) {
printGroup(os, name, entry.group, tab_depth);
printed = true;
}
return printed;
}
void Settings::printValue(std::ostream &os, const std::string &name,
const std::string &value, u32 tab_depth)
{
for (u32 i = 0; i != tab_depth; i++)
os << "\t";
os << name << " = ";
if (value.find('\n') != std::string::npos)
os << "\"\"\"\n" << value << "\n\"\"\"\n";
else
os << value << "\n";
}
void Settings::printGroup(std::ostream &os, const std::string &name,
const Settings *group, u32 tab_depth)
{
// Recursively write group contents
for (u32 i = 0; i != tab_depth; i++) for (u32 i = 0; i != tab_depth; i++)
os << "\t"; os << "\t";
os << name << " = {\n"; if (entry.is_group) {
group->writeLines(os, tab_depth + 1); os << name << " = {\n";
for (u32 i = 0; i != tab_depth; i++) entry.group->writeLines(os, tab_depth + 1);
os << "\t";
os << "}\n"; for (u32 i = 0; i != tab_depth; i++)
} os << "\t";
os << "}\n";
} else {
os << name << " = ";
if (entry.value.find('\n') != std::string::npos)
void Settings::getNamesPresent(std::istream &is, const std::string &end, os << "\"\"\"\n" << entry.value << "\n\"\"\"\n";
std::set<std::string> &present_values, std::set<std::string> &present_groups) else
{ os << entry.value << "\n";
std::string name, value, line;
bool end_found = false;
int depth = 0;
size_t old_pos = is.tellg();
while (is.good() && !end_found) {
std::getline(is, line);
SettingsParseEvent event = parseConfigObject(line,
depth ? "}" : end, name, value);
switch (event) {
case SPE_END:
if (depth == 0)
end_found = true;
else
depth--;
break;
case SPE_MULTILINE:
while (is.good() && line != "\"\"\"")
std::getline(is, line);
/* FALLTHROUGH */
case SPE_KVPAIR:
if (depth == 0)
present_values.insert(name);
break;
case SPE_GROUP:
if (depth == 0)
present_groups.insert(name);
depth++;
break;
case SPE_NONE:
case SPE_COMMENT:
case SPE_INVALID:
break;
}
} }
is.clear();
is.seekg(old_pos);
} }
@ -260,13 +188,11 @@ bool Settings::updateConfigObject(std::istream &is, std::ostream &os,
const std::string &end, u32 tab_depth) const std::string &end, u32 tab_depth)
{ {
std::map<std::string, SettingsEntry>::const_iterator it; std::map<std::string, SettingsEntry>::const_iterator it;
std::set<std::string> present_values, present_groups; std::set<std::string> present_entries;
std::string line, name, value; std::string line, name, value;
bool was_modified = false; bool was_modified = false;
bool end_found = false; bool end_found = false;
getNamesPresent(is, end, present_values, present_groups);
// Add any settings that exist in the config file with the current value // Add any settings that exist in the config file with the current value
// in the object if existing // in the object if existing
while (is.good() && !end_found) { while (is.good() && !end_found) {
@ -283,48 +209,31 @@ bool Settings::updateConfigObject(std::istream &is, std::ostream &os,
/* FALLTHROUGH */ /* FALLTHROUGH */
case SPE_KVPAIR: case SPE_KVPAIR:
it = m_settings.find(name); it = m_settings.find(name);
if (it != m_settings.end() && value != it->second.value) { if (it != m_settings.end() &&
if (!it->second.group || it->second.value != "") (it->second.is_group || it->second.value != value)) {
printValue(os, name, it->second.value, tab_depth); printEntry(os, name, it->second, tab_depth);
was_modified = true; was_modified = true;
} else { } else {
assert(it->second.group == NULL);
os << line << "\n"; os << line << "\n";
if (event == SPE_MULTILINE) if (event == SPE_MULTILINE)
os << value << "\n\"\"\"\n"; os << value << "\n\"\"\"\n";
} }
present_entries.insert(name);
// If this value name has a group not in the file, print it
if (it != m_settings.end() && it->second.group &&
present_groups.find(name) == present_groups.end()) {
printGroup(os, name, it->second.group, tab_depth);
was_modified = true;
}
break; break;
case SPE_GROUP: { case SPE_GROUP:
Settings *group = NULL;
it = m_settings.find(name); it = m_settings.find(name);
if (it != m_settings.end()) if (it != m_settings.end() && it->second.is_group) {
group = it->second.group; os << line << "\n";
assert(it->second.group != NULL);
// If this group name has a non-blank value not in the file, print it was_modified |= it->second.group->updateConfigObject(is, os,
if (it != m_settings.end() && it->second.value != "" && "}", tab_depth + 1);
present_values.find(name) == present_values.end()) { } else {
printValue(os, name, it->second.value, tab_depth); printEntry(os, name, it->second, tab_depth);
was_modified = true; was_modified = true;
} }
present_entries.insert(name);
os << line << "\n";
if (group) {
was_modified |= group->updateConfigObject(is, os, "}", tab_depth + 1);
} else {
// If a group exists in the file but not memory, don't touch it
Settings dummy_settings;
dummy_settings.updateConfigObject(is, os, "}", tab_depth + 1);
}
break; break;
}
default: default:
os << line << (is.eof() ? "" : "\n"); os << line << (is.eof() ? "" : "\n");
break; break;
@ -333,11 +242,11 @@ bool Settings::updateConfigObject(std::istream &is, std::ostream &os,
// Add any settings in the object that don't exist in the config file yet // Add any settings in the object that don't exist in the config file yet
for (it = m_settings.begin(); it != m_settings.end(); ++it) { for (it = m_settings.begin(); it != m_settings.end(); ++it) {
if (present_values.find(it->first) != present_values.end() || if (present_entries.find(it->first) != present_entries.end())
present_groups.find(it->first) != present_groups.end())
continue; continue;
was_modified |= printEntry(os, it->first, it->second, tab_depth); printEntry(os, it->first, it->second, tab_depth);
was_modified = true;
} }
return was_modified; return was_modified;
@ -440,16 +349,19 @@ const SettingsEntry &Settings::getEntry(const std::string &name) const
Settings *Settings::getGroup(const std::string &name) const Settings *Settings::getGroup(const std::string &name) const
{ {
Settings *group = getEntry(name).group; const SettingsEntry &entry = getEntry(name);
if (group == NULL) if (!entry.is_group)
throw SettingNotFoundException("Setting [" + name + "] is not a group."); throw SettingNotFoundException("Setting [" + name + "] is not a group.");
return group; return entry.group;
} }
std::string Settings::get(const std::string &name) const std::string Settings::get(const std::string &name) const
{ {
return getEntry(name).value; const SettingsEntry &entry = getEntry(name);
if (entry.is_group)
throw SettingNotFoundException("Setting [" + name + "] is a group.");
return entry.value;
} }
@ -772,49 +684,49 @@ bool Settings::getFlagStrNoEx(const std::string &name, u32 &val,
* Setters * * Setters *
***********/ ***********/
void Settings::setEntry(const std::string &name, const void *data,
void Settings::set(const std::string &name, const std::string &value) bool set_group, bool set_default)
{ {
Settings *old_group = NULL;
{ {
JMutexAutoLock lock(m_mutex); JMutexAutoLock lock(m_mutex);
m_settings[name].value = value; SettingsEntry &entry = set_default ? m_defaults[name] : m_settings[name];
old_group = entry.group;
entry.value = set_group ? "" : *(const std::string *)data;
entry.group = set_group ? *(Settings **)data : NULL;
entry.is_group = set_group;
} }
doCallbacks(name);
delete old_group;
} }
void Settings::setGroup(const std::string &name, Settings *group) void Settings::set(const std::string &name, const std::string &value)
{ {
Settings *old_group = NULL; setEntry(name, &value, false, false);
{
JMutexAutoLock lock(m_mutex);
old_group = m_settings[name].group; doCallbacks(name);
m_settings[name].group = group;
}
delete old_group;
} }
void Settings::setDefault(const std::string &name, const std::string &value) void Settings::setDefault(const std::string &name, const std::string &value)
{ {
JMutexAutoLock lock(m_mutex); setEntry(name, &value, false, true);
}
m_defaults[name].value = value;
void Settings::setGroup(const std::string &name, Settings *group)
{
setEntry(name, &group, true, false);
} }
void Settings::setGroupDefault(const std::string &name, Settings *group) void Settings::setGroupDefault(const std::string &name, Settings *group)
{ {
Settings *old_group = NULL; setEntry(name, &group, true, true);
{
JMutexAutoLock lock(m_mutex);
old_group = m_defaults[name].group;
m_defaults[name].group = group;
}
delete old_group;
} }
@ -891,7 +803,8 @@ bool Settings::setStruct(const std::string &name, const std::string &format,
} }
void Settings::setNoiseParams(const std::string &name, const NoiseParams &np) void Settings::setNoiseParams(const std::string &name,
const NoiseParams &np, bool set_default)
{ {
Settings *group = new Settings; Settings *group = new Settings;
@ -904,21 +817,15 @@ void Settings::setNoiseParams(const std::string &name, const NoiseParams &np)
group->setFloat("lacunarity", np.lacunarity); group->setFloat("lacunarity", np.lacunarity);
group->setFlagStr("flags", np.flags, flagdesc_noiseparams, np.flags); group->setFlagStr("flags", np.flags, flagdesc_noiseparams, np.flags);
Settings *old_group; setEntry(name, &group, true, set_default);
{
JMutexAutoLock lock(m_mutex);
old_group = m_settings[name].group;
m_settings[name].group = group;
m_settings[name].value = "";
}
delete old_group;
} }
bool Settings::remove(const std::string &name) bool Settings::remove(const std::string &name)
{ {
JMutexAutoLock lock(m_mutex); JMutexAutoLock lock(m_mutex);
delete m_settings[name].group;
return m_settings.erase(name); return m_settings.erase(name);
} }
@ -995,7 +902,13 @@ void Settings::updateNoLock(const Settings &other)
void Settings::clearNoLock() void Settings::clearNoLock()
{ {
std::map<std::string, SettingsEntry>::const_iterator it;
for (it = m_settings.begin(); it != m_settings.end(); ++it)
delete it->second.group;
m_settings.clear(); m_settings.clear();
for (it = m_defaults.begin(); it != m_defaults.end(); ++it)
delete it->second.group;
m_defaults.clear(); m_defaults.clear();
} }
@ -1018,8 +931,8 @@ void Settings::doCallbacks(const std::string name)
} }
} }
for (std::vector<setting_changed_callback>::iterator iter = tempvector.begin(); std::vector<setting_changed_callback>::iterator iter;
iter != tempvector.end(); iter ++) for (iter = tempvector.begin(); iter != tempvector.end(); iter++)
{ {
(*iter)(name); (*iter)(name);
} }

View File

@ -59,36 +59,31 @@ struct ValueSpec {
const char *help; const char *help;
}; };
/** function type to register a changed callback */
struct SettingsEntry { struct SettingsEntry {
SettingsEntry() SettingsEntry()
{ {
group = NULL; group = NULL;
is_group = false;
} }
SettingsEntry(const std::string &value_) SettingsEntry(const std::string &value_)
{ {
value = value_; value = value_;
group = NULL; group = NULL;
is_group = false;
} }
SettingsEntry(Settings *group_) SettingsEntry(Settings *group_)
{ {
group = group_; group = group_;
} is_group = true;
SettingsEntry(const std::string &value_, Settings *group_)
{
value = value_;
group = group_;
} }
std::string value; std::string value;
Settings *group; Settings *group;
bool is_group;
}; };
class Settings { class Settings {
public: public:
Settings() {} Settings() {}
@ -97,7 +92,6 @@ public:
Settings & operator += (const Settings &other); Settings & operator += (const Settings &other);
Settings & operator = (const Settings &other); Settings & operator = (const Settings &other);
/*********************** /***********************
* Reading and writing * * Reading and writing *
***********************/ ***********************/
@ -114,20 +108,13 @@ public:
SettingsParseEvent parseConfigObject(const std::string &line, SettingsParseEvent parseConfigObject(const std::string &line,
const std::string &end, std::string &name, std::string &value); const std::string &end, std::string &name, std::string &value);
void getNamesPresent(std::istream &is, const std::string &end,
std::set<std::string> &present_values,
std::set<std::string> &present_groups);
bool updateConfigObject(std::istream &is, std::ostream &os, bool updateConfigObject(std::istream &is, std::ostream &os,
const std::string &end, u32 tab_depth=0); const std::string &end, u32 tab_depth=0);
static std::string getMultiline(std::istream &is, size_t *num_lines=NULL); static std::string getMultiline(std::istream &is, size_t *num_lines=NULL);
static std::string sanitizeString(const std::string &value); static std::string sanitizeString(const std::string &value);
static bool printEntry(std::ostream &os, const std::string &name, static void printEntry(std::ostream &os, const std::string &name,
const SettingsEntry &entry, u32 tab_depth=0); const SettingsEntry &entry, u32 tab_depth=0);
static void printValue(std::ostream &os, const std::string &name,
const std::string &value, u32 tab_depth=0);
static void printGroup(std::ostream &os, const std::string &name,
const Settings *group, u32 tab_depth=0);
/*********** /***********
* Getters * * Getters *
@ -186,9 +173,11 @@ public:
// N.B. Groups not allocated with new must be set to NULL in the settings // N.B. Groups not allocated with new must be set to NULL in the settings
// tree before object destruction. // tree before object destruction.
void setEntry(const std::string &name, const void *entry,
bool set_group, bool set_default);
void set(const std::string &name, const std::string &value); void set(const std::string &name, const std::string &value);
void setGroup(const std::string &name, Settings *group);
void setDefault(const std::string &name, const std::string &value); void setDefault(const std::string &name, const std::string &value);
void setGroup(const std::string &name, Settings *group);
void setGroupDefault(const std::string &name, Settings *group); void setGroupDefault(const std::string &name, Settings *group);
void setBool(const std::string &name, bool value); void setBool(const std::string &name, bool value);
void setS16(const std::string &name, s16 value); void setS16(const std::string &name, s16 value);
@ -200,7 +189,8 @@ public:
void setV3F(const std::string &name, v3f value); void setV3F(const std::string &name, v3f value);
void setFlagStr(const std::string &name, u32 flags, void setFlagStr(const std::string &name, u32 flags,
const FlagDesc *flagdesc, u32 flagmask); const FlagDesc *flagdesc, u32 flagmask);
void setNoiseParams(const std::string &name, const NoiseParams &np); void setNoiseParams(const std::string &name, const NoiseParams &np,
bool set_default=false);
// N.B. if setStruct() is used to write a non-POD aggregate type, // N.B. if setStruct() is used to write a non-POD aggregate type,
// the behavior is undefined. // the behavior is undefined.
bool setStruct(const std::string &name, const std::string &format, void *value); bool setStruct(const std::string &name, const std::string &format, void *value);

View File

@ -452,7 +452,6 @@ struct TestPath: public TestBase
"coord = (1, 2, 4.5)\n" \ "coord = (1, 2, 4.5)\n" \
" # this is just a comment\n" \ " # this is just a comment\n" \
"this is an invalid line\n" \ "this is an invalid line\n" \
"asdf = sdfghj\n" \
"asdf = {\n" \ "asdf = {\n" \
" a = 5\n" \ " a = 5\n" \
" bb = 2.5\n" \ " bb = 2.5\n" \
@ -481,10 +480,6 @@ struct TestPath: public TestBase
"floaty_thing_2 = 1.2\n" \ "floaty_thing_2 = 1.2\n" \
"groupy_thing = {\n" \ "groupy_thing = {\n" \
" animals = cute\n" \ " animals = cute\n" \
" animals = {\n" \
" cat = meow\n" \
" dog = woof\n" \
" }\n" \
" num_apples = 4\n" \ " num_apples = 4\n" \
" num_oranges = 53\n" \ " num_oranges = 53\n" \
"}\n" "}\n"
@ -493,6 +488,7 @@ struct TestSettings: public TestBase
{ {
void Run() void Run()
{ {
try {
Settings s; Settings s;
// Test reading of settings // Test reading of settings
@ -526,8 +522,6 @@ struct TestSettings: public TestBase
UASSERT(group->getS16("a") == 5); UASSERT(group->getS16("a") == 5);
UASSERT(fabs(group->getFloat("bb") - 2.5) < 0.001); UASSERT(fabs(group->getFloat("bb") - 2.5) < 0.001);
s.set("asdf", "sdfghj");
Settings *group3 = new Settings; Settings *group3 = new Settings;
group3->set("cat", "meow"); group3->set("cat", "meow");
group3->set("dog", "woof"); group3->set("dog", "woof");
@ -536,18 +530,19 @@ struct TestSettings: public TestBase
group2->setS16("num_apples", 4); group2->setS16("num_apples", 4);
group2->setS16("num_oranges", 53); group2->setS16("num_oranges", 53);
group2->setGroup("animals", group3); group2->setGroup("animals", group3);
group2->set("animals", "cute"); group2->set("animals", "cute"); //destroys group 3
s.setGroup("groupy_thing", group2); s.setGroup("groupy_thing", group2);
// Test multiline settings // Test multiline settings
UASSERT(group->get("ccc") == "testy\n testa "); UASSERT(group->get("ccc") == "testy\n testa ");
s.setGroup("asdf", NULL);
UASSERT(s.get("blarg") == UASSERT(s.get("blarg") ==
"some multiline text\n" "some multiline text\n"
" with leading whitespace!"); " with leading whitespace!");
// Test NoiseParams // Test NoiseParams
UASSERT(s.getEntry("np_terrain").is_group == false);
NoiseParams np; NoiseParams np;
UASSERT(s.getNoiseParams("np_terrain", np) == true); UASSERT(s.getNoiseParams("np_terrain", np) == true);
UASSERT(fabs(np.offset - 5) < 0.001); UASSERT(fabs(np.offset - 5) < 0.001);
@ -563,6 +558,8 @@ struct TestSettings: public TestBase
np.octaves = 6; np.octaves = 6;
s.setNoiseParams("np_terrain", np); s.setNoiseParams("np_terrain", np);
UASSERT(s.getEntry("np_terrain").is_group == true);
// Test writing // Test writing
std::ostringstream os(std::ios_base::binary); std::ostringstream os(std::ios_base::binary);
is.clear(); is.clear();
@ -572,6 +569,9 @@ struct TestSettings: public TestBase
//printf(">>>> expected config:\n%s\n", TEST_CONFIG_TEXT_AFTER); //printf(">>>> expected config:\n%s\n", TEST_CONFIG_TEXT_AFTER);
//printf(">>>> actual config:\n%s\n", os.str().c_str()); //printf(">>>> actual config:\n%s\n", os.str().c_str());
UASSERT(os.str() == TEST_CONFIG_TEXT_AFTER); UASSERT(os.str() == TEST_CONFIG_TEXT_AFTER);
} catch (SettingNotFoundException &e) {
UASSERT(!"Setting not found!");
}
} }
}; };