projects/smsdaemon/ConfigFile.cpp

#include "ConfigFile.h"
#include "Util.h"

#include <fstream>
#include <sstream>
#include <stdexcept>

#include <stdlib.h>

const char SEPERATOR = '/';

std::string trim(std::string const& source, char const* delims = " \t\r\n")
{
        std::string result(source);
        std::string::size_type index = result.find_last_not_of(delims);
        if (index != std::string::npos)
                result.erase(++index);

        index = result.find_first_not_of(delims);
        if (index != std::string::npos)
                result.erase(0, index);
        else
                result.erase();
        return result;
}

ConfigFile::ConfigFile()
{
}

ConfigFile::ConfigFile(std::string const& configFile)
{
        Open(configFile);
}

bool ConfigFile::Open(std::string const& configFile)
{
        std::ifstream file(configFile.c_str());

        std::string line;
        std::string name;
        std::string value;
        std::string inSection;
        int posEqual;

        if (!file)
        {
                return false;
        }

        while (std::getline(file,line))
        {

                if (! line.length()) continue;

                if (line[0] == '#') continue;
                if (line[0] == ';') continue;

                if (line[0] == '[')
                {
                        inSection=trim(line.substr(1,line.find(']')-1));
                        continue;
                }

                posEqual=line.find('=');
                name  = trim(line.substr(0,posEqual));
                value = trim(line.substr(posEqual+1));

                content_.insert(std::make_pair(inSection+SEPERATOR+name,Value(value)));
        }
        return true;
}

Value const& ConfigFile::GetValue(std::string const& section, std::string const& entry) const
{

        content_iterator ci = content_.find(section + SEPERATOR + entry);

        if (ci == content_.end()) throw "does not exist";

        return ci->second;
}

std::vector<Value> ConfigFile::GetValues(std::string const& section, std::string const& entry) const
{
        std::vector<Value> values;
        std::string search = section + SEPERATOR + entry;
        std::pair<content_iterator, content_iterator> range = content_.equal_range(search);

        for (content_iterator it=range.first; it != range.second; ++it)
        {
                values.push_back( it->second );
        }
        return values;
}

Value const& ConfigFile::GetValue(std::string const& section, std::string const& entry, double value)
{
        try
        {
                return GetValue(section, entry);
        }
        catch (const char *)
        {
                return content_.insert(std::make_pair(section+SEPERATOR+entry, Value(value)))->second;
        }
}

Value const& ConfigFile::GetValue(std::string const& section, std::string const& entry, std::string const& value)
{
        try
        {
                return GetValue(section, entry);
        }
        catch (const char *)
        {
                return content_.insert(std::make_pair(section+SEPERATOR+entry, Value(value)))->second;
        }
}

std::string ConfigFile::DumpConfig() const
{
        std::ostringstream ss;  
        for (content_iterator it=content_.begin(); it!=content_.end(); ++it)
        {
                ss << it->first << "=" << it->second.StringValue() << std::endl;
        }
        return ss.str();
}


namespace ConfigHelper
{
    std::map<std::string, std::string> ParseArguments(const std::string& args)
        {
                std::map<std::string, std::string> config;

                std::vector<std::string> sections = Util::str_split(args, ";"); 

                for (unsigned i=0; i<sections.size(); i++)
                {
                        std::string current = Util::str_trim(sections[i]);
                        std::vector<std::string> params = Util::str_split( current, "=");
                        if (params.size() != 2)
                                throw std::runtime_error(std::string("syntax error in config line: ") + args);

                        std::string key = Util::str_tolower(Util::str_trim(params[0]));
                        std::string val = Util::str_trim(params[1]);
                        config[key] = val;
                }
        
                return config;
        }

