ConfigurationFile Class Reference

#include <ConfigurationFile.hh>

Inheritance diagram for ConfigurationFile:

Collaboration diagram for ConfigurationFile:

Classes
struct	Key

Public Member Functions
	ConfigurationFile (bool doChecking=false)
virtual	~ConfigurationFile ()
void	load (std::istream &inputStream)
bool	hasKey (const std::string &key)
std::string	value (const std::string &key, int index=0)
int	itemCount (const std::string &key)
int	intValue (const std::string &key, int index=0)
float	floatValue (const std::string &key, int index=0)
std::string	stringValue (const std::string &key, int index=0)
bool	booleanValue (const std::string &key, int index=0)
unsigned int	timeStampValue (const std::string &key)

Protected Types
enum	ConfigurationValueType {   VT_INTEGER , VT_FLOAT , VT_STRING , VT_BOOLEAN ,   VT_READABLE_TIME , VT_UNIX_TIMESTAMP }
enum	ConfigurationFileError { FE_SYNTAX , FE_ILLEGAL_TYPE , FE_UNKNOWN_KEY , FE_MISSING_VALUE }

Protected Member Functions
void	addSupportedKey (const std::string &key, ConfigurationValueType type, bool caseSensitive=false)
virtual bool	handleError (int lineNumber, ConfigurationFileError error, const std::string &line)

Private Types
typedef std::map< TCEString, std::vector< TCEString > >	ValueContainer
typedef std::map< Key *, ConfigurationValueType >	KeyContainer

Private Member Functions
void	parse (std::istream &inputStream)
bool	checkSemantics (const std::string &key, const std::string &value, int lineNumber, const std::string &line)
bool	isComment (const std::string &line)
bool	legalTime (const std::string &line)
std::string	valueOfKey (const std::string &key, int index)

Private Attributes
bool	check_
	True if semantics of the configuration file is checked.
ValueContainer	values_
	Contains all the values of configuration file.
KeyContainer	keys_
	Contains all the legal keys of the configuration file.

Detailed Description

Class that is able to read files with key-value-pairs, such as the processor configuration file.

Can do simple sanity and type checking of the file while loading it.

Definition at line 50 of file ConfigurationFile.hh.

Member Typedef Documentation

KeyContainer

typedef std::map<Key*, ConfigurationValueType> ConfigurationFile::KeyContainer

private

Definition at line 107 of file ConfigurationFile.hh.

ValueContainer

typedef std::map<TCEString, std::vector<TCEString> > ConfigurationFile::ValueContainer

private

Definition at line 104 of file ConfigurationFile.hh.

Member Enumeration Documentation

ConfigurationFileError

enum ConfigurationFile::ConfigurationFileError

protected

Error types.

Enumerator
FE_SYNTAX	Syntax error.
FE_ILLEGAL_TYPE	Illegal type error.
FE_UNKNOWN_KEY	Unknown key error.
FE_MISSING_VALUE	Missing value error.

Definition at line 85 of file ConfigurationFile.hh.

                                {
        FE_SYNTAX,        ///< Syntax error.
        FE_ILLEGAL_TYPE,  ///< Illegal type error.
        FE_UNKNOWN_KEY,   ///< Unknown key error.
        FE_MISSING_VALUE  ///< Missing value error.
    };

ConfigurationValueType

enum ConfigurationFile::ConfigurationValueType

protected

Different value types.

Enumerator
VT_INTEGER	Integer value.
VT_FLOAT	Float value.
VT_STRING	String value.
VT_BOOLEAN	Boolean value.
VT_READABLE_TIME	Time in readable format.
VT_UNIX_TIMESTAMP	Time as seconds since starting of 1970.

Definition at line 73 of file ConfigurationFile.hh.

                                {
        VT_INTEGER,       ///< Integer value.
        VT_FLOAT,         ///< Float value.
        VT_STRING,        ///< String value.
        VT_BOOLEAN,       ///< Boolean value.
        VT_READABLE_TIME, ///< Time in readable format.
        VT_UNIX_TIMESTAMP ///< Time as seconds since starting of 1970.
    };

