2011-10-12 12:53:38 +02:00
|
|
|
/*
|
2013-02-24 18:40:43 +01:00
|
|
|
Minetest
|
2013-02-24 19:38:45 +01:00
|
|
|
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2011-10-12 12:53:38 +02:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 16:56:56 +02:00
|
|
|
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
|
2011-10-12 12:53:38 +02:00
|
|
|
(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
|
2012-06-05 16:56:56 +02:00
|
|
|
GNU Lesser General Public License for more details.
|
2011-10-12 12:53:38 +02:00
|
|
|
|
2012-06-05 16:56:56 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2011-10-12 12:53:38 +02:00
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2017-08-17 22:19:39 +02:00
|
|
|
#pragma once
|
2011-10-12 12:53:38 +02:00
|
|
|
|
2012-06-17 03:00:31 +02:00
|
|
|
#include "irrlichttypes_bloated.h"
|
2012-06-17 01:40:36 +02:00
|
|
|
#include "util/string.h"
|
2021-06-23 15:22:31 +02:00
|
|
|
#include "util/basic_macros.h"
|
2014-09-12 00:22:05 +02:00
|
|
|
#include <string>
|
|
|
|
#include <list>
|
2012-12-20 18:19:49 +01:00
|
|
|
#include <set>
|
2017-06-06 16:29:28 +02:00
|
|
|
#include <mutex>
|
2011-10-12 12:53:38 +02:00
|
|
|
|
2014-11-30 21:49:04 +01:00
|
|
|
class Settings;
|
2014-12-02 09:58:57 +01:00
|
|
|
struct NoiseParams;
|
2014-11-30 21:49:04 +01:00
|
|
|
|
2015-04-01 15:01:28 +02:00
|
|
|
// Global objects
|
2020-11-22 17:49:30 +01:00
|
|
|
extern Settings *g_settings; // Same as Settings::getLayer(SL_GLOBAL);
|
2015-04-01 15:01:28 +02:00
|
|
|
extern std::string g_settings_path;
|
|
|
|
|
2016-06-11 06:10:25 +02:00
|
|
|
// Type for a settings changed callback function
|
|
|
|
typedef void (*SettingsChangedCallback)(const std::string &name, void *data);
|
|
|
|
|
|
|
|
typedef std::vector<
|
|
|
|
std::pair<
|
|
|
|
SettingsChangedCallback,
|
|
|
|
void *
|
|
|
|
>
|
|
|
|
> SettingsCallbackList;
|
|
|
|
|
2017-06-04 21:00:04 +02:00
|
|
|
typedef std::unordered_map<std::string, SettingsCallbackList> SettingsCallbackMap;
|
2014-11-30 21:49:04 +01:00
|
|
|
|
|
|
|
enum ValueType {
|
2011-10-12 12:53:38 +02:00
|
|
|
VALUETYPE_STRING,
|
|
|
|
VALUETYPE_FLAG // Doesn't take any arguments
|
|
|
|
};
|
|
|
|
|
2014-11-30 21:49:04 +01:00
|
|
|
enum SettingsParseEvent {
|
|
|
|
SPE_NONE,
|
|
|
|
SPE_INVALID,
|
|
|
|
SPE_COMMENT,
|
|
|
|
SPE_KVPAIR,
|
|
|
|
SPE_END,
|
|
|
|
SPE_GROUP,
|
|
|
|
SPE_MULTILINE,
|
|
|
|
};
|
|
|
|
|
2021-06-23 15:22:31 +02:00
|
|
|
// Describes the global setting layers, SL_GLOBAL is where settings are read from
|
2020-11-22 17:49:30 +01:00
|
|
|
enum SettingsLayer {
|
|
|
|
SL_DEFAULTS,
|
|
|
|
SL_GAME,
|
|
|
|
SL_GLOBAL,
|
|
|
|
SL_TOTAL_COUNT
|
|
|
|
};
|
|
|
|
|
2021-06-23 15:22:31 +02:00
|
|
|
// Implements the hierarchy a settings object may be part of
|
|
|
|
class SettingsHierarchy {
|
|
|
|
public:
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
DISABLE_CLASS_COPY(SettingsHierarchy)
|
|
|
|
|
|
|
|
Settings *getLayer(int layer) const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
friend class Settings;
|
|
|
|
Settings *getParent(int layer) const;
|
|
|
|
void onLayerCreated(int layer, Settings *obj);
|
|
|
|
void onLayerRemoved(int layer);
|
|
|
|
|
|
|
|
std::vector<Settings*> layers;
|
|
|
|
};
|
|
|
|
|
2014-11-30 21:49:04 +01:00
|
|
|
struct ValueSpec {
|
2011-10-12 12:53:38 +02:00
|
|
|
ValueSpec(ValueType a_type, const char *a_help=NULL)
|
|
|
|
{
|
|
|
|
type = a_type;
|
|
|
|
help = a_help;
|
|
|
|
}
|
2014-12-10 05:52:13 +01:00
|
|
|
|
2011-10-12 12:53:38 +02:00
|
|
|
ValueType type;
|
|
|
|
const char *help;
|
|
|
|
};
|
|
|
|
|
2014-11-30 21:49:04 +01:00
|
|
|
struct SettingsEntry {
|
2017-08-19 14:25:35 +02:00
|
|
|
SettingsEntry() = default;
|
2017-04-21 10:06:08 +02:00
|
|
|
|
|
|
|
SettingsEntry(const std::string &value_) :
|
2017-06-21 11:51:29 +02:00
|
|
|
value(value_)
|
2017-04-21 10:06:08 +02:00
|
|
|
{}
|
|
|
|
|
|
|
|
SettingsEntry(Settings *group_) :
|
|
|
|
group(group_),
|
|
|
|
is_group(true)
|
|
|
|
{}
|
2014-11-30 21:49:04 +01:00
|
|
|
|
2017-06-21 11:51:29 +02:00
|
|
|
std::string value = "";
|
|
|
|
Settings *group = nullptr;
|
|
|
|
bool is_group = false;
|
2014-11-30 21:49:04 +01:00
|
|
|
};
|
|
|
|
|
2017-06-04 21:00:04 +02:00
|
|
|
typedef std::unordered_map<std::string, SettingsEntry> SettingEntries;
|
2016-10-05 09:03:55 +02:00
|
|
|
|
2014-11-30 21:49:04 +01:00
|
|
|
class Settings {
|
2011-10-12 12:53:38 +02:00
|
|
|
public:
|
2021-06-23 15:22:31 +02:00
|
|
|
/* These functions operate on the global hierarchy! */
|
2020-11-22 17:49:30 +01:00
|
|
|
static Settings *createLayer(SettingsLayer sl, const std::string &end_tag = "");
|
|
|
|
static Settings *getLayer(SettingsLayer sl);
|
2021-06-23 15:22:31 +02:00
|
|
|
/**/
|
2017-08-19 14:25:35 +02:00
|
|
|
|
2020-11-22 17:49:30 +01:00
|
|
|
Settings(const std::string &end_tag = "") :
|
|
|
|
m_end_tag(end_tag)
|
|
|
|
{}
|
2021-06-23 15:22:31 +02:00
|
|
|
Settings(const std::string &end_tag, SettingsHierarchy *h, int settings_layer);
|
2014-11-30 21:49:04 +01:00
|
|
|
~Settings();
|
2011-10-12 12:53:38 +02:00
|
|
|
|
2014-09-12 00:22:05 +02:00
|
|
|
Settings & operator += (const Settings &other);
|
|
|
|
Settings & operator = (const Settings &other);
|
2011-10-12 12:53:38 +02:00
|
|
|
|
2014-09-12 00:22:05 +02:00
|
|
|
/***********************
|
|
|
|
* Reading and writing *
|
|
|
|
***********************/
|
2011-10-12 12:53:38 +02:00
|
|
|
|
2014-09-12 00:22:05 +02:00
|
|
|
// 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.
|
2011-10-12 12:53:38 +02:00
|
|
|
bool parseCommandLine(int argc, char *argv[],
|
2014-09-12 00:22:05 +02:00
|
|
|
std::map<std::string, ValueSpec> &allowed_options);
|
2020-11-22 17:49:30 +01:00
|
|
|
bool parseConfigLines(std::istream &is);
|
2014-11-30 21:49:04 +01:00
|
|
|
void writeLines(std::ostream &os, u32 tab_depth=0) const;
|
2014-09-12 00:22:05 +02:00
|
|
|
|
|
|
|
/***********
|
|
|
|
* Getters *
|
|
|
|
***********/
|
|
|
|
|
2014-11-30 21:49:04 +01:00
|
|
|
Settings *getGroup(const std::string &name) const;
|
2017-03-22 21:41:02 +01:00
|
|
|
const std::string &get(const std::string &name) const;
|
2014-09-12 00:22:05 +02:00
|
|
|
bool getBool(const std::string &name) const;
|
|
|
|
u16 getU16(const std::string &name) const;
|
|
|
|
s16 getS16(const std::string &name) const;
|
2017-07-18 21:39:55 +02:00
|
|
|
u32 getU32(const std::string &name) const;
|
2014-09-12 00:22:05 +02:00
|
|
|
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;
|
2014-09-11 19:42:21 +02:00
|
|
|
u32 getFlagStr(const std::string &name, const FlagDesc *flagdesc,
|
2014-09-12 00:22:05 +02:00
|
|
|
u32 *flagmask) const;
|
2014-12-02 09:58:57 +01:00
|
|
|
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;
|
2014-02-04 04:40:57 +01:00
|
|
|
|
2022-01-09 21:15:35 +01:00
|
|
|
// return all keys used in this object
|
2014-09-12 00:22:05 +02:00
|
|
|
std::vector<std::string> getNames() const;
|
2022-01-09 21:15:35 +01:00
|
|
|
// check if setting exists anywhere in the hierarchy
|
2014-09-12 00:22:05 +02:00
|
|
|
bool exists(const std::string &name) const;
|
2022-01-09 21:15:35 +01:00
|
|
|
// check if setting exists in this object ("locally")
|
|
|
|
bool existsLocal(const std::string &name) const;
|
2014-09-12 00:22:05 +02:00
|
|
|
|
|
|
|
|
|
|
|
/***************************************
|
|
|
|
* Getters that don't throw exceptions *
|
|
|
|
***************************************/
|
|
|
|
|
2014-11-30 21:49:04 +01:00
|
|
|
bool getGroupNoEx(const std::string &name, Settings *&val) const;
|
2014-09-12 00:22:05 +02:00
|
|
|
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;
|
2021-07-31 19:54:40 +02:00
|
|
|
bool getU32NoEx(const std::string &name, u32 &val) const;
|
2014-09-12 00:22:05 +02:00
|
|
|
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;
|
2020-01-25 16:56:54 +01:00
|
|
|
|
|
|
|
// 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;
|
2014-09-12 00:22:05 +02:00
|
|
|
|
|
|
|
|
|
|
|
/***********
|
|
|
|
* Setters *
|
|
|
|
***********/
|
|
|
|
|
2014-11-30 21:49:04 +01:00
|
|
|
// N.B. Groups not allocated with new must be set to NULL in the settings
|
|
|
|
// tree before object destruction.
|
2014-12-12 06:44:17 +01:00
|
|
|
bool setEntry(const std::string &name, const void *entry,
|
2020-11-22 17:49:30 +01:00
|
|
|
bool set_group);
|
2014-12-12 06:44:17 +01:00
|
|
|
bool set(const std::string &name, const std::string &value);
|
|
|
|
bool setDefault(const std::string &name, const std::string &value);
|
2020-09-22 18:40:34 +02:00
|
|
|
bool setGroup(const std::string &name, const Settings &group);
|
2014-12-12 06:44:17 +01:00
|
|
|
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,
|
2020-01-25 16:56:54 +01:00
|
|
|
const FlagDesc *flagdesc = nullptr, u32 flagmask = U32_MAX);
|
2020-11-22 17:49:30 +01:00
|
|
|
bool setNoiseParams(const std::string &name, const NoiseParams &np);
|
2014-02-08 23:50:26 +01:00
|
|
|
|
2014-09-12 00:22:05 +02:00
|
|
|
// remove a setting
|
|
|
|
bool remove(const std::string &name);
|
2011-10-12 12:53:38 +02:00
|
|
|
|
2021-06-23 15:22:31 +02:00
|
|
|
/*****************
|
|
|
|
* Miscellaneous *
|
|
|
|
*****************/
|
2020-01-25 16:56:54 +01:00
|
|
|
|
|
|
|
void setDefault(const std::string &name, const FlagDesc *flagdesc, u32 flags);
|
|
|
|
const FlagDesc *getFlagDescFallback(const std::string &name) const;
|
|
|
|
|
2016-06-11 06:10:25 +02:00
|
|
|
void registerChangedCallback(const std::string &name,
|
|
|
|
SettingsChangedCallback cbf, void *userdata = NULL);
|
|
|
|
void deregisterChangedCallback(const std::string &name,
|
|
|
|
SettingsChangedCallback cbf, void *userdata = NULL);
|
2014-09-11 20:23:04 +02:00
|
|
|
|
2020-10-06 13:10:37 +02:00
|
|
|
void removeSecureSettings();
|
|
|
|
|
2021-06-23 15:22:31 +02:00
|
|
|
// 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; }
|
|
|
|
|
2016-06-11 06:10:25 +02:00
|
|
|
private:
|
2020-09-20 12:52:35 +02:00
|
|
|
/***********************
|
|
|
|
* Reading and writing *
|
|
|
|
***********************/
|
|
|
|
|
|
|
|
SettingsParseEvent parseConfigObject(const std::string &line,
|
2020-11-22 17:49:30 +01:00
|
|
|
std::string &name, std::string &value);
|
2020-09-20 12:52:35 +02:00
|
|
|
bool updateConfigObject(std::istream &is, std::ostream &os,
|
2020-11-22 17:49:30 +01:00
|
|
|
u32 tab_depth=0);
|
2020-09-20 12:52:35 +02:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
/***********
|
|
|
|
* Getters *
|
|
|
|
***********/
|
2020-11-22 17:49:30 +01:00
|
|
|
Settings *getParent() const;
|
2020-09-20 12:52:35 +02:00
|
|
|
|
|
|
|
const SettingsEntry &getEntry(const std::string &name) const;
|
|
|
|
|
|
|
|
// Allow TestSettings to run sanity checks using private functions.
|
|
|
|
friend class TestSettings;
|
2021-01-20 16:58:59 +01:00
|
|
|
// For sane mutex locking when iterating
|
|
|
|
friend class LuaSettings;
|
2020-09-20 12:52:35 +02:00
|
|
|
|
2014-09-12 00:22:05 +02:00
|
|
|
void updateNoLock(const Settings &other);
|
|
|
|
void clearNoLock();
|
2015-03-13 04:35:34 +01:00
|
|
|
void clearDefaultsNoLock();
|
2014-09-11 20:23:04 +02:00
|
|
|
|
2016-06-11 06:10:25 +02:00
|
|
|
void doCallbacks(const std::string &name) const;
|
2014-09-11 20:23:04 +02:00
|
|
|
|
2016-10-05 09:03:55 +02:00
|
|
|
SettingEntries m_settings;
|
2016-06-11 06:10:25 +02:00
|
|
|
SettingsCallbackMap m_callbacks;
|
2020-11-22 17:49:30 +01:00
|
|
|
std::string m_end_tag;
|
2016-06-11 06:10:25 +02:00
|
|
|
|
2017-06-06 16:29:28 +02:00
|
|
|
mutable std::mutex m_callback_mutex;
|
2015-01-24 10:40:27 +01:00
|
|
|
|
2016-06-11 06:10:25 +02:00
|
|
|
// All methods that access m_settings/m_defaults directly should lock this.
|
2017-06-06 16:29:28 +02:00
|
|
|
mutable std::mutex m_mutex;
|
2015-01-24 10:40:27 +01:00
|
|
|
|
2021-06-23 15:22:31 +02:00
|
|
|
SettingsHierarchy *m_hierarchy = nullptr;
|
|
|
|
int m_settingslayer = -1;
|
|
|
|
|
2020-11-22 17:49:30 +01:00
|
|
|
static std::unordered_map<std::string, const FlagDesc *> s_flags;
|
2011-10-12 12:53:38 +02:00
|
|
|
};
|