src/tools/conf_impl.cpp

Go to the documentation of this file.

#include <string>
#include <stdlib.h>
#include <fstream>
#include "engine/mutex.h"
#include "log.h"
#include "conversion.h"
#include "conf_impl.h"

ConfigImpl::ConfigImpl() : Mutex(RECURSIVE_MUTEX)
{
        Lock();
        loaded = false;
        Unlock();
}

static ssize_t getline(std::string &line, std::ifstream& file)
{
        line.clear();
        std::getline(file, line);
        if(file.eof())
                return -1;
        return line.size();
}

void ConfigImpl::Parse(std::string line)
{
        Lock();
        std::string::size_type equ_pos = line.find('=',0);
        if(equ_pos == std::string::npos)
        {
                fprintf(stderr ,"Badly formated option on command line: %s\n", line.c_str());
                Unlock();
                return;
        }

        std::string opt = line.substr(0, equ_pos);
        std::string val = line.substr(equ_pos+1);

        // check if it's a list:
        size_t comma_pos = 0;
        size_t last_comma = 0;
        while(true)
        {
                // Find next comma
                while(comma_pos != std::string::npos && (comma_pos == last_comma || (comma_pos != 0 && val[comma_pos - 1] == '\\')))
                {
                        if(comma_pos != 0 && val[comma_pos - 1] == '\\')
                                comma_pos ++;
                        comma_pos = val.find(',', comma_pos);
                }

                std::string subval;
                if(comma_pos != std::string::npos)
                        subval = val.substr(last_comma, comma_pos - last_comma);
                else
                        subval = val.substr(last_comma);

                // remove backslash of escaped string:
                size_t bs = subval.find('\\', 0);
                while(bs != std::string::npos)
                {
                        if(bs < subval.size() - 1 && subval[bs + 1] == ',')
                                subval.replace(bs, 1, "");
                        else
                                bs++;
                        bs = subval.find('\\', bs);
                }

                bool is_list = !(last_comma == 0 && comma_pos == std::string::npos);
                // val is considered to be an int if it doesn't contain
                // a '.' (ip address have to be handled as string...
                if(subval != "" && subval.find('.',0) == std::string::npos
                && (subval.at(0) >= '0' && subval.at(0) <= '9'))
                {
                        int nbr = atoi(subval.c_str());
                        if(is_list)
                        {
                                if(int_list_value.find(opt) == int_list_value.end())
                                        int_list_value[ opt ] = std::list<int>();
                                int_list_value[ opt ].push_back(nbr);
                        }
                        else
                                int_value[ opt ] = nbr;
                }
                else
                {
                        if(subval == "true")
                                bool_value[ opt ] = true;
                        else
                        if(subval == "false")
                                bool_value[ opt ] = false;
                        else
                        {
                                if(is_list)
                                {
                                        if(str_list_value.find(opt) == str_list_value.end())
                                                str_list_value[ opt ] = std::list<std::string>();
                                        str_list_value[ opt ].push_back(subval);
                                }
                                else
                                        str_value[ opt ] = subval;
                        }
                }
                if(comma_pos == std::string::npos)
                        break;
                comma_pos++;
                last_comma = comma_pos;
        }
        Unlock();
}

void ConfigImpl::Load(std::string _file)
{
        Lock();
        log(LogInfo, "Loading config file %s", _file.c_str());
        int line_nbr = 0;
        loaded = true;

        // Parse the file
        std::ifstream fin;
        fin.open(_file.c_str(), std::ios::in);
        if(!fin)
        {
                fprintf(stderr, "Unable to open config file %s\n", _file.c_str());
                Unlock();
                return;
        }

        ssize_t read;
        std::string line;

        while ((read = getline(line, fin)) >= 0)
        {
                line_nbr++;
                if(line.size() == 0 || line.at(0) == '#' )
                        continue;

                std::string::size_type equ_pos = line.find('=',0);
                if(equ_pos == std::string::npos)
                {
                        fprintf(stderr, "Wrong format on line %i\n",line_nbr);
                        continue;
                }

                Parse(line);
        }
        Unlock();
}

std::string escape(std::string str)
{
        size_t pos = str.find(',');
        while(pos != std::string::npos)
        {
                std::string new_str = str.substr(0, pos) + std::string("\\") + str.substr(pos);
                pos = new_str.find(',', pos + 2);
                str = new_str;
        }
        return str;
}

