X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fsettings.h;h=6db2f9481672873b87843c26b443449d4812ca4e;hb=ad58ece18062d4c545432b45d71ce6dbe841746b;hp=f972ce3ece1ce8528d97eb2c82514ca9e5aef550;hpb=9e46cbf7ea512330f35d0f2ede0c7c0c085c7cf4;p=dragonfireclient.git

diff --git a/src/settings.h b/src/settings.h
index f972ce3ec..6db2f9481 100644
--- a/src/settings.h
+++ b/src/settings.h
@@ -1,583 +1,255 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+GNU Lesser General Public License for more details.
 
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser General Public License along
 with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#ifndef SETTINGS_HEADER
-#define SETTINGS_HEADER
+#pragma once
 
-#include "common_irrlicht.h"
+#include "irrlichttypes_bloated.h"
+#include "util/string.h"
 #include <string>
-#include <jthread.h>
-#include <jmutex.h>
-#include <jmutexautolock.h>
-#include "strfnd.h"
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include "debug.h"
-#include "utility.h"
-
-enum ValueType
-{
+#include <list>
+#include <set>
+#include <mutex>
+
+class Settings;
+struct NoiseParams;
+
+// Global objects
+extern Settings *g_settings;
+extern std::string g_settings_path;
+
+// Type for a settings changed callback function
+typedef void (*SettingsChangedCallback)(const std::string &name, void *data);
+
+typedef std::vector<
+	std::pair<
+		SettingsChangedCallback,
+		void *
+	>
+> SettingsCallbackList;
+
+typedef std::unordered_map<std::string, SettingsCallbackList> SettingsCallbackMap;
+
+enum ValueType {
 	VALUETYPE_STRING,
 	VALUETYPE_FLAG // Doesn't take any arguments
 };
 
-struct ValueSpec
-{
+enum SettingsParseEvent {
+	SPE_NONE,
+	SPE_INVALID,
+	SPE_COMMENT,
+	SPE_KVPAIR,
+	SPE_END,
+	SPE_GROUP,
+	SPE_MULTILINE,
+};
+
+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()
-	{
-		m_mutex.Init();
-	}
-
-	void writeLines(std::ostream &os)
-	{
-		JMutexAutoLock lock(m_mutex);
-		
-		for(core::map<std::string, std::string>::Iterator
-				i = m_settings.getIterator();
-				i.atEnd() == false; i++)
-		{
-			std::string name = i.getNode()->getKey();
-			std::string value = i.getNode()->getValue();
-			os<<name<<" = "<<value<<"\n";
-		}
-	}
-
-	bool parseConfigLine(const std::string &line)
-	{
-		JMutexAutoLock lock(m_mutex);
-		
-		std::string trimmedline = trim(line);
-		
-		// Ignore comments
-		if(trimmedline[0] == '#')
-			return true;
-
-		//dstream<<"trimmedline=\""<<trimmedline<<"\""<<std::endl;
-
-		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);
-
-		/*dstream<<"Config name=\""<<name<<"\" value=\""
-				<<value<<"\""<<std::endl;*/
-		
-		m_settings[name] = value;
-		
-		return true;
-	}
-
-	// 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);
-		//dstream<<"got line: \""<<line<<"\""<<std::endl;
-
-		return parseConfigLine(line);
-	}
+struct SettingsEntry {
+	SettingsEntry() = default;
 
-	/*
-		Read configuration file
+	SettingsEntry(const std::string &value_) :
+		value(value_)
+	{}
 
-		Returns true on success
-	*/
-	bool readConfigFile(const char *filename)
-	{
-		std::ifstream is(filename);
-		if(is.good() == false)
-		{
-			dstream<<"Error opening configuration file \""
-					<<filename<<"\""<<std::endl;
-			return false;
-		}
-
-		dstream<<"Parsing configuration file: \""
-				<<filename<<"\""<<std::endl;
-				
-		while(parseConfigObject(is));
-		
-		return true;
-	}
+	SettingsEntry(Settings *group_) :
+		group(group_),
+		is_group(true)
+	{}
 
-	/*
-		Reads a configuration object from stream (usually a single line)
-		and adds it to dst.
-		
-		Preserves comments and empty lines.
+	std::string value = "";
+	Settings *group = nullptr;
+	bool is_group = false;
+};
 
-		Settings that were added to dst are also added to updated.
-		key of updated is setting name, value of updated is dummy.
+typedef std::unordered_map<std::string, SettingsEntry> SettingEntries;
 
-		Returns false on EOF
-	*/
-	bool getUpdatedConfigObject(std::istream &is,
-			core::list<std::string> &dst,
-			core::map<std::string, bool> &updated)
-	{
-		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 comments
-		if(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))
-		{
-			std::string newvalue = m_settings[name];
-			
-			if(newvalue != value)
-			{
-				dstream<<"Changing value of \""<<name<<"\" = \""
-						<<value<<"\" -> \""<<newvalue<<"\""
-						<<std::endl;
-			}
-
-			dst.push_back(name + " = " + newvalue + line_end);
-
-			updated[name] = true;
-		}
-		
-		return true;
-	}
+class Settings {
+public:
+	Settings() = default;
 
-	/*
-		Updates configuration file
+	~Settings();
 
-		Returns true on success
-	*/
-	bool updateConfigFile(const char *filename)
-	{
-		dstream<<"Updating configuration file: \""
-				<<filename<<"\""<<std::endl;
-		
-		core::list<std::string> objects;
-		core::map<std::string, bool> updated;
-		
-		// Read and modify stuff
-		{
-			std::ifstream is(filename);
-			if(is.good() == false)
-			{
-				dstream<<"INFO: updateConfigFile():"
-						" Error opening configuration file"
-						" for reading: \""
-						<<filename<<"\""<<std::endl;
-			}
-			else
-			{
-				while(getUpdatedConfigObject(is, objects, updated));
-			}
-		}
-		
-		JMutexAutoLock lock(m_mutex);
-		
-		// Write stuff back
-		{
-			std::ofstream os(filename);
-			if(os.good() == false)
-			{
-				dstream<<"Error opening configuration file"
-						" for writing: \""
-						<<filename<<"\""<<std::endl;
-				return false;
-			}
-			
-			/*
-				Write updated stuff
-			*/
-			for(core::list<std::string>::Iterator
-					i = objects.begin();
-					i != objects.end(); i++)
-			{
-				os<<(*i);
-			}
-
-			/*
-				Write stuff that was not already in the file
-			*/
-			for(core::map<std::string, std::string>::Iterator
-					i = m_settings.getIterator();
-					i.atEnd() == false; i++)
-			{
-				if(updated.find(i.getNode()->getKey()))
-					continue;
-				std::string name = i.getNode()->getKey();
-				std::string value = i.getNode()->getValue();
-				dstream<<"Adding \""<<name<<"\" = \""<<value<<"\""
-						<<std::endl;
-				os<<name<<" = "<<value<<"\n";
-			}
-		}
-		
-		return true;
-	}
+	Settings & operator += (const Settings &other);
+	Settings & operator = (const Settings &other);
 
-	/*
-		NOTE: Types of allowed_options are ignored
+	/***********************
+	 * Reading and writing *
+	 ***********************/
 
-		returns true on success
-	*/
+	// 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[],
-			core::map<std::string, ValueSpec> &allowed_options)
-	{
-		int i=1;
-		for(;;)
-		{
-			if(i >= argc)
-				break;
-			std::string argname = argv[i];
-			if(argname.substr(0, 2) != "--")
-			{
-				dstream<<"Invalid command-line parameter \""
-						<<argname<<"\": --<option> expected."<<std::endl;
-				return false;
-			}
-			i++;
-
-			std::string name = argname.substr(2);
-
-			core::map<std::string, ValueSpec>::Node *n;
-			n = allowed_options.find(name);
-			if(n == NULL)
-			{
-				dstream<<"Unknown command-line parameter \""
-						<<argname<<"\""<<std::endl;
-				return false;
-			}
-
-			ValueType type = n->getValue().type;
-
-			std::string value = "";
-			
-			if(type == VALUETYPE_FLAG)
-			{
-				value = "true";
-			}
-			else
-			{
-				if(i >= argc)
-				{
-					dstream<<"Invalid command-line parameter \""
-							<<name<<"\": missing value"<<std::endl;
-					return false;
-				}
-				value = argv[i];
-				i++;
-			}
-			
-
-			dstream<<"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_defaults.find(name));
-	}
-
-	std::string get(std::string name)
-	{
-		JMutexAutoLock lock(m_mutex);
-		
-		core::map<std::string, std::string>::Node *n;
-		n = m_settings.find(name);
-		if(n == NULL)
-		{
-			n = m_defaults.find(name);
-			if(n == NULL)
-			{
-				dstream<<"INFO: Settings: Setting not found: \""
-						<<name<<"\""<<std::endl;
-				throw SettingNotFoundException("Setting not found");
-			}
-		}
-
-		return n->getValue();
-	}
+			std::map<std::string, ValueSpec> &allowed_options);
+	bool parseConfigLines(std::istream &is, const std::string &end = "");
+	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;
+	const std::string &getDefault(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
+	std::vector<std::string> getNames() const;
+	bool exists(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 getDefaultNoEx(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 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_default);
+	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 setGroupDefault(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,
+		bool set_default=false);
+
+	// remove a setting
+	bool remove(const std::string &name);
+	void clear();
+	void clearDefaults();
+
+	/**************
+	 * Miscellany *
+	 **************/
+
+	void setDefault(const std::string &name, const FlagDesc *flagdesc, u32 flags);
+	// Takes the provided setting values and uses them as new defaults
+	void overrideDefaults(Settings *other);
+	const FlagDesc *getFlagDescFallback(const std::string &name) const;
+
+	void registerChangedCallback(const std::string &name,
+		SettingsChangedCallback cbf, void *userdata = NULL);
+	void deregisterChangedCallback(const std::string &name,
+		SettingsChangedCallback cbf, void *userdata = NULL);
+
+	void removeSecureSettings();
 
-	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);
-		
-		std::string s;
-		char templine[10];
-		std::cout<<question<<" ["<<def<<"]: ";
-		std::cin.getline(templine, 10);
-		s = templine;
-
-		if(s == "")
-			return def;
-
-		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;
-	}
+private:
+	/***********************
+	 * Reading and writing *
+	 ***********************/
 
