diff options
Diffstat (limited to 'lib/libconfig.h++')
| -rw-r--r-- | lib/libconfig.h++ | 574 |
1 files changed, 574 insertions, 0 deletions
diff --git a/lib/libconfig.h++ b/lib/libconfig.h++ new file mode 100644 index 0000000..18578fa --- /dev/null +++ b/lib/libconfig.h++ @@ -0,0 +1,574 @@ +/* ---------------------------------------------------------------------------- + libconfig - A library for processing structured configuration files + Copyright (C) 2005-2018 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/>. + ---------------------------------------------------------------------------- +*/ + +#ifndef __libconfig_hpp +#define __libconfig_hpp + +#include <stdio.h> +#include <exception> +#include <string> + +#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +#if defined(LIBCONFIGXX_STATIC) +#define LIBCONFIGXX_API +#elif defined(LIBCONFIGXX_EXPORTS) +#define LIBCONFIGXX_API __declspec(dllexport) +#else /* ! LIBCONFIGXX_EXPORTS */ +#define LIBCONFIGXX_API __declspec(dllimport) +#endif /* LIBCONFIGXX_STATIC */ +#else /* ! WIN32 */ +#define LIBCONFIGXX_API +#endif /* WIN32 */ + +#define LIBCONFIGXX_VER_MAJOR 1 +#define LIBCONFIGXX_VER_MINOR 7 +#define LIBCONFIGXX_VER_REVISION 0 + +#if __cplusplus < 201103L +#define LIBCONFIGXX_NOEXCEPT throw() +#else +#define LIBCONFIGXX_NOEXCEPT noexcept +#endif + +struct config_t; // fwd decl +struct config_setting_t; // fwd decl + +namespace libconfig { + +class LIBCONFIGXX_API ConfigException : public std::exception { }; + +class Setting; // fwd decl +class SettingIterator; +class SettingConstIterator; + +class LIBCONFIGXX_API SettingException : public ConfigException +{ + public: + + SettingException(const Setting &setting); + SettingException(const Setting &setting, int idx); + SettingException(const Setting &setting, const char *name); + SettingException(const char *path); + + SettingException(const SettingException &other); + SettingException& operator=(const SettingException &other); + + virtual ~SettingException() LIBCONFIGXX_NOEXCEPT; + + const char *getPath() const; + + virtual const char *what() const LIBCONFIGXX_NOEXCEPT; + + private: + + char *_path; +}; + +class LIBCONFIGXX_API SettingTypeException : public SettingException +{ + public: + + SettingTypeException(const Setting &setting); + SettingTypeException(const Setting &setting, int idx); + SettingTypeException(const Setting &setting, const char *name); + + virtual const char *what() const LIBCONFIGXX_NOEXCEPT; +}; + +class LIBCONFIGXX_API SettingNotFoundException : public SettingException +{ + public: + + SettingNotFoundException(const char *path); + SettingNotFoundException(const Setting &setting, int idx); + SettingNotFoundException(const Setting &setting, const char *name); + + virtual const char *what() const LIBCONFIGXX_NOEXCEPT; +}; + +class LIBCONFIGXX_API SettingNameException : public SettingException +{ + public: + + SettingNameException(const Setting &setting, const char *name); + + virtual const char *what() const LIBCONFIGXX_NOEXCEPT; +}; + +class LIBCONFIGXX_API FileIOException : public ConfigException +{ + public: + + virtual const char *what() const LIBCONFIGXX_NOEXCEPT; +}; + +class LIBCONFIGXX_API ParseException : public ConfigException +{ + public: + + ParseException(const char *file, int line, const char *error); + + ParseException(const ParseException &other); + + virtual ~ParseException() LIBCONFIGXX_NOEXCEPT; + + inline const char *getFile() const + { return(_file); } + + inline int getLine() const + { return(_line); } + + inline const char *getError() const + { return(_error); } + + virtual const char *what() const LIBCONFIGXX_NOEXCEPT; + + private: + + const char *_file; + int _line; + const char *_error; +}; + +class LIBCONFIGXX_API Setting +{ + friend class Config; + + public: + + enum Type + { + TypeNone = 0, + // scalar types + TypeInt, + TypeInt64, + TypeFloat, + TypeString, + TypeBoolean, + // aggregate types + TypeGroup, + TypeArray, + TypeList + }; + + enum Format + { + FormatDefault = 0, + FormatHex = 1 + }; + + typedef SettingIterator iterator; + typedef SettingConstIterator const_iterator; + + public: + + virtual ~Setting(); + + inline Type getType() const { return(_type); } + + inline Format getFormat() const { return(_format); } + void setFormat(Format format); + + operator bool() const; + operator int() const; + operator unsigned int() const; + operator long() const; + operator unsigned long() const; + operator long long() const; + operator unsigned long long() const; + operator double() const; + operator float() const; + operator const char *() const; + operator std::string() const; + + inline const char *c_str() const + { return operator const char *(); } + + Setting & operator=(bool value); + Setting & operator=(int value); + Setting & operator=(long value); + Setting & operator=(const long long &value); + Setting & operator=(const double &value); + Setting & operator=(float value); + Setting & operator=(const char *value); + Setting & operator=(const std::string &value); + + Setting & lookup(const char *path) const; + inline Setting & lookup(const std::string &path) const + { return(lookup(path.c_str())); } + + Setting & operator[](const char *name) const; + + inline Setting & operator[](const std::string &name) const + { return(operator[](name.c_str())); } + + Setting & operator[](int index) const; + + bool lookupValue(const char *name, bool &value) const; + bool lookupValue(const char *name, int &value) const; + bool lookupValue(const char *name, unsigned int &value) const; + bool lookupValue(const char *name, long long &value) const; + bool lookupValue(const char *name, unsigned long long &value) const; + bool lookupValue(const char *name, double &value) const; + bool lookupValue(const char *name, float &value) const; + bool lookupValue(const char *name, const char *&value) const; + bool lookupValue(const char *name, std::string &value) const; + + inline bool lookupValue(const std::string &name, bool &value) const + { return(lookupValue(name.c_str(), value)); } + + inline bool lookupValue(const std::string &name, int &value) const + { return(lookupValue(name.c_str(), value)); } + + inline bool lookupValue(const std::string &name, unsigned int &value) const + { return(lookupValue(name.c_str(), value)); } + + inline bool lookupValue(const std::string &name, long long &value) const + { return(lookupValue(name.c_str(), value)); } + + inline bool lookupValue(const std::string &name, + unsigned long long &value) const + { return(lookupValue(name.c_str(), value)); } + + inline bool lookupValue(const std::string &name, double &value) const + { return(lookupValue(name.c_str(), value)); } + + inline bool lookupValue(const std::string &name, float &value) const + { return(lookupValue(name.c_str(), value)); } + + inline bool lookupValue(const std::string &name, const char *&value) const + { return(lookupValue(name.c_str(), value)); } + + inline bool lookupValue(const std::string &name, std::string &value) const + { return(lookupValue(name.c_str(), value)); } + + void remove(const char *name); + + inline void remove(const std::string &name) + { remove(name.c_str()); } + + void remove(unsigned int idx); + + Setting & add(const char *name, Type type); + + inline Setting & add(const std::string &name, Type type) + { return(add(name.c_str(), type)); } + + Setting & add(Type type); + + bool exists(const char *name) const; + + inline bool exists(const std::string &name) const + { return(exists(name.c_str())); } + + int getLength() const; + const char *getName() const; + std::string getPath() const; + int getIndex() const; + + const Setting & getParent() const; + Setting & getParent(); + + bool isRoot() const; + + inline bool isGroup() const + { return(_type == TypeGroup); } + + inline bool isArray() const + { return(_type == TypeArray); } + + inline bool isList() const + { return(_type == TypeList); } + + inline bool isAggregate() const + { return(_type >= TypeGroup); } + + inline bool isScalar() const + { return((_type > TypeNone) && (_type < TypeGroup)); } + + inline bool isNumber() const + { + return((_type == TypeInt) || (_type == TypeInt64) || (_type == TypeFloat)); + } + + inline bool isString() const + { return(_type == TypeString); } + + unsigned int getSourceLine() const; + const char *getSourceFile() const; + + iterator begin(); + iterator end(); + + const_iterator begin() const; + const_iterator end() const; + + private: + + config_setting_t *_setting; + Type _type; + Format _format; + + Setting(config_setting_t *setting); + + void assertType(Type type) const; + static Setting & wrapSetting(config_setting_t *setting); + + Setting(const Setting& other); // not supported + Setting& operator=(const Setting& other); // not supported +}; + + +class LIBCONFIGXX_API SettingIterator +{ + public: + + SettingIterator(Setting &setting, bool endIterator = false); + SettingIterator(const SettingIterator &other); + SettingIterator& operator=(const SettingIterator &other); + + // Equality comparison. + inline bool operator==(SettingIterator const &other) const + { return((_setting == other._setting) && (_idx == other._idx)); } + + inline bool operator!=(SettingIterator const &other) const + { return(!operator==(other)); } + + bool operator<(SettingIterator const &other) const; + + // Dereference operators. + inline Setting & operator*() + { return((*_setting)[_idx]); } + + inline Setting * operator->() + { return(&(*_setting)[_idx]); } + + inline const Setting & operator*() const + { return(*_setting)[_idx]; } + inline const Setting * operator->() const + { return(&(*_setting)[_idx]); } + + // Increment and decrement operators. + SettingIterator & operator++(); + SettingIterator operator++(int); + + SettingIterator & operator--(); + SettingIterator operator--(int); + + // Arithmetic operators. + SettingIterator operator+(int offset) const; + SettingIterator & operator+=(int offset); + + SettingIterator operator-(int offset) const; + SettingIterator & operator-=(int offset); + + int operator-(const SettingIterator &other) const; + + private: + + Setting *_setting; + + int _count; + int _idx; +}; + +SettingIterator operator+(int offset, const SettingIterator &si); + +class LIBCONFIGXX_API SettingConstIterator +{ + public: + + SettingConstIterator(const Setting &setting, bool endIterator = false); + SettingConstIterator(const SettingConstIterator &rhs); + SettingConstIterator& operator=(const SettingConstIterator &rhs); + + // Equality comparison. + bool operator==(SettingConstIterator const &other) const + { return((_setting == other._setting) && (_idx == other._idx)); } + + inline bool operator!=(SettingConstIterator const &other) const + { return(!operator==(other)); } + + // Dereference operators. + inline Setting const & operator*() + { return((*_setting)[_idx]); } + inline Setting const * operator->() + { return(&(*_setting)[_idx]); } + + inline const Setting& operator*() const + { return((*_setting)[_idx]); } + inline const Setting * operator->() const + { return(&(*_setting)[_idx]); } + + // Increment and decrement operators. + SettingConstIterator & operator++(); + SettingConstIterator operator++(int); + + SettingConstIterator & operator--(); + SettingConstIterator operator--(int); + + // Arithmetic operators. + SettingConstIterator operator+(int offset) const; + SettingConstIterator & operator+=(int offset); + + SettingConstIterator operator-(int offset) const; + SettingConstIterator & operator-=(int offset); + + int operator-(const SettingConstIterator &other) const; + + private: + + const Setting *_setting; + + int _count; + int _idx; +}; + +SettingConstIterator operator+(int offset, const SettingConstIterator &si); + +class LIBCONFIGXX_API Config +{ + public: + + enum Option + { + OptionNone = 0, + OptionAutoConvert = 0x01, + OptionSemicolonSeparators = 0x02, + OptionColonAssignmentForGroups = 0x04, + OptionColonAssignmentForNonGroups = 0x08, + OptionOpenBraceOnSeparateLine = 0x10, + OptionAllowScientificNotation = 0x20, + OptionFsync = 0x40, + OptionAllowOverrides = 0x80 + }; + + Config(); + virtual ~Config(); + + void clear(); + + void setOptions(int options); + int getOptions() const; + + void setOption(Config::Option option, bool flag); + bool getOption(Config::Option option) const; + + inline void setAutoConvert(bool flag) + { setOption(Config::OptionAutoConvert, flag); } + inline bool getAutoConvert() const + { return(getOption(Config::OptionAutoConvert)); } + + void setDefaultFormat(Setting::Format format); + inline Setting::Format getDefaultFormat() const + { return(_defaultFormat); } + + void setTabWidth(unsigned short width); + unsigned short getTabWidth() const; + + void setFloatPrecision(unsigned short digits); + unsigned short getFloatPrecision() const; + + void setIncludeDir(const char *includeDir); + const char *getIncludeDir() const; + + virtual const char **evaluateIncludePath(const char *path, + const char **error); + + void read(FILE *stream); + void write(FILE *stream) const; + + void readString(const char *str); + inline void readString(const std::string &str) + { return(readString(str.c_str())); } + + void readFile(const char *filename); + inline void readFile(const std::string &filename) + { readFile(filename.c_str()); } + + void writeFile(const char *filename); + inline void writeFile(const std::string &filename) + { writeFile(filename.c_str()); } + + Setting & lookup(const char *path) const; + inline Setting & lookup(const std::string &path) const + { return(lookup(path.c_str())); } + + bool exists(const char *path) const; + inline bool exists(const std::string &path) const + { return(exists(path.c_str())); } + + bool lookupValue(const char *path, bool &value) const; + bool lookupValue(const char *path, int &value) const; + bool lookupValue(const char *path, unsigned int &value) const; + bool lookupValue(const char *path, long long &value) const; + bool lookupValue(const char *path, unsigned long long &value) const; + bool lookupValue(const char *path, double &value) const; + bool lookupValue(const char *path, float &value) const; + bool lookupValue(const char *path, const char *&value) const; + bool lookupValue(const char *path, std::string &value) const; + + inline bool lookupValue(const std::string &path, bool &value) const + { return(lookupValue(path.c_str(), value)); } + + inline bool lookupValue(const std::string &path, int &value) const + { return(lookupValue(path.c_str(), value)); } + + inline bool lookupValue(const std::string &path, unsigned int &value) const + { return(lookupValue(path.c_str(), value)); } + + inline bool lookupValue(const std::string &path, long long &value) const + { return(lookupValue(path.c_str(), value)); } + + inline bool lookupValue(const std::string &path, + unsigned long long &value) const + { return(lookupValue(path.c_str(), value)); } + + inline bool lookupValue(const std::string &path, double &value) const + { return(lookupValue(path.c_str(), value)); } + + inline bool lookupValue(const std::string &path, float &value) const + { return(lookupValue(path.c_str(), value)); } + + inline bool lookupValue(const std::string &path, const char *&value) const + { return(lookupValue(path.c_str(), value)); } + + inline bool lookupValue(const std::string &path, std::string &value) const + { return(lookupValue(path.c_str(), value)); } + + Setting & getRoot() const; + + private: + + static void ConfigDestructor(void *arg); + void handleError() const; + + config_t *_config; + Setting::Format _defaultFormat; + + Config(const Config& other); // not supported + Config& operator=(const Config& other); // not supported +}; + +} // namespace libconfig + +#endif // __libconfig_hpp |