51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#ifndef SETTINGS_HEADER
-#define SETTINGS_HEADER
+#pragma once
#include "irrlichttypes_bloated.h"
-#include "exceptions.h"
-#include <string>
-#include "jthread/jmutex.h"
-#include "jthread/jmutexautolock.h"
-#include "strfnd.h"
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include "debug.h"
-#include "log.h"
#include "util/string.h"
-#include "util/serialize.h"
+#include "util/basic_macros.h"
+#include <string>
#include <list>
-#include <map>
#include <set>
-#include "filesys.h"
-#include <cctype>
-
-enum ValueType
-{
- VALUETYPE_STRING,
- VALUETYPE_FLAG // Doesn't take any arguments
-};
-
-struct ValueSpec
-{
- ValueSpec(ValueType a_type, const char *a_help=NULL)
- {
- type = a_type;
- help = a_help;
- }
- ValueType type;
- const char *help;
-};
-
-class Settings
-{
-public:
- Settings()
- {
- }
-
- void writeLines(std::ostream &os)
- {
- JMutexAutoLock lock(m_mutex);
-
- for(std::map<std::string, std::string>::iterator
- i = m_settings.begin();
- i != m_settings.end(); ++i)
- {
- std::string name = i->first;
- std::string value = i->second;
- os<<name<<" = "<<value<<"\n";
- }
- }
-
- // return all keys used
- std::vector<std::string> getNames(){
- std::vector<std::string> names;
- for(std::map<std::string, std::string>::iterator
- i = m_settings.begin();
- i != m_settings.end(); ++i)
- {
- names.push_back(i->first);
- }
- return names;
- }
-
- // remove a setting
- bool remove(const std::string& name)
- {
- return m_settings.erase(name);
- }
+#include <mutex>
+class Settings;
+struct NoiseParams;
- bool parseConfigLine(const std::string &line)
- {
- JMutexAutoLock lock(m_mutex);
+// Global objects
+extern Settings *g_settings; // Same as Settings::getLayer(SL_GLOBAL);
+extern std::string g_settings_path;
- std::string trimmedline = trim(line);
+// Type for a settings changed callback function
+typedef void (*SettingsChangedCallback)(const std::string &name, void *data);
- // Ignore empty lines and comments
- if(trimmedline.size() == 0 || trimmedline[0] == '#')
- return true;
+typedef std::vector<
+ std::pair<
+ SettingsChangedCallback,
+ void *
+ >
+> SettingsCallbackList;
- //infostream<<"trimmedline=\""<<trimmedline<<"\""<<std::endl;
+typedef std::unordered_map<std::string, SettingsCallbackList> SettingsCallbackMap;
- Strfnd sf(trim(line));
-
- std::string name = sf.next("=");
- name = trim(name);
-
- if(name == "")
- return true;
-
- std::string value = sf.next("\n");
- value = trim(value);
-
- /*infostream<<"Config name=\""<<name<<"\" value=\""
- <<value<<"\""<<std::endl;*/
-
- m_settings[name] = value;
-
- return true;
- }
-
- void parseConfigLines(std::istream &is, const std::string &endstring)
- {
- for(;;){
- if(is.eof())
- break;
- std::string line;
- std::getline(is, line);
- std::string trimmedline = trim(line);
- if(endstring != ""){
- if(trimmedline == endstring)
- break;
- }
- parseConfigLine(line);
- }
- }
-
- // Returns false on EOF
- bool parseConfigObject(std::istream &is)
- {
- if(is.eof())
- return false;
-
- /*
- NOTE: This function might be expanded to allow multi-line
- settings.
- */
- std::string line;
- std::getline(is, line);
- //infostream<<"got line: \""<<line<<"\""<<std::endl;
-
- return parseConfigLine(line);
- }
-
- /*
- Read configuration file
-
- Returns true on success
- */
- bool readConfigFile(const char *filename)
- {
- std::ifstream is(filename);
- if(is.good() == false)
- return false;
-
- /*infostream<<"Parsing configuration file: \""
- <<filename<<"\""<<std::endl;*/
-
- while(parseConfigObject(is));
-
- return true;
- }
-
- /*
- Reads a configuration object from stream (usually a single line)
- and adds it to dst.
-
- Preserves comments and empty lines.
-
- Settings that were added to dst are also added to updated.
- key of updated is setting name, value of updated is dummy.
-
- Returns false on EOF
- */
- bool getUpdatedConfigObject(std::istream &is,
- std::list<std::string> &dst,
- std::set<std::string> &updated,
- bool &value_changed)
- {
- JMutexAutoLock lock(m_mutex);
-
- if(is.eof())
- return false;
-
- // NOTE: This function will be expanded to allow multi-line settings
- std::string line;
- std::getline(is, line);
-
- std::string trimmedline = trim(line);
-
- std::string line_end = "";
- if(is.eof() == false)
- line_end = "\n";
-
- // Ignore empty lines and comments
- if(trimmedline.size() == 0 || trimmedline[0] == '#')
- {
- dst.push_back(line+line_end);
- return true;
- }
-
- Strfnd sf(trim(line));
-
- std::string name = sf.next("=");
- name = trim(name);
-
- if(name == "")
- {
- dst.push_back(line+line_end);
- return true;
- }
-
- std::string value = sf.next("\n");
- value = trim(value);
-
- if(m_settings.find(name) != m_settings.end())
- {
- std::string newvalue = m_settings[name];
-
- if(newvalue != value)
- {
- infostream<<"Changing value of \""<<name<<"\" = \""
- <<value<<"\" -> \""<<newvalue<<"\""
- <<std::endl;
- value_changed = true;
- }
-
- dst.push_back(name + " = " + newvalue + line_end);
-
- updated.insert(name);
- }
- else //file contains a setting which is not in m_settings
- value_changed=true;
-
- return true;
- }
+enum ValueType {
+ VALUETYPE_STRING,
+ VALUETYPE_FLAG // Doesn't take any arguments
+};
- /*
- Updates configuration file
+enum SettingsParseEvent {
+ SPE_NONE,
+ SPE_INVALID,
+ SPE_COMMENT,
+ SPE_KVPAIR,
+ SPE_END,
+ SPE_GROUP,
+ SPE_MULTILINE,
+};
- Returns true on success
- */
- bool updateConfigFile(const char *filename)
- {
- infostream<<"Updating configuration file: \""
- <<filename<<"\""<<std::endl;
-
- std::list<std::string> objects;
- std::set<std::string> updated;
- bool something_actually_changed = false;
-
- // Read and modify stuff
- {
- std::ifstream is(filename);
- if(is.good() == false)
- {
- infostream<<"updateConfigFile():"
- " Error opening configuration file"
- " for reading: \""
- <<filename<<"\""<<std::endl;
- }
- else
- {
- while(getUpdatedConfigObject(is, objects, updated,
- something_actually_changed));
- }
- }
-
- JMutexAutoLock lock(m_mutex);
-
- // If something not yet determined to have been changed, check if
- // any new stuff was added
- if(!something_actually_changed){
- for(std::map<std::string, std::string>::iterator
- i = m_settings.begin();
- i != m_settings.end(); ++i)
- {
- if(updated.find(i->first) != updated.end())
- continue;
- something_actually_changed = true;
- break;
- }
- }
-
- // If nothing was actually changed, skip writing the file
- if(!something_actually_changed){
- infostream<<"Skipping writing of "<<filename
- <<" because content wouldn't be modified"<<std::endl;
- return true;
- }
-
- // Write stuff back
- {
- std::ostringstream ss(std::ios_base::binary);
-
- /*
- Write updated stuff
- */
- for(std::list<std::string>::iterator
- i = objects.begin();
- i != objects.end(); ++i)
- {
- ss<<(*i);
- }
-
- /*
- Write stuff that was not already in the file
- */
- for(std::map<std::string, std::string>::iterator
- i = m_settings.begin();
- i != m_settings.end(); ++i)
- {
- if(updated.find(i->first) != updated.end())
- continue;
- std::string name = i->first;
- std::string value = i->second;
- infostream<<"Adding \""<<name<<"\" = \""<<value<<"\""
- <<std::endl;
- ss<<name<<" = "<<value<<"\n";
- }
-
- if(!fs::safeWriteToFile(filename, ss.str()))
- {
- errorstream<<"Error writing configuration file: \""
- <<filename<<"\""<<std::endl;
- return false;
- }
- }
-
- return true;
- }
+// Describes the global setting layers, SL_GLOBAL is where settings are read from
+enum SettingsLayer {
+ SL_DEFAULTS,
+ SL_GAME,
+ SL_GLOBAL,
+ SL_TOTAL_COUNT
+};
+// Implements the hierarchy a settings object may be part of
+class SettingsHierarchy {
+public:
/*
- NOTE: Types of allowed_options are ignored
-
- returns true on success
- */
- bool parseCommandLine(int argc, char *argv[],
- std::map<std::string, ValueSpec> &allowed_options)
- {
- int nonopt_index = 0;
- int i=1;
- for(;;)
- {
- if(i >= argc)
- break;
- std::string argname = argv[i];
- if(argname.substr(0, 2) != "--")
- {
- // If option doesn't start with -, read it in as nonoptX
- if(argname[0] != '-'){
- std::string name = "nonopt";
- name += itos(nonopt_index);
- set(name, argname);
- nonopt_index++;
- i++;
- continue;
- }
- errorstream<<"Invalid command-line parameter \""
- <<argname<<"\": --<option> expected."<<std::endl;
- return false;
- }
- i++;
-
- std::string name = argname.substr(2);
-
- std::map<std::string, ValueSpec>::iterator n;
- n = allowed_options.find(name);
- if(n == allowed_options.end())
- {
- errorstream<<"Unknown command-line parameter \""
- <<argname<<"\""<<std::endl;
- return false;
- }
-
- ValueType type = n->second.type;
-
- std::string value = "";
-
- if(type == VALUETYPE_FLAG)
- {
- value = "true";
- }
- else
- {
- if(i >= argc)
- {
- errorstream<<"Invalid command-line parameter \""
- <<name<<"\": missing value"<<std::endl;
- return false;
- }
- value = argv[i];
- i++;
- }
-
-
- infostream<<"Valid command-line parameter: \""
- <<name<<"\" = \""<<value<<"\""
- <<std::endl;
- set(name, value);
- }
-
- return true;
- }
-
- void set(std::string name, std::string value)
- {
- JMutexAutoLock lock(m_mutex);
-
- m_settings[name] = value;
- }
-
- void set(std::string name, const char *value)
- {
- JMutexAutoLock lock(m_mutex);
-
- m_settings[name] = value;
- }
-
-
- void setDefault(std::string name, std::string value)
- {
- JMutexAutoLock lock(m_mutex);
-
- m_defaults[name] = value;
- }
-
- bool exists(std::string name)
- {
- JMutexAutoLock lock(m_mutex);
-
- return (m_settings.find(name) != m_settings.end() || m_defaults.find(name) != m_defaults.end());
- }
-
- std::string get(std::string name)
- {
- JMutexAutoLock lock(m_mutex);
-
- std::map<std::string, std::string>::iterator n;
- n = m_settings.find(name);
- if(n == m_settings.end())
- {
- n = m_defaults.find(name);
- if(n == m_defaults.end())
- {
- throw SettingNotFoundException(("Setting [" + name + "] not found ").c_str());
- }
- }
-
- return n->second;
- }
-
- //////////// Get setting
- bool getBool(std::string name)
- {
- return is_yes(get(name));
- }
-
- bool getFlag(std::string name)
- {
- try
- {
- return getBool(name);
- }
- catch(SettingNotFoundException &e)
- {
- return false;
- }
- }
-
- // Asks if empty
- bool getBoolAsk(std::string name, std::string question, bool def)
- {
- // If it is in settings
- if(exists(name))
- return getBool(name);
-
- std::string s;
- char templine[10];
- std::cout<<question<<" [y/N]: ";
- std::cin.getline(templine, 10);
- s = templine;
-
- if(s == "")
- return def;
-
- return is_yes(s);
- }
-
- float getFloat(std::string name)
- {
- return stof(get(name));
- }
-
- u16 getU16(std::string name)
- {
- return stoi(get(name), 0, 65535);
- }
-
- u16 getU16Ask(std::string name, std::string question, u16 def)
- {
- // If it is in settings
- if(exists(name))
- return getU16(name);
+ * A settings object that may be part of another hierarchy can
+ * occupy the index 0 as a fallback. If not set you can use 0 on your own.
+ */
+ SettingsHierarchy(Settings *fallback = nullptr);
- std::string s;
- char templine[10];
- std::cout<<question<<" ["<<def<<"]: ";
- std::cin.getline(templine, 10);
- s = templine;
+ DISABLE_CLASS_COPY(SettingsHierarchy)
- if(s == "")
- return def;
+ Settings *getLayer(int layer) const;
- return stoi(s, 0, 65535);
- }
-
- s16 getS16(std::string name)
- {
- return stoi(get(name), -32768, 32767);
- }
-
- s32 getS32(std::string name)
- {
- return stoi(get(name));
- }
-
- v3f getV3F(std::string name)
- {
- v3f value;
- Strfnd f(get(name));
- f.next("(");
- value.X = stof(f.next(","));
- value.Y = stof(f.next(","));
- value.Z = stof(f.next(")"));
- return value;
- }
-
- v2f getV2F(std::string name)
- {
- v2f value;
- Strfnd f(get(name));
- f.next("(");
- value.X = stof(f.next(","));
- value.Y = stof(f.next(")"));
- return value;
- }
-
- u64 getU64(std::string name)
- {
- u64 value = 0;
- std::string s = get(name);
- std::istringstream ss(s);
- ss>>value;
- return value;
- }
-
- u32 getFlagStr(std::string name, FlagDesc *flagdesc, u32 *flagmask)
- {
- std::string val = get(name);
- return (std::isdigit(val[0])) ? stoi(val) :
- readFlagString(val, flagdesc, flagmask);
- }
-
- // N.B. if getStruct() is used to read a non-POD aggregate type,
- // the behavior is undefined.
- bool getStruct(std::string name, std::string format, void *out, size_t olen)
- {
- std::string valstr;
-
- try {
- valstr = get(name);
- } catch (SettingNotFoundException &e) {
- return false;
- }
-
- if (!deSerializeStringToStruct(valstr, format, out, olen))
- return false;
-
- return true;
- }
-
- //////////// Try to get value, no exception thrown
- bool getNoEx(std::string name, std::string &val)
- {
- try {
- val = get(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- // N.B. getFlagStrNoEx() does not set val, but merely modifies it. Thus,
- // val must be initialized before using getFlagStrNoEx(). The intention of
- // this is to simplify modifying a flags field from a default value.
- bool getFlagStrNoEx(std::string name, u32 &val, FlagDesc *flagdesc)
- {
- try {
- u32 flags, flagmask;
-
- flags = getFlagStr(name, flagdesc, &flagmask);
-
- val &= ~flagmask;
- val |= flags;
-
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getFloatNoEx(std::string name, float &val)
- {
- try {
- val = getFloat(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getU16NoEx(std::string name, int &val)
- {
- try {
- val = getU16(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getU16NoEx(std::string name, u16 &val)
- {
- try {
- val = getU16(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getS16NoEx(std::string name, int &val)
- {
- try {
- val = getU16(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getS16NoEx(std::string name, s16 &val)
- {
- try {
- val = getS16(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getS32NoEx(std::string name, s32 &val)
- {
- try {
- val = getS32(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getV3FNoEx(std::string name, v3f &val)
- {
- try {
- val = getV3F(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getV2FNoEx(std::string name, v2f &val)
- {
- try {
- val = getV2F(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- bool getU64NoEx(std::string name, u64 &val)
- {
- try {
- val = getU64(name);
- return true;
- } catch (SettingNotFoundException &e) {
- return false;
- }
- }
-
- //////////// Set setting
-
- // N.B. if setStruct() is used to write a non-POD aggregate type,
- // the behavior is undefined.
- bool setStruct(std::string name, std::string format, void *value)
- {
- std::string structstr;
- if (!serializeStructToString(&structstr, format, value))
- return false;
-
- set(name, structstr);
- return true;
- }
-
- void setFlagStr(std::string name, u32 flags,
- FlagDesc *flagdesc, u32 flagmask)
- {
- set(name, writeFlagString(flags, flagdesc, flagmask));
- }
-
- void setBool(std::string name, bool value)
- {
- if(value)
- set(name, "true");
- else
- set(name, "false");
- }
+private:
+ friend class Settings;
+ Settings *getParent(int layer) const;
+ void onLayerCreated(int layer, Settings *obj);
+ void onLayerRemoved(int layer);
- void setFloat(std::string name, float value)
- {
- set(name, ftos(value));
- }
+ std::vector<Settings*> layers;
+};
- void setV3F(std::string name, v3f value)
+struct ValueSpec {
+ ValueSpec(ValueType a_type, const char *a_help=NULL)
{
- std::ostringstream os;
- os<<"("<<value.X<<","<<value.Y<<","<<value.Z<<")";
- set(name, os.str());
+ type = a_type;
+ help = a_help;
}
- void setV2F(std::string name, v2f value)
- {
- std::ostringstream os;
- os<<"("<<value.X<<","<<value.Y<<")";
- set(name, os.str());
- }
+ ValueType type;
+ const char *help;
+};
- void setS16(std::string name, s16 value)
- {
- set(name, itos(value));
- }
+struct SettingsEntry {
+ SettingsEntry() = default;
- void setS32(std::string name, s32 value)
- {
- set(name, itos(value));
- }
+ SettingsEntry(const std::string &value_) :
+ value(value_)
+ {}
- void setU64(std::string name, u64 value)
- {
- std::ostringstream os;
- os<<value;
- set(name, os.str());
- }
+ SettingsEntry(Settings *group_) :
+ group(group_),
+ is_group(true)
+ {}
- void clear()
- {
- JMutexAutoLock lock(m_mutex);
+ std::string value = "";
+ Settings *group = nullptr;
+ bool is_group = false;
+};
- m_settings.clear();
- m_defaults.clear();
- }
+typedef std::unordered_map<std::string, SettingsEntry> SettingEntries;
- void updateValue(Settings &other, const std::string &name)
- {
- JMutexAutoLock lock(m_mutex);
+class Settings {
+public:
+ /* These functions operate on the global hierarchy! */
+ static Settings *createLayer(SettingsLayer sl, const std::string &end_tag = "");
+ static Settings *getLayer(SettingsLayer sl);
+ /**/
+
+ Settings(const std::string &end_tag = "") :
+ m_end_tag(end_tag)
+ {}
+ Settings(const std::string &end_tag, SettingsHierarchy *h, int settings_layer);
+ ~Settings();
+
+ Settings & operator += (const Settings &other);
+ Settings & operator = (const Settings &other);
+
+ /***********************
+ * Reading and writing *
+ ***********************/
+
+ // Read configuration file. Returns success.
+ bool readConfigFile(const char *filename);
+ //Updates configuration file. Returns success.
+ bool updateConfigFile(const char *filename);
+ // NOTE: Types of allowed_options are ignored. Returns success.
+ bool parseCommandLine(int argc, char *argv[],
+ std::map<std::string, ValueSpec> &allowed_options);
+ bool parseConfigLines(std::istream &is);
+ void writeLines(std::ostream &os, u32 tab_depth=0) const;
+
+ /***********
+ * Getters *
+ ***********/
+
+ Settings *getGroup(const std::string &name) const;
+ const std::string &get(const std::string &name) const;
+ bool getBool(const std::string &name) const;
+ u16 getU16(const std::string &name) const;
+ s16 getS16(const std::string &name) const;
+ u32 getU32(const std::string &name) const;
+ s32 getS32(const std::string &name) const;
+ u64 getU64(const std::string &name) const;
+ float getFloat(const std::string &name) const;
+ v2f getV2F(const std::string &name) const;
+ v3f getV3F(const std::string &name) const;
+ u32 getFlagStr(const std::string &name, const FlagDesc *flagdesc,
+ u32 *flagmask) const;
+ bool getNoiseParams(const std::string &name, NoiseParams &np) const;
+ bool getNoiseParamsFromValue(const std::string &name, NoiseParams &np) const;
+ bool getNoiseParamsFromGroup(const std::string &name, NoiseParams &np) const;
+
+ // return all keys used in this object
+ std::vector<std::string> getNames() const;
+ // check if setting exists anywhere in the hierarchy
+ bool exists(const std::string &name) const;
+ // check if setting exists in this object ("locally")
+ bool existsLocal(const std::string &name) const;
+
+
+ /***************************************
+ * Getters that don't throw exceptions *
+ ***************************************/
+
+ bool getGroupNoEx(const std::string &name, Settings *&val) const;
+ bool getNoEx(const std::string &name, std::string &val) const;
+ bool getFlag(const std::string &name) const;
+ bool getU16NoEx(const std::string &name, u16 &val) const;
+ bool getS16NoEx(const std::string &name, s16 &val) const;
+ bool getU32NoEx(const std::string &name, u32 &val) const;
+ bool getS32NoEx(const std::string &name, s32 &val) const;
+ bool getU64NoEx(const std::string &name, u64 &val) const;
+ bool getFloatNoEx(const std::string &name, float &val) const;
+ bool getV2FNoEx(const std::string &name, v2f &val) const;
+ bool getV3FNoEx(const std::string &name, v3f &val) const;
+
+ // Like other getters, but handling each flag individualy:
+ // 1) Read default flags (or 0)
+ // 2) Override using user-defined flags
+ bool getFlagStrNoEx(const std::string &name, u32 &val,
+ const FlagDesc *flagdesc) const;
+
+
+ /***********
+ * Setters *
+ ***********/
+
+ // N.B. Groups not allocated with new must be set to NULL in the settings
+ // tree before object destruction.
+ bool setEntry(const std::string &name, const void *entry,
+ bool set_group);
+ bool set(const std::string &name, const std::string &value);
+ bool setDefault(const std::string &name, const std::string &value);
+ bool setGroup(const std::string &name, const Settings &group);
+ bool setBool(const std::string &name, bool value);
+ bool setS16(const std::string &name, s16 value);
+ bool setU16(const std::string &name, u16 value);
+ bool setS32(const std::string &name, s32 value);
+ bool setU64(const std::string &name, u64 value);
+ bool setFloat(const std::string &name, float value);
+ bool setV2F(const std::string &name, v2f value);
+ bool setV3F(const std::string &name, v3f value);
+ bool setFlagStr(const std::string &name, u32 flags,
+ const FlagDesc *flagdesc = nullptr, u32 flagmask = U32_MAX);
+ bool setNoiseParams(const std::string &name, const NoiseParams &np);
- if(&other == this)
- return;
+ // remove a setting
+ bool remove(const std::string &name);
- try{
- std::string val = other.get(name);
- m_settings[name] = val;
- } catch(SettingNotFoundException &e){
- }
+ /*****************
+ * Miscellaneous *
+ *****************/
- return;
- }
+ void setDefault(const std::string &name, const FlagDesc *flagdesc, u32 flags);
+ const FlagDesc *getFlagDescFallback(const std::string &name) const;
- void update(Settings &other)
- {
- JMutexAutoLock lock(m_mutex);
- JMutexAutoLock lock2(other.m_mutex);
+ void registerChangedCallback(const std::string &name,
+ SettingsChangedCallback cbf, void *userdata = NULL);
+ void deregisterChangedCallback(const std::string &name,
+ SettingsChangedCallback cbf, void *userdata = NULL);
- if(&other == this)
- return;
+ void removeSecureSettings();
- m_settings.insert(other.m_settings.begin(), other.m_settings.end());
- m_defaults.insert(other.m_defaults.begin(), other.m_defaults.end());
+ // Returns the settings layer this object is.
+ // If within the global hierarchy you can cast this to enum SettingsLayer
+ inline int getLayer() const { return m_settingslayer; }
- return;
- }
+private:
+ /***********************
+ * Reading and writing *
+ ***********************/
- Settings & operator+=(Settings &other)
- {
- JMutexAutoLock lock(m_mutex);
- JMutexAutoLock lock2(other.m_mutex);
+ SettingsParseEvent parseConfigObject(const std::string &line,
+ std::string &name, std::string &value);
+ bool updateConfigObject(std::istream &is, std::ostream &os,
+ u32 tab_depth=0);
- if(&other == this)
- return *this;
+ static bool checkNameValid(const std::string &name);
+ static bool checkValueValid(const std::string &value);
+ static std::string getMultiline(std::istream &is, size_t *num_lines=NULL);
+ static void printEntry(std::ostream &os, const std::string &name,
+ const SettingsEntry &entry, u32 tab_depth=0);
- update(other);
+ /***********
+ * Getters *
+ ***********/
+ Settings *getParent() const;
- return *this;
+ const SettingsEntry &getEntry(const std::string &name) const;
- }
+ // Allow TestSettings to run sanity checks using private functions.
+ friend class TestSettings;
+ // For sane mutex locking when iterating
+ friend class LuaSettings;
- Settings & operator=(Settings &other)
- {
- JMutexAutoLock lock(m_mutex);
- JMutexAutoLock lock2(other.m_mutex);
+ void updateNoLock(const Settings &other);
+ void clearNoLock();
+ void clearDefaultsNoLock();
- if(&other == this)
- return *this;
+ void doCallbacks(const std::string &name) const;
- clear();
- (*this) += other;
+ SettingEntries m_settings;
+ SettingsCallbackMap m_callbacks;
+ std::string m_end_tag;
- return *this;
- }
+ mutable std::mutex m_callback_mutex;
-private:
- std::map<std::string, std::string> m_settings;
- std::map<std::string, std::string> m_defaults;
// All methods that access m_settings/m_defaults directly should lock this.
- JMutex m_mutex;
-};
+ mutable std::mutex m_mutex;
-#endif
+ SettingsHierarchy *m_hierarchy = nullptr;
+ int m_settingslayer = -1;
+ static std::unordered_map<std::string, const FlagDesc *> s_flags;
+};