ede/pekwm/CfgParserKey.hh
2011-10-23 00:10:40 +00:00

190 lines
5.8 KiB
C++

//
// Copyright © 2005-2009 Claes Nästén <me@pekdon.net>
//
// This program is licensed under the GNU GPL.
// See the LICENSE file for more information.
//
#ifndef _CFG_PARSER_KEY_HH_
#define _CFG_PARSER_KEY_HH_
#include <string>
#include <limits>
#include <cstdlib>
#include "Util.hh"
//! @brief CfgParserKey value type.
enum CfgParserKeyType {
KEY_SECTION, //!< Subsection.
KEY_BOOL, //!< Boolean value.
KEY_NUMERIC, //!< Integer value.
KEY_STRING, //!< String value.
KEY_PATH //!< Path value.
};
//! @brief CfgParserKey base class.
class CfgParserKey {
public:
//! @brief CfgParserKey constructor.
CfgParserKey(const char *name) : _name(name) { }
//! @brief CfgParserKey destructor.
virtual ~CfgParserKey(void) { }
//! @brief Returns Key name.
const char *get_name(void) const { return _name; }
//! @brief Returns Key type.
const CfgParserKeyType get_type(void) const { return _type; }
//! @brief Parses value and sets Key value.
virtual void parse_value(const std::string &value) throw (std::string&) { }
protected:
CfgParserKeyType _type; //!< Key type.
const char *_name; //!< Key name.
};
/**
* CfgParserKey numeric type with minimum, maximum and default
* value. The type must be available in numeric_limits.
*/
template<typename T>
class CfgParserKeyNumeric : public CfgParserKey {
public:
/**
* CfgParserKeyNumeric constructor, sets default values
*
* @param name Name of the key.
* @param set Variable to store parsed value in.
* @param default_val Default value for key, defaults to 0.
* @param value_min Minimum value for key, defaults to limits<T>::min().
* @param value_min Maximum value for key, defaults to limits<T>::max().
*/
CfgParserKeyNumeric(const char *name, T &set, const T default_val = 0,
const T value_min = std::numeric_limits<T>::min(),
const T value_max = std::numeric_limits<T>::max())
: CfgParserKey(name),
_set(set), _default(default_val),
_value_min(value_min), _value_max(value_max)
{
_type = KEY_NUMERIC;
}
/**
* CfgParserKeyNumeric destructor.
*/
virtual ~CfgParserKeyNumeric(void) { }
/**
* Parses and store integer value.
*
* @param value Reference to string representing integer value.
*/
virtual void
parse_value(const std::string &value_str)
throw (std::string&)
{
double value;
char *endptr;
// Get long value.
value = strtod(value_str.c_str(), &endptr);
// Check for validity, 0 is returned on failiure with endptr set to the
// beginning of the string, else we are (semi) ok.
if ((value == 0) && (endptr == value_str.c_str())) {
_set = _default;
} else {
T value_for_type = static_cast<T>(value);
if (value_for_type < _value_min) {
_set = _value_min;
throw std::string("value to low, min value " + Util::to_string<T>(_value_min));
} if (value_for_type > _value_max) {
_set = _value_max;
throw std::string("value to high, max value " + Util::to_string<T>(_value_max));
}
_set = value_for_type;
}
}
private:
T &_set; /**< Reference to store parsed value in. */
const T _default; /**< Default value. */
const T _value_min; /**< Minimum value. */
const T _value_max; /**< Maximum value. */
};
//! @brief CfgParser Key boolean value parser.
class CfgParserKeyBool : public CfgParserKey {
public:
//! @brief CfgParserKeyBool constructor.
CfgParserKeyBool(const char *name,
bool &set, const bool default_val = false)
: CfgParserKey(name),
_set(set), _default(default_val)
{
_type = KEY_BOOL;
}
//! @brief CfgParserKeyBool destructor.
virtual ~CfgParserKeyBool(void) { }
virtual void parse_value(const std::string &value) throw (std::string&);
private:
bool &_set; //! Reference to stored parsed value in.
const bool _default; //! Default value.
};
//! @brief CfgParser Key string value parser.
class CfgParserKeyString : public CfgParserKey {
public:
//! @brief CfgParserKeyString constructor.
CfgParserKeyString(const char *name,
std::string &set, const std::string default_val = "",
const int length_min = std::numeric_limits<int>::min(),
const int length_max = std::numeric_limits<int>::max())
: CfgParserKey(name),
_set(set), _default(default_val),
_length_min(length_min), _length_max(length_max)
{
_type = KEY_STRING;
}
//! @brief CfgParserKeyString destructor.
virtual ~CfgParserKeyString(void) { }
virtual void parse_value(const std::string &value) throw (std::string&);
private:
std::string &_set; //!< Reference to store parsed value in.
const std::string _default; //!< Default value.
const int _length_min; //!< Minimum lenght of string.
const int _length_max; //!< Maximum length of string.
};
//! @brief CfgParser Key path parser.
class CfgParserKeyPath : public CfgParserKey {
public:
//! @brief CfgParserKeyPath constructor.
CfgParserKeyPath(const char *name,
std::string &set, const std::string default_val = "")
: CfgParserKey(name),
_set(set), _default(default_val)
{
_type = KEY_PATH;
Util::expandFileName(_default);
}
//! @brief CfgParserKeyPath destructor.
virtual ~CfgParserKeyPath(void) { }
virtual void parse_value(const std::string &value) throw (std::string&);
private:
std::string &_set; //!< Reference to store parsed value in.
std::string _default; //!< Default value.
};
#endif // _CFG_PARSER_KEY_HH_