]> git.stg.codes - stg.git/blob - stglibs/conffiles.lib/conffiles.cpp
47a92db08a024cae1ebadc12a3c9afe943edf96e
[stg.git] / stglibs / conffiles.lib / conffiles.cpp
1 /*
2  *    This program is free software; you can redistribute it and/or modify
3  *    it under the terms of the GNU General Public License as published by
4  *    the Free Software Foundation; either version 2 of the License, or
5  *    (at your option) any later version.
6  *
7  *    This program is distributed in the hope that it will be useful,
8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *    GNU General Public License for more details.
11  *
12  *    You should have received a copy of the GNU General Public License
13  *    along with this program; if not, write to the Free Software
14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  */
16
17 /*
18  *    Date: 27.10.2002
19  */
20
21 /*
22  *    Author : Boris Mikhailenko <stg34@ua.fm>
23  */
24
25  /*
26  $Revision: 1.5 $
27  $Date: 2009/10/22 11:40:22 $
28  */
29
30 //---------------------------------------------------------------------------
31 #include <cerrno>
32 #include <cstring>
33 #include <cstdlib>
34
35 #include <fstream>
36
37 #include "conffiles.h"
38 #include "common.h"
39
40 using namespace std;
41
42 //---------------------------------------------------------------------------
43 bool StringCaseCmp(const string & str1, const string & str2)
44 {
45 return (strcasecmp(str1.c_str(), str2.c_str()) < 0);
46 }
47 //---------------------------------------------------------------------------
48 CONFIGFILE::CONFIGFILE(const string & fn, bool nook)
49     : param_val(StringCaseCmp),
50       fileName(fn),
51       error(0)
52 {
53 ifstream f(fileName.c_str());
54
55 if (!f)
56     {
57     if (!nook)
58         error = -1;
59     return;
60     }
61
62 string line;
63 while (getline(f, line))
64     {
65     size_t pos = line.find('#');
66     if (pos != string::npos)
67         line.resize(pos);
68
69     if (line.find_first_not_of(" \t\r") == string::npos)
70         continue;
71
72     pos = line.find_first_of('=');
73     if (pos == string::npos)
74         {
75         error = -1;
76         return;
77         }
78
79     string parameter = line.substr(0, pos);
80     string value = line.substr(pos + 1);
81     param_val[parameter] = value;
82     }
83 }
84 //---------------------------------------------------------------------------
85 CONFIGFILE::~CONFIGFILE()
86 {
87 }
88 //---------------------------------------------------------------------------
89 const string & CONFIGFILE::GetFileName() const
90 {
91 return fileName;
92 }
93 //---------------------------------------------------------------------------
94 int CONFIGFILE::Error()
95 {
96 int e = error;
97 error = 0;
98 return e;
99 }
100 //---------------------------------------------------------------------------
101 int CONFIGFILE::Flush()
102 {
103 ofstream f(fileName.c_str());
104 if (!f.is_open())
105     {
106     error = EIO;
107     return EIO;
108     }
109
110 map<string, string>::const_iterator it = param_val.begin();
111 while (it != param_val.end())
112     {
113     f << it->first << "=" << it->second << "\n";
114     it++;
115     }
116
117 f.close();
118
119 return 0;
120 }
121 /*//---------------------------------------------------------------------------
122 int CONFIGFILE::ReadString(const string & param, char * str, int * maxLen, const char * defaultVal) const
123 {
124 it = param_val.find(param);
125 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
126
127 if (it != param_val.end())
128     {
129     // þÔÏ-ÔÏ ÓÔÏÉÔ
130     strncpy(str, param_val[param].c_str(), *maxLen);
131     *maxLen = param_val[param].size();
132     return 0;
133     }
134
135 strncpy(str, defaultVal, *maxLen);
136 *maxLen = strlen(defaultVal);
137 return -1;
138 }*/
139 //---------------------------------------------------------------------------
140 int CONFIGFILE::ReadString(const string & param, string * val, const string & defaultVal) const
141 {
142 const map<string, string>::const_iterator it(param_val.find(param));
143 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
144
145 if (it != param_val.end())
146     {
147     // þÔÏ-ÔÏ ÓÔÏÉÔ
148     *val = it->second;
149     return 0;
150     }
151
152 *val = defaultVal;
153 return -1;
154 }
155 /*//---------------------------------------------------------------------------
156 int CONFIGFILE::WriteString(const string & param, const char * val)
157 {
158 WriteString(param, string(val));
159 return 0;
160 }*/
161 //---------------------------------------------------------------------------
162 int CONFIGFILE::WriteString(const string & param, const string &val)
163 {
164 param_val[param] = val;
165 Flush();
166 return 0;
167 }
168 //---------------------------------------------------------------------------
169 int CONFIGFILE::ReadTime(const string & param, time_t * val, time_t defaultVal) const
170 {
171 const map<string, string>::const_iterator it(param_val.find(param));
172
173 if (it != param_val.end())
174     {
175     char *res;
176     *val = strtol(it->second.c_str(), &res, 10);
177     if (*res != 0)
178         {
179         *val = defaultVal; //Error!
180         return EINVAL;
181         }
182     return 0;
183     }
184
185 *val = defaultVal;
186 return -1;
187 }
188 //---------------------------------------------------------------------------
189 int CONFIGFILE::ReadInt(const string & param, int * val, int defaultVal) const
190 {
191 const map<string, string>::const_iterator it(param_val.find(param));
192 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
193
194 if (it != param_val.end())
195     {
196     // þÔÏ-ÔÏ ÓÔÏÉÔ
197     char *res;
198     *val = strtol(it->second.c_str(), &res, 10);
199     if (*res != 0)
200         {
201         *val = defaultVal; //Error!
202         return EINVAL;
203         }
204     return 0;
205     }
206
207 *val = defaultVal;
208 return -1;
209 }
210 //---------------------------------------------------------------------------
211 int CONFIGFILE::ReadUInt(const string & param, unsigned int * val, unsigned int defaultVal) const
212 {
213 const map<string, string>::const_iterator it(param_val.find(param));
214 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
215
216 if (it != param_val.end())
217     {
218     // þÔÏ-ÔÏ ÓÔÏÉÔ
219     char *res;
220     *val = strtoul(it->second.c_str(), &res, 10);
221     if (*res != 0)
222         {
223         *val = defaultVal; //Error!
224         return EINVAL;
225         }
226     return 0;
227     }
228
229 *val = defaultVal;
230 return -1;
231 }
232 //---------------------------------------------------------------------------
233 int CONFIGFILE::ReadLongInt(const string & param, long int * val, long int defaultVal) const
234 {
235 const map<string, string>::const_iterator it(param_val.find(param));
236 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
237
238 if (it != param_val.end())
239     {
240     // þÔÏ-ÔÏ ÓÔÏÉÔ
241     char *res;
242     *val = strtol(it->second.c_str(), &res, 10);
243     if (*res != 0)
244         {
245         *val = defaultVal; //Error!
246         return EINVAL;
247         }
248     return 0;
249     }
250
251 *val = defaultVal;
252 return -1;
253 }
254 //---------------------------------------------------------------------------
255 int CONFIGFILE::ReadULongInt(const string & param, unsigned long int * val, unsigned long int defaultVal) const
256 {
257 const map<string, string>::const_iterator it(param_val.find(param));
258 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
259
260 if (it != param_val.end())
261     {
262     // þÔÏ-ÔÏ ÓÔÏÉÔ
263     char *res;
264     *val = strtoul(it->second.c_str(), &res, 10);
265     if (*res != 0)
266         {
267         *val = defaultVal; //Error!
268         return EINVAL;
269         }
270     return 0;
271     }
272
273 *val = defaultVal;
274 return -1;
275 }
276 //---------------------------------------------------------------------------
277 int CONFIGFILE::ReadLongLongInt(const string & param, int64_t * val, int64_t defaultVal) const
278 {
279 const map<string, string>::const_iterator it(param_val.find(param));
280 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
281
282 if (it != param_val.end())
283     {
284     // þÔÏ-ÔÏ ÓÔÏÉÔ
285     char *res;
286     *val = strtoll(it->second.c_str(), &res, 10);
287     if (*res != 0)
288         {
289         *val = defaultVal; //Error!
290         return EINVAL;
291         }
292     return 0;
293     }
294
295 *val = defaultVal;
296 return -1;
297 }
298 //---------------------------------------------------------------------------
299 int CONFIGFILE::ReadULongLongInt(const string & param, uint64_t * val, uint64_t defaultVal) const
300 {
301 const map<string, string>::const_iterator it(param_val.find(param));
302 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
303
304 if (it != param_val.end())
305     {
306     // þÔÏ-ÔÏ ÓÔÏÉÔ
307     char *res;
308     *val = strtoull(it->second.c_str(), &res, 10);
309     if (*res != 0)
310         {
311         *val = defaultVal; //Error!
312         return EINVAL;
313         }
314     return 0;
315     }
316
317 *val = defaultVal;
318 return -1;
319 }
320 //---------------------------------------------------------------------------
321 int CONFIGFILE::ReadShortInt(const string & param, short int * val, short int defaultVal) const
322 {
323 const map<string, string>::const_iterator it(param_val.find(param));
324 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
325
326 if (it != param_val.end())
327     {
328     // þÔÏ-ÔÏ ÓÔÏÉÔ
329     char *res;
330     *val = (short)strtol(it->second.c_str(), &res, 10);
331     if (*res != 0)
332         {
333         *val = defaultVal; //Error!
334         return EINVAL;
335         }
336     return 0;
337     }
338
339 *val = defaultVal;
340 return -1;
341 }
342 //---------------------------------------------------------------------------
343 int CONFIGFILE::ReadUShortInt(const string & param, unsigned short int * val, unsigned short int defaultVal) const
344 {
345 const map<string, string>::const_iterator it(param_val.find(param));
346 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
347
348 if (it != param_val.end())
349     {
350     // þÔÏ-ÔÏ ÓÔÏÉÔ
351     char *res;
352     *val = (short)strtoul(it->second.c_str(), &res, 10);
353     if (*res != 0)
354         {
355         *val = defaultVal; //Error!
356         return EINVAL;
357         }
358     return 0;
359     }
360
361 *val = defaultVal;
362 return -1;
363 }
364 //---------------------------------------------------------------------------
365 int CONFIGFILE::WriteInt(const string & param, int64_t val)
366 {
367 string s;
368 //sprintf(s, "%lld", val);
369 x2str(val, s);
370 param_val[param] = s;
371 Flush();
372 return 0;
373 }
374 //---------------------------------------------------------------------------
375 int CONFIGFILE::ReadDouble(const string & param, double * val, double defaultVal) const
376 {
377 const map<string, string>::const_iterator it(param_val.find(param));
378 // îÁÛÌÉ ÎÕÖÎÕÀ ÐÅÒÅÍÅÎÎÕÀ
379
380 if (it != param_val.end())
381     {
382     // þÔÏ-ÔÏ ÓÔÏÉÔ
383     char *res;
384     *val = strtod(it->second.c_str(), &res);
385     if (*res != 0)
386         {
387         *val = defaultVal; //Error!
388         return EINVAL;
389         }
390     return 0;
391     }
392
393 *val = defaultVal;
394 return -1;
395 }
396 //---------------------------------------------------------------------------
397 int CONFIGFILE::WriteDouble(const string & param, double val)
398 {
399 char s[30];
400 sprintf(s, "%f", val);
401 param_val[param] = s;
402 Flush();
403 return 0;
404 }
405 //---------------------------------------------------------------------------