Mercurial > hg > orthanc-stone
comparison Resources/CodeGeneration/testWasmIntegrated/jsoncpp-1.8.4/json/json-forwards.h @ 499:baa9e1e932db bgo-commands-codegen
wasm + ts demonstrator WORKS!
author | bgo-osimis |
---|---|
date | Sun, 24 Feb 2019 20:22:56 +0100 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
498:6d62fc8a6988 | 499:baa9e1e932db |
---|---|
1 /// Json-cpp amalgamated forward header (http://jsoncpp.sourceforge.net/). | |
2 /// It is intended to be used with #include "json/json-forwards.h" | |
3 /// This header provides forward declaration for all JsonCpp types. | |
4 | |
5 // ////////////////////////////////////////////////////////////////////// | |
6 // Beginning of content of file: LICENSE | |
7 // ////////////////////////////////////////////////////////////////////// | |
8 | |
9 /* | |
10 The JsonCpp library's source code, including accompanying documentation, | |
11 tests and demonstration applications, are licensed under the following | |
12 conditions... | |
13 | |
14 Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all | |
15 jurisdictions which recognize such a disclaimer. In such jurisdictions, | |
16 this software is released into the Public Domain. | |
17 | |
18 In jurisdictions which do not recognize Public Domain property (e.g. Germany as of | |
19 2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and | |
20 The JsonCpp Authors, and is released under the terms of the MIT License (see below). | |
21 | |
22 In jurisdictions which recognize Public Domain property, the user of this | |
23 software may choose to accept it either as 1) Public Domain, 2) under the | |
24 conditions of the MIT License (see below), or 3) under the terms of dual | |
25 Public Domain/MIT License conditions described here, as they choose. | |
26 | |
27 The MIT License is about as close to Public Domain as a license can get, and is | |
28 described in clear, concise terms at: | |
29 | |
30 http://en.wikipedia.org/wiki/MIT_License | |
31 | |
32 The full text of the MIT License follows: | |
33 | |
34 ======================================================================== | |
35 Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors | |
36 | |
37 Permission is hereby granted, free of charge, to any person | |
38 obtaining a copy of this software and associated documentation | |
39 files (the "Software"), to deal in the Software without | |
40 restriction, including without limitation the rights to use, copy, | |
41 modify, merge, publish, distribute, sublicense, and/or sell copies | |
42 of the Software, and to permit persons to whom the Software is | |
43 furnished to do so, subject to the following conditions: | |
44 | |
45 The above copyright notice and this permission notice shall be | |
46 included in all copies or substantial portions of the Software. | |
47 | |
48 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
49 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
50 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
51 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
52 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
53 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
54 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
55 SOFTWARE. | |
56 ======================================================================== | |
57 (END LICENSE TEXT) | |
58 | |
59 The MIT license is compatible with both the GPL and commercial | |
60 software, affording one all of the rights of Public Domain with the | |
61 minor nuisance of being required to keep the above copyright notice | |
62 and license text in the source code. Note also that by accepting the | |
63 Public Domain "license" you can re-license your copy using whatever | |
64 license you like. | |
65 | |
66 */ | |
67 | |
68 // ////////////////////////////////////////////////////////////////////// | |
69 // End of content of file: LICENSE | |
70 // ////////////////////////////////////////////////////////////////////// | |
71 | |
72 | |
73 | |
74 | |
75 | |
76 #ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED | |
77 # define JSON_FORWARD_AMALGAMATED_H_INCLUDED | |
78 /// If defined, indicates that the source file is amalgamated | |
79 /// to prevent private header inclusion. | |
80 #define JSON_IS_AMALGAMATION | |
81 | |
82 // ////////////////////////////////////////////////////////////////////// | |
83 // Beginning of content of file: include/json/config.h | |
84 // ////////////////////////////////////////////////////////////////////// | |
85 | |
86 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors | |
87 // Distributed under MIT license, or public domain if desired and | |
88 // recognized in your jurisdiction. | |
89 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE | |
90 | |
91 #ifndef JSON_CONFIG_H_INCLUDED | |
92 #define JSON_CONFIG_H_INCLUDED | |
93 #include <cstddef> | |
94 #include <cstdint> | |
95 #include <istream> | |
96 #include <memory> | |
97 #include <ostream> | |
98 #include <sstream> | |
99 #include <string> | |
100 #include <type_traits> | |
101 | |
102 /// If defined, indicates that json library is embedded in CppTL library. | |
103 //# define JSON_IN_CPPTL 1 | |
104 | |
105 /// If defined, indicates that json may leverage CppTL library | |
106 //# define JSON_USE_CPPTL 1 | |
107 /// If defined, indicates that cpptl vector based map should be used instead of | |
108 /// std::map | |
109 /// as Value container. | |
110 //# define JSON_USE_CPPTL_SMALLMAP 1 | |
111 | |
112 // If non-zero, the library uses exceptions to report bad input instead of C | |
113 // assertion macros. The default is to use exceptions. | |
114 #ifndef JSON_USE_EXCEPTION | |
115 #define JSON_USE_EXCEPTION 1 | |
116 #endif | |
117 | |
118 /// If defined, indicates that the source file is amalgamated | |
119 /// to prevent private header inclusion. | |
120 /// Remarks: it is automatically defined in the generated amalgamated header. | |
121 // #define JSON_IS_AMALGAMATION | |
122 | |
123 #ifdef JSON_IN_CPPTL | |
124 #include <cpptl/config.h> | |
125 #ifndef JSON_USE_CPPTL | |
126 #define JSON_USE_CPPTL 1 | |
127 #endif | |
128 #endif | |
129 | |
130 #ifdef JSON_IN_CPPTL | |
131 #define JSON_API CPPTL_API | |
132 #elif defined(JSON_DLL_BUILD) | |
133 #if defined(_MSC_VER) || defined(__MINGW32__) | |
134 #define JSON_API __declspec(dllexport) | |
135 #define JSONCPP_DISABLE_DLL_INTERFACE_WARNING | |
136 #endif // if defined(_MSC_VER) | |
137 #elif defined(JSON_DLL) | |
138 #if defined(_MSC_VER) || defined(__MINGW32__) | |
139 #define JSON_API __declspec(dllimport) | |
140 #define JSONCPP_DISABLE_DLL_INTERFACE_WARNING | |
141 #endif // if defined(_MSC_VER) | |
142 #endif // ifdef JSON_IN_CPPTL | |
143 #if !defined(JSON_API) | |
144 #define JSON_API | |
145 #endif | |
146 | |
147 #if defined(_MSC_VER) && _MSC_VER < 1800 | |
148 #error \ | |
149 "ERROR: Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities" | |
150 #endif | |
151 | |
152 #if defined(_MSC_VER) && _MSC_VER < 1900 | |
153 // As recommended at | |
154 // https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010 | |
155 extern JSON_API int | |
156 msvc_pre1900_c99_snprintf(char* outBuf, size_t size, const char* format, ...); | |
157 #define jsoncpp_snprintf msvc_pre1900_c99_snprintf | |
158 #else | |
159 #define jsoncpp_snprintf std::snprintf | |
160 #endif | |
161 | |
162 // If JSON_NO_INT64 is defined, then Json only support C++ "int" type for | |
163 // integer | |
164 // Storages, and 64 bits integer support is disabled. | |
165 // #define JSON_NO_INT64 1 | |
166 | |
167 #if defined(_MSC_VER) // MSVC | |
168 #define JSONCPP_DEPRECATED(message) __declspec(deprecated(message)) | |
169 #endif // defined(_MSC_VER) | |
170 | |
171 // JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools. | |
172 // C++11 should be used directly in JSONCPP. | |
173 #define JSONCPP_OVERRIDE override | |
174 | |
175 #if __cplusplus >= 201103L | |
176 #define JSONCPP_NOEXCEPT noexcept | |
177 #define JSONCPP_OP_EXPLICIT explicit | |
178 #elif defined(_MSC_VER) && _MSC_VER < 1900 | |
179 #define JSONCPP_NOEXCEPT throw() | |
180 #define JSONCPP_OP_EXPLICIT explicit | |
181 #elif defined(_MSC_VER) && _MSC_VER >= 1900 | |
182 #define JSONCPP_NOEXCEPT noexcept | |
183 #define JSONCPP_OP_EXPLICIT explicit | |
184 #else | |
185 #define JSONCPP_NOEXCEPT throw() | |
186 #define JSONCPP_OP_EXPLICIT | |
187 #endif | |
188 | |
189 #ifndef JSON_HAS_RVALUE_REFERENCES | |
190 | |
191 #if defined(_MSC_VER) | |
192 #define JSON_HAS_RVALUE_REFERENCES 1 | |
193 #endif // MSVC >= 2013 | |
194 | |
195 #ifdef __clang__ | |
196 #if __has_feature(cxx_rvalue_references) | |
197 #define JSON_HAS_RVALUE_REFERENCES 1 | |
198 #endif // has_feature | |
199 | |
200 #elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc) | |
201 #if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L) | |
202 #define JSON_HAS_RVALUE_REFERENCES 1 | |
203 #endif // GXX_EXPERIMENTAL | |
204 | |
205 #endif // __clang__ || __GNUC__ | |
206 | |
207 #endif // not defined JSON_HAS_RVALUE_REFERENCES | |
208 | |
209 #ifndef JSON_HAS_RVALUE_REFERENCES | |
210 #define JSON_HAS_RVALUE_REFERENCES 0 | |
211 #endif | |
212 | |
213 #ifdef __clang__ | |
214 #if __has_extension(attribute_deprecated_with_message) | |
215 #define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message))) | |
216 #endif | |
217 #elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc) | |
218 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) | |
219 #define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message))) | |
220 #elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) | |
221 #define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__)) | |
222 #endif // GNUC version | |
223 #endif // __clang__ || __GNUC__ | |
224 | |
225 #if !defined(JSONCPP_DEPRECATED) | |
226 #define JSONCPP_DEPRECATED(message) | |
227 #endif // if !defined(JSONCPP_DEPRECATED) | |
228 | |
229 #if __GNUC__ >= 6 | |
230 #define JSON_USE_INT64_DOUBLE_CONVERSION 1 | |
231 #endif | |
232 | |
233 #if !defined(JSON_IS_AMALGAMATION) | |
234 | |
235 #include "allocator.h" | |
236 #include "version.h" | |
237 | |
238 #endif // if !defined(JSON_IS_AMALGAMATION) | |
239 | |
240 namespace Json { | |
241 typedef int Int; | |
242 typedef unsigned int UInt; | |
243 #if defined(JSON_NO_INT64) | |
244 typedef int LargestInt; | |
245 typedef unsigned int LargestUInt; | |
246 #undef JSON_HAS_INT64 | |
247 #else // if defined(JSON_NO_INT64) | |
248 // For Microsoft Visual use specific types as long long is not supported | |
249 #if defined(_MSC_VER) // Microsoft Visual Studio | |
250 typedef __int64 Int64; | |
251 typedef unsigned __int64 UInt64; | |
252 #else // if defined(_MSC_VER) // Other platforms, use long long | |
253 typedef int64_t Int64; | |
254 typedef uint64_t UInt64; | |
255 #endif // if defined(_MSC_VER) | |
256 typedef Int64 LargestInt; | |
257 typedef UInt64 LargestUInt; | |
258 #define JSON_HAS_INT64 | |
259 #endif // if defined(JSON_NO_INT64) | |
260 | |
261 template <typename T> | |
262 using Allocator = typename std::conditional<JSONCPP_USING_SECURE_MEMORY, | |
263 SecureAllocator<T>, | |
264 std::allocator<T>>::type; | |
265 using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>; | |
266 using IStringStream = std::basic_istringstream<String::value_type, | |
267 String::traits_type, | |
268 String::allocator_type>; | |
269 using OStringStream = std::basic_ostringstream<String::value_type, | |
270 String::traits_type, | |
271 String::allocator_type>; | |
272 using IStream = std::istream; | |
273 using OStream = std::ostream; | |
274 } // namespace Json | |
275 | |
276 // Legacy names (formerly macros). | |
277 using JSONCPP_STRING = Json::String; | |
278 using JSONCPP_ISTRINGSTREAM = Json::IStringStream; | |
279 using JSONCPP_OSTRINGSTREAM = Json::OStringStream; | |
280 using JSONCPP_ISTREAM = Json::IStream; | |
281 using JSONCPP_OSTREAM = Json::OStream; | |
282 | |
283 #endif // JSON_CONFIG_H_INCLUDED | |
284 | |
285 // ////////////////////////////////////////////////////////////////////// | |
286 // End of content of file: include/json/config.h | |
287 // ////////////////////////////////////////////////////////////////////// | |
288 | |
289 | |
290 | |
291 | |
292 | |
293 | |
294 // ////////////////////////////////////////////////////////////////////// | |
295 // Beginning of content of file: include/json/forwards.h | |
296 // ////////////////////////////////////////////////////////////////////// | |
297 | |
298 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors | |
299 // Distributed under MIT license, or public domain if desired and | |
300 // recognized in your jurisdiction. | |
301 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE | |
302 | |
303 #ifndef JSON_FORWARDS_H_INCLUDED | |
304 #define JSON_FORWARDS_H_INCLUDED | |
305 | |
306 #if !defined(JSON_IS_AMALGAMATION) | |
307 #include "config.h" | |
308 #endif // if !defined(JSON_IS_AMALGAMATION) | |
309 | |
310 namespace Json { | |
311 | |
312 // writer.h | |
313 class FastWriter; | |
314 class StyledWriter; | |
315 | |
316 // reader.h | |
317 class Reader; | |
318 | |
319 // features.h | |
320 class Features; | |
321 | |
322 // value.h | |
323 typedef unsigned int ArrayIndex; | |
324 class StaticString; | |
325 class Path; | |
326 class PathArgument; | |
327 class Value; | |
328 class ValueIteratorBase; | |
329 class ValueIterator; | |
330 class ValueConstIterator; | |
331 | |
332 } // namespace Json | |
333 | |
334 #endif // JSON_FORWARDS_H_INCLUDED | |
335 | |
336 // ////////////////////////////////////////////////////////////////////// | |
337 // End of content of file: include/json/forwards.h | |
338 // ////////////////////////////////////////////////////////////////////// | |
339 | |
340 | |
341 | |
342 | |
343 | |
344 #endif //ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED |