Settings: Make setting entry group and values mutually exclusive

This greatly reduces the complexity of Settings code.
Additionally, several memory leaks were fixed.

diff --git a/src/settings.cpp b/src/settings.cpp
index 09b413ed0a9ec30d3805ec79ae1bb68a3bbf4426..487b3da785605bd4afc1aa877903a79ac5aaafd9 100644 (file)
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -36,9 +36,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 Settings::~Settings()
 {
-       std::map<std::string, SettingsEntry>::const_iterator it;
-       for (it = m_settings.begin(); it != m_settings.end(); ++it)
-               delete it->second.group;
+       clear();
 }
 
 
@@ -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)
 {
        JMutexAutoLock lock(m_mutex);
@@ -122,11 +130,12 @@ bool Settings::parseConfigLines(std::istream &is, const std::string &end)
                case SPE_END:
                        return true;
                case SPE_GROUP: {
-                       Settings *branch = new Settings;
-                       if (!branch->parseConfigLines(is, "}"))
+                       Settings *group = new Settings;
+                       if (!group->parseConfigLines(is, "}")) {
+                               delete group;
                                return false;
-
-                       m_settings[name] = SettingsEntry(branch);
+                       }
+                       m_settings[name] = SettingsEntry(group);
                        break;
                }
                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
 {
        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)
 {
-       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++)
-               os << "\t";
-
-       os << name << " = {\n";
-       group->writeLines(os, tab_depth + 1);
-
        for (u32 i = 0; i != tab_depth; i++)
                os << "\t";
 
-       os << "}\n";
-}
-
+       if (entry.is_group) {
+               os << name << " = {\n";
 
-void Settings::getNamesPresent(std::istream &is, const std::string &end,
-       std::set<std::string> &present_values, std::set<std::string> &present_groups)
-{
-       std::string name, value, line;
-       bool end_found = false;
-       int depth = 0;
-       size_t old_pos = is.tellg();
+               entry.group->writeLines(os, tab_depth + 1);
 
-       while (is.good() && !end_found) {
-               std::getline(is, line);
-               SettingsParseEvent event = parseConfigObject(line,
-                       depth ? "}" : end, name, value);
+               for (u32 i = 0; i != tab_depth; i++)
+                       os << "\t";
+               os << "}\n";
+       } else {
+               os << name << " = ";
 
-               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;
-               }
+               if (entry.value.find('\n') != std::string::npos)
+                       os << "\"\"\"\n" << entry.value << "\n\"\"\"\n";
+               else
+                       os << entry.value << "\n";
        }
-
-       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)
 {
        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;
        bool was_modified = 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
        // in the object if existing
        while (is.good() && !end_found) {
@@ -283,48 +209,31 @@ bool Settings::updateConfigObject(std::istream &is, std::ostream &os,
                        /* FALLTHROUGH */
                case SPE_KVPAIR:
                        it = m_settings.find(name);
-                       if (it != m_settings.end() && value != it->second.value) {
-                               if (!it->second.group || it->second.value != "")
-                                       printValue(os, name, it->second.value, tab_depth);
+                       if (it != m_settings.end() &&
+                               (it->second.is_group || it->second.value != value)) {
+                               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";
                        }
-
-                       // 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;
-                       }
-
+                       present_entries.insert(name);
                        break;
-               case SPE_GROUP: {
-                       Settings *group = NULL;
+               case SPE_GROUP:
                        it = m_settings.find(name);
-                       if (it != m_settings.end())
-                               group = it->second.group;
-
-                       // If this group name has a non-blank value not in the file, print it
-                       if (it != m_settings.end() && it->second.value != "" &&
-                                       present_values.find(name) == present_values.end()) {
-                               printValue(os, name, it->second.value, tab_depth);
-                               was_modified = true;
-                       }
-
-                       os << line << "\n";
-
-                       if (group) {
-                               was_modified |= group->updateConfigObject(is, os, "}", tab_depth + 1);
+                       if (it != m_settings.end() && it->second.is_group) {
+                               os << line << "\n";
+                               assert(it->second.group != NULL);
+                               was_modified |= it->second.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);
+                               printEntry(os, name, it->second, tab_depth);
+                               was_modified = true;
                        }
+                       present_entries.insert(name);
                        break;
-               }
                default:
                        os << line << (is.eof() ? "" : "\n");
                        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
        for (it = m_settings.begin(); it != m_settings.end(); ++it) {
-               if (present_values.find(it->first) != present_values.end() ||
-                       present_groups.find(it->first) != present_groups.end())
+               if (present_entries.find(it->first) != present_entries.end())
                        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;
@@ -440,16 +349,19 @@ const SettingsEntry &Settings::getEntry(const std::string &name) const
 
 Settings *Settings::getGroup(const std::string &name) const
 {
-       Settings *group = getEntry(name).group;
-       if (group == NULL)
+       const SettingsEntry &entry = getEntry(name);
+       if (!entry.is_group)
                throw SettingNotFoundException("Setting [" + name + "] is not a group.");
-       return group;
+       return entry.group;
 }
 
 
 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 *
  ***********/
 
-
-void Settings::set(const std::string &name, const std::string &value)
+void Settings::setEntry(const std::string &name, const void *data,
+       bool set_group, bool set_default)
 {
+       Settings *old_group = NULL;
+
        {
                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;
-       {
-               JMutexAutoLock lock(m_mutex);
+       setEntry(name, &value, false, false);
 
-               old_group = m_settings[name].group;
-               m_settings[name].group = group;
-       }
-       delete old_group;
+       doCallbacks(name);
 }
 
 
 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)
 {
-       Settings *old_group = NULL;
-       {
-               JMutexAutoLock lock(m_mutex);
-
-               old_group = m_defaults[name].group;
-               m_defaults[name].group = group;
-       }
-       delete old_group;
+       setEntry(name, &group, true, true);
 }
 
 
@@ -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;
 
@@ -904,21 +817,15 @@ void Settings::setNoiseParams(const std::string &name, const NoiseParams &np)
        group->setFloat("lacunarity",  np.lacunarity);
        group->setFlagStr("flags",     np.flags, flagdesc_noiseparams, np.flags);
 
-       Settings *old_group;
-       {
-               JMutexAutoLock lock(m_mutex);
-
-               old_group = m_settings[name].group;
-               m_settings[name].group = group;
-               m_settings[name].value = "";
-       }
-       delete old_group;
+       setEntry(name, &group, true, set_default);
 }
 
 
 bool Settings::remove(const std::string &name)
 {
        JMutexAutoLock lock(m_mutex);
+
+       delete m_settings[name].group;
        return m_settings.erase(name);
 }
 
@@ -995,7 +902,13 @@ void Settings::updateNoLock(const Settings &other)
 
 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();
+
+       for (it = m_defaults.begin(); it != m_defaults.end(); ++it)
+               delete it->second.group;
        m_defaults.clear();
 }
 
@@ -1018,8 +931,8 @@ void Settings::doCallbacks(const std::string name)
                }
        }
 
-       for (std::vector<setting_changed_callback>::iterator iter = tempvector.begin();
-                       iter != tempvector.end(); iter ++)
+       std::vector<setting_changed_callback>::iterator iter;
+       for (iter = tempvector.begin(); iter != tempvector.end(); iter++)
        {
                (*iter)(name);
        }

diff --git a/src/settings.h b/src/settings.h
index 6c063e43e5fca2801ac27bc300547663cdc87b6f..7241877bdb1093456eeb1637ed8522136c898b30 100644 (file)
--- a/src/settings.h
+++ b/src/settings.h
@@ -59,36 +59,31 @@ struct ValueSpec {
        const char *help;
 };
 
-/** function type to register a changed callback */
-
 struct SettingsEntry {
        SettingsEntry()
        {
-               group = NULL;
+               group    = NULL;
+               is_group = false;
        }
 
        SettingsEntry(const std::string &value_)
        {
-               value = value_;
-               group = NULL;
+               value    = value_;
+               group    = NULL;
+               is_group = false;
        }
 
        SettingsEntry(Settings *group_)
        {
-               group = group_;
-       }
-
-       SettingsEntry(const std::string &value_, Settings *group_)
-       {
-               value = value_;
-               group = group_;
+               group    = group_;
+               is_group = true;
        }
 
        std::string value;
        Settings *group;
+       bool is_group;
 };
 
-
 class Settings {
 public:
        Settings() {}
@@ -97,7 +92,6 @@ public:
        Settings & operator += (const Settings &other);
        Settings & operator = (const Settings &other);
 
-
        /***********************
         * Reading and writing *
         ***********************/
@@ -114,20 +108,13 @@ public:
 
        SettingsParseEvent parseConfigObject(const std::string &line,
                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,
                const std::string &end, u32 tab_depth=0);
 
        static std::string getMultiline(std::istream &is, size_t *num_lines=NULL);
        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);
-       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 *
@@ -186,9 +173,11 @@ public:
 
        // N.B. Groups not allocated with new must be set to NULL in the settings
        // 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 setGroup(const std::string &name, Settings *group);
        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 setBool(const std::string &name, bool value);
        void setS16(const std::string &name, s16 value);
@@ -200,7 +189,8 @@ public:
        void setV3F(const std::string &name, v3f value);
        void setFlagStr(const std::string &name, u32 flags,
                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,
        // the behavior is undefined.
        bool setStruct(const std::string &name, const std::string &format, void *value);

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