std::string ConfigImpl::GetAsString()
{
        Lock();
        std::string str = "";

        // Booleans
        for(std::map<std::string, bool>::iterator cfg = bool_value.begin();
                        cfg != bool_value.end();
                        ++cfg)
                str += cfg->first + std::string(cfg->second ? "=true\n" : "=false\n");
        // Integers
        for(std::map<std::string, int>::iterator cfg = int_value.begin();
                        cfg != int_value.end();
                        ++cfg)
                str += cfg->first + std::string("=") + int2str(cfg->second) + std::string("\n");
        // Strings
        for(std::map<std::string, std::string>::iterator cfg = str_value.begin();
                        cfg != str_value.end();
                        ++cfg)
                str += cfg->first + std::string("=") + escape(cfg->second) + std::string("\n");

        // Strings lists
        for(std::map<std::string, std::list<std::string> >::iterator cfg = str_list_value.begin();
                        cfg != str_list_value.end();
                        ++cfg)
        {
                str += cfg->first + std::string("=");

                unsigned int i = 0;
                for(std::list<std::string>::iterator it = cfg->second.begin();
                                it != cfg->second.end();
                                ++it, ++i)
                {
                        str += escape(*it);
                        if(i != cfg->second.size() - 1)
                                str += std::string(",");
                }
                str += std::string("\n");
        }

        // Integers lists
        for(std::map<std::string, std::list<int> >::iterator cfg = int_list_value.begin();
                        cfg != int_list_value.end();
                        ++cfg)
        {
                str += cfg->first + std::string("=");

                unsigned int i = 0;
                for(std::list<int>::iterator it = cfg->second.begin();
                                it != cfg->second.end();
                                ++it, ++i)
                {
                        str += int2str(*it);
                        if(i != cfg->second.size() - 1)
                                str += std::string(",");
                }
                str += std::string("\n");
        }

        Unlock();
        return str;
}

bool ConfigImpl::Get(const std::string & name, bool & value)
{
        Lock();
        if( bool_value.find(name) == bool_value.end() )
        {
                Unlock();
                return false;
        }

        value = bool_value[ name ];
        Unlock();
        return true;
}

bool ConfigImpl::Get(const std::string & name, int & value)
{
        Lock();
        if( int_value.find(name) == int_value.end() )
        {
                Unlock();
                return false;
        }

        value = int_value[ name ];
        Unlock();
        return true;
}

bool ConfigImpl::Get(const std::string & name, std::string & value)
{
        Lock();
        if( str_value.find(name) == str_value.end() )
        {
                Unlock();
                return false;
        }

        value = str_value[ name ];
        Unlock();
        return true;
}

bool ConfigImpl::Get(const std::string & name, std::list<std::string> & value)
{
        Lock();
        if( str_list_value.find(name) == str_list_value.end() )
        {
                std::string val;
                if(Get(name, val))
                {
                        str_value.erase(name);
                        str_list_value[ name ] = std::list<std::string>();
                        str_list_value[ name ].push_back(val);
                }
                else
                {
                        Unlock();
                        return false;
                }
        }

        value = str_list_value[ name ];
        Unlock();
        return true;
}

bool ConfigImpl::Get(const std::string & name, std::list<int> & value)
{
        Lock();
        if( int_list_value.find(name) == int_list_value.end() )
        {
                int val;
                if(Get(name, val))
                {
                        int_value.erase(name);
                        int_list_value[ name ] = std::list<int>();
                        int_list_value[ name ].push_back(val);
                }
                else
                {
                        Unlock();
                        return false;
                }
        }

        value = int_list_value[ name ];
        Unlock();
        return true;
}

void ConfigImpl::SetDefaultBool(const std::string & name, const bool & value)
{
        Lock();
        bool val;
        if( ! Get(name, val) )
                bool_value[ name ] = value;
        Unlock();
}

void ConfigImpl::SetDefaultInt(const std::string & name, const int & value)
{
        Lock();
        int val;
        if( ! Get(name, val) )
                int_value[ name ] = value;
        Unlock();
}

void ConfigImpl::SetDefaultString(const std::string & name, const std::string & value)
{
        Lock();
        std::string val;
        if( ! Get(name, val) )
                str_value[ name ] = value;
        Unlock();
}

void ConfigImpl::ParseShellArgs(int argc, char** argv)
{
        Lock();
        for(int no=1; no < argc; no++)
                Parse(std::string( (char*)argv[no] ));
        Unlock();
}

void ConfigImpl::SetBool(std::string name, const bool & value)
{
        Lock();
        loaded = true;
        bool_value[name] = value;
        Unlock();
}

void ConfigImpl::SetInt(std::string name, const int & value)
{
        Lock();
        loaded = true;
        int_value[name] = value;
        Unlock();
}

void ConfigImpl::SetString(std::string name, const std::string & value)
{
        Lock();
        loaded = true;
        str_value[name] = value;
        Unlock();
}

void ConfigImpl::SetStringList(std::string name, const std::list<std::string> & value)
{
        Lock();
        loaded = true;
        str_list_value[name] = value;
        Unlock();
}

void ConfigImpl::SetIntList(std::string name, const std::list<int> & value)
{
        Lock();
        loaded = true;
        int_list_value[name] = value;
        Unlock();
}

bool ConfigImpl::IsLoaded()
{
        Lock();
        bool ret = loaded;
        Unlock();
        return ret;
}

---