#define SETTINGS_HEADER
#include "irrlichttypes_bloated.h"
+#include "exceptions.h"
#include <string>
-#include <jthread.h>
-#include <jmutex.h>
-#include <jmutexautolock.h>
+#include "jthread/jmutex.h"
+#include "jthread/jmutexautolock.h"
#include "strfnd.h"
#include <iostream>
#include <fstream>
#include <list>
#include <map>
#include <set>
+#include "filesys.h"
enum ValueType
{
public:
Settings()
{
- m_mutex.Init();
}
void writeLines(std::ostream &os)
}
}
- // return all keys used
+ // return all keys used
std::vector<std::string> getNames(){
std::vector<std::string> names;
for(std::map<std::string, std::string>::iterator
{
names.push_back(i->first);
}
- return names;
+ return names;
}
// remove a setting
// Write stuff back
{
- std::ofstream os(filename);
- if(os.good() == false)
- {
- errorstream<<"Error opening configuration file"
- " for writing: \""
- <<filename<<"\""<<std::endl;
- return false;
- }
+ std::ostringstream ss(std::ios_base::binary);
/*
Write updated stuff
i = objects.begin();
i != objects.end(); ++i)
{
- os<<(*i);
+ ss<<(*i);
}
/*
std::string value = i->second;
infostream<<"Adding \""<<name<<"\" = \""<<value<<"\""
<<std::endl;
- os<<name<<" = "<<value<<"\n";
+ ss<<name<<" = "<<value<<"\n";
+ }
+
+ if(!fs::safeWriteToFile(filename, ss.str()))
+ {
+ errorstream<<"Error writing configuration file: \""
+ <<filename<<"\""<<std::endl;
+ return false;
}
}
return n->second;
}
+ //////////// Get setting
bool getBool(std::string name)
{
return is_yes(get(name));
return value;
}
- u32 getFlagStr(std::string name, FlagDesc *flagdesc)
+ u32 getFlagStr(std::string name, FlagDesc *flagdesc, u32 *flagmask)
{
std::string val = get(name);
- return (isdigit(val[0])) ? stoi(val) : readFlagString(val, flagdesc);
+ return (isdigit(val[0])) ? stoi(val) :
+ readFlagString(val, flagdesc, flagmask);
}
- template <class T> T *getStruct(std::string name, std::string format)
+ // 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)
{
- size_t len = sizeof(T);
+ size_t len = olen;
std::vector<std::string *> strs_alloced;
- std::string *str;
- std::string valstr = get(name);
- char *s = &valstr[0];
- T *buf = new T;
- char *bufpos = (char *)buf;
+ std::string *str, valstr;
char *f, *snext;
size_t pos;
+ try {
+ valstr = get(name);
+ } catch (SettingNotFoundException &e) {
+ return false;
+ }
+
+ char *s = &valstr[0];
+ char *buf = new char[len];
+ char *bufpos = buf;
+
char *fmtpos, *fmt = &format[0];
while ((f = strtok_r(fmt, ",", &fmtpos)) && s) {
fmt = NULL;
case 'i':
if (width == 16) {
bufpos += PADDING(bufpos, u16);
- if ((bufpos - (char *)buf) + sizeof(u16) <= len) {
+ if ((bufpos - buf) + sizeof(u16) <= len) {
if (is_unsigned)
*(u16 *)bufpos = (u16)strtoul(s, &s, 10);
else
bufpos += sizeof(u16);
} else if (width == 32) {
bufpos += PADDING(bufpos, u32);
- if ((bufpos - (char *)buf) + sizeof(u32) <= len) {
+ if ((bufpos - buf) + sizeof(u32) <= len) {
if (is_unsigned)
*(u32 *)bufpos = (u32)strtoul(s, &s, 10);
else
bufpos += sizeof(u32);
} else if (width == 64) {
bufpos += PADDING(bufpos, u64);
- if ((bufpos - (char *)buf) + sizeof(u64) <= len) {
+ if ((bufpos - buf) + sizeof(u64) <= len) {
if (is_unsigned)
*(u64 *)bufpos = (u64)strtoull(s, &s, 10);
else
*snext++ = 0;
bufpos += PADDING(bufpos, bool);
- if ((bufpos - (char *)buf) + sizeof(bool) <= len)
+ if ((bufpos - buf) + sizeof(bool) <= len)
*(bool *)bufpos = is_yes(std::string(s));
bufpos += sizeof(bool);
break;
case 'f':
bufpos += PADDING(bufpos, float);
- if ((bufpos - (char *)buf) + sizeof(float) <= len)
+ if ((bufpos - buf) + sizeof(float) <= len)
*(float *)bufpos = strtof(s, &s);
bufpos += sizeof(float);
while ((pos = str->find("\\\"", pos)) != std::string::npos)
str->erase(pos, 1);
- if ((bufpos - (char *)buf) + sizeof(std::string *) <= len)
+ if ((bufpos - buf) + sizeof(std::string *) <= len)
*(std::string **)bufpos = str;
bufpos += sizeof(std::string *);
strs_alloced.push_back(str);
if (width == 2) {
bufpos += PADDING(bufpos, v2f);
- if ((bufpos - (char *)buf) + sizeof(v2f) <= len) {
+ if ((bufpos - buf) + sizeof(v2f) <= len) {
v2f *v = (v2f *)bufpos;
v->X = strtof(s, &s);
s++;
bufpos += sizeof(v2f);
} else if (width == 3) {
bufpos += PADDING(bufpos, v3f);
- if ((bufpos - (char *)buf) + sizeof(v3f) <= len) {
+ if ((bufpos - buf) + sizeof(v3f) <= len) {
v3f *v = (v3f *)bufpos;
v->X = strtof(s, &s);
s++;
if (s && *s == ',')
s++;
- if ((size_t)(bufpos - (char *)buf) > len) //error, buffer too small
+ if ((size_t)(bufpos - buf) > len) //error, buffer too small
goto fail;
}
if (f && *f) { //error, mismatched number of fields and values
fail:
- for (unsigned int i = 0; i != strs_alloced.size(); i++)
+ for (size_t i = 0; i != strs_alloced.size(); i++)
delete strs_alloced[i];
- delete buf;
- //delete[] buf;
- buf = NULL;
+ delete[] buf;
+ return false;
+ }
+
+ memcpy(out, buf, olen);
+ delete[] buf;
+ 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;
}
+ }
- return buf;
+ 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)
{
char sbuf[2048];
set(name, std::string(sbuf));
return true;
}
-
- void setFlagStr(std::string name, u32 flags, FlagDesc *flagdesc)
+
+ void setFlagStr(std::string name, u32 flags,
+ FlagDesc *flagdesc, u32 flagmask)
{
- set(name, writeFlagString(flags, flagdesc));
+ set(name, writeFlagString(flags, flagdesc, flagmask));
}
void setBool(std::string name, bool value)
projects / minetest.git / blobdiff