        int StringToInt(const std::string& input)
        {
                char* endptr = (char*) input.c_str();
                int retval = strtol(input.c_str(), &endptr, 10);

                if ( *endptr != 0)
                        throw std::runtime_error( std::string("Error: can not convert this to a number: ") + input);

                return retval;
        }
}
1	torben	146	#include "ConfigFile.h"
2	torben	205	#include "Util.h"
3	torben	146
4			#include <fstream>
5	torben	202	#include <sstream>
6	torben	205	#include <stdexcept>
7	torben	146
8	torben	205	#include <stdlib.h>
9
10	torben	146	const char SEPERATOR = '/';
11
12			std::string trim(std::string const& source, char const* delims = " \t\r\n")
13			{
14			std::string result(source);
15			std::string::size_type index = result.find_last_not_of(delims);
16			if (index != std::string::npos)
17			result.erase(++index);
18
19			index = result.find_first_not_of(delims);
20			if (index != std::string::npos)
21			result.erase(0, index);
22			else
23			result.erase();
24			return result;
25			}
26
27			ConfigFile::ConfigFile()
28			{
29			}
30
31			ConfigFile::ConfigFile(std::string const& configFile)
32			{
33			Open(configFile);
34			}
35
36			bool ConfigFile::Open(std::string const& configFile)
37			{
38			std::ifstream file(configFile.c_str());
39
40			std::string line;
41			std::string name;
42			std::string value;
43			std::string inSection;
44			int posEqual;
45
46			if (!file)
47			{
48			return false;
49			}
50
51			while (std::getline(file,line))
52			{
53
54			if (! line.length()) continue;
55
56			if (line[0] == '#') continue;
57			if (line[0] == ';') continue;
58
59			if (line[0] == '[')
60			{
61			inSection=trim(line.substr(1,line.find(']')-1));
62			continue;
63			}
64
65			posEqual=line.find('=');
66			name = trim(line.substr(0,posEqual));
67			value = trim(line.substr(posEqual+1));
68
69	torben	201	content_.insert(std::make_pair(inSection+SEPERATOR+name,Value(value)));
70	torben	146	}
71			return true;
72			}
73
74			Value const& ConfigFile::GetValue(std::string const& section, std::string const& entry) const
75			{
76
77	torben	201	content_iterator ci = content_.find(section + SEPERATOR + entry);
78	torben	146
79			if (ci == content_.end()) throw "does not exist";
80
81			return ci->second;
82			}
83
84	torben	201	std::vector<Value> ConfigFile::GetValues(std::string const& section, std::string const& entry) const
85			{
86			std::vector<Value> values;
87			std::string search = section + SEPERATOR + entry;
88			std::pair<content_iterator, content_iterator> range = content_.equal_range(search);
89
90			for (content_iterator it=range.first; it != range.second; ++it)
91			{
92			values.push_back( it->second );
93			}
94			return values;
95			}
96
97	torben	146	Value const& ConfigFile::GetValue(std::string const& section, std::string const& entry, double value)
98			{
99			try
100			{
101			return GetValue(section, entry);
102			}
103			catch (const char *)
104			{
105	torben	201	return content_.insert(std::make_pair(section+SEPERATOR+entry, Value(value)))->second;
106	torben	146	}
107			}
108
109			Value const& ConfigFile::GetValue(std::string const& section, std::string const& entry, std::string const& value)
110			{
111			try
112			{
113			return GetValue(section, entry);
114			}
115			catch (const char *)
116			{
117	torben	201	return content_.insert(std::make_pair(section+SEPERATOR+entry, Value(value)))->second;
118	torben	146	}
119			}
120
121	torben	202	std::string ConfigFile::DumpConfig() const
122			{
123			std::ostringstream ss;
124			for (content_iterator it=content_.begin(); it!=content_.end(); ++it)
125			{
126			ss << it->first << "=" << it->second.StringValue() << std::endl;
127			}
128			return ss.str();
129			}
130	torben	205
131
132			namespace ConfigHelper
133			{
134			std::map<std::string, std::string> ParseArguments(const std::string& args)
135			{
136			std::map<std::string, std::string> config;
137
138			std::vector<std::string> sections = Util::str_split(args, ";");
139
140			for (unsigned i=0; i<sections.size(); i++)
141			{
142			std::string current = Util::str_trim(sections[i]);
143			std::vector<std::string> params = Util::str_split( current, "=");
144			if (params.size() != 2)
145			throw std::runtime_error(std::string("syntax error in config line: ") + args);
146
147			std::string key = Util::str_tolower(Util::str_trim(params[0]));
148			std::string val = Util::str_trim(params[1]);
149			config[key] = val;
150			}
151
152			return config;
153			}
154
155			int StringToInt(const std::string& input)
156			{
157			char* endptr = (char*) input.c_str();
158			int retval = strtol(input.c_str(), &endptr, 10);
159
160			if ( *endptr != 0)
161			throw std::runtime_error( std::string("Error: can not convert this to a number: ") + input);
162
163			return retval;
164			}
165			}