Constructor & Destructor Documentation

ConfigurationFile()

ConfigurationFile::ConfigurationFile

(

bool

doChecking = false

)

Constructor.

Parameters

doChecking

If true, checks the semantics of the configuration file while reading it.

Definition at line 72 of file ConfigurationFile.cc.

                                                    : check_(doChecking) {
}

~ConfigurationFile()

ConfigurationFile::~ConfigurationFile ( )

virtual

Destructor.

Definition at line 78 of file ConfigurationFile.cc.

                                      {
    MapTools::deleteAllKeys(keys_);
}

References MapTools::deleteAllKeys(), and keys_.

Here is the call graph for this function:

Member Function Documentation

addSupportedKey()

void ConfigurationFile::addSupportedKey ( const std::string &  key, ConfigurationValueType  type, bool  caseSensitive = false  )

protected

Add supported key type.

Parameters

key	Key to be added.
type	Type of the value.
caseSensitive	True if key is case sensitive.

Definition at line 292 of file ConfigurationFile.cc.

                        {
 
    Key* k = new Key();
    k->name_ = key;
    k->caseSensitive_ = caseSensitive;
 
    keys_[k] = type;
}

References ConfigurationFile::Key::caseSensitive_, keys_, and ConfigurationFile::Key::name_.

Referenced by ProcessorConfigurationFile::ProcessorConfigurationFile().

booleanValue()

bool ConfigurationFile::booleanValue	(	const std::string &	key,
		int	index = 0
	)

Returns the boolean value of the given key.

Parameters

key	The key.
index	The index of the value.

Returns

The boolean value of the key.

Exceptions

KeyNotFound	If key is not found.
OutOfRange	If index is out of range.
InvalidData	If value type is wrong.

Definition at line 202 of file ConfigurationFile.cc.

                                                               {
    string value = valueOfKey(key, index);
    value = StringTools::stringToLower(value);
    if (value == "true" || value == "yes" || value == "on" ||
        value == "enabled" || value == "1") {
 
        return true;
    } else if (value == "false" || value == "no" || value == "off" ||
               value == "disabled" || value == "0") {
 
        return false;
    } else {
        string msg = "Wrong type of value: " + value;
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
        return false;
    }
}

References __func__, StringTools::stringToLower(), value(), and valueOfKey().

Here is the call graph for this function:

checkSemantics()

bool ConfigurationFile::checkSemantics ( const std::string &  key, const std::string &  value, int  lineNumber, const std::string &  line  )

private

Check the semantics of key value pair.

Parameters

key	The key.
value	The value.
lineNumber	The line number.
line	The line.

Returns

True if semantics are ok, otherwise false.

Definition at line 406 of file ConfigurationFile.cc.

                           {
 
    KeyContainer::iterator iter = keys_.begin();
    while (iter != keys_.end()) {
        Key* current = (*iter).first;
        if (current->caseSensitive_) {
            if (current->name_ == key) {
                break;
            }
        } else {
            if (StringTools::stringToUpper(current->name_) ==
                StringTools::stringToUpper(key)) {
                break;
            }
        }
        iter++;
    }
 
    if (iter == keys_.end()) {
        return handleError(lineNumber, FE_UNKNOWN_KEY, line);
    }
 
    ConfigurationValueType type = (*iter).second;
    switch (type) {
    case VT_INTEGER:
        try {
            Conversion::toInt(value);
        } catch (const NumberFormatException& n) {
            return handleError(lineNumber, FE_ILLEGAL_TYPE, line);
        }
        break;
    case VT_FLOAT:
        try {
            Conversion::toFloat(value);
        } catch (const NumberFormatException& n) {
            return handleError(lineNumber, FE_ILLEGAL_TYPE, line);
        }
        break;
    case VT_BOOLEAN:
        if (value != "true" && value != "yes" && value != "on" &&
            value != "enable" && value != "1" && value != "false" &&
            value != "no" && value != "off" && value != "disable" &&
            value != "0") {
 
            return handleError(lineNumber, FE_ILLEGAL_TYPE, line);
        }
        break;
    case VT_READABLE_TIME:
        if (!legalTime(value)) {
            return handleError(lineNumber, FE_ILLEGAL_TYPE, line);
        }
        break;
    case VT_UNIX_TIMESTAMP:
        try {
            Conversion::toInt(value);
        } catch (const NumberFormatException& n) {
            return handleError(lineNumber, FE_ILLEGAL_TYPE, line);
        }
        break;
    default:
        break;
    }
 
    return true;
}

