|
101
|
1 /*
|
|
|
2 * The MIT License (MIT)
|
|
|
3 * Copyright (c) 2018 Danijel Durakovic
|
|
|
4 *
|
|
|
5 * Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
|
6 * this software and associated documentation files (the "Software"), to deal in
|
|
|
7 * the Software without restriction, including without limitation the rights to
|
|
|
8 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
|
9 * of the Software, and to permit persons to whom the Software is furnished to do
|
|
|
10 * so, subject to the following conditions:
|
|
|
11 *
|
|
|
12 * The above copyright notice and this permission notice shall be included in all
|
|
|
13 * copies or substantial portions of the Software.
|
|
|
14 *
|
|
|
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
|
17 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
|
18 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
|
19 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
20 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
21 *
|
|
|
22 */
|
|
|
23
|
|
|
24 ///////////////////////////////////////////////////////////////////////////////
|
|
|
25 //
|
|
|
26 // /mINI/ v0.9.14
|
|
|
27 // An INI file reader and writer for the modern age.
|
|
|
28 //
|
|
|
29 ///////////////////////////////////////////////////////////////////////////////
|
|
|
30 //
|
|
|
31 // A tiny utility library for manipulating INI files with a straightforward
|
|
|
32 // API and a minimal footprint. It conforms to the (somewhat) standard INI
|
|
|
33 // format - sections and keys are case insensitive and all leading and
|
|
|
34 // trailing whitespace is ignored. Comments are lines that begin with a
|
|
|
35 // semicolon. Trailing comments are allowed on section lines.
|
|
|
36 //
|
|
|
37 // Files are read on demand, upon which data is kept in memory and the file
|
|
|
38 // is closed. This utility supports lazy writing, which only writes changes
|
|
|
39 // and updates to a file and preserves custom formatting and comments. A lazy
|
|
|
40 // write invoked by a write() call will read the output file, find what
|
|
|
41 // changes have been made and update the file accordingly. If you only need to
|
|
|
42 // generate files, use generate() instead. Section and key order is preserved
|
|
|
43 // on read, write and insert.
|
|
|
44 //
|
|
|
45 ///////////////////////////////////////////////////////////////////////////////
|
|
|
46 //
|
|
|
47 // /* BASIC USAGE EXAMPLE: */
|
|
|
48 //
|
|
|
49 // /* read from file */
|
|
|
50 // mINI::INIFile file("myfile.ini");
|
|
|
51 // mINI::INIStructure ini;
|
|
|
52 // file.read(ini);
|
|
|
53 //
|
|
|
54 // /* read value; gets a reference to actual value in the structure.
|
|
|
55 // if key or section don't exist, a new empty value will be created */
|
|
|
56 // std::string& value = ini["section"]["key"];
|
|
|
57 //
|
|
|
58 // /* read value safely; gets a copy of value in the structure.
|
|
|
59 // does not alter the structure */
|
|
|
60 // std::string value = ini.get("section").get("key");
|
|
|
61 //
|
|
|
62 // /* set or update values */
|
|
|
63 // ini["section"]["key"] = "value";
|
|
|
64 //
|
|
|
65 // /* set multiple values */
|
|
|
66 // ini["section2"].set({
|
|
|
67 // {"key1", "value1"},
|
|
|
68 // {"key2", "value2"}
|
|
|
69 // });
|
|
|
70 //
|
|
|
71 // /* write updates back to file, preserving comments and formatting */
|
|
|
72 // file.write(ini);
|
|
|
73 //
|
|
|
74 // /* or generate a file (overwrites the original) */
|
|
|
75 // file.generate(ini);
|
|
|
76 //
|
|
|
77 ///////////////////////////////////////////////////////////////////////////////
|
|
|
78 //
|
|
|
79 // Long live the INI file!!!
|
|
|
80 //
|
|
|
81 ///////////////////////////////////////////////////////////////////////////////
|
|
|
82
|
|
|
83 #ifndef MINI_INI_H_
|
|
|
84 #define MINI_INI_H_
|
|
|
85
|
|
|
86 #include <string>
|
|
|
87 #include <sstream>
|
|
|
88 #include <algorithm>
|
|
|
89 #include <utility>
|
|
|
90 #include <unordered_map>
|
|
|
91 #include <vector>
|
|
|
92 #include <memory>
|
|
|
93 #include <fstream>
|
|
|
94 #include <sys/stat.h>
|
|
|
95 #include <cctype>
|
|
|
96
|
|
|
97 namespace mINI
|
|
|
98 {
|
|
|
99 namespace INIStringUtil
|
|
|
100 {
|
|
|
101 const char* const whitespaceDelimiters = " \t\n\r\f\v";
|
|
|
102 inline void trim(std::string& str)
|
|
|
103 {
|
|
|
104 str.erase(str.find_last_not_of(whitespaceDelimiters) + 1);
|
|
|
105 str.erase(0, str.find_first_not_of(whitespaceDelimiters));
|
|
|
106 }
|
|
|
107 #ifndef MINI_CASE_SENSITIVE
|
|
|
108 inline void toLower(std::string& str)
|
|
|
109 {
|
|
|
110 std::transform(str.begin(), str.end(), str.begin(), [](const char c) {
|
|
|
111 return static_cast<char>(std::tolower(c));
|
|
|
112 });
|
|
|
113 }
|
|
|
114 #endif
|
|
|
115 inline void replace(std::string& str, std::string const& a, std::string const& b)
|
|
|
116 {
|
|
|
117 if (!a.empty())
|
|
|
118 {
|
|
|
119 std::size_t pos = 0;
|
|
|
120 while ((pos = str.find(a, pos)) != std::string::npos)
|
|
|
121 {
|
|
|
122 str.replace(pos, a.size(), b);
|
|
|
123 pos += b.size();
|
|
|
124 }
|
|
|
125 }
|
|
|
126 }
|
|
|
127 #ifdef _WIN32
|
|
|
128 const char* const endl = "\r\n";
|
|
|
129 #else
|
|
|
130 const char* const endl = "\n";
|
|
|
131 #endif
|
|
|
132 }
|
|
|
133
|
|
|
134 template<typename T>
|
|
|
135 class INIMap
|
|
|
136 {
|
|
|
137 private:
|
|
|
138 using T_DataIndexMap = std::unordered_map<std::string, std::size_t>;
|
|
|
139 using T_DataItem = std::pair<std::string, T>;
|
|
|
140 using T_DataContainer = std::vector<T_DataItem>;
|
|
|
141 using T_MultiArgs = typename std::vector<std::pair<std::string, T>>;
|
|
|
142
|
|
|
143 T_DataIndexMap dataIndexMap;
|
|
|
144 T_DataContainer data;
|
|
|
145
|
|
|
146 inline std::size_t setEmpty(std::string& key)
|
|
|
147 {
|
|
|
148 std::size_t index = data.size();
|
|
|
149 dataIndexMap[key] = index;
|
|
|
150 data.emplace_back(key, T());
|
|
|
151 return index;
|
|
|
152 }
|
|
|
153
|
|
|
154 public:
|
|
|
155 using const_iterator = typename T_DataContainer::const_iterator;
|
|
|
156
|
|
|
157 INIMap() { }
|
|
|
158
|
|
|
159 INIMap(INIMap const& other)
|
|
|
160 {
|
|
|
161 std::size_t data_size = other.data.size();
|
|
|
162 for (std::size_t i = 0; i < data_size; ++i)
|
|
|
163 {
|
|
|
164 auto const& key = other.data[i].first;
|
|
|
165 auto const& obj = other.data[i].second;
|
|
|
166 data.emplace_back(key, obj);
|
|
|
167 }
|
|
|
168 dataIndexMap = T_DataIndexMap(other.dataIndexMap);
|
|
|
169 }
|
|
|
170
|
|
|
171 T& operator[](std::string key)
|
|
|
172 {
|
|
|
173 INIStringUtil::trim(key);
|
|
|
174 #ifndef MINI_CASE_SENSITIVE
|
|
|
175 INIStringUtil::toLower(key);
|
|
|
176 #endif
|
|
|
177 auto it = dataIndexMap.find(key);
|
|
|
178 bool hasIt = (it != dataIndexMap.end());
|
|
|
179 std::size_t index = (hasIt) ? it->second : setEmpty(key);
|
|
|
180 return data[index].second;
|
|
|
181 }
|
|
|
182 T get(std::string key) const
|
|
|
183 {
|
|
|
184 INIStringUtil::trim(key);
|
|
|
185 #ifndef MINI_CASE_SENSITIVE
|
|
|
186 INIStringUtil::toLower(key);
|
|
|
187 #endif
|
|
|
188 auto it = dataIndexMap.find(key);
|
|
|
189 if (it == dataIndexMap.end())
|
|
|
190 {
|
|
|
191 return T();
|
|
|
192 }
|
|
|
193 return T(data[it->second].second);
|
|
|
194 }
|
|
|
195 bool has(std::string key) const
|
|
|
196 {
|
|
|
197 INIStringUtil::trim(key);
|
|
|
198 #ifndef MINI_CASE_SENSITIVE
|
|
|
199 INIStringUtil::toLower(key);
|
|
|
200 #endif
|
|
|
201 return (dataIndexMap.count(key) == 1);
|
|
|
202 }
|
|
|
203 void set(std::string key, T obj)
|
|
|
204 {
|
|
|
205 INIStringUtil::trim(key);
|
|
|
206 #ifndef MINI_CASE_SENSITIVE
|
|
|
207 INIStringUtil::toLower(key);
|
|
|
208 #endif
|
|
|
209 auto it = dataIndexMap.find(key);
|
|
|
210 if (it != dataIndexMap.end())
|
|
|
211 {
|
|
|
212 data[it->second].second = obj;
|
|
|
213 }
|
|
|
214 else
|
|
|
215 {
|
|
|
216 dataIndexMap[key] = data.size();
|
|
|
217 data.emplace_back(key, obj);
|
|
|
218 }
|
|
|
219 }
|
|
|
220 void set(T_MultiArgs const& multiArgs)
|
|
|
221 {
|
|
|
222 for (auto const& it : multiArgs)
|
|
|
223 {
|
|
|
224 auto const& key = it.first;
|
|
|
225 auto const& obj = it.second;
|
|
|
226 set(key, obj);
|
|
|
227 }
|
|
|
228 }
|
|
|
229 bool remove(std::string key)
|
|
|
230 {
|
|
|
231 INIStringUtil::trim(key);
|
|
|
232 #ifndef MINI_CASE_SENSITIVE
|
|
|
233 INIStringUtil::toLower(key);
|
|
|
234 #endif
|
|
|
235 auto it = dataIndexMap.find(key);
|
|
|
236 if (it != dataIndexMap.end())
|
|
|
237 {
|
|
|
238 std::size_t index = it->second;
|
|
|
239 data.erase(data.begin() + index);
|
|
|
240 dataIndexMap.erase(it);
|
|
|
241 for (auto& it2 : dataIndexMap)
|
|
|
242 {
|
|
|
243 auto& vi = it2.second;
|
|
|
244 if (vi > index)
|
|
|
245 {
|
|
|
246 vi--;
|
|
|
247 }
|
|
|
248 }
|
|
|
249 return true;
|
|
|
250 }
|
|
|
251 return false;
|
|
|
252 }
|
|
|
253 void clear()
|
|
|
254 {
|
|
|
255 data.clear();
|
|
|
256 dataIndexMap.clear();
|
|
|
257 }
|
|
|
258 std::size_t size() const
|
|
|
259 {
|
|
|
260 return data.size();
|
|
|
261 }
|
|
|
262 const_iterator begin() const { return data.begin(); }
|
|
|
263 const_iterator end() const { return data.end(); }
|
|
|
264 };
|
|
|
265
|
|
|
266 using INIStructure = INIMap<INIMap<std::string>>;
|
|
|
267
|
|
|
268 namespace INIParser
|
|
|
269 {
|
|
|
270 using T_ParseValues = std::pair<std::string, std::string>;
|
|
|
271
|
|
|
272 enum class PDataType : char
|
|
|
273 {
|
|
|
274 PDATA_NONE,
|
|
|
275 PDATA_COMMENT,
|
|
|
276 PDATA_SECTION,
|
|
|
277 PDATA_KEYVALUE,
|
|
|
278 PDATA_UNKNOWN
|
|
|
279 };
|
|
|
280
|
|
|
281 inline PDataType parseLine(std::string line, T_ParseValues& parseData)
|
|
|
282 {
|
|
|
283 parseData.first.clear();
|
|
|
284 parseData.second.clear();
|
|
|
285 INIStringUtil::trim(line);
|
|
|
286 if (line.empty())
|
|
|
287 {
|
|
|
288 return PDataType::PDATA_NONE;
|
|
|
289 }
|
|
|
290 char firstCharacter = line[0];
|
|
|
291 if (firstCharacter == ';')
|
|
|
292 {
|
|
|
293 return PDataType::PDATA_COMMENT;
|
|
|
294 }
|
|
|
295 if (firstCharacter == '[')
|
|
|
296 {
|
|
|
297 auto commentAt = line.find_first_of(';');
|
|
|
298 if (commentAt != std::string::npos)
|
|
|
299 {
|
|
|
300 line = line.substr(0, commentAt);
|
|
|
301 }
|
|
|
302 auto closingBracketAt = line.find_last_of(']');
|
|
|
303 if (closingBracketAt != std::string::npos)
|
|
|
304 {
|
|
|
305 auto section = line.substr(1, closingBracketAt - 1);
|
|
|
306 INIStringUtil::trim(section);
|
|
|
307 parseData.first = section;
|
|
|
308 return PDataType::PDATA_SECTION;
|
|
|
309 }
|
|
|
310 }
|
|
|
311 auto lineNorm = line;
|
|
|
312 INIStringUtil::replace(lineNorm, "\\=", " ");
|
|
|
313 auto equalsAt = lineNorm.find_first_of('=');
|
|
|
314 if (equalsAt != std::string::npos)
|
|
|
315 {
|
|
|
316 auto key = line.substr(0, equalsAt);
|
|
|
317 INIStringUtil::trim(key);
|
|
|
318 INIStringUtil::replace(key, "\\=", "=");
|
|
|
319 auto value = line.substr(equalsAt + 1);
|
|
|
320 INIStringUtil::trim(value);
|
|
|
321 parseData.first = key;
|
|
|
322 parseData.second = value;
|
|
|
323 return PDataType::PDATA_KEYVALUE;
|
|
|
324 }
|
|
|
325 return PDataType::PDATA_UNKNOWN;
|
|
|
326 }
|
|
|
327 }
|
|
|
328
|
|
|
329 class INIReader
|
|
|
330 {
|
|
|
331 public:
|
|
|
332 using T_LineData = std::vector<std::string>;
|
|
|
333 using T_LineDataPtr = std::shared_ptr<T_LineData>;
|
|
|
334
|
|
|
335 bool isBOM = false;
|
|
|
336
|
|
|
337 private:
|
|
|
338 std::ifstream fileReadStream;
|
|
|
339 T_LineDataPtr lineData;
|
|
|
340
|
|
|
341 T_LineData readFile()
|
|
|
342 {
|
|
|
343 fileReadStream.seekg(0, std::ios::end);
|
|
|
344 const std::size_t fileSize = static_cast<std::size_t>(fileReadStream.tellg());
|
|
|
345 fileReadStream.seekg(0, std::ios::beg);
|
|
|
346 if (fileSize >= 3) {
|
|
|
347 const char header[3] = {
|
|
|
348 static_cast<char>(fileReadStream.get()),
|
|
|
349 static_cast<char>(fileReadStream.get()),
|
|
|
350 static_cast<char>(fileReadStream.get())
|
|
|
351 };
|
|
|
352 isBOM = (
|
|
|
353 header[0] == static_cast<char>(0xEF) &&
|
|
|
354 header[1] == static_cast<char>(0xBB) &&
|
|
|
355 header[2] == static_cast<char>(0xBF)
|
|
|
356 );
|
|
|
357 }
|
|
|
358 else {
|
|
|
359 isBOM = false;
|
|
|
360 }
|
|
|
361 std::string fileContents;
|
|
|
362 fileContents.resize(fileSize);
|
|
|
363 fileReadStream.seekg(isBOM ? 3 : 0, std::ios::beg);
|
|
|
364 fileReadStream.read(&fileContents[0], fileSize);
|
|
|
365 fileReadStream.close();
|
|
|
366 T_LineData output;
|
|
|
367 if (fileSize == 0)
|
|
|
368 {
|
|
|
369 return output;
|
|
|
370 }
|
|
|
371 std::string buffer;
|
|
|
372 buffer.reserve(50);
|
|
|
373 for (std::size_t i = 0; i < fileSize; ++i)
|
|
|
374 {
|
|
|
375 char& c = fileContents[i];
|
|
|
376 if (c == '\n')
|
|
|
377 {
|
|
|
378 output.emplace_back(buffer);
|
|
|
379 buffer.clear();
|
|
|
380 continue;
|
|
|
381 }
|
|
|
382 if (c != '\0' && c != '\r')
|
|
|
383 {
|
|
|
384 buffer += c;
|
|
|
385 }
|
|
|
386 }
|
|
|
387 output.emplace_back(buffer);
|
|
|
388 return output;
|
|
|
389 }
|
|
|
390
|
|
|
391 public:
|
|
|
392 INIReader(std::string const& filename, bool keepLineData = false)
|
|
|
393 {
|
|
|
394 fileReadStream.open(filename, std::ios::in | std::ios::binary);
|
|
|
395 if (keepLineData)
|
|
|
396 {
|
|
|
397 lineData = std::make_shared<T_LineData>();
|
|
|
398 }
|
|
|
399 }
|
|
|
400 ~INIReader() { }
|
|
|
401
|
|
|
402 bool operator>>(INIStructure& data)
|
|
|
403 {
|
|
|
404 if (!fileReadStream.is_open())
|
|
|
405 {
|
|
|
406 return false;
|
|
|
407 }
|
|
|
408 T_LineData fileLines = readFile();
|
|
|
409 std::string section;
|
|
|
410 bool inSection = false;
|
|
|
411 INIParser::T_ParseValues parseData;
|
|
|
412 for (auto const& line : fileLines)
|
|
|
413 {
|
|
|
414 auto parseResult = INIParser::parseLine(line, parseData);
|
|
|
415 if (parseResult == INIParser::PDataType::PDATA_SECTION)
|
|
|
416 {
|
|
|
417 inSection = true;
|
|
|
418 data[section = parseData.first];
|
|
|
419 }
|
|
|
420 else if (inSection && parseResult == INIParser::PDataType::PDATA_KEYVALUE)
|
|
|
421 {
|
|
|
422 auto const& key = parseData.first;
|
|
|
423 auto const& value = parseData.second;
|
|
|
424 data[section][key] = value;
|
|
|
425 }
|
|
|
426 if (lineData && parseResult != INIParser::PDataType::PDATA_UNKNOWN)
|
|
|
427 {
|
|
|
428 if (parseResult == INIParser::PDataType::PDATA_KEYVALUE && !inSection)
|
|
|
429 {
|
|
|
430 continue;
|
|
|
431 }
|
|
|
432 lineData->emplace_back(line);
|
|
|
433 }
|
|
|
434 }
|
|
|
435 return true;
|
|
|
436 }
|
|
|
437 T_LineDataPtr getLines()
|
|
|
438 {
|
|
|
439 return lineData;
|
|
|
440 }
|
|
|
441 };
|
|
|
442
|
|
|
443 class INIGenerator
|
|
|
444 {
|
|
|
445 private:
|
|
|
446 std::ofstream fileWriteStream;
|
|
|
447
|
|
|
448 public:
|
|
|
449 bool prettyPrint = false;
|
|
|
450
|
|
|
451 INIGenerator(std::string const& filename)
|
|
|
452 {
|
|
|
453 fileWriteStream.open(filename, std::ios::out | std::ios::binary);
|
|
|
454 }
|
|
|
455 ~INIGenerator() { }
|
|
|
456
|
|
|
457 bool operator<<(INIStructure const& data)
|
|
|
458 {
|
|
|
459 if (!fileWriteStream.is_open())
|
|
|
460 {
|
|
|
461 return false;
|
|
|
462 }
|
|
|
463 if (!data.size())
|
|
|
464 {
|
|
|
465 return true;
|
|
|
466 }
|
|
|
467 auto it = data.begin();
|
|
|
468 for (;;)
|
|
|
469 {
|
|
|
470 auto const& section = it->first;
|
|
|
471 auto const& collection = it->second;
|
|
|
472 fileWriteStream
|
|
|
473 << "["
|
|
|
474 << section
|
|
|
475 << "]";
|
|
|
476 if (collection.size())
|
|
|
477 {
|
|
|
478 fileWriteStream << INIStringUtil::endl;
|
|
|
479 auto it2 = collection.begin();
|
|
|
480 for (;;)
|
|
|
481 {
|
|
|
482 auto key = it2->first;
|
|
|
483 INIStringUtil::replace(key, "=", "\\=");
|
|
|
484 auto value = it2->second;
|
|
|
485 INIStringUtil::trim(value);
|
|
|
486 fileWriteStream
|
|
|
487 << key
|
|
|
488 << ((prettyPrint) ? " = " : "=")
|
|
|
489 << value;
|
|
|
490 if (++it2 == collection.end())
|
|
|
491 {
|
|
|
492 break;
|
|
|
493 }
|
|
|
494 fileWriteStream << INIStringUtil::endl;
|
|
|
495 }
|
|
|
496 }
|
|
|
497 if (++it == data.end())
|
|
|
498 {
|
|
|
499 break;
|
|
|
500 }
|
|
|
501 fileWriteStream << INIStringUtil::endl;
|
|
|
502 if (prettyPrint)
|
|
|
503 {
|
|
|
504 fileWriteStream << INIStringUtil::endl;
|
|
|
505 }
|
|
|
506 }
|
|
|
507 return true;
|
|
|
508 }
|
|
|
509 };
|
|
|
510
|
|
|
511 class INIWriter
|
|
|
512 {
|
|
|
513 private:
|
|
|
514 using T_LineData = std::vector<std::string>;
|
|
|
515 using T_LineDataPtr = std::shared_ptr<T_LineData>;
|
|
|
516
|
|
|
517 std::string filename;
|
|
|
518
|
|
|
519 T_LineData getLazyOutput(T_LineDataPtr const& lineData, INIStructure& data, INIStructure& original)
|
|
|
520 {
|
|
|
521 T_LineData output;
|
|
|
522 INIParser::T_ParseValues parseData;
|
|
|
523 std::string sectionCurrent;
|
|
|
524 bool parsingSection = false;
|
|
|
525 bool continueToNextSection = false;
|
|
|
526 bool discardNextEmpty = false;
|
|
|
527 bool writeNewKeys = false;
|
|
|
528 std::size_t lastKeyLine = 0;
|
|
|
529 for (auto line = lineData->begin(); line != lineData->end(); ++line)
|
|
|
530 {
|
|
|
531 if (!writeNewKeys)
|
|
|
532 {
|
|
|
533 auto parseResult = INIParser::parseLine(*line, parseData);
|
|
|
534 if (parseResult == INIParser::PDataType::PDATA_SECTION)
|
|
|
535 {
|
|
|
536 if (parsingSection)
|
|
|
537 {
|
|
|
538 writeNewKeys = true;
|
|
|
539 parsingSection = false;
|
|
|
540 --line;
|
|
|
541 continue;
|
|
|
542 }
|
|
|
543 sectionCurrent = parseData.first;
|
|
|
544 if (data.has(sectionCurrent))
|
|
|
545 {
|
|
|
546 parsingSection = true;
|
|
|
547 continueToNextSection = false;
|
|
|
548 discardNextEmpty = false;
|
|
|
549 output.emplace_back(*line);
|
|
|
550 lastKeyLine = output.size();
|
|
|
551 }
|
|
|
552 else
|
|
|
553 {
|
|
|
554 continueToNextSection = true;
|
|
|
555 discardNextEmpty = true;
|
|
|
556 continue;
|
|
|
557 }
|
|
|
558 }
|
|
|
559 else if (parseResult == INIParser::PDataType::PDATA_KEYVALUE)
|
|
|
560 {
|
|
|
561 if (continueToNextSection)
|
|
|
562 {
|
|
|
563 continue;
|
|
|
564 }
|
|
|
565 if (data.has(sectionCurrent))
|
|
|
566 {
|
|
|
567 auto& collection = data[sectionCurrent];
|
|
|
568 auto const& key = parseData.first;
|
|
|
569 auto const& value = parseData.second;
|
|
|
570 if (collection.has(key))
|
|
|
571 {
|
|
|
572 auto outputValue = collection[key];
|
|
|
573 if (value == outputValue)
|
|
|
574 {
|
|
|
575 output.emplace_back(*line);
|
|
|
576 }
|
|
|
577 else
|
|
|
578 {
|
|
|
579 INIStringUtil::trim(outputValue);
|
|
|
580 auto lineNorm = *line;
|
|
|
581 INIStringUtil::replace(lineNorm, "\\=", " ");
|
|
|
582 auto equalsAt = lineNorm.find_first_of('=');
|
|
|
583 auto valueAt = lineNorm.find_first_not_of(
|
|
|
584 INIStringUtil::whitespaceDelimiters,
|
|
|
585 equalsAt + 1
|
|
|
586 );
|
|
|
587 std::string outputLine = line->substr(0, valueAt);
|
|
|
588 if (prettyPrint && equalsAt + 1 == valueAt)
|
|
|
589 {
|
|
|
590 outputLine += " ";
|
|
|
591 }
|
|
|
592 outputLine += outputValue;
|
|
|
593 output.emplace_back(outputLine);
|
|
|
594 }
|
|
|
595 lastKeyLine = output.size();
|
|
|
596 }
|
|
|
597 }
|
|
|
598 }
|
|
|
599 else
|
|
|
600 {
|
|
|
601 if (discardNextEmpty && line->empty())
|
|
|
602 {
|
|
|
603 discardNextEmpty = false;
|
|
|
604 }
|
|
|
605 else if (parseResult != INIParser::PDataType::PDATA_UNKNOWN)
|
|
|
606 {
|
|
|
607 output.emplace_back(*line);
|
|
|
608 }
|
|
|
609 }
|
|
|
610 }
|
|
|
611 if (writeNewKeys || std::next(line) == lineData->end())
|
|
|
612 {
|
|
|
613 T_LineData linesToAdd;
|
|
|
614 if (data.has(sectionCurrent) && original.has(sectionCurrent))
|
|
|
615 {
|
|
|
616 auto const& collection = data[sectionCurrent];
|
|
|
617 auto const& collectionOriginal = original[sectionCurrent];
|
|
|
618 for (auto const& it : collection)
|
|
|
619 {
|
|
|
620 auto key = it.first;
|
|
|
621 if (collectionOriginal.has(key))
|
|
|
622 {
|
|
|
623 continue;
|
|
|
624 }
|
|
|
625 auto value = it.second;
|
|
|
626 INIStringUtil::replace(key, "=", "\\=");
|
|
|
627 INIStringUtil::trim(value);
|
|
|
628 linesToAdd.emplace_back(
|
|
|
629 key + ((prettyPrint) ? " = " : "=") + value
|
|
|
630 );
|
|
|
631 }
|
|
|
632 }
|
|
|
633 if (!linesToAdd.empty())
|
|
|
634 {
|
|
|
635 output.insert(
|
|
|
636 output.begin() + lastKeyLine,
|
|
|
637 linesToAdd.begin(),
|
|
|
638 linesToAdd.end()
|
|
|
639 );
|
|
|
640 }
|
|
|
641 if (writeNewKeys)
|
|
|
642 {
|
|
|
643 writeNewKeys = false;
|
|
|
644 --line;
|
|
|
645 }
|
|
|
646 }
|
|
|
647 }
|
|
|
648 for (auto const& it : data)
|
|
|
649 {
|
|
|
650 auto const& section = it.first;
|
|
|
651 if (original.has(section))
|
|
|
652 {
|
|
|
653 continue;
|
|
|
654 }
|
|
|
655 if (prettyPrint && output.size() > 0 && !output.back().empty())
|
|
|
656 {
|
|
|
657 output.emplace_back();
|
|
|
658 }
|
|
|
659 output.emplace_back("[" + section + "]");
|
|
|
660 auto const& collection = it.second;
|
|
|
661 for (auto const& it2 : collection)
|
|
|
662 {
|
|
|
663 auto key = it2.first;
|
|
|
664 auto value = it2.second;
|
|
|
665 INIStringUtil::replace(key, "=", "\\=");
|
|
|
666 INIStringUtil::trim(value);
|
|
|
667 output.emplace_back(
|
|
|
668 key + ((prettyPrint) ? " = " : "=") + value
|
|
|
669 );
|
|
|
670 }
|
|
|
671 }
|
|
|
672 return output;
|
|
|
673 }
|
|
|
674
|
|
|
675 public:
|
|
|
676 bool prettyPrint = false;
|
|
|
677
|
|
|
678 INIWriter(std::string const& filename)
|
|
|
679 : filename(filename)
|
|
|
680 {
|
|
|
681 }
|
|
|
682 ~INIWriter() { }
|
|
|
683
|
|
|
684 bool operator<<(INIStructure& data)
|
|
|
685 {
|
|
|
686 struct stat buf;
|
|
|
687 bool fileExists = (stat(filename.c_str(), &buf) == 0);
|
|
|
688 if (!fileExists)
|
|
|
689 {
|
|
|
690 INIGenerator generator(filename);
|
|
|
691 generator.prettyPrint = prettyPrint;
|
|
|
692 return generator << data;
|
|
|
693 }
|
|
|
694 INIStructure originalData;
|
|
|
695 T_LineDataPtr lineData;
|
|
|
696 bool readSuccess = false;
|
|
|
697 bool fileIsBOM = false;
|
|
|
698 {
|
|
|
699 INIReader reader(filename, true);
|
|
|
700 if ((readSuccess = reader >> originalData))
|
|
|
701 {
|
|
|
702 lineData = reader.getLines();
|
|
|
703 fileIsBOM = reader.isBOM;
|
|
|
704 }
|
|
|
705 }
|
|
|
706 if (!readSuccess)
|
|
|
707 {
|
|
|
708 return false;
|
|
|
709 }
|
|
|
710 T_LineData output = getLazyOutput(lineData, data, originalData);
|
|
|
711 std::ofstream fileWriteStream(filename, std::ios::out | std::ios::binary);
|
|
|
712 if (fileWriteStream.is_open())
|
|
|
713 {
|
|
|
714 if (fileIsBOM) {
|
|
|
715 const char utf8_BOM[3] = {
|
|
|
716 static_cast<char>(0xEF),
|
|
|
717 static_cast<char>(0xBB),
|
|
|
718 static_cast<char>(0xBF)
|
|
|
719 };
|
|
|
720 fileWriteStream.write(utf8_BOM, 3);
|
|
|
721 }
|
|
|
722 if (output.size())
|
|
|
723 {
|
|
|
724 auto line = output.begin();
|
|
|
725 for (;;)
|
|
|
726 {
|
|
|
727 fileWriteStream << *line;
|
|
|
728 if (++line == output.end())
|
|
|
729 {
|
|
|
730 break;
|
|
|
731 }
|
|
|
732 fileWriteStream << INIStringUtil::endl;
|
|
|
733 }
|
|
|
734 }
|
|
|
735 return true;
|
|
|
736 }
|
|
|
737 return false;
|
|
|
738 }
|
|
|
739 };
|
|
|
740
|
|
|
741 class INIFile
|
|
|
742 {
|
|
|
743 private:
|
|
|
744 std::string filename;
|
|
|
745
|
|
|
746 public:
|
|
|
747 INIFile(std::string const& filename)
|
|
|
748 : filename(filename)
|
|
|
749 { }
|
|
|
750
|
|
|
751 ~INIFile() { }
|
|
|
752
|
|
|
753 bool read(INIStructure& data) const
|
|
|
754 {
|
|
|
755 if (data.size())
|
|
|
756 {
|
|
|
757 data.clear();
|
|
|
758 }
|
|
|
759 if (filename.empty())
|
|
|
760 {
|
|
|
761 return false;
|
|
|
762 }
|
|
|
763 INIReader reader(filename);
|
|
|
764 return reader >> data;
|
|
|
765 }
|
|
|
766 bool generate(INIStructure const& data, bool pretty = false) const
|
|
|
767 {
|
|
|
768 if (filename.empty())
|
|
|
769 {
|
|
|
770 return false;
|
|
|
771 }
|
|
|
772 INIGenerator generator(filename);
|
|
|
773 generator.prettyPrint = pretty;
|
|
|
774 return generator << data;
|
|
|
775 }
|
|
|
776 bool write(INIStructure& data, bool pretty = false) const
|
|
|
777 {
|
|
|
778 if (filename.empty())
|
|
|
779 {
|
|
|
780 return false;
|
|
|
781 }
|
|
|
782 INIWriter writer(filename);
|
|
|
783 writer.prettyPrint = pretty;
|
|
|
784 return writer << data;
|
|
|
785 }
|
|
|
786 };
|
|
|
787 }
|
|
|
788
|
|
|
789 #endif // MINI_INI_H_
|