-	u64 getU64(std::string name)
-	{
-		u64 value = 0;
-		std::string s = get(name);
-		std::istringstream ss(s);
-		ss>>value;
-		return value;
-	}
+	SettingsParseEvent parseConfigObject(const std::string &line,
+		const std::string &end, std::string &name, std::string &value);
+	bool updateConfigObject(std::istream &is, std::ostream &os,
+		const std::string &end, u32 tab_depth=0);
 
-	void setBool(std::string name, bool value)
-	{
-		if(value)
-			set(name, "true");
-		else
-			set(name, "false");
-	}
+	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);
 
-	void setS32(std::string name, s32 value)
-	{
-		set(name, itos(value));
-	}
+	/***********
+	 * Getters *
+	 ***********/
 
-	void setFloat(std::string name, float value)
-	{
-		set(name, ftos(value));
-	}
+	const SettingsEntry &getEntry(const std::string &name) const;
+	const SettingsEntry &getEntryDefault(const std::string &name) const;
 
-	void setV3F(std::string name, v3f value)
-	{
-		std::ostringstream os;
-		os<<"("<<value.X<<","<<value.Y<<","<<value.Z<<")";
-		set(name, os.str());
-	}
+	// Allow TestSettings to run sanity checks using private functions.
+	friend class TestSettings;
 