References ConfigurationFile::Key::caseSensitive_, FE_ILLEGAL_TYPE, FE_UNKNOWN_KEY, handleError(), keys_, legalTime(), ConfigurationFile::Key::name_, StringTools::stringToUpper(), Conversion::toFloat(), Conversion::toInt(), value(), VT_BOOLEAN, VT_FLOAT, VT_INTEGER, VT_READABLE_TIME, and VT_UNIX_TIMESTAMP.

Referenced by parse().

Here is the call graph for this function:

floatValue()

float ConfigurationFile::floatValue	(	const std::string &	key,
		int	index = 0
	)

Returns the float value of the given key.

Parameters

key	The key.
index	The index of the value.

Returns

The float value of the given key.

Exceptions

KeyNotFound	If key is not found.
OutOfRange	If index is out of range.
InvalidData	If data is wrong type.

Definition at line 167 of file ConfigurationFile.cc.

                                                             {
    string value = valueOfKey(key, index);
    try {
        return Conversion::toFloat(value);
    } catch (const NumberFormatException& n) {
        string msg = "Wrong type of value: " + value;
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
}

References __func__, Conversion::toFloat(), value(), and valueOfKey().

Here is the call graph for this function:

handleError()

bool ConfigurationFile::handleError ( int  lineNumber, ConfigurationFileError  error, const std::string &  line  )

protectedvirtual

Default implementation, all errors are handled.

Returns

True.

Reimplemented in ProcessorConfigurationFile.

Definition at line 310 of file ConfigurationFile.cc.

                      {
 
    return true;
}

Referenced by checkSemantics(), and parse().

hasKey()

bool ConfigurationFile::hasKey

(

const std::string &

key

)

Returns true if there is a given key with a value in configuration.

Parameters

key

The key.

Returns

True if there is a given key in a configuration.

Definition at line 99 of file ConfigurationFile.cc.

                                              {
    ValueContainer::iterator iter = values_.find(key);
    return iter != values_.end();
}

References values_.

intValue()

int ConfigurationFile::intValue	(	const std::string &	key,
		int	index = 0
	)

Returns the int value of the given key.

Parameters

key	The key.
index	The index of the value.

Returns

The int value of the key.

Exceptions

KeyNotFound	If key is not found.
OutOfRange	If index is out of range.
InvalidData	If data is wrong type.

Definition at line 146 of file ConfigurationFile.cc.

                                                           {
    string value = valueOfKey(key, index);
    try {
        return Conversion::toInt(value);
    } catch (const NumberFormatException& n) {
        string msg = "Wrong type of value: " + value;
        throw InvalidData(__FILE__, __LINE__, __func__, msg);
    }
}

References __func__, Conversion::toInt(), value(), and valueOfKey().

Referenced by ProcessorConfigurationFile::architectureSize(), ProcessorConfigurationFile::encodingMapSize(), and ProcessorConfigurationFile::implementationSize().

Here is the call graph for this function:

isComment()

bool ConfigurationFile::isComment ( const std::string &  line )

private

Returns true if line is a comment.

Parameters

line	Line to be checked.

Returns

True if line is a comment.

Definition at line 388 of file ConfigurationFile.cc.

                                                  {
    if (line.substr(0, 1) == "#") {
        return true;
    } else {
        return false;
    }
}

Referenced by parse().

itemCount()

int ConfigurationFile::itemCount

(

const std::string &

key

)

Returns the number of values a given key has.

Parameters

key

The key.

Returns

The number of values key has.

Exceptions

KeyNotFound

If key is not found.

Definition at line 126 of file ConfigurationFile.cc.

                                                 {
    ValueContainer::iterator iter = values_.find(key);
    if (iter == values_.end()) {
        string msg = "Key " + key + " not found";
        throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
    }
    return (*iter).second.size();
}

References __func__, and values_.

legalTime()

bool ConfigurationFile::legalTime ( const std::string &  line )

private

Returns true if string is a legal time representation.

Parameters

line	Line to be checked.

Returns

True if string is legal time, false otherwise.

Definition at line 483 of file ConfigurationFile.cc.

                                                  {
 
    const char* regExp = "([0-9]{4})-([0-9]{1,2})-([0-9]{1,2}) ([0-9]{1,2}):([0-9]{2})";
    boost::regex expression(regExp);
    boost::smatch what;
    if (!boost::regex_match(line, what, expression)) {
        return false;
    } else {
        return true;
    }
}

Referenced by checkSemantics(), and timeStampValue().

load()

void ConfigurationFile::load

(

std::istream &

inputStream

)

Parses the configuration file and stores the results to internal structure.

Parameters

inputStream

Input file stream.

Definition at line 88 of file ConfigurationFile.cc.

                                               {
    parse(inputStream);
}

References parse().

Referenced by ProcessorConfigurationFile::ProcessorConfigurationFile().

Here is the call graph for this function:

parse()

void ConfigurationFile::parse ( std::istream &  inputStream )

private

Parses the configuration file.

Parameters

inputStream

Stream where file is read from.

Definition at line 324 of file ConfigurationFile.cc.

                                                {
 
    string line = "";
    int lineNumber = 1;
    while (getline(inputStream, line)) {
        line = StringTools::trim(line);
 
        if (isComment(line) || line == "") {
            lineNumber++;
            continue;
        } else {
            const char* regExp = "[ ]*(.+)[ ]*=[ ]*(.+)[ ]*";
            boost::regex expression(regExp);
            boost::smatch what;
            if (!boost::regex_match(line, what, expression)) {
                if (!handleError(lineNumber, FE_SYNTAX, line)) {
                    return;
                } else {
                    lineNumber++;
                    continue;
                }
            }
 
            TCEString key = std::string(what[1]);
            TCEString value = std::string(what[2]);
            key = StringTools::trim(key);
            value = StringTools::trim(value);
 
            vector<TCEString> values = StringTools::chopString(value, " ");
 
            if (value == "") {
                if (!handleError(lineNumber, FE_MISSING_VALUE, line)) {
                    return;
                } else {
                    lineNumber++;
                    continue;
                }
            }
 
            if (check_) {
                if (!checkSemantics(key, value, lineNumber, line)) {
                    return;
                }
            }
            ValueContainer::iterator iter = values_.find(key);
            if (iter == values_.end()) {
                values_[key] = values;
            } else {
                for (size_t i = 0; i < values.size(); i++) {
                    (*iter).second.push_back(values[i]);
                }
            }
        }
        lineNumber++;
    }
}

References check_, checkSemantics(), StringTools::chopString(), FE_MISSING_VALUE, FE_SYNTAX, handleError(), isComment(), StringTools::trim(), value(), and values_.

Referenced by load().

Here is the call graph for this function:

stringValue()

string ConfigurationFile::stringValue	(	const std::string &	key,
		int	index = 0
	)

Returns string value of the given key.

Parameters

key	The key.
index	The index of the value.

Returns

The string value of the given key.

Exceptions

KeyNotFound	If key is not found.
OutOfRange	If index is out of range.

Definition at line 187 of file ConfigurationFile.cc.

                                                              {
    return valueOfKey(key, index);
}

References valueOfKey().

Here is the call graph for this function:

timeStampValue()

unsigned int ConfigurationFile::timeStampValue

(

const std::string &

key

)

Returns the time stamp value of the given key.

Parameters

key

The key.

Returns

The time stamp value.

Exceptions

KeyNotFound

If key is not found.

Definition at line 228 of file ConfigurationFile.cc.

                                                      {
    ValueContainer::iterator iter = values_.find(key);
    if (iter == values_.end()) {
        string msg = "Key " + key + " not found";
        throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
    }
 
    string value = "";
    for (size_t i = 0; i < (*iter).second.size(); i++) {
        value += (*iter).second[i] + " ";
    }
 
    value = StringTools::trim(value);
 
    if (!legalTime(value)) {
        return 0;
    }
 
    size_t pos = value.find("-");
    string year = value.substr(0, pos);
    value.replace(0, pos + 1, "");
 
    pos = value.find("-");
    string month = value.substr(0, pos);
    value.replace(0, pos + 1, "");
 
    pos = value.find(" ");
    string day = value.substr(0, pos);
    value.replace(0, pos + 1, "");
 
    pos = value.find(":");
    string hours = value.substr(0, pos);
    value.replace(0, pos + 1, "");
 
    string minutes = value;
 
    time_t rawtime;
    tm* timeinfo;
 
    time(&rawtime);
    timeinfo = localtime (&rawtime);
 
    int temp = Conversion::toInt(year);
    timeinfo->tm_year = temp - 1900;
    temp = Conversion::toInt(month);
    timeinfo->tm_mon = temp - 1;
    temp = Conversion::toInt(day);
    timeinfo->tm_mday = temp;
    temp = Conversion::toInt(hours);
    timeinfo->tm_hour = temp;
    temp = Conversion::toInt(minutes);
    timeinfo->tm_min = temp;
 
    return mktime(timeinfo);
}

References __func__, legalTime(), Conversion::toInt(), StringTools::trim(), value(), and values_.

Referenced by ProcessorConfigurationFile::architectureModified(), ProcessorConfigurationFile::encodingMapModified(), and ProcessorConfigurationFile::implementationModified().

Here is the call graph for this function:

value()

std::string ConfigurationFile::value	(	const std::string &	key,
		int	index = 0
	)

Returns the value of the given key.

Parameters

key	The key.
index	The index of the value.

Returns

The value of the given key.

Exceptions

KeyNotFound	If key is not found.
OutOfRange	If index is out of range.

Definition at line 114 of file ConfigurationFile.cc.

                                                        {
    return valueOfKey(key, index);
}

References valueOfKey().

Referenced by ProcessorConfigurationFile::architectureName(), booleanValue(), checkSemantics(), ProcessorConfigurationFile::encodingMapName(), floatValue(), ProcessorConfigurationFile::implementationName(), intValue(), parse(), and timeStampValue().

Here is the call graph for this function:

valueOfKey()

string ConfigurationFile::valueOfKey ( const std::string &  key, int  index  )

private

Returns the value of the given key and a given index.

Parameters

key	The key.
index	Index of the value.

Returns

The value of the key.

Exceptions

KeyNotFound	If key is not found.
OutOfRange	If index is out of range.

Definition at line 505 of file ConfigurationFile.cc.

                                                             {
    ValueContainer::iterator iter = values_.find(key);
    if (iter == values_.end()) {
        string msg = "Key " + key + " not found";
        throw KeyNotFound(__FILE__, __LINE__, __func__, msg);
    }
 
    if (index < 0 || index > static_cast<int>((*iter).second.size()) - 1) {
        string msg = "Index out of range.";
        throw OutOfRange(__FILE__, __LINE__, __func__, msg);
    }
    return (*iter).second[index];
}

References __func__, and values_.

Referenced by booleanValue(), floatValue(), intValue(), stringValue(), and value().

Member Data Documentation

check_

bool ConfigurationFile::check_

private

True if semantics of the configuration file is checked.

Definition at line 134 of file ConfigurationFile.hh.

Referenced by parse().

keys_

KeyContainer ConfigurationFile::keys_

private

Contains all the legal keys of the configuration file.

Definition at line 138 of file ConfigurationFile.hh.

Referenced by addSupportedKey(), checkSemantics(), and ~ConfigurationFile().

values_

ValueContainer ConfigurationFile::values_

private

Contains all the values of configuration file.

Definition at line 136 of file ConfigurationFile.hh.

Referenced by hasKey(), itemCount(), parse(), timeStampValue(), and valueOfKey().

---

The documentation for this class was generated from the following files:

• ConfigurationFile.hh
• ConfigurationFile.cc