+1 -1

scripts/codespell-project.sh

··· 19 19 set -e 20 20 21 21 # Comma-delimited list of words for codespell to not try to correct. 22 22 - IGNORE_WORDS_LIST="ang,sinc,sie,stoll,wil,daa,localy,od,ser,unknwn,parm,inflight,marge,devault,errorprone" 22 22 + IGNORE_WORDS_LIST="ang,sinc,sie,stoll,wil,daa,localy,od,ser,unknwn,parm,inflight,marge,devault,errorprone,childs" 23 23 IGNORE_REGEX="\b(pEvent|inout|Kimera)\b" 24 24 25 25 SCRIPTDIR=$(cd "$(dirname "$0")" && pwd)

+21

src/external/valve-file-vdf/LICENSE

··· 1 1 + The MIT License (MIT) 2 2 + 3 3 + Copyright (c) Matthias Moeller 2016 m_moeller@live.de 4 4 + 5 5 + Permission is hereby granted, free of charge, to any person obtaining a copy 6 6 + of this software and associated documentation files (the "Software"), to deal 7 7 + in the Software without restriction, including without limitation the rights 8 8 + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 9 + copies of the Software, and to permit persons to whom the Software is 10 10 + furnished to do so, subject to the following conditions: 11 11 + 12 12 + The above copyright notice and this permission notice shall be included in all 13 13 + copies or substantial portions of the Software. 14 14 + 15 15 + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 16 + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 17 + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 18 + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 19 + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 20 + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 21 + SOFTWARE.

-280

src/external/valve-file-vdf/Readme.md

··· 1 1 - Upstream source - https://github.com/TinyTinni/ValveFileVDF 2 2 - 3 3 - # Valve Data Format (.vdf) Reader and Writer in C++ 4 4 - 5 5 - [](https://github.com/TinyTinni/ValveFileVDF/actions/workflows/cmake.yml) 6 6 - 7 7 - Valve uses its own JSON-like data format: [KeyValue, also known as vdf.](https://developer.valvesoftware.com/wiki/KeyValues) 8 8 - e.g. in game manifest files or as SteamCMD output. 9 9 - This header-only file provides a parser and writer to load and save the given data. 10 10 - 11 11 - ## Features: 12 12 - - read and write vdf data in C++ 13 13 - - build-in encodings: `char` and `wchar_t` 14 14 - - supports custom character sets 15 15 - - support for C++ (//) and C (/**/) comments 16 16 - - `#include`/`#base` keyword (note: searches for files in the current working directory) 17 17 - - platform independent 18 18 - - header-only 19 19 - 20 20 - ## Requirements 21 21 - - C++11 22 22 - 23 23 - ## Test Requirements 24 24 - - C++14 (uses [catch2](https://github.com/catchorg/Catch2)) 25 25 - 26 26 - (works with the C++11 features of vs120/"Visual Studio 2013" and newer) 27 27 - 28 28 - ## How-To Use 29 29 - First, you have to include the main file `vdf-Parser.h`. 30 30 - This file provides several functions and data-structures which are 31 31 - in the namespace `tyti::vdf`. 32 32 - 33 33 - All functions and data structures supports wide characters. 34 34 - The wide character data structure is indicated by the commonly known `w`-prefix. 35 35 - Functions are templates and don't need a prefix. 36 36 - 37 37 - To read an file, create a stream e.g. `std::ifsteam` or `std::wifstream` 38 38 - and call the `tyti::vdf::read` function. 39 39 - ```c++ 40 40 - std::ifstream file("PathToMyFile"); 41 41 - auto root = tyti::vdf::read(file); 42 42 - ``` 43 43 - You can also define a sequence of character defined by a range. 44 44 - ```c++ 45 45 - std::string blob; 46 46 - ... 47 47 - auto root = tyti::vdf::read(std::cbegin(blob), std::cend(blob)); 48 48 - 49 49 - //given .vdf below, following holds 50 50 - assert(root.name == "name"); 51 51 - const std::shared_ptr<tyti::vdf::object> child = root.childs["child0"]; 52 52 - assert(child->name == "child0"); 53 53 - const std::string& k = root[0].attribs["attrib0"]; 54 54 - assert(k == "value"); 55 55 - ``` 56 56 - 57 57 - The `tyti::vdf::object` is a tree like data structure. 58 58 - It has its name, some attributes as a pair of `key` and `value` 59 59 - and its object childs. Below you can see a vdf data structure and how it is stored by naming: 60 60 - ```javascript 61 61 - "name" 62 62 - { 63 63 - "attrib0" "value" // saved as a pair, first -> key, second -> value 64 64 - "#base" "includeFile.vdf" // appends object defined in the file to childs 65 65 - "child0" 66 66 - { 67 67 - ... 68 68 - } 69 69 - ... 70 70 - } 71 71 - ``` 72 72 - 73 73 - Given such an object, you can also write it into vdf files via: 74 74 - ```c++ 75 75 - tyti::vdf::write(file, object); 76 76 - ``` 77 77 - 78 78 - ## Multi-Key and Custom Output Type 79 79 - 80 80 - It is also possible to customize your output dataformat. 81 81 - Per default, the parser stores all items in a std::unordered_map, which, per definition, 82 82 - doesn't allow different entries with the same key. 83 83 - 84 84 - However, the Valve vdf format supports multiple keys. Therefore, the output data format 85 85 - has to store all items in e.g. a std::unordered_multimap. 86 86 - 87 87 - You can change the output format by passing the output type via template argument to 88 88 - the read function 89 89 - ```c++ 90 90 - namespace tyti; 91 91 - vdf::object no_multi_key = vdf::read(file); 92 92 - vdf::multikey_object multi_key = vdf::read<vdf::multikey_object>(file); 93 93 - ``` 94 94 - 95 95 - __Note__: The interface of [std::unordered_map](http://en.cppreference.com/w/cpp/container/unordered_map) and [std::unordered_multimap](http://en.cppreference.com/w/cpp/container/unordered_multimap) 96 96 - are different when you access the elements. 97 97 - 98 98 - It is also possible to create your own data structure which is used by the parser. 99 99 - Your output class needs to define 3 functions with the following signature: 100 100 - 101 101 - ```c++ 102 102 - void add_attribute(std::basic_string<CHAR> key, std::basic_string<CHAR> value); 103 103 - void add_child(std::unique_ptr< MYCLASS > child); 104 104 - void set_name(std::basic_string<CHAR> n); 105 105 - ``` 106 106 - where ```MYCLASS``` is the tpe of your class and ```CHAR``` the type of your character set. 107 107 - Also, the type has to be [default constructible](http://en.cppreference.com/w/cpp/types/is_default_constructible) 108 108 - and [move constructible](http://en.cppreference.com/w/cpp/types/is_move_constructible). 109 109 - 110 110 - This also allows you, to inspect the file without storing it in a data structure. 111 111 - Lets say, for example, you want to count all attributes of a file without storing it. 112 112 - You can do this by using this class 113 113 - 114 114 - ```c++ 115 115 - struct counter 116 116 - { 117 117 - size_t num_attributes = 0; 118 118 - void add_attribute(std::string key, std::string value) 119 119 - { 120 120 - ++num_attributes; 121 121 - } 122 122 - void add_child(std::unique_ptr< counter > child) 123 123 - { 124 124 - num_attributes += child->num_attributes; 125 125 - } 126 126 - void set_name(std::string n) 127 127 - {} 128 128 - }; 129 129 - ``` 130 130 - 131 131 - and then call the read function 132 132 - ```c++ 133 133 - std::vector<counter> num = tyti::vdf::read<counter>(file); 134 134 - ``` 135 135 - 136 136 - ## Options (experimental) 137 137 - 138 138 - You can configure the parser, the non default options are not well tested yet. 139 139 - 140 140 - ```c++ 141 141 - struct Options 142 142 - { 143 143 - bool strip_escape_symbols; //default true 144 144 - bool ignore_all_platform_conditionals; // default false 145 145 - bool ignore_includes; //default false 146 146 - }; 147 147 - 148 148 - ``` 149 149 - 150 150 - ## Reference 151 151 - ```c++ 152 152 - ///////////////////////////////////////////////////////////// 153 153 - // pre-defined output classes 154 154 - ///////////////////////////////////////////////////////////// 155 155 - // default output object 156 156 - template<typename T> 157 157 - basic_object<T> 158 158 - { 159 159 - std::basic_string<char_type> name; 160 160 - std::unordered_map<std::basic_string<char_type>, std::basic_string<char_type> > attribs; 161 161 - std::unordered_map<std::basic_string<char_type>, std::shared_ptr< basic_object<char_type> > > childs; 162 162 - }; 163 163 - typedef basic_object<char> object; 164 164 - typedef basic_object<wchar_t> wobject 165 165 - 166 166 - // output object with multikey support 167 167 - template<typename T> 168 168 - basic_multikey_object<T> 169 169 - { 170 170 - std::basic_string<char_type> name; 171 171 - std::unordered_multimap<std::basic_string<char_type>, std::basic_string<char_type> > attribs; 172 172 - std::unordered_multimap<std::basic_string<char_type>, std::shared_ptr< basic_object<char_type> > > childs; 173 173 - }; 174 174 - typedef basic_multikey_object<char> multikey_object; 175 175 - typedef basic_multikey_object<wchar_t> wmultikey_object 176 176 - 177 177 - ///////////////////////////////////////////////////////////// 178 178 - // error codes 179 179 - ///////////////////////////////////////////////////////////// 180 180 - /* 181 181 - Possible error codes: 182 182 - std::errc::protocol_error: file is mailformatted 183 183 - std::errc::not_enough_memory: not enough space 184 184 - std::errc::invalid_argument: iterators throws e.g. out of range 185 185 - */ 186 186 - 187 187 - ///////////////////////////////////////////////////////////// 188 188 - // read from stream 189 189 - ///////////////////////////////////////////////////////////// 190 190 - 191 191 - /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf formatted data. 192 192 - throws "std::bad_alloc" if file buffer could not be allocated 193 193 - throws "std::runtime_error" if a parsing error occured 194 194 - */ 195 195 - template<ytpename OutputT, typename iStreamT> 196 196 - std::vector<OutputT> read(iStreamT& inStream, const Options &opt = Options{}); 197 197 - 198 198 - template<typename iStreamT> 199 199 - std::vector<basic_object<typename iStreamT::char_type>> read(iStreamT& inStream, const Options &opt = Options{}); 200 200 - 201 201 - /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf formatted data. 202 202 - throws "std::bad_alloc" if file buffer could not be allocated 203 203 - ok == false, if a parsing error occured 204 204 - */ 205 205 - template<typename OutputT, typename iStreamT> 206 206 - std::vector<OutputT> read(iStreamT& inStream, bool* ok, const Options &opt = Options{}); 207 207 - 208 208 - template<typename iStreamT> 209 209 - std::vector<basic_object<typename iStreamT::char_type>> read(iStreamT& inStream, bool* ok, const Options &opt = Options{}); 210 210 - 211 211 - /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf formatted data. 212 212 - throws "std::bad_alloc" if file buffer could not be allocated 213 213 - */ 214 214 - template<typename OutputT, typename iStreamT> 215 215 - std::vector<OutputT> read(iStreamT& inStream, std::error_code& ec, const Options &opt = Options{}); 216 216 - 217 217 - template<typename iStreamT> 218 218 - std::vector<basic_object<iStreamT::char_type>> read(iStreamT& inStream, std::error_code& ec, const Options &opt = Options{}); 219 219 - 220 220 - ///////////////////////////////////////////////////////////// 221 221 - // read from memory 222 222 - ///////////////////////////////////////////////////////////// 223 223 - 224 224 - /** \brief Read VDF formatted sequences defined by the range [first, last). 225 225 - If the file is mailformatted, parser will try to read it until it can. 226 226 - @param first begin iterator 227 227 - @param end end iterator 228 228 - 229 229 - throws "std::runtime_error" if a parsing error occured 230 230 - throws "std::bad_alloc" if not enough memory could be allocated 231 231 - */ 232 232 - template<typename OutputT, typename IterT> 233 233 - std::vector<OutputT> read(IterT first, IterT last, const Options &opt = Options{}); 234 234 - 235 235 - template<typename IterT> 236 236 - std::vector<basic_object<typename std::iterator_traits<IterT>::value_type>> read(IterT first, IterT last, const Options &opt = Options{}); 237 237 - 238 238 - /** \brief Read VDF formatted sequences defined by the range [first, last). 239 239 - If the file is mailformatted, parser will try to read it until it can. 240 240 - @param first begin iterator 241 241 - @param end end iterator 242 242 - @param ok output bool. true, if parser successed, false, if parser failed 243 243 - */ 244 244 - template<typename OutputT, typename IterT> 245 245 - std::vector<OutputT> read(IterT first, IterT last, bool* ok, const Options &opt = Options{}) noexcept; 246 246 - 247 247 - template<typename IterT> 248 248 - std::vector<basic_object<typename std::iterator_traits<IterT>::value_type>> read(IterT first, IterT last, bool* ok, const Options &opt = Options{}) noexcept; 249 249 - 250 250 - 251 251 - 252 252 - /** \brief Read VDF formatted sequences defined by the range [first, last). 253 253 - If the file is mailformatted, parser will try to read it until it can. 254 254 - @param first begin iterator 255 255 - @param end end iterator 256 256 - @param ec output bool. 0 if ok, otherwise, holds an system error code 257 257 - */ 258 258 - template<typename OutputT, typename IterT> 259 259 - std::vector<OutputT> read(IterT first, IterT last, std::error_code& ec, const Options &opt = Options{}) noexcept; 260 260 - 261 261 - template<typename IterT> 262 262 - std::vector<basic_object<typename std::iterator_traits<IterT>::value_type>> read(IterT first, IterT last, std::error_code& ec, const Options &opt = Options{}) noexcept; 263 263 - 264 264 - 265 265 - ///////////////////////////////////////////////////////////////////////////// 266 266 - // Writer functions 267 267 - /// writes given obj into out in vdf style 268 268 - /// Output is prettyfied, using tabs 269 269 - template<typename oStreamT, typename T> 270 270 - void write(oStreamT& out, const T& obj, const Options &opt = Options{}); 271 271 - 272 272 - ``` 273 273 - 274 274 - ## Remarks for Errors 275 275 - The current version is a greedy implementation and jumps over unrecognized fields. 276 276 - Therefore, the error detection is very imprecise an does not give the line, where the error occurs. 277 277 - 278 278 - ## License 279 279 - 280 280 - [MIT License](./LICENSE) © Matthias Möller. Made with ♥ in Germany.

