aboutsummaryrefslogtreecommitdiffstats
path: root/libconfigcpp.c++
diff options
context:
space:
mode:
Diffstat (limited to 'libconfigcpp.c++')
-rw-r--r--libconfigcpp.c++1112
1 files changed, 0 insertions, 1112 deletions
diff --git a/libconfigcpp.c++ b/libconfigcpp.c++
deleted file mode 100644
index 82ad56e..0000000
--- a/libconfigcpp.c++
+++ /dev/null
@@ -1,1112 +0,0 @@
-/* ----------------------------------------------------------------------------
- libconfig - A library for processing structured configuration files
- Copyright (C) 2005-2009 Mark A Lindner
-
- This file is part of libconfig.
-
- This library is free software; you can redistribute it and/or
- modify 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 library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Library General Public
- License along with this library; if not, see
- <http://www.gnu.org/licenses/>.
- ----------------------------------------------------------------------------
-*/
-
-#include "libconfig.h++"
-
-#ifdef _MSC_VER
-#pragma warning (disable: 4996)
-#endif
-
-#include "wincompat.h"
-
-using namespace libconfig;
-
-#include <cstring>
-#include <cstdlib>
-#include <sstream>
-
-// ---------------------------------------------------------------------------
-
-ParseException::ParseException(int line, const char *error)
- : _line(line), _error(error)
-{
-}
-
-// ---------------------------------------------------------------------------
-
-ParseException::~ParseException() throw()
-{
-}
-
-// ---------------------------------------------------------------------------
-
-const char *ParseException::what() const throw()
-{
- return("ParseException");
-}
-
-// ---------------------------------------------------------------------------
-
-static int __toTypeCode(Setting::Type type)
-{
- int typecode;
-
- switch(type)
- {
- case Setting::TypeGroup:
- typecode = CONFIG_TYPE_GROUP;
- break;
-
- case Setting::TypeInt:
- typecode = CONFIG_TYPE_INT;
- break;
-
- case Setting::TypeInt64:
- typecode = CONFIG_TYPE_INT64;
- break;
-
- case Setting::TypeFloat:
- typecode = CONFIG_TYPE_FLOAT;
- break;
-
- case Setting::TypeString:
- typecode = CONFIG_TYPE_STRING;
- break;
-
- case Setting::TypeBoolean:
- typecode = CONFIG_TYPE_BOOL;
- break;
-
- case Setting::TypeArray:
- typecode = CONFIG_TYPE_ARRAY;
- break;
-
- case Setting::TypeList:
- typecode = CONFIG_TYPE_LIST;
- break;
-
- default:
- typecode = CONFIG_TYPE_NONE;
- }
-
- return(typecode);
-}
-
-// ---------------------------------------------------------------------------
-
-static void __constructPath(const Setting &setting,
- std::stringstream &path)
-{
- // head recursion to print path from root to target
-
- if(! setting.isRoot())
- {
- __constructPath(setting.getParent(), path);
- if(path.tellp() > 0)
- path << '.';
-
- const char *name = setting.getName();
- if(name)
- path << name;
- else
- path << '[' << setting.getIndex() << ']';
- }
-}
-
-// ---------------------------------------------------------------------------
-
-SettingException::SettingException(const Setting &setting)
-{
- std::stringstream sstr;
- __constructPath(setting, sstr);
-
- _path = ::strdup(sstr.str().c_str());
-}
-
-// ---------------------------------------------------------------------------
-
-SettingException::SettingException(const Setting &setting, int idx)
-{
- std::stringstream sstr;
- __constructPath(setting, sstr);
- sstr << ".[" << idx << "]";
-
- _path = ::strdup(sstr.str().c_str());
-}
-
-// ---------------------------------------------------------------------------
-
-SettingException::SettingException(const Setting &setting, const char *name)
-{
- std::stringstream sstr;
- __constructPath(setting, sstr);
- sstr << '.' << name;
-
- _path = ::strdup(sstr.str().c_str());
-}
-
-// ---------------------------------------------------------------------------
-
-SettingException::SettingException(const char *path)
-{
- _path = ::strdup(path);
-}
-
-// ---------------------------------------------------------------------------
-
-const char *SettingException::getPath() const
-{
- return(_path);
-}
-
-// ---------------------------------------------------------------------------
-
-SettingException::SettingException(const SettingException &other)
-{
- _path = ::strdup(other._path);
-}
-
-// ---------------------------------------------------------------------------
-
-SettingException &SettingException::operator=(const SettingException &other)
-{
- ::free(_path);
- _path = ::strdup(other._path);
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-const char *SettingException::what() const throw()
-{
- return("SettingException");
-}
-
-// ---------------------------------------------------------------------------
-
-SettingException::~SettingException() throw()
-{
- ::free(_path);
-}
-
-// ---------------------------------------------------------------------------
-
-SettingTypeException::SettingTypeException(const Setting &setting)
- : SettingException(setting)
-{
-}
-
-// ---------------------------------------------------------------------------
-
-SettingTypeException::SettingTypeException(const Setting &setting, int idx)
- : SettingException(setting, idx)
-{
-}
-
-// ---------------------------------------------------------------------------
-
-SettingTypeException::SettingTypeException(const Setting &setting,
- const char *name)
- : SettingException(setting, name)
-{
-}
-
-// ---------------------------------------------------------------------------
-
-const char *SettingTypeException::what() const throw()
-{
- return("SettingTypeException");
-}
-
-// ---------------------------------------------------------------------------
-
-SettingNotFoundException::SettingNotFoundException(const Setting &setting,
- int idx)
- : SettingException(setting, idx)
-{
-}
-
-// ---------------------------------------------------------------------------
-
-SettingNotFoundException::SettingNotFoundException(const Setting &setting,
- const char *name)
- : SettingException(setting, name)
-{
-}
-
-// ---------------------------------------------------------------------------
-
-SettingNotFoundException::SettingNotFoundException(const char *path)
- : SettingException(path)
-{
-}
-
-// ---------------------------------------------------------------------------
-
-const char *SettingNotFoundException::what() const throw()
-{
- return("SettingNotFoundException");
-}
-
-// ---------------------------------------------------------------------------
-
-SettingNameException::SettingNameException(const Setting &setting,
- const char *name)
- : SettingException(setting, name)
-{
-}
-
-// ---------------------------------------------------------------------------
-
-const char *SettingNameException::what() const throw()
-{
- return("SettingNameException");
-}
-
-// ---------------------------------------------------------------------------
-
-const char *FileIOException::what() const throw()
-{
- return("FileIOException");
-}
-
-// ---------------------------------------------------------------------------
-
-void Config::ConfigDestructor(void *arg)
-{
- delete reinterpret_cast<Setting *>(arg);
-}
-
-// ---------------------------------------------------------------------------
-
-Config::Config()
-{
- config_init(& _config);
- config_set_destructor(& _config, ConfigDestructor);
-}
-
-// ---------------------------------------------------------------------------
-
-Config::~Config()
-{
- config_destroy(& _config);
-}
-
-// ---------------------------------------------------------------------------
-
-void Config::setAutoConvert(bool flag)
-{
- config_set_auto_convert(& _config, (flag ? CONFIG_TRUE : CONFIG_FALSE));
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::getAutoConvert() const
-{
- return(config_get_auto_convert(& _config) != CONFIG_FALSE);
-}
-
-// ---------------------------------------------------------------------------
-
-void Config::read(FILE *stream) throw(ParseException)
-{
- if(! config_read(& _config, stream))
- throw ParseException(config_error_line(& _config),
- config_error_text(& _config));
-}
-
-// ---------------------------------------------------------------------------
-
-void Config::write(FILE *stream) const
-{
- config_write(& _config, stream);
-}
-
-// ---------------------------------------------------------------------------
-
-void Config::readFile(const char *filename) throw(FileIOException,
- ParseException)
-{
- FILE *f = fopen(filename, "rt");
- if(f == NULL)
- throw FileIOException();
- try
- {
- read(f);
- fclose(f);
- }
- catch(ParseException& p)
- {
- fclose(f);
- throw p;
- }
-}
-
-// ---------------------------------------------------------------------------
-
-void Config::writeFile(const char *filename) throw(FileIOException)
-{
- if(! config_write_file(& _config, filename))
- throw FileIOException();
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Config::lookup(const char *path) const
- throw(SettingNotFoundException)
-{
- config_setting_t *s = config_lookup(& _config, path);
- if(! s)
- throw SettingNotFoundException(path);
-
- return(Setting::wrapSetting(s));
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::exists(const char *path) const throw()
-{
- config_setting_t *s = config_lookup(& _config, path);
-
- return(s != NULL);
-}
-
-// ---------------------------------------------------------------------------
-
-#define CONFIG_LOOKUP_NO_EXCEPTIONS(P, T, V) \
- try \
- { \
- Setting &s = lookup(P); \
- V = (T)s; \
- return(true); \
- } \
- catch(ConfigException) \
- { \
- return(false); \
- }
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, bool &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, bool, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, long &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, long, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, unsigned long &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, unsigned long, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, int &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, int, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, unsigned int &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, unsigned int, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, long long &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, long long, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, unsigned long long &value)
- const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, unsigned long long, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, double &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, double, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, float &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, float, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, const char *&value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, const char *, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Config::lookupValue(const char *path, std::string &value) const throw()
-{
- CONFIG_LOOKUP_NO_EXCEPTIONS(path, const char *, value);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Config::getRoot() const
-{
- return(Setting::wrapSetting(config_root_setting(& _config)));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::Setting(config_setting_t *setting)
- : _setting(setting)
-{
- switch(config_setting_type(setting))
- {
- case CONFIG_TYPE_GROUP:
- _type = TypeGroup;
- break;
-
- case CONFIG_TYPE_INT:
- _type = TypeInt;
- break;
-
- case CONFIG_TYPE_INT64:
- _type = TypeInt64;
- break;
-
- case CONFIG_TYPE_FLOAT:
- _type = TypeFloat;
- break;
-
- case CONFIG_TYPE_STRING:
- _type = TypeString;
- break;
-
- case CONFIG_TYPE_BOOL:
- _type = TypeBoolean;
- break;
-
- case CONFIG_TYPE_ARRAY:
- _type = TypeArray;
- break;
-
- case CONFIG_TYPE_LIST:
- _type = TypeList;
- break;
-
- case CONFIG_TYPE_NONE:
- default:
- _type = TypeNone;
- break;
- }
-
- switch(config_setting_get_format(setting))
- {
- case CONFIG_FORMAT_HEX:
- _format = FormatHex;
- break;
-
- case CONFIG_FORMAT_DEFAULT:
- default:
- _format = FormatDefault;
- break;
- }
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::~Setting() throw()
-{
- _setting = NULL;
-}
-
-// ---------------------------------------------------------------------------
-
-void Setting::setFormat(Format format) throw()
-{
- if((_type == TypeInt) || (_type == TypeInt64))
- {
- if(format == FormatHex)
- _format = FormatHex;
- else
- _format = FormatDefault;
- }
- else
- _format = FormatDefault;
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator bool() const throw(SettingTypeException)
-{
- assertType(TypeBoolean);
-
- return(config_setting_get_bool(_setting) ? true : false);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator long() const throw(SettingTypeException)
-{
- assertType(TypeInt);
-
- return(config_setting_get_int(_setting));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator unsigned long() const throw(SettingTypeException)
-{
- assertType(TypeInt);
-
- long v = config_setting_get_int(_setting);
-
- if(v < 0)
- v = 0;
-
- return(static_cast<unsigned long>(v));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator int() const throw(SettingTypeException)
-{
- assertType(TypeInt);
-
- // may cause loss of precision:
- return(static_cast<int>(config_setting_get_int(_setting)));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator unsigned int() const throw(SettingTypeException)
-{
- assertType(TypeInt);
-
- long v = config_setting_get_int(_setting);
-
- if(v < 0)
- v = 0;
-
- return(static_cast<unsigned int>(v));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator long long() const throw(SettingTypeException)
-{
- assertType(TypeInt64);
-
- return(config_setting_get_int64(_setting));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator unsigned long long() const throw(SettingTypeException)
-{
- assertType(TypeInt64);
-
- long long v = config_setting_get_int64(_setting);
-
- if(v < INT64_CONST(0))
- v = INT64_CONST(0);
-
- return(static_cast<unsigned long long>(v));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator double() const throw(SettingTypeException)
-{
- assertType(TypeFloat);
-
- return(config_setting_get_float(_setting));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator float() const throw(SettingTypeException)
-{
- assertType(TypeFloat);
-
- // may cause loss of precision:
- return(static_cast<float>(config_setting_get_float(_setting)));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator const char *() const throw(SettingTypeException)
-{
- assertType(TypeString);
-
- return(config_setting_get_string(_setting));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting::operator std::string() const throw(SettingTypeException)
-{
- assertType(TypeString);
-
- const char *s = config_setting_get_string(_setting);
-
- std::string str;
- if(s)
- str = s;
-
- return(str);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator=(bool value) throw(SettingTypeException)
-{
- assertType(TypeBoolean);
-
- config_setting_set_bool(_setting, value);
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator=(long value) throw(SettingTypeException)
-{
- assertType(TypeInt);
-
- config_setting_set_int(_setting, value);
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator=(int value) throw(SettingTypeException)
-{
- assertType(TypeInt);
-
- long cvalue = static_cast<long>(value);
-
- config_setting_set_int(_setting, cvalue);
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator=(const long long &value)
- throw(SettingTypeException)
-{
- assertType(TypeInt64);
-
- config_setting_set_int64(_setting, value);
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator=(const double &value) throw(SettingTypeException)
-{
- assertType(TypeFloat);
-
- config_setting_set_float(_setting, value);
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator=(float value) throw(SettingTypeException)
-{
- assertType(TypeFloat);
-
- double cvalue = static_cast<double>(value);
-
- config_setting_set_float(_setting, cvalue);
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator=(const char *value) throw(SettingTypeException)
-{
- assertType(TypeString);
-
- config_setting_set_string(_setting, value);
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator=(const std::string &value)
- throw(SettingTypeException)
-{
- assertType(TypeString);
-
- config_setting_set_string(_setting, value.c_str());
-
- return(*this);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator[](int i) const
- throw(SettingTypeException, SettingNotFoundException)
-{
- if((_type != TypeArray) && (_type != TypeGroup) && (_type != TypeList))
- throw SettingTypeException(*this, i);
-
- config_setting_t *setting = config_setting_get_elem(_setting, i);
-
- if(! setting)
- throw SettingNotFoundException(*this, i);
-
- return(wrapSetting(setting));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::operator[](const char *key) const
- throw(SettingTypeException, SettingNotFoundException)
-{
- assertType(TypeGroup);
-
- config_setting_t *setting = config_setting_get_member(_setting, key);
-
- if(! setting)
- throw SettingNotFoundException(*this, key);
-
- return(wrapSetting(setting));
-}
-
-// ---------------------------------------------------------------------------
-
-#define SETTING_LOOKUP_NO_EXCEPTIONS(K, T, V) \
- try \
- { \
- Setting &s = operator[](K); \
- V = (T)s; \
- return(true); \
- } \
- catch(ConfigException) \
- { \
- return(false); \
- }
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, bool &value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, bool, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, long &value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, long, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, unsigned long &value)
- const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, unsigned long, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, int &value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, int, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, unsigned int &value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, unsigned int, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, long long &value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, long long, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, unsigned long long &value)
- const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, unsigned long long, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, double &value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, double, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, float &value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, float, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, const char *&value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, const char *, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::lookupValue(const char *name, std::string &value) const throw()
-{
- SETTING_LOOKUP_NO_EXCEPTIONS(name, const char *, value);
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::exists(const char *name) const throw()
-{
- if(_type != TypeGroup)
- return(false);
-
- config_setting_t *setting = config_setting_get_member(_setting, name);
-
- return(setting != NULL);
-}
-
-// ---------------------------------------------------------------------------
-
-int Setting::getLength() const throw()
-{
- return(config_setting_length(_setting));
-}
-
-// ---------------------------------------------------------------------------
-
-const char * Setting::getName() const throw()
-{
- return(config_setting_name(_setting));
-}
-
-// ---------------------------------------------------------------------------
-
-std::string Setting::getPath() const
-{
- std::stringstream path;
-
- __constructPath(*this, path);
-
- return(path.str());
-}
-
-// ---------------------------------------------------------------------------
-
-const Setting & Setting::getParent() const throw(SettingNotFoundException)
-{
- config_setting_t *setting = config_setting_parent(_setting);
-
- if(! setting)
- throw SettingNotFoundException(NULL);
-
- return(wrapSetting(setting));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::getParent() throw(SettingNotFoundException)
-{
- config_setting_t *setting = config_setting_parent(_setting);
-
- if(! setting)
- throw SettingNotFoundException(NULL);
-
- return(wrapSetting(setting));
-}
-
-// ---------------------------------------------------------------------------
-
-bool Setting::isRoot() const throw()
-{
- return(config_setting_is_root(_setting));
-}
-
-// ---------------------------------------------------------------------------
-
-int Setting::getIndex() const throw()
-{
- return(config_setting_index(_setting));
-}
-
-// ---------------------------------------------------------------------------
-
-void Setting::remove(const char *name)
- throw(SettingTypeException, SettingNotFoundException)
-{
- assertType(TypeGroup);
-
- if(! config_setting_remove(_setting, name))
- throw SettingNotFoundException(*this, name);
-}
-
-// ---------------------------------------------------------------------------
-
-void Setting::remove(unsigned int idx)
- throw(SettingTypeException, SettingNotFoundException)
-{
- if((_type != TypeArray) && (_type != TypeGroup) && (_type != TypeList))
- throw SettingTypeException(*this, idx);
-
- if(! config_setting_remove_elem(_setting, idx))
- throw SettingNotFoundException(*this, idx);
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::add(const char *name, Setting::Type type)
- throw(SettingNameException, SettingTypeException)
-{
- assertType(TypeGroup);
-
- int typecode = __toTypeCode(type);
-
- if(typecode == CONFIG_TYPE_NONE)
- throw SettingTypeException(*this, name);
-
- config_setting_t *setting = config_setting_add(_setting, name, typecode);
-
- if(! setting)
- throw SettingNameException(*this, name);
-
- return(wrapSetting(setting));
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::add(Setting::Type type) throw(SettingTypeException)
-{
- if((_type != TypeArray) && (_type != TypeList))
- throw SettingTypeException(*this);
-
- if(_type == TypeArray)
- {
- int idx = getLength();
-
- if(idx > 0)
- {
- Setting::Type atype = operator[](0).getType();
- if(type != atype)
- throw SettingTypeException(*this, idx);
- }
- else
- {
- if((type != TypeInt) && (type != TypeFloat) && (type != TypeString)
- && (type != TypeBoolean))
- throw SettingTypeException(*this, idx);
- }
- }
-
- int typecode = __toTypeCode(type);
- config_setting_t *s = config_setting_add(_setting, NULL, typecode);
-
- Setting &ns = wrapSetting(s);
-
- switch(type)
- {
- case TypeInt:
- ns = 0;
- break;
-
- case TypeInt64:
- ns = INT64_CONST(0);
- break;
-
- case TypeFloat:
- ns = 0.0;
- break;
-
- case TypeString:
- ns = (char *)NULL;
- break;
-
- case TypeBoolean:
- ns = false;
- break;
-
- default:
- // won't happen
- break;
- }
-
- return(ns);
-}
-
-// ---------------------------------------------------------------------------
-
-void Setting::assertType(Setting::Type type) const throw(SettingTypeException)
-{
- if(type != _type)
- {
- if(!(isNumber() && config_get_auto_convert(_setting->config)
- && ((type == TypeInt) || (type == TypeFloat))))
- throw SettingTypeException(*this);
- }
-}
-
-// ---------------------------------------------------------------------------
-
-Setting & Setting::wrapSetting(config_setting_t *s)
-{
- Setting *setting = NULL;
-
- void *hook = config_setting_get_hook(s);
- if(! hook)
- {
- setting = new Setting(s);
- config_setting_set_hook(s, reinterpret_cast<void *>(setting));
- }
- else
- setting = reinterpret_cast<Setting *>(hook);
-
- return(*setting);
-}
-
-// ---------------------------------------------------------------------------
-// eof