← Back to branch summary

~ci-train-bot/unity-api/unity-api-ubuntu-yakkety-landing-003

« back to all changes in this revision

Viewing changes to src/unity/util/IniParser.cpp

  • Committer: CI Train Bot
  • Author(s): Marcus Tomlinson
  • Date: 2016-04-05 06:03:31 UTC
  • mfrom: (213.2.27 lp-1552082)
  • Revision ID: ci-train-bot@canonical.com-20160405060331-of9ys2hpycxm9kjj
Add set*() methods to IniParser Fixes: #1552082
Approved by: Michi Henning, Unity8 CI Bot

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/unity/util/IniParser.cpp
16
16
 * Authored by: Jussi Pakkanen <jussi.pakkanen@canonical.com>
17
17
 */
18
18
 
19
 
#include<unity/UnityExceptions.h>
20
 
#include<unity/util/IniParser.h>
21
 
#include<glib.h>
22
 
#include<mutex>
 
19
#include <unity/UnityExceptions.h>
 
20
#include <unity/util/IniParser.h>
 
21
 
 
22
#include <mutex>
 
23
 
 
24
#include <glib.h>
23
25
 
24
26
using namespace std;
25
27
 
29
31
namespace util
30
32
{
31
33
 
32
 
 
33
34
namespace internal
34
35
{
35
36
 
37
38
{
38
39
    GKeyFile *k;
39
40
    string filename;
 
41
    bool dirty = false;
40
42
};
41
43
 
42
44
static std::mutex parser_mutex;
68
70
 
69
71
IniParser::IniParser(const char* filename)
70
72
{
71
 
    lock_guard<std::mutex> lock(internal::parser_mutex);
72
 
 
73
73
    GKeyFile* kf = g_key_file_new();
74
74
    GError* e = nullptr;
75
75
    if (!kf)
95
95
 
96
96
IniParser::~IniParser() noexcept
97
97
{
98
 
    lock_guard<std::mutex> lock(internal::parser_mutex);
99
 
 
100
98
    g_key_file_free(p->k);
101
99
    delete p;
102
100
}
103
101
 
104
102
bool IniParser::has_group(const std::string& group) const noexcept
105
103
{
 
104
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
105
 
106
106
    gboolean rval;
107
107
    rval = g_key_file_has_group(p->k, group.c_str());
108
108
    return rval;
110
110
 
111
111
bool IniParser::has_key(const std::string& group, const std::string& key) const
112
112
{
 
113
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
114
 
113
115
    gboolean rval;
114
116
    GError* e = nullptr;
115
117
    rval = g_key_file_has_key(p->k, group.c_str(), key.c_str(), &e);
119
121
 
120
122
std::string IniParser::get_string(const std::string& group, const std::string& key) const
121
123
{
 
124
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
125
 
122
126
    gchar* value;
123
127
    GError* e = nullptr;
124
128
    string result;
131
135
 
132
136
std::string IniParser::get_locale_string(const std::string& group, const std::string& key, const std::string& locale) const
133
137
{
 
138
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
139
 
134
140
    gchar* value;
135
141
    GError* e = nullptr;
136
142
    string result;
143
149
 
144
150
bool IniParser::get_boolean(const std::string& group, const std::string& key) const
145
151
{
 
152
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
153
 
146
154
    bool rval;
147
155
    GError* e = nullptr;
148
156
    rval = g_key_file_get_boolean(p->k, group.c_str(), key.c_str(), &e);
152
160
 
153
161
int IniParser::get_int(const std::string& group, const std::string& key) const
154
162
{
 
163
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
164
 
155
165
    int rval;
156
166
    GError* e = nullptr;
157
167
    rval = g_key_file_get_integer(p->k, group.c_str(), key.c_str(), &e);
159
169
    return rval;
160
170
}
161
171
 
 
172
double IniParser::get_double(const std::string& group, const std::string& key) const
 
173
{
 
174
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
175
 
 
176
    double rval;
 
177
    GError* e = nullptr;
 
178
    rval = g_key_file_get_double(p->k, group.c_str(), key.c_str(), &e);
 
179
    inspect_error(e, "Could not get double value", p->filename, group);
 
180
    return rval;
 
181
}
 
182
 
162
183
std::vector<std::string> IniParser::get_string_array(const std::string& group, const std::string& key) const
163
184
{
 
185
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
186
 
164
187
    vector<string> result;
165
188
    GError* e = nullptr;
166
189
    gchar** strlist;
179
202
                                                            const std::string& key,
180
203
                                                            const std::string& locale) const
181
204
{
 
205
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
206
 
182
207
    vector<string> result;
183
208
    GError* e = nullptr;
184
209
    gchar** strlist;
194
219
    return result;
195
220
}
196
221
 
 
222
vector<bool> IniParser::get_boolean_array(const std::string& group, const std::string& key) const
 
223
{
 
224
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
225
 
 
226
    vector<bool> result;
 
227
    GError* e = nullptr;
 
228
    gboolean* bools;
 
229
    gsize count;
 
230
    bools = g_key_file_get_boolean_list(p->k, group.c_str(), key.c_str(), &count, &e);
 
231
    inspect_error(e, "Could not get boolean array", p->filename, group);
 
232
    for (gsize i = 0; i < count; i++)
 
233
    {
 
234
        result.push_back(bools[i]);
 
235
    }
 
236
    g_free(bools);
 
237
    return result;
 
238
}
 
239
 
197
240
vector<int> IniParser::get_int_array(const std::string& group, const std::string& key) const
198
241
{
 
242
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
243
 
199
244
    vector<int> result;
200
245
    GError* e = nullptr;
201
246
    gint* ints;
210
255
    return result;
211
256
}
212
257
 
213
 
vector<bool> IniParser::get_boolean_array(const std::string& group, const std::string& key) const
 
258
vector<double> IniParser::get_double_array(const std::string& group, const std::string& key) const
214
259
{
215
 
    vector<bool> result;
 
260
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
261
 
 
262
    vector<double> result;
216
263
    GError* e = nullptr;
217
 
    gboolean* bools;
 
264
    gdouble* doubles;
218
265
    gsize count;
219
 
    bools = g_key_file_get_boolean_list(p->k, group.c_str(), key.c_str(), &count, &e);
220
 
    inspect_error(e, "Could not get boolean array", p->filename, group);
 
266
    doubles = g_key_file_get_double_list(p->k, group.c_str(), key.c_str(), &count, &e);
 
267
    inspect_error(e, "Could not get double array", p->filename, group);
221
268
    for (gsize i = 0; i < count; i++)
222
269
    {
223
 
        result.push_back(bools[i]);
 
270
        result.push_back(doubles[i]);
224
271
    }
225
 
    g_free(bools);
 
272
    g_free(doubles);
226
273
    return result;
227
274
}
228
275
 
229
276
string IniParser::get_start_group() const
230
277
{
 
278
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
279
 
231
280
    gchar* sg = g_key_file_get_start_group(p->k);
232
281
    string result(sg);
233
282
    g_free(sg);
236
285
 
237
286
vector<string> IniParser::get_groups() const
238
287
{
 
288
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
289
 
239
290
    vector<string> result;
240
291
    gsize count;
241
292
    gchar** groups = g_key_file_get_groups(p->k, &count);
249
300
 
250
301
vector<string> IniParser::get_keys(const std::string& group) const
251
302
{
 
303
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
304
 
252
305
    vector<string> result;
253
306
    GError* e = nullptr;
254
307
    gchar** strlist;
264
317
    return result;
265
318
}
266
319
 
 
320
bool IniParser::remove_group(const std::string& group)
 
321
{
 
322
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
323
 
 
324
    gboolean rval;
 
325
    GError* e = nullptr;
 
326
    rval = g_key_file_remove_group(p->k, group.c_str(), &e);
 
327
    inspect_error(e, "Error removing group", p->filename, group);
 
328
    return rval;
 
329
}
 
330
 
 
331
bool IniParser::remove_key(const std::string& group, const std::string& key)
 
332
{
 
333
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
334
 
 
335
    gboolean rval;
 
336
    GError* e = nullptr;
 
337
    rval = g_key_file_remove_key(p->k, group.c_str(), key.c_str(), &e);
 
338
    inspect_error(e, "Error removing key", p->filename, group);
 
339
    return rval;
 
340
}
 
341
 
 
342
void IniParser::set_string(const std::string& group, const std::string& key, const std::string& value)
 
343
{
 
344
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
345
 
 
346
    g_key_file_set_string(p->k, group.c_str(), key.c_str(), value.c_str());
 
347
    p->dirty = true;
 
348
}
 
349
 
 
350
void IniParser::set_locale_string(const std::string& group, const std::string& key,
 
351
                                  const std::string& value, const std::string& locale)
 
352
{
 
353
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
354
 
 
355
    g_key_file_set_locale_string(p->k, group.c_str(), key.c_str(), locale.c_str(), value.c_str());
 
356
    p->dirty = true;
 
357
}
 
358
 
 
359
void IniParser::set_boolean(const std::string& group, const std::string& key, bool value)
 
360
{
 
361
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
362
 
 
363
    g_key_file_set_boolean(p->k, group.c_str(), key.c_str(), value);
 
364
    p->dirty = true;
 
365
}
 
366
 
 
367
void IniParser::set_int(const std::string& group, const std::string& key, int value)
 
368
{
 
369
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
370
 
 
371
    g_key_file_set_integer(p->k, group.c_str(), key.c_str(), value);
 
372
    p->dirty = true;
 
373
}
 
374
 
 
375
void IniParser::set_double(const std::string& group, const std::string& key, double value)
 
376
{
 
377
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
378
 
 
379
    g_key_file_set_double(p->k, group.c_str(), key.c_str(), value);
 
380
    p->dirty = true;
 
381
}
 
382
 
 
383
void IniParser::set_string_array(const std::string& group, const std::string& key,
 
384
                                 const std::vector<std::string>& value)
 
385
{
 
386
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
387
 
 
388
    int count = value.size();
 
389
    gchar** strlist = g_new(gchar*, count+1);
 
390
 
 
391
    for (int i = 0; i < count; ++i)
 
392
    {
 
393
        strlist[i] = g_strdup(value[i].c_str());
 
394
    }
 
395
    strlist[count] = nullptr;
 
396
 
 
397
    g_key_file_set_string_list(p->k, group.c_str(), key.c_str(), strlist, count);
 
398
    p->dirty = true;
 
399
 
 
400
    g_strfreev(strlist);
 
401
}
 
402
 
 
403
void IniParser::set_locale_string_array(const std::string& group, const std::string& key,
 
404
                                        const std::vector<std::string>& value, const std::string& locale)
 
405
{
 
406
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
407
 
 
408
    int count = value.size();
 
409
    gchar** strlist = g_new(gchar*, count+1);
 
410
 
 
411
    for (int i = 0; i < count; ++i)
 
412
    {
 
413
        strlist[i] = g_strdup(value[i].c_str());
 
414
    }
 
415
    strlist[count] = nullptr;
 
416
 
 
417
    g_key_file_set_locale_string_list(p->k, group.c_str(), key.c_str(), locale.c_str(), strlist, count);
 
418
    p->dirty = true;
 
419
 
 
420
    g_strfreev(strlist);
 
421
}
 
422
 
 
423
void IniParser::set_boolean_array(const std::string& group, const std::string& key, const std::vector<bool>& value)
 
424
{
 
425
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
426
 
 
427
    int count = value.size();
 
428
    gboolean* boollist = g_new(gboolean, count);
 
429
 
 
430
    for (int i = 0; i < count; ++i)
 
431
    {
 
432
        boollist[i] = value[i];
 
433
    }
 
434
 
 
435
    g_key_file_set_boolean_list(p->k, group.c_str(), key.c_str(), boollist, count);
 
436
    p->dirty = true;
 
437
 
 
438
    g_free(boollist);
 
439
}
 
440
 
 
441
void IniParser::set_int_array(const std::string& group, const std::string& key, const std::vector<int>& value)
 
442
{
 
443
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
444
 
 
445
    int count = value.size();
 
446
    gint* intlist = g_new(gint, count);
 
447
 
 
448
    for (int i = 0; i < count; ++i)
 
449
    {
 
450
        intlist[i] = value[i];
 
451
    }
 
452
 
 
453
    g_key_file_set_integer_list(p->k, group.c_str(), key.c_str(), intlist, count);
 
454
    p->dirty = true;
 
455
 
 
456
    g_free(intlist);
 
457
}
 
458
 
 
459
void IniParser::set_double_array(const std::string& group, const std::string& key, const std::vector<double>& value)
 
460
{
 
461
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
462
 
 
463
    int count = value.size();
 
464
    gdouble* doublelist = g_new(gdouble, count);
 
465
 
 
466
    for (int i = 0; i < count; ++i)
 
467
    {
 
468
        doublelist[i] = value[i];
 
469
    }
 
470
 
 
471
    g_key_file_set_double_list(p->k, group.c_str(), key.c_str(), doublelist, count);
 
472
    p->dirty = true;
 
473
 
 
474
    g_free(doublelist);
 
475
}
 
476
 
 
477
void IniParser::sync()
 
478
{
 
479
    lock_guard<std::mutex> lock(internal::parser_mutex);
 
480
 
 
481
    if (p->dirty)
 
482
    {
 
483
        GError* e = nullptr;
 
484
        if (!g_key_file_save_to_file(p->k, p->filename.c_str(), &e))
 
485
        {
 
486
            string message = "Could not write ini file ";
 
487
            message += p->filename;
 
488
            message += ": ";
 
489
            message += e->message;
 
490
            int errnum = e->code;
 
491
            g_error_free(e);
 
492
            throw FileException(message, errnum);
 
493
        }
 
494
 
 
495
        p->dirty = false;
 
496
    }
 
497
}
267
498
 
268
499
} // namespace util
269
500