+677 -583

src/external/valve-file-vdf/vdf_parser.hpp

··· 1 1 - //MIT License 1 1 + // MIT License 2 2 // 3 3 - //Copyright(c) 2016 Matthias Moeller 3 3 + // Copyright(c) 2016 Matthias Moeller 4 4 // 5 5 - //Permission is hereby granted, free of charge, to any person obtaining a copy 6 6 - //of this software and associated documentation files(the "Software"), to deal 7 7 - //in the Software without restriction, including without limitation the rights 8 8 - //to use, copy, modify, merge, publish, distribute, sublicense, and / or sell 9 9 - //copies of the Software, and to permit persons to whom the Software is 10 10 - //furnished to do so, subject to the following conditions : 5 5 + // Permission is hereby granted, free of charge, to any person obtaining a copy 6 6 + // of this software and associated documentation files(the "Software"), to deal 7 7 + // in the Software without restriction, including without limitation the rights 8 8 + // to use, copy, modify, merge, publish, distribute, sublicense, and / or sell 9 9 + // copies of the Software, and to permit persons to whom the Software is 10 10 + // furnished to do so, subject to the following conditions : 11 11 // 12 12 - //The above copyright notice and this permission notice shall be included in all 13 13 - //copies or substantial portions of the Software. 12 12 + // The above copyright notice and this permission notice shall be included in 13 13 + // all copies or substantial portions of the Software. 14 14 // 15 15 - //THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 16 - //IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 17 - //FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE 18 18 - //AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 19 - //LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 20 - //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 21 - //SOFTWARE. 15 15 + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 16 + // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 17 + // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE 18 18 + // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 19 + // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 20 + // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 21 + // SOFTWARE. 22 22 23 23 #ifndef __TYTI_STEAM_VDF_PARSER_H__ 24 24 #define __TYTI_STEAM_VDF_PARSER_H__ 25 25 26 26 + #include <algorithm> 27 27 + #include <fstream> 28 28 + #include <functional> 29 29 + #include <iterator> 26 30 #include <map> 27 27 - #include <vector> 31 31 + #include <memory> 28 32 #include <unordered_map> 29 29 - #include <utility> 30 30 - #include <fstream> 31 31 - #include <memory> 32 33 #include <unordered_set> 33 33 - #include <algorithm> 34 34 - #include <iterator> 35 35 - #include <functional> 34 34 + #include <utility> 35 35 + #include <vector> 36 36 37 37 - #include <system_error> 38 37 #include <exception> 38 38 + #include <system_error> 39 39 40 40 - //for wstring support 40 40 + // for wstring support 41 41 #include <locale> 42 42 #include <string> 43 43 44 44 // internal 45 45 #include <stack> 46 46 47 47 - //VS < 2015 has only partial C++11 support 47 47 + // VS < 2015 has only partial C++11 support 48 48 #if defined(_MSC_VER) && _MSC_VER < 1900 49 49 #ifndef CONSTEXPR 50 50 #define CONSTEXPR ··· 68 68 69 69 namespace tyti 70 70 { 71 71 - namespace vdf 71 71 + namespace vdf 72 72 + { 73 73 + namespace detail 74 74 + { 75 75 + /////////////////////////////////////////////////////////////////////////// 76 76 + // Helper functions selecting the right encoding (char/wchar_T) 77 77 + /////////////////////////////////////////////////////////////////////////// 78 78 + 79 79 + template <typename T> struct literal_macro_help 80 80 + { 81 81 + static CONSTEXPR const char *result(const char *c, const wchar_t *) NOEXCEPT 82 82 + { 83 83 + return c; 84 84 + } 85 85 + static CONSTEXPR const char result(const char c, const wchar_t) NOEXCEPT 72 86 { 73 73 - namespace detail 74 74 - { 75 75 - /////////////////////////////////////////////////////////////////////////// 76 76 - // Helper functions selecting the right encoding (char/wchar_T) 77 77 - /////////////////////////////////////////////////////////////////////////// 87 87 + return c; 88 88 + } 89 89 + }; 78 90 79 79 - template <typename T> 80 80 - struct literal_macro_help 81 81 - { 82 82 - static CONSTEXPR const char* result(const char* c, const wchar_t*) NOEXCEPT 83 83 - { 84 84 - return c; 85 85 - } 86 86 - static CONSTEXPR const char result(const char c, const wchar_t) NOEXCEPT 87 87 - { 88 88 - return c; 89 89 - } 90 90 - }; 91 91 + template <> struct literal_macro_help<wchar_t> 92 92 + { 93 93 + static CONSTEXPR const wchar_t *result(const char *, 94 94 + const wchar_t *wc) NOEXCEPT 95 95 + { 96 96 + return wc; 97 97 + } 98 98 + static CONSTEXPR const wchar_t result(const char, const wchar_t wc) NOEXCEPT 99 99 + { 100 100 + return wc; 101 101 + } 102 102 + }; 103 103 + #define TYTI_L(type, text) \ 104 104 + vdf::detail::literal_macro_help<type>::result(text, L##text) 91 105 92 92 - template <> 93 93 - struct literal_macro_help<wchar_t> 94 94 - { 95 95 - static CONSTEXPR const wchar_t* result(const char*, const wchar_t* wc) NOEXCEPT 96 96 - { 97 97 - return wc; 98 98 - } 99 99 - static CONSTEXPR const wchar_t result(const char, const wchar_t wc) NOEXCEPT 100 100 - { 101 101 - return wc; 102 102 - } 103 103 - }; 104 104 - #define TYTI_L(type, text) vdf::detail::literal_macro_help<type>::result(text, L##text) 106 106 + inline std::string string_converter(const std::string &w) NOEXCEPT { return w; } 105 107 106 106 - inline std::string string_converter(const std::string& w) NOEXCEPT 107 107 - { 108 108 - return w; 109 109 - } 108 108 + // utility wrapper to adapt locale-bound facets for wstring/wbuffer convert 109 109 + // from cppreference 110 110 + template <class Facet> struct deletable_facet : Facet 111 111 + { 112 112 + template <class... Args> 113 113 + deletable_facet(Args &&...args) : Facet(std::forward<Args>(args)...) 114 114 + { 115 115 + } 116 116 + ~deletable_facet() {} 117 117 + }; 110 118 111 111 - // utility wrapper to adapt locale-bound facets for wstring/wbuffer convert 112 112 - // from cppreference 113 113 - template <class Facet> 114 114 - struct deletable_facet : Facet 115 115 - { 116 116 - template <class... Args> 117 117 - deletable_facet(Args &&... args) : Facet(std::forward<Args>(args)...) {} 118 118 - ~deletable_facet() {} 119 119 - }; 119 119 + inline std::string 120 120 + string_converter(const std::wstring &w) // todo: use us-locale 121 121 + { 122 122 + std::wstring_convert< 123 123 + deletable_facet<std::codecvt<wchar_t, char, std::mbstate_t>>> 124 124 + conv1; 125 125 + return conv1.to_bytes(w); 126 126 + } 120 127 121 121 - inline std::string string_converter(const std::wstring& w) //todo: use us-locale 122 122 - { 123 123 - std::wstring_convert<deletable_facet<std::codecvt<wchar_t, char, std::mbstate_t>>> conv1; 124 124 - return conv1.to_bytes(w); 125 125 - } 128 128 + /////////////////////////////////////////////////////////////////////////// 129 129 + // Writer helper functions 130 130 + /////////////////////////////////////////////////////////////////////////// 126 131 127 127 - /////////////////////////////////////////////////////////////////////////// 128 128 - // Writer helper functions 129 129 - /////////////////////////////////////////////////////////////////////////// 132 132 + template <typename charT> class tabs 133 133 + { 134 134 + const size_t t; 130 135 131 131 - template <typename charT> 132 132 - class tabs 133 133 - { 134 134 - const size_t t; 136 136 + public: 137 137 + explicit CONSTEXPR tabs(size_t i) NOEXCEPT : t(i) {} 138 138 + std::basic_string<charT> print() const 139 139 + { 140 140 + return std::basic_string<charT>(t, TYTI_L(charT, '\t')); 141 141 + } 142 142 + inline CONSTEXPR tabs operator+(size_t i) const NOEXCEPT 143 143 + { 144 144 + return tabs(t + i); 145 145 + } 146 146 + }; 135 147 136 136 - public: 137 137 - explicit CONSTEXPR tabs(size_t i) NOEXCEPT : t(i) {} 138 138 - std::basic_string<charT> print() const { return std::basic_string<charT>(t, TYTI_L(charT, '\t')); } 139 139 - inline CONSTEXPR tabs operator+(size_t i) const NOEXCEPT 140 140 - { 141 141 - return tabs(t + i); 142 142 - } 143 143 - }; 148 148 + template <typename oStreamT> 149 149 + oStreamT &operator<<(oStreamT &s, const tabs<typename oStreamT::char_type> t) 150 150 + { 151 151 + s << t.print(); 152 152 + return s; 153 153 + } 154 154 + } // end namespace detail 144 155 145 145 - template <typename oStreamT> 146 146 - oStreamT& operator<<(oStreamT& s, const tabs<typename oStreamT::char_type> t) 147 147 - { 148 148 - s << t.print(); 149 149 - return s; 150 150 - } 151 151 - } // end namespace detail 156 156 + /////////////////////////////////////////////////////////////////////////// 157 157 + // Interface 158 158 + /////////////////////////////////////////////////////////////////////////// 152 159 153 153 - /////////////////////////////////////////////////////////////////////////// 154 154 - // Interface 155 155 - /////////////////////////////////////////////////////////////////////////// 160 160 + /// custom objects and their corresponding write functions 156 161 157 157 - /// custom objects and their corresponding write functions 162 162 + /// basic object node. Every object has a name and can contains attributes saved 163 163 + /// as key_value pairs or childrens 164 164 + template <typename CharT> struct basic_object 165 165 + { 166 166 + typedef CharT char_type; 167 167 + std::basic_string<char_type> name; 168 168 + std::unordered_map<std::basic_string<char_type>, 169 169 + std::basic_string<char_type>> 170 170 + attribs; 171 171 + std::unordered_map<std::basic_string<char_type>, 172 172 + std::shared_ptr<basic_object<char_type>>> 173 173 + childs; 158 174 159 159 - /// basic object node. Every object has a name and can contains attributes saved as key_value pairs or childrens 160 160 - template <typename CharT> 161 161 - struct basic_object 162 162 - { 163 163 - typedef CharT char_type; 164 164 - std::basic_string<char_type> name; 165 165 - std::unordered_map<std::basic_string<char_type>, std::basic_string<char_type>> attribs; 166 166 - std::unordered_map<std::basic_string<char_type>, std::shared_ptr<basic_object<char_type>>> children; 175 175 + void add_attribute(std::basic_string<char_type> key, 176 176 + std::basic_string<char_type> value) 177 177 + { 178 178 + attribs.emplace(std::move(key), std::move(value)); 179 179 + } 180 180 + void add_child(std::unique_ptr<basic_object<char_type>> child) 181 181 + { 182 182 + std::shared_ptr<basic_object<char_type>> obj{child.release()}; 183 183 + childs.emplace(obj->name, obj); 184 184 + } 185 185 + void set_name(std::basic_string<char_type> n) { name = std::move(n); } 186 186 + }; 167 187 168 168 - void add_attribute(std::basic_string<char_type> key, std::basic_string<char_type> value) 169 169 - { 170 170 - attribs.emplace(std::move(key), std::move(value)); 171 171 - } 172 172 - void add_child(std::unique_ptr<basic_object<char_type>> child) 173 173 - { 174 174 - std::shared_ptr<basic_object<char_type>> obj{ child.release() }; 175 175 - children.emplace(obj->name, obj); 176 176 - } 177 177 - void set_name(std::basic_string<char_type> n) 178 178 - { 179 179 - name = std::move(n); 180 180 - } 181 181 - }; 188 188 + template <typename CharT> struct basic_multikey_object 189 189 + { 190 190 + typedef CharT char_type; 191 191 + std::basic_string<char_type> name; 192 192 + std::unordered_multimap<std::basic_string<char_type>, 193 193 + std::basic_string<char_type>> 194 194 + attribs; 195 195 + std::unordered_multimap<std::basic_string<char_type>, 196 196 + std::shared_ptr<basic_multikey_object<char_type>>> 197 197 + childs; 182 198 183 183 - template <typename CharT> 184 184 - struct basic_multikey_object 185 185 - { 186 186 - typedef CharT char_type; 187 187 - std::basic_string<char_type> name; 188 188 - std::unordered_multimap<std::basic_string<char_type>, std::basic_string<char_type>> attribs; 189 189 - std::unordered_multimap<std::basic_string<char_type>, std::shared_ptr<basic_multikey_object<char_type>>> children; 190 190 - 191 191 - void add_attribute(std::basic_string<char_type> key, std::basic_string<char_type> value) 192 192 - { 193 193 - attribs.emplace(std::move(key), std::move(value)); 194 194 - } 195 195 - void add_child(std::unique_ptr<basic_multikey_object<char_type>> child) 196 196 - { 197 197 - std::shared_ptr<basic_multikey_object<char_type>> obj{ child.release() }; 198 198 - children.emplace(obj->name, obj); 199 199 - } 200 200 - void set_name(std::basic_string<char_type> n) 201 201 - { 202 202 - name = std::move(n); 203 203 - } 204 204 - }; 199 199 + void add_attribute(std::basic_string<char_type> key, 200 200 + std::basic_string<char_type> value) 201 201 + { 202 202 + attribs.emplace(std::move(key), std::move(value)); 203 203 + } 204 204 + void add_child(std::unique_ptr<basic_multikey_object<char_type>> child) 205 205 + { 206 206 + std::shared_ptr<basic_multikey_object<char_type>> obj{child.release()}; 207 207 + childs.emplace(obj->name, obj); 208 208 + } 209 209 + void set_name(std::basic_string<char_type> n) { name = std::move(n); } 210 210 + }; 205 211 206 206 - typedef basic_object<char> object; 207 207 - typedef basic_object<wchar_t> wobject; 208 208 - typedef basic_multikey_object<char> multikey_object; 209 209 - typedef basic_multikey_object<wchar_t> wmultikey_object; 212 212 + typedef basic_object<char> object; 213 213 + typedef basic_object<wchar_t> wobject; 214 214 + typedef basic_multikey_object<char> multikey_object; 215 215 + typedef basic_multikey_object<wchar_t> wmultikey_object; 210 216 211 211 - struct Options 212 212 - { 213 213 - bool strip_escape_symbols; 214 214 - bool ignore_all_platform_conditionals; 215 215 - bool ignore_includes; 217 217 + struct Options 218 218 + { 219 219 + bool strip_escape_symbols; 220 220 + bool ignore_all_platform_conditionals; 221 221 + bool ignore_includes; 216 222 217 217 - Options() : strip_escape_symbols(true), ignore_all_platform_conditionals(false), ignore_includes(false) {} 218 218 - }; 223 223 + Options() 224 224 + : strip_escape_symbols(true), ignore_all_platform_conditionals(false), 225 225 + ignore_includes(false) 226 226 + { 227 227 + } 228 228 + }; 219 229 220 220 - //forward decls 221 221 - //forward decl 222 222 - template <typename OutputT, typename iStreamT> 223 223 - OutputT read(iStreamT& inStream, const Options& opt = Options{}); 230 230 + // forward decls 231 231 + // forward decl 232 232 + template <typename OutputT, typename iStreamT> 233 233 + OutputT read(iStreamT &inStream, const Options &opt = Options{}); 224 234 225 225 - /** \brief writes given object tree in vdf format to given stream. 226 226 - Output is prettyfied, using tabs 227 227 - */ 228 228 - template <typename oStreamT, typename T> 229 229 - void write(oStreamT& s, const T& r, 230 230 - const detail::tabs<typename oStreamT::char_type> tab = detail::tabs<typename oStreamT::char_type>(0)) 231 231 - { 232 232 - typedef typename oStreamT::char_type charT; 233 233 - using namespace detail; 234 234 - s << tab << TYTI_L(charT, '"') << r.name << TYTI_L(charT, "\"\n") << tab << TYTI_L(charT, "{\n"); 235 235 - for (const auto& i : r.attribs) 236 236 - s << tab + 1 << TYTI_L(charT, '"') << i.first << TYTI_L(charT, "\"\t\t\"") << i.second << TYTI_L(charT, "\"\n"); 237 237 - for (const auto& i : r.children) 238 238 - if (i.second) 239 239 - write(s, *i.second, tab + 1); 240 240 - s << tab << TYTI_L(charT, "}\n"); 241 241 - } 235 235 + /** \brief writes given object tree in vdf format to given stream. 236 236 + Output is prettyfied, using tabs 237 237 + */ 238 238 + template <typename oStreamT, typename T> 239 239 + void write(oStreamT &s, const T &r, 240 240 + const detail::tabs<typename oStreamT::char_type> tab = 241 241 + detail::tabs<typename oStreamT::char_type>(0)) 242 242 + { 243 243 + typedef typename oStreamT::char_type charT; 244 244 + using namespace detail; 245 245 + s << tab << TYTI_L(charT, '"') << r.name << TYTI_L(charT, "\"\n") << tab 246 246 + << TYTI_L(charT, "{\n"); 247 247 + for (const auto &i : r.attribs) 248 248 + s << tab + 1 << TYTI_L(charT, '"') << i.first 249 249 + << TYTI_L(charT, "\"\t\t\"") << i.second << TYTI_L(charT, "\"\n"); 250 250 + for (const auto &i : r.childs) 251 251 + if (i.second) 252 252 + write(s, *i.second, tab + 1); 253 253 + s << tab << TYTI_L(charT, "}\n"); 254 254 + } 242 255 243 243 - namespace detail 244 244 - { 245 245 - template <typename iStreamT> 246 246 - std::basic_string<typename iStreamT::char_type> read_file(iStreamT& inStream) 247 247 - { 248 248 - // cache the file 249 249 - typedef typename iStreamT::char_type charT; 250 250 - std::basic_string<charT> str; 251 251 - inStream.seekg(0, std::ios::end); 252 252 - str.resize(static_cast<size_t>(inStream.tellg())); 253 253 - if (str.empty()) 254 254 - return str; 256 256 + namespace detail 257 257 + { 258 258 + template <typename iStreamT> 259 259 + std::basic_string<typename iStreamT::char_type> read_file(iStreamT &inStream) 260 260 + { 261 261 + // cache the file 262 262 + typedef typename iStreamT::char_type charT; 263 263 + std::basic_string<charT> str; 264 264 + inStream.seekg(0, std::ios::end); 265 265 + str.resize(static_cast<size_t>(inStream.tellg())); 266 266 + if (str.empty()) 267 267 + return str; 255 268 256 256 - inStream.seekg(0, std::ios::beg); 257 257 - inStream.read(&str[0], str.size()); 258 258 - return str; 259 259 - } 269 269 + inStream.seekg(0, std::ios::beg); 270 270 + inStream.read(&str[0], str.size()); 271 271 + return str; 272 272 + } 260 273 261 261 - /** \brief Read VDF formatted sequences defined by the range [first, last). 262 262 - If the file is mailformatted, parser will try to read it until it can. 263 263 - @param first begin iterator 264 264 - @param end end iterator 265 265 - @param exclude_files list of files which cant be included anymore. 266 266 - prevents circular includes 274 274 + /** \brief Read VDF formatted sequences defined by the range [first, last). 275 275 + If the file is mailformatted, parser will try to read it until it can. 276 276 + @param first begin iterator 277 277 + @param end end iterator 278 278 + @param exclude_files list of files which cant be included anymore. 279 279 + prevents circular includes 267 280 268 268 - can thow: 269 269 - - "std::runtime_error" if a parsing error occured 270 270 - - "std::bad_alloc" if not enough memory coup be allocated 271 271 - */ 272 272 - template <typename OutputT, typename IterT> 273 273 - std::vector<std::unique_ptr<OutputT>> read_internal(IterT first, const IterT last, 274 274 - std::unordered_set<std::basic_string<typename std::iterator_traits<IterT>::value_type>>& exclude_files, 275 275 - const Options& opt) 276 276 - { 277 277 - static_assert(std::is_default_constructible<OutputT>::value, 278 278 - "Output Type must be default constructible (provide constructor without arguments)"); 279 279 - static_assert(std::is_move_constructible<OutputT>::value, 280 280 - "Output Type must be move constructible"); 281 281 + can thow: 282 282 + - "std::runtime_error" if a parsing error occured 283 283 + - "std::bad_alloc" if not enough memory coup be allocated 284 284 + */ 285 285 + template <typename OutputT, typename IterT> 286 286 + std::vector<std::unique_ptr<OutputT>> read_internal( 287 287 + IterT first, const IterT last, 288 288 + std::unordered_set< 289 289 + std::basic_string<typename std::iterator_traits<IterT>::value_type>> 290 290 + &exclude_files, 291 291 + const Options &opt) 292 292 + { 293 293 + static_assert(std::is_default_constructible<OutputT>::value, 294 294 + "Output Type must be default constructible (provide " 295 295 + "constructor without arguments)"); 296 296 + static_assert(std::is_move_constructible<OutputT>::value, 297 297 + "Output Type must be move constructible"); 281 298 282 282 - typedef typename std::iterator_traits<IterT>::value_type charT; 299 299 + typedef typename std::iterator_traits<IterT>::value_type charT; 283 300 284 284 - const std::basic_string<charT> comment_end_str = TYTI_L(charT, "*/"); 285 285 - const std::basic_string<charT> whitespaces = TYTI_L(charT, " \n\v\f\r\t"); 301 301 + const std::basic_string<charT> comment_end_str = TYTI_L(charT, "*/"); 302 302 + const std::basic_string<charT> whitespaces = TYTI_L(charT, " \n\v\f\r\t"); 286 303 287 304 #ifdef WIN32 288 288 - std::function<bool(const std::basic_string<charT>&)> is_platform_str = [](const std::basic_string<charT>& in) { 289 289 - return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$WINDOWS"); 290 290 - }; 305 305 + std::function<bool(const std::basic_string<charT> &)> is_platform_str = 306 306 + [](const std::basic_string<charT> &in) 307 307 + { 308 308 + return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$WINDOWS"); 309 309 + }; 291 310 #elif __APPLE__ 292 292 - // WIN32 stands for pc in general 293 293 - std::function<bool(const std::basic_string<charT>&)> is_platform_str = [](const std::basic_string<charT>& in) { 294 294 - return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$POSIX") || in == TYTI_L(charT, "$OSX"); 295 295 - }; 311 311 + // WIN32 stands for pc in general 312 312 + std::function<bool(const std::basic_string<charT> &)> is_platform_str = 313 313 + [](const std::basic_string<charT> &in) 314 314 + { 315 315 + return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$POSIX") || 316 316 + in == TYTI_L(charT, "$OSX"); 317 317 + }; 296 318 297 319 #elif __linux__ 298 298 - // WIN32 stands for pc in general 299 299 - std::function<bool(const std::basic_string<charT>&)> is_platform_str = [](const std::basic_string<charT>& in) { 300 300 - return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$POSIX") || in == TYTI_L(charT, "$LINUX"); 301 301 - }; 320 320 + // WIN32 stands for pc in general 321 321 + std::function<bool(const std::basic_string<charT> &)> is_platform_str = 322 322 + [](const std::basic_string<charT> &in) 323 323 + { 324 324 + return in == TYTI_L(charT, "$WIN32") || in == TYTI_L(charT, "$POSIX") || 325 325 + in == TYTI_L(charT, "$LINUX"); 326 326 + }; 302 327 #else 303 303 - std::function<bool(const std::basic_string<charT>&)> is_platform_str = [](const std::basic_string<charT>& in) { 304 304 - return false; 305 305 - }; 328 328 + std::function<bool(const std::basic_string<charT> &)> is_platform_str = 329 329 + [](const std::basic_string<charT> &in) { return false; }; 306 330 #endif 307 331 308 308 - if (opt.ignore_all_platform_conditionals) 309 309 - is_platform_str = [](const std::basic_string<charT>&) { 310 310 - return false; 311 311 - }; 332 332 + if (opt.ignore_all_platform_conditionals) 333 333 + is_platform_str = [](const std::basic_string<charT> &) 334 334 + { return false; }; 312 335 313 313 - // function for skipping a comment block 314 314 - // iter: iterator poition to the position after a '/' 315 315 - auto skip_comments = [&comment_end_str](IterT iter, const IterT& last) -> IterT { 316 316 - ++iter; 317 317 - if (iter != last) 318 318 - { 319 319 - if (*iter == TYTI_L(charT, '/')) 320 320 - { 321 321 - // line comment, skip whole line 322 322 - iter = std::find(iter + 1, last, TYTI_L(charT, '\n')); 323 323 - } 336 336 + // function for skipping a comment block 337 337 + // iter: iterator poition to the position after a '/' 338 338 + auto skip_comments = [&comment_end_str](IterT iter, 339 339 + const IterT &last) -> IterT 340 340 + { 341 341 + ++iter; 342 342 + if (iter == last) 343 343 + return last; 324 344 325 325 - if (*iter == '*') 326 326 - { 327 327 - // block comment, skip until next occurance of "*\" 328 328 - iter = std::search(iter + 1, last, std::begin(comment_end_str), std::end(comment_end_str)); 329 329 - iter += 2; 330 330 - } 331 331 - } 332 332 - return iter; 333 333 - }; 345 345 + if (*iter == TYTI_L(charT, '/')) 346 346 + { 347 347 + // line comment, skip whole line 348 348 + iter = std::find(iter + 1, last, TYTI_L(charT, '\n')); 349 349 + if (iter == last) 350 350 + return last; 351 351 + } 334 352 335 335 - auto end_quote = [](IterT iter, const IterT& last) -> IterT { 336 336 - const auto begin = iter; 337 337 - auto last_esc = iter; 338 338 - do 339 339 - { 340 340 - ++iter; 341 341 - iter = std::find(iter, last, TYTI_L(charT, '\"')); 342 342 - if (iter == last) 343 343 - break; 353 353 + if (*iter == '*') 354 354 + { 355 355 + // block comment, skip until next occurance of "*\" 356 356 + iter = std::search(iter + 1, last, std::begin(comment_end_str), 357 357 + std::end(comment_end_str)); 358 358 + if (std::distance(iter, last) <= 2) 359 359 + return last; 360 360 + iter += 2; 361 361 + } 344 362 345 345 - last_esc = std::prev(iter); 346 346 - while (last_esc != begin && *last_esc == '\\') 347 347 - --last_esc; 348 348 - } while (!(std::distance(last_esc, iter) % 2)); 349 349 - if (iter == last) 350 350 - throw std::runtime_error{ "quote was opened but not closed." }; 351 351 - return iter; 352 352 - }; 363 363 + return iter; 364 364 + }; 353 365 354 354 - auto end_word = [&whitespaces](IterT iter, const IterT& last) -> IterT { 355 355 - const auto begin = iter; 356 356 - auto last_esc = iter; 357 357 - do 358 358 - { 359 359 - ++iter; 360 360 - iter = std::find_first_of(iter, last, std::begin(whitespaces), std::end(whitespaces)); 361 361 - if (iter == last) 362 362 - break; 366 366 + auto end_quote = [](IterT iter, const IterT &last) -> IterT 367 367 + { 368 368 + const auto begin = iter; 369 369 + auto last_esc = iter; 370 370 + if (iter == last) 371 371 + throw std::runtime_error{"quote was opened but not closed."}; 372 372 + do 373 373 + { 374 374 + ++iter; 375 375 + iter = std::find(iter, last, TYTI_L(charT, '\"')); 376 376 + if (iter == last) 377 377 + break; 363 378 364 364 - last_esc = std::prev(iter); 365 365 - while (last_esc != begin && *last_esc == '\\') 366 366 - --last_esc; 367 367 - } while (!(std::distance(last_esc, iter) % 2)); 368 368 - //if (iter == last) 369 369 - // throw std::runtime_error{ "word wasnt properly ended" }; 370 370 - return iter; 371 371 - }; 379 379 + last_esc = std::prev(iter); 380 380 + while (last_esc != begin && *last_esc == '\\') 381 381 + --last_esc; 382 382 + } while (!(std::distance(last_esc, iter) % 2) && iter != last); 383 383 + if (iter == last) 384 384 + throw std::runtime_error{"quote was opened but not closed."}; 385 385 + return iter; 386 386 + }; 372 387 373 373 - auto skip_whitespaces = [&whitespaces](IterT iter, const IterT& last) -> IterT { 374 374 - iter = std::find_if_not(iter, last, [&whitespaces](charT c) { 375 375 - // return true if whitespace 376 376 - return std::any_of(std::begin(whitespaces), std::end(whitespaces), [c](charT pc) { return pc == c; }); 377 377 - }); 378 378 - return iter; 379 379 - }; 388 388 + auto end_word = [&whitespaces](IterT iter, const IterT &last) -> IterT 389 389 + { 390 390 + const auto begin = iter; 391 391 + auto last_esc = iter; 392 392 + if (iter == last) 393 393 + throw std::runtime_error{"quote was opened but not closed."}; 394 394 + do 395 395 + { 396 396 + ++iter; 397 397 + iter = std::find_first_of(iter, last, std::begin(whitespaces), 398 398 + std::end(whitespaces)); 399 399 + if (iter == last) 400 400 + break; 380 401 381 381 - std::function<void(std::basic_string<charT>&)> strip_escape_symbols = [](std::basic_string<charT>& s) { 382 382 - auto quote_searcher = [&s](size_t pos) { return s.find(TYTI_L(charT, "\\\""), pos); }; 383 383 - auto p = quote_searcher(0); 384 384 - while (p != s.npos) 385 385 - { 386 386 - s.replace(p, 2, TYTI_L(charT, "\"")); 387 387 - p = quote_searcher(p); 388 388 - } 389 389 - auto searcher = [&s](size_t pos) { return s.find(TYTI_L(charT, "\\\\"), pos); }; 390 390 - p = searcher(0); 391 391 - while (p != s.npos) 392 392 - { 393 393 - s.replace(p, 2, TYTI_L(charT, "\\")); 394 394 - p = searcher(p); 395 395 - } 396 396 - }; 402 402 + last_esc = std::prev(iter); 403 403 + while (last_esc != begin && *last_esc == '\\') 404 404 + --last_esc; 405 405 + } while (!(std::distance(last_esc, iter) % 2) && iter != last); 406 406 + if (iter == last) 407 407 + throw std::runtime_error{"word wasnt properly ended"}; 408 408 + return iter; 409 409 + }; 397 410 398 398 - if (!opt.strip_escape_symbols) 399 399 - strip_escape_symbols = [](std::basic_string<charT>&) {}; 411 411 + auto skip_whitespaces = [&whitespaces](IterT iter, 412 412 + const IterT &last) -> IterT 413 413 + { 414 414 + if (iter == last) 415 415 + return iter; 416 416 + iter = std::find_if_not(iter, last, 417 417 + [&whitespaces](charT c) 418 418 + { 419 419 + // return true if whitespace 420 420 + return std::any_of(std::begin(whitespaces), 421 421 + std::end(whitespaces), 422 422 + [c](charT pc) 423 423 + { return pc == c; }); 424 424 + }); 425 425 + return iter; 426 426 + }; 400 427 401 401 - auto conditional_fullfilled = [&skip_whitespaces, &is_platform_str](IterT& iter, const IterT& last) { 402 402 - iter = skip_whitespaces(iter, last); 403 403 - if (*iter == '[') 404 404 - { 405 405 - ++iter; 406 406 - const auto end = std::find(iter, last, ']'); 407 407 - const bool negate = *iter == '!'; 408 408 - if (negate) 409 409 - ++iter; 410 410 - auto conditional = std::basic_string<charT>(iter, end); 428 428 + std::function<void(std::basic_string<charT> &)> strip_escape_symbols = 429 429 + [](std::basic_string<charT> &s) 430 430 + { 431 431 + auto quote_searcher = [&s](size_t pos) 432 432 + { return s.find(TYTI_L(charT, "\\\""), pos); }; 433 433 + auto p = quote_searcher(0); 434 434 + while (p != s.npos) 435 435 + { 436 436 + s.replace(p, 2, TYTI_L(charT, "\"")); 437 437 + p = quote_searcher(p); 438 438 + } 439 439 + auto searcher = [&s](size_t pos) 440 440 + { return s.find(TYTI_L(charT, "\\\\"), pos); }; 441 441 + p = searcher(0); 442 442 + while (p != s.npos) 443 443 + { 444 444 + s.replace(p, 2, TYTI_L(charT, "\\")); 445 445 + p = searcher(p); 446 446 + } 447 447 + }; 411 448 412 412 - const bool is_platform = is_platform_str(conditional); 413 413 - iter = end + 1; 449 449 + if (!opt.strip_escape_symbols) 450 450 + strip_escape_symbols = [](std::basic_string<charT> &) {}; 414 451 415 415 - return static_cast<bool>(is_platform ^ negate); 416 416 - } 417 417 - return true; 418 418 - }; 452 452 + auto conditional_fullfilled = 453 453 + [&skip_whitespaces, &is_platform_str](IterT &iter, const IterT &last) 454 454 + { 455 455 + iter = skip_whitespaces(iter, last); 456 456 + if (iter == last) 457 457 + return true; 458 458 + if (*iter == '[') 459 459 + { 460 460 + ++iter; 461 461 + if (iter == last) 462 462 + throw std::runtime_error("conditional not closed"); 463 463 + const auto end = std::find(iter, last, ']'); 464 464 + if (end == last) 465 465 + throw std::runtime_error("conditional not closed"); 466 466 + const bool negate = *iter == '!'; 467 467 + if (negate) 468 468 + ++iter; 469 469 + auto conditional = std::basic_string<charT>(iter, end); 419 470 420 420 - //read header 421 421 - // first, quoted name 422 422 - std::unique_ptr<OutputT> curObj = nullptr; 423 423 - std::vector<std::unique_ptr<OutputT>> roots; 424 424 - std::stack<std::unique_ptr<OutputT>> lvls; 425 425 - auto curIter = first; 471 471 + const bool is_platform = is_platform_str(conditional); 472 472 + iter = end + 1; 426 473 427 427 - while (curIter != last && *curIter != '\0') 428 428 - { 429 429 - //find first starting attrib/child, or ending 430 430 - curIter = skip_whitespaces(curIter, last); 431 431 - if (curIter == last || *curIter == '\0') 432 432 - break; 433 433 - if (*curIter == TYTI_L(charT, '/')) 434 434 - { 435 435 - curIter = skip_comments(curIter, last); 436 436 - } 437 437 - else if (*curIter != TYTI_L(charT, '}')) 438 438 - { 474 474 + return static_cast<bool>(is_platform ^ negate); 475 475 + } 476 476 + return true; 477 477 + }; 439 478 440 440 - // get key 441 441 - const auto keyEnd = (*curIter == TYTI_L(charT, '\"')) ? end_quote(curIter, last) : end_word(curIter, last); 442 442 - if (*curIter == TYTI_L(charT, '\"')) 443 443 - ++curIter; 444 444 - std::basic_string<charT> key(curIter, keyEnd); 445 445 - strip_escape_symbols(key); 446 446 - curIter = keyEnd + ((*keyEnd == TYTI_L(charT, '\"')) ? 1 : 0); 479 479 + // read header 480 480 + // first, quoted name 481 481 + std::unique_ptr<OutputT> curObj = nullptr; 482 482 + std::vector<std::unique_ptr<OutputT>> roots; 483 483 + std::stack<std::unique_ptr<OutputT>> lvls; 484 484 + auto curIter = first; 485 485 + 486 486 + while (curIter != last && *curIter != '\0') 487 487 + { 488 488 + // find first starting attrib/child, or ending 489 489 + curIter = skip_whitespaces(curIter, last); 490 490 + if (curIter == last || *curIter == '\0') 491 491 + break; 492 492 + if (*curIter == TYTI_L(charT, '/')) 493 493 + { 494 494 + curIter = skip_comments(curIter, last); 495 495 + if (curIter == last || *curIter == '\0') 496 496 + throw std::runtime_error("Unexpected eof"); 497 497 + } 498 498 + else if (*curIter != TYTI_L(charT, '}')) 499 499 + { 500 500 + // get key 501 501 + const auto keyEnd = (*curIter == TYTI_L(charT, '\"')) 502 502 + ? end_quote(curIter, last) 503 503 + : end_word(curIter, last); 504 504 + if (*curIter == TYTI_L(charT, '\"')) 505 505 + ++curIter; 506 506 + std::basic_string<charT> key(curIter, keyEnd); 507 507 + strip_escape_symbols(key); 508 508 + curIter = keyEnd + ((*keyEnd == TYTI_L(charT, '\"')) ? 1 : 0); 509 509 + if (curIter == last) 510 510 + throw std::runtime_error{"key opened, but never closed"}; 447 511 448 448 - curIter = skip_whitespaces(curIter, last); 512 512 + curIter = skip_whitespaces(curIter, last); 449 513 450 450 - auto conditional = conditional_fullfilled(curIter, last); 451 451 - if (!conditional) 452 452 - continue; 514 514 + auto conditional = conditional_fullfilled(curIter, last); 515 515 + if (!conditional) 516 516 + continue; 517 517 + if (curIter == last) 518 518 + throw std::runtime_error{"key declared, but no value"}; 453 519 454 454 - while (*curIter == TYTI_L(charT, '/')) 455 455 - { 520 520 + while (*curIter == TYTI_L(charT, '/')) 521 521 + { 456 522 457 457 - curIter = skip_comments(curIter, last); 458 458 - if (curIter == last || *curIter == '}') 459 459 - throw std::runtime_error{ "key declared, but no value" }; 460 460 - curIter = skip_whitespaces(curIter, last); 461 461 - if (curIter == last || *curIter == '}') 462 462 - throw std::runtime_error{ "key declared, but no value" }; 463 463 - } 464 464 - // get value 465 465 - if (*curIter != '{') 466 466 - { 467 467 - const auto valueEnd = (*curIter == TYTI_L(charT, '\"')) ? end_quote(curIter, last) : end_word(curIter, last); 468 468 - if (*curIter == TYTI_L(charT, '\"')) 469 469 - ++curIter; 523 523 + curIter = skip_comments(curIter, last); 524 524 + if (curIter == last || *curIter == '}') 525 525 + throw std::runtime_error{"key declared, but no value"}; 526 526 + curIter = skip_whitespaces(curIter, last); 527 527 + if (curIter == last || *curIter == '}') 528 528 + throw std::runtime_error{"key declared, but no value"}; 529 529 + } 530 530 + // get value 531 531 + if (*curIter != '{') 532 532 + { 533 533 + if (curIter == last) 534 534 + throw std::runtime_error{"key declared, but no value"}; 535 535 + const auto valueEnd = (*curIter == TYTI_L(charT, '\"')) 536 536 + ? end_quote(curIter, last) 537 537 + : end_word(curIter, last); 538 538 + if (valueEnd == last) 539 539 + throw std::runtime_error("No closed word"); 540 540 + if (*curIter == TYTI_L(charT, '\"')) 541 541 + ++curIter; 542 542 + if (curIter == last) 543 543 + throw std::runtime_error("No closed word"); 470 544 471 471 - auto value = std::basic_string<charT>(curIter, valueEnd); 472 472 - strip_escape_symbols(value); 473 473 - curIter = valueEnd + ((*valueEnd == TYTI_L(charT, '\"')) ? 1 : 0); 545 545 + auto value = std::basic_string<charT>(curIter, valueEnd); 546 546 + strip_escape_symbols(value); 547 547 + curIter = 548 548 + valueEnd + ((*valueEnd == TYTI_L(charT, '\"')) ? 1 : 0); 474 549 475 475 - auto conditional = conditional_fullfilled(curIter, last); 476 476 - if (!conditional) 477 477 - continue; 550 550 + auto conditional = conditional_fullfilled(curIter, last); 551 551 + if (!conditional) 552 552 + continue; 478 553 479 479 - // process value 480 480 - if (key != TYTI_L(charT, "#include") && key != TYTI_L(charT, "#base")) 481 481 - { 482 482 - if (curObj) 483 483 - { 484 484 - curObj->add_attribute(std::move(key), std::move(value)); 485 485 - } 486 486 - else 487 487 - { 488 488 - throw std::runtime_error{ "unexpected key without object" }; 489 489 - } 490 490 - } 491 491 - else 492 492 - { 493 493 - if (!opt.ignore_includes && exclude_files.find(value) == exclude_files.end()) 494 494 - { 495 495 - exclude_files.insert(value); 496 496 - std::basic_ifstream<charT> i(detail::string_converter(value)); 497 497 - auto str = read_file(i); 498 498 - auto file_objs = read_internal<OutputT>(str.begin(), str.end(), exclude_files, opt); 499 499 - for (auto& n : file_objs) 500 500 - { 501 501 - if (curObj) 502 502 - curObj->add_child(std::move(n)); 503 503 - else 504 504 - roots.push_back(std::move(n)); 505 505 - } 506 506 - exclude_files.erase(value); 507 507 - } 508 508 - } 509 509 - } 510 510 - else if (*curIter == '{') 511 511 - { 512 512 - if (curObj) 513 513 - lvls.push(std::move(curObj)); 514 514 - curObj = std::make_unique<OutputT>(); 515 515 - curObj->set_name(std::move(key)); 516 516 - ++curIter; 517 517 - } 518 518 - } 519 519 - //end of new object 520 520 - else if (curObj && *curIter == TYTI_L(charT, '}')) 554 554 + // process value 555 555 + if (key != TYTI_L(charT, "#include") && 556 556 + key != TYTI_L(charT, "#base")) 557 557 + { 558 558 + if (curObj) 521 559 { 522 522 - if (!lvls.empty()) 523 523 - { 524 524 - //get object before 525 525 - std::unique_ptr<OutputT> prev{ std::move(lvls.top()) }; 526 526 - lvls.pop(); 527 527 - 528 528 - // add finished obj to obj before and release it from processing 529 529 - prev->add_child(std::move(curObj)); 530 530 - curObj = std::move(prev); 531 531 - } 532 532 - else 533 533 - { 534 534 - roots.push_back(std::move(curObj)); 535 535 - curObj.reset(); 536 536 - } 537 537 - ++curIter; 560 560 + curObj->add_attribute(std::move(key), std::move(value)); 538 561 } 539 562 else 540 563 { 541 541 - throw std::runtime_error{ "unexpected '}'" }; 564 564 + throw std::runtime_error{ 565 565 + "unexpected key without object"}; 542 566 } 543 567 } 544 544 - if (curObj != nullptr || !lvls.empty()) 568 568 + else 545 569 { 546 546 - throw std::runtime_error{ "object is not closed with '}'" }; 570 570 + if (!opt.ignore_includes && 571 571 + exclude_files.find(value) == exclude_files.end()) 572 572 + { 573 573 + exclude_files.insert(value); 574 574 + std::basic_ifstream<charT> i( 575 575 + detail::string_converter(value)); 576 576 + auto str = read_file(i); 577 577 + auto file_objs = read_internal<OutputT>( 578 578 + str.begin(), str.end(), exclude_files, opt); 579 579 + for (auto &n : file_objs) 580 580 + { 581 581 + if (curObj) 582 582 + curObj->add_child(std::move(n)); 583 583 + else 584 584 + roots.push_back(std::move(n)); 585 585 + } 586 586 + exclude_files.erase(value); 587 587 + } 547 588 } 548 548 - 549 549 - return roots; 550 589 } 551 551 - 552 552 - } // namespace detail 553 553 - 554 554 - /** \brief Read VDF formatted sequences defined by the range [first, last). 555 555 - If the file is mailformatted, parser will try to read it until it can. 556 556 - @param first begin iterator 557 557 - @param end end iterator 558 558 - 559 559 - can thow: 560 560 - - "std::runtime_error" if a parsing error occured 561 561 - - "std::bad_alloc" if not enough memory coup be allocated 562 562 - */ 563 563 - template <typename OutputT, typename IterT> 564 564 - OutputT read(IterT first, const IterT last, const Options& opt = Options{}) 565 565 - { 566 566 - auto exclude_files = std::unordered_set<std::basic_string<typename std::iterator_traits<IterT>::value_type>>{}; 567 567 - auto roots = detail::read_internal<OutputT>(first, last, exclude_files, opt); 568 568 - 569 569 - OutputT result; 570 570 - if (roots.size() > 1) 590 590 + else if (*curIter == '{') 571 591 { 572 572 - for (auto& i : roots) 573 573 - result.add_child(std::move(i)); 592 592 + if (curObj) 593 593 + lvls.push(std::move(curObj)); 594 594 + curObj = std::make_unique<OutputT>(); 595 595 + curObj->set_name(std::move(key)); 596 596 + ++curIter; 574 597 } 575 575 - else if (roots.size() == 1) 576 576 - result = std::move(*roots[0]); 577 577 - 578 578 - return result; 579 598 } 580 580 - 581 581 - /** \brief Read VDF formatted sequences defined by the range [first, last). 582 582 - If the file is mailformatted, parser will try to read it until it can. 583 583 - @param first begin iterator 584 584 - @param end end iterator 585 585 - @param ec output bool. 0 if ok, otherwise, holds an system error code 586 586 - 587 587 - Possible error codes: 588 588 - std::errc::protocol_error: file is mailformatted 589 589 - std::errc::not_enough_memory: not enough space 590 590 - std::errc::invalid_argument: iterators throws e.g. out of range 591 591 - */ 592 592 - template <typename OutputT, typename IterT> 593 593 - OutputT read(IterT first, IterT last, std::error_code& ec, const Options& opt = Options{}) NOEXCEPT 594 594 - 599 599 + // end of new object 600 600 + else if (curObj && *curIter == TYTI_L(charT, '}')) 595 601 { 596 596 - ec.clear(); 597 597 - OutputT r{}; 598 598 - try 602 602 + if (!lvls.empty()) 599 603 { 600 600 - r = read<OutputT>(first, last, opt); 604 604 + // get object before 605 605 + std::unique_ptr<OutputT> prev{std::move(lvls.top())}; 606 606 + lvls.pop(); 607 607 + 608 608 + // add finished obj to obj before and release it from processing 609 609 + prev->add_child(std::move(curObj)); 610 610 + curObj = std::move(prev); 601 611 } 602 602 - catch (std::runtime_error&) 612 612 + else 603 613 { 604 604 - ec = std::make_error_code(std::errc::protocol_error); 605 605 - } 606 606 - catch (std::bad_alloc&) 607 607 - { 608 608 - ec = std::make_error_code(std::errc::not_enough_memory); 609 609 - } 610 610 - catch (...) 611 611 - { 612 612 - ec = std::make_error_code(std::errc::invalid_argument); 614 614 + roots.push_back(std::move(curObj)); 615 615 + curObj.reset(); 613 616 } 614 614 - return r; 617 617 + ++curIter; 615 618 } 616 616 - 617 617 - /** \brief Read VDF formatted sequences defined by the range [first, last). 618 618 - If the file is mailformatted, parser will try to read it until it can. 619 619 - @param first begin iterator 620 620 - @param end end iterator 621 621 - @param ok output bool. true, if parser successed, false, if parser failed 622 622 - */ 623 623 - template <typename OutputT, typename IterT> 624 624 - OutputT read(IterT first, const IterT last, bool* ok, const Options& opt = Options{}) NOEXCEPT 619 619 + else 625 620 { 626 626 - std::error_code ec; 627 627 - auto r = read<OutputT>(first, last, ec, opt); 628 628 - if (ok) 629 629 - *ok = !ec; 630 630 - return r; 621 621 + throw std::runtime_error{"unexpected '}'"}; 631 622 } 623 623 + } 624 624 + if (curObj != nullptr || !lvls.empty()) 625 625 + { 626 626 + throw std::runtime_error{"object is not closed with '}'"}; 627 627 + } 632 628 633 633 - template <typename IterT> 634 634 - inline auto read(IterT first, const IterT last, bool* ok, const Options& opt = Options{}) NOEXCEPT -> basic_object<typename std::iterator_traits<IterT>::value_type> 635 635 - { 636 636 - return read<basic_object<typename std::iterator_traits<IterT>::value_type>>(first, last, ok, opt); 637 637 - } 629 629 + return roots; 630 630 + } 631 631 + 632 632 + } // namespace detail 633 633 + 634 634 + /** \brief Read VDF formatted sequences defined by the range [first, last). 635 635 + If the file is mailformatted, parser will try to read it until it can. 636 636 + @param first begin iterator 637 637 + @param end end iterator 638 638 + 639 639 + can thow: 640 640 + - "std::runtime_error" if a parsing error occured 641 641 + - "std::bad_alloc" if not enough memory coup be allocated 642 642 + */ 643 643 + template <typename OutputT, typename IterT> 644 644 + OutputT read(IterT first, const IterT last, const Options &opt = Options{}) 645 645 + { 646 646 + auto exclude_files = std::unordered_set< 647 647 + std::basic_string<typename std::iterator_traits<IterT>::value_type>>{}; 648 648 + auto roots = 649 649 + detail::read_internal<OutputT>(first, last, exclude_files, opt); 650 650 + 651 651 + OutputT result; 652 652 + if (roots.size() > 1) 653 653 + { 654 654 + for (auto &i : roots) 655 655 + result.add_child(std::move(i)); 656 656 + } 657 657 + else if (roots.size() == 1) 658 658 + result = std::move(*roots[0]); 659 659 + 660 660 + return result; 661 661 + } 662 662 + 663 663 + /** \brief Read VDF formatted sequences defined by the range [first, last). 664 664 + If the file is mailformatted, parser will try to read it until it can. 665 665 + @param first begin iterator 666 666 + @param end end iterator 667 667 + @param ec output bool. 0 if ok, otherwise, holds an system error code 668 668 + 669 669 + Possible error codes: 670 670 + std::errc::protocol_error: file is mailformatted 671 671 + std::errc::not_enough_memory: not enough space 672 672 + std::errc::invalid_argument: iterators throws e.g. out of range 673 673 + */ 674 674 + template <typename OutputT, typename IterT> 675 675 + OutputT read(IterT first, IterT last, std::error_code &ec, 676 676 + const Options &opt = Options{}) NOEXCEPT 677 677 + 678 678 + { 679 679 + ec.clear(); 680 680 + OutputT r{}; 681 681 + try 682 682 + { 683 683 + r = read<OutputT>(first, last, opt); 684 684 + } 685 685 + catch (std::runtime_error &) 686 686 + { 687 687 + ec = std::make_error_code(std::errc::protocol_error); 688 688 + } 689 689 + catch (std::bad_alloc &) 690 690 + { 691 691 + ec = std::make_error_code(std::errc::not_enough_memory); 692 692 + } 693 693 + catch (...) 694 694 + { 695 695 + ec = std::make_error_code(std::errc::invalid_argument); 696 696 + } 697 697 + return r; 698 698 + } 699 699 + 700 700 + /** \brief Read VDF formatted sequences defined by the range [first, last). 701 701 + If the file is mailformatted, parser will try to read it until it can. 702 702 + @param first begin iterator 703 703 + @param end end iterator 704 704 + @param ok output bool. true, if parser successed, false, if parser failed 705 705 + */ 706 706 + template <typename OutputT, typename IterT> 707 707 + OutputT read(IterT first, const IterT last, bool *ok, 708 708 + const Options &opt = Options{}) NOEXCEPT 709 709 + { 710 710 + std::error_code ec; 711 711 + auto r = read<OutputT>(first, last, ec, opt); 712 712 + if (ok) 713 713 + *ok = !ec; 714 714 + return r; 715 715 + } 638 716 639 639 - template <typename IterT> 640 640 - inline auto read(IterT first, IterT last, std::error_code& ec, const Options& opt = Options{}) NOEXCEPT 641 641 - -> basic_object<typename std::iterator_traits<IterT>::value_type> 642 642 - { 643 643 - return read<basic_object<typename std::iterator_traits<IterT>::value_type>>(first, last, ec, opt); 644 644 - } 717 717 + template <typename IterT> 718 718 + inline auto read(IterT first, const IterT last, bool *ok, 719 719 + const Options &opt = Options{}) NOEXCEPT 720 720 + ->basic_object<typename std::iterator_traits<IterT>::value_type> 721 721 + { 722 722 + return read<basic_object<typename std::iterator_traits<IterT>::value_type>>( 723 723 + first, last, ok, opt); 724 724 + } 645 725 646 646 - template <typename IterT> 647 647 - inline auto read(IterT first, const IterT last, const Options& opt = Options{}) 648 648 - -> basic_object<typename std::iterator_traits<IterT>::value_type> 649 649 - { 650 650 - return read<basic_object<typename std::iterator_traits<IterT>::value_type>>(first, last, opt); 651 651 - } 726 726 + template <typename IterT> 727 727 + inline auto read(IterT first, IterT last, std::error_code &ec, 728 728 + const Options &opt = Options{}) NOEXCEPT 729 729 + ->basic_object<typename std::iterator_traits<IterT>::value_type> 730 730 + { 731 731 + return read<basic_object<typename std::iterator_traits<IterT>::value_type>>( 732 732 + first, last, ec, opt); 733 733 + } 734 734 + 735 735 + template <typename IterT> 736 736 + inline auto read(IterT first, const IterT last, const Options &opt = Options{}) 737 737 + -> basic_object<typename std::iterator_traits<IterT>::value_type> 738 738 + { 739 739 + return read<basic_object<typename std::iterator_traits<IterT>::value_type>>( 740 740 + first, last, opt); 741 741 + } 652 742 653 653 - /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf formatted data. 654 654 - throws "std::bad_alloc" if file buffer could not be allocated 655 655 - */ 656 656 - template <typename OutputT, typename iStreamT> 657 657 - OutputT read(iStreamT& inStream, std::error_code& ec, const Options& opt = Options{}) 658 658 - { 659 659 - // cache the file 660 660 - typedef typename iStreamT::char_type charT; 661 661 - std::basic_string<charT> str = detail::read_file(inStream); 743 743 + /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf 744 744 + formatted data. throws "std::bad_alloc" if file buffer could not be allocated 745 745 + */ 746 746 + template <typename OutputT, typename iStreamT> 747 747 + OutputT read(iStreamT &inStream, std::error_code &ec, 748 748 + const Options &opt = Options{}) 749 749 + { 750 750 + // cache the file 751 751 + typedef typename iStreamT::char_type charT; 752 752 + std::basic_string<charT> str = detail::read_file(inStream); 662 753 663 663 - // parse it 664 664 - return read<OutputT>(str.begin(), str.end(), ec, opt); 665 665 - } 754 754 + // parse it 755 755 + return read<OutputT>(str.begin(), str.end(), ec, opt); 756 756 + } 666 757 667 667 - template <typename iStreamT> 668 668 - inline basic_object<typename iStreamT::char_type> read(iStreamT& inStream, std::error_code& ec, const Options& opt = Options{}) 669 669 - { 670 670 - return read<basic_object<typename iStreamT::char_type>>(inStream, ec, opt); 671 671 - } 758 758 + template <typename iStreamT> 759 759 + inline basic_object<typename iStreamT::char_type> 760 760 + read(iStreamT &inStream, std::error_code &ec, const Options &opt = Options{}) 761 761 + { 762 762 + return read<basic_object<typename iStreamT::char_type>>(inStream, ec, opt); 763 763 + } 672 764 673 673 - /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf formatted data. 674 674 - throws "std::bad_alloc" if file buffer could not be allocated 675 675 - ok == false, if a parsing error occured 676 676 - */ 677 677 - template <typename OutputT, typename iStreamT> 678 678 - OutputT read(iStreamT& inStream, bool* ok, const Options& opt = Options{}) 679 679 - { 680 680 - std::error_code ec; 681 681 - const auto r = read<OutputT>(inStream, ec, opt); 682 682 - if (ok) 683 683 - *ok = !ec; 684 684 - return r; 685 685 - } 765 765 + /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf 766 766 + formatted data. throws "std::bad_alloc" if file buffer could not be allocated 767 767 + ok == false, if a parsing error occured 768 768 + */ 769 769 + template <typename OutputT, typename iStreamT> 770 770 + OutputT read(iStreamT &inStream, bool *ok, const Options &opt = Options{}) 771 771 + { 772 772 + std::error_code ec; 773 773 + const auto r = read<OutputT>(inStream, ec, opt); 774 774 + if (ok) 775 775 + *ok = !ec; 776 776 + return r; 777 777 + } 686 778 687 687 - template <typename iStreamT> 688 688 - inline basic_object<typename iStreamT::char_type> read(iStreamT& inStream, bool* ok, const Options& opt = Options{}) 689 689 - { 690 690 - return read<basic_object<typename iStreamT::char_type>>(inStream, ok, opt); 691 691 - } 779 779 + template <typename iStreamT> 780 780 + inline basic_object<typename iStreamT::char_type> 781 781 + read(iStreamT &inStream, bool *ok, const Options &opt = Options{}) 782 782 + { 783 783 + return read<basic_object<typename iStreamT::char_type>>(inStream, ok, opt); 784 784 + } 692 785 693 693 - /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf formatted data. 694 694 - throws "std::bad_alloc" if file buffer could not be allocated 695 695 - throws "std::runtime_error" if a parsing error occured 696 696 - */ 697 697 - template <typename OutputT, typename iStreamT> 698 698 - OutputT read(iStreamT& inStream, const Options& opt) 699 699 - { 786 786 + /** \brief Loads a stream (e.g. filestream) into the memory and parses the vdf 787 787 + formatted data. throws "std::bad_alloc" if file buffer could not be allocated 788 788 + throws "std::runtime_error" if a parsing error occured 789 789 + */ 790 790 + template <typename OutputT, typename iStreamT> 791 791 + OutputT read(iStreamT &inStream, const Options &opt) 792 792 + { 700 793 701 701 - // cache the file 702 702 - typedef typename iStreamT::char_type charT; 703 703 - std::basic_string<charT> str = detail::read_file(inStream); 704 704 - // parse it 705 705 - return read<OutputT>(str.begin(), str.end(), opt); 706 706 - } 794 794 + // cache the file 795 795 + typedef typename iStreamT::char_type charT; 796 796 + std::basic_string<charT> str = detail::read_file(inStream); 797 797 + // parse it 798 798 + return read<OutputT>(str.begin(), str.end(), opt); 799 799 + } 707 800 708 708 - template <typename iStreamT> 709 709 - inline basic_object<typename iStreamT::char_type> read(iStreamT& inStream, const Options& opt = Options{}) 710 710 - { 711 711 - return read<basic_object<typename iStreamT::char_type>>(inStream, opt); 712 712 - } 801 801 + template <typename iStreamT> 802 802 + inline basic_object<typename iStreamT::char_type> 803 803 + read(iStreamT &inStream, const Options &opt = Options{}) 804 804 + { 805 805 + return read<basic_object<typename iStreamT::char_type>>(inStream, opt); 806 806 + } 713 807 714 714 - } // namespace vdf 808 808 + } // namespace vdf 715 809 } // namespace tyti 716 810 #ifndef TYTI_NO_L_UNDEF 717 811 #undef TYTI_L

+2 -2

src/xrt/drivers/steamvr_lh/steamvr_lh.cpp

··· 79 79 std::ifstream file(STEAM_INSTALL_DIR + "/steamapps/libraryfolders.vdf"); 80 80 auto root = vdf::read(file); 81 81 assert(root.name == "libraryfolders"); 82 82 - for (auto &[_, child] : root.children) { 82 82 + for (auto &[_, child] : root.childs) { 83 83 U_LOG_D("Found library folder %s", child->attribs["path"].c_str()); 84 84 - std::shared_ptr<vdf::object> apps = child->children["apps"]; 84 84 + std::shared_ptr<vdf::object> apps = child->childs["apps"]; 85 85 for (auto &[appid, _] : apps->attribs) { 86 86 if (appid == STEAMVR_APPID) { 87 87 return child->attribs["path"] + "/steamapps/common/SteamVR";