-	void setU64(std::string name, u64 value)
-	{
-		std::ostringstream os;
-		os<<value;
-		set(name, os.str());
-	}
+	void updateNoLock(const Settings &other);
+	void clearNoLock();
+	void clearDefaultsNoLock();
 
-	void clear()
-	{
-		JMutexAutoLock lock(m_mutex);
-		
-		m_settings.clear();
-		m_defaults.clear();
-	}
+	void doCallbacks(const std::string &name) const;
 
-	Settings & operator+=(Settings &other)
-	{
-		JMutexAutoLock lock(m_mutex);
-		JMutexAutoLock lock2(other.m_mutex);
-		
-		if(&other == this)
-			return *this;
-
-		for(core::map<std::string, std::string>::Iterator
-				i = other.m_settings.getIterator();
-				i.atEnd() == false; i++)
-		{
-			m_settings.insert(i.getNode()->getKey(),
-					i.getNode()->getValue());
-		}
-		
-		for(core::map<std::string, std::string>::Iterator
-				i = other.m_defaults.getIterator();
-				i.atEnd() == false; i++)
-		{
-			m_defaults.insert(i.getNode()->getKey(),
-					i.getNode()->getValue());
-		}
-
-		return *this;
+	SettingEntries m_settings;
+	SettingEntries m_defaults;
+	std::unordered_map<std::string, const FlagDesc *> m_flags;
 
-	}
+	SettingsCallbackMap m_callbacks;
 
-	Settings & operator=(Settings &other)
-	{
-		JMutexAutoLock lock(m_mutex);
-		JMutexAutoLock lock2(other.m_mutex);
-		
-		if(&other == this)
-			return *this;
-
-		clear();
-		(*this) += other;
-		
-		return *this;
-	}
+	mutable std::mutex m_callback_mutex;
 
-private:
-	core::map<std::string, std::string> m_settings;
-	core::map<std::string, std::string> m_defaults;
 	// All methods that access m_settings/m_defaults directly should lock this.
-	JMutex m_mutex;
-};
-
-#endif
+	mutable std::mutex m_mutex;
 
+};