rapidjson 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (53) hide show
  1. checksums.yaml +7 -0
  2. data/CODE_OF_CONDUCT.md +84 -0
  3. data/LICENSE.txt +21 -0
  4. data/README.md +110 -0
  5. data/Rakefile +20 -0
  6. data/ext/rapidjson/buffer.hh +66 -0
  7. data/ext/rapidjson/cext.cc +77 -0
  8. data/ext/rapidjson/cext.hh +20 -0
  9. data/ext/rapidjson/encoder.hh +150 -0
  10. data/ext/rapidjson/extconf.rb +19 -0
  11. data/ext/rapidjson/parser.hh +149 -0
  12. data/ext/rapidjson/rapidjson/include/rapidjson/allocators.h +692 -0
  13. data/ext/rapidjson/rapidjson/include/rapidjson/cursorstreamwrapper.h +78 -0
  14. data/ext/rapidjson/rapidjson/include/rapidjson/document.h +3027 -0
  15. data/ext/rapidjson/rapidjson/include/rapidjson/encodedstream.h +299 -0
  16. data/ext/rapidjson/rapidjson/include/rapidjson/encodings.h +716 -0
  17. data/ext/rapidjson/rapidjson/include/rapidjson/error/en.h +122 -0
  18. data/ext/rapidjson/rapidjson/include/rapidjson/error/error.h +216 -0
  19. data/ext/rapidjson/rapidjson/include/rapidjson/filereadstream.h +99 -0
  20. data/ext/rapidjson/rapidjson/include/rapidjson/filewritestream.h +104 -0
  21. data/ext/rapidjson/rapidjson/include/rapidjson/fwd.h +151 -0
  22. data/ext/rapidjson/rapidjson/include/rapidjson/internal/biginteger.h +297 -0
  23. data/ext/rapidjson/rapidjson/include/rapidjson/internal/clzll.h +71 -0
  24. data/ext/rapidjson/rapidjson/include/rapidjson/internal/diyfp.h +261 -0
  25. data/ext/rapidjson/rapidjson/include/rapidjson/internal/dtoa.h +249 -0
  26. data/ext/rapidjson/rapidjson/include/rapidjson/internal/ieee754.h +78 -0
  27. data/ext/rapidjson/rapidjson/include/rapidjson/internal/itoa.h +308 -0
  28. data/ext/rapidjson/rapidjson/include/rapidjson/internal/meta.h +186 -0
  29. data/ext/rapidjson/rapidjson/include/rapidjson/internal/pow10.h +55 -0
  30. data/ext/rapidjson/rapidjson/include/rapidjson/internal/regex.h +739 -0
  31. data/ext/rapidjson/rapidjson/include/rapidjson/internal/stack.h +232 -0
  32. data/ext/rapidjson/rapidjson/include/rapidjson/internal/strfunc.h +83 -0
  33. data/ext/rapidjson/rapidjson/include/rapidjson/internal/strtod.h +293 -0
  34. data/ext/rapidjson/rapidjson/include/rapidjson/internal/swap.h +46 -0
  35. data/ext/rapidjson/rapidjson/include/rapidjson/istreamwrapper.h +128 -0
  36. data/ext/rapidjson/rapidjson/include/rapidjson/memorybuffer.h +70 -0
  37. data/ext/rapidjson/rapidjson/include/rapidjson/memorystream.h +71 -0
  38. data/ext/rapidjson/rapidjson/include/rapidjson/msinttypes/inttypes.h +316 -0
  39. data/ext/rapidjson/rapidjson/include/rapidjson/msinttypes/stdint.h +300 -0
  40. data/ext/rapidjson/rapidjson/include/rapidjson/ostreamwrapper.h +81 -0
  41. data/ext/rapidjson/rapidjson/include/rapidjson/pointer.h +1482 -0
  42. data/ext/rapidjson/rapidjson/include/rapidjson/prettywriter.h +277 -0
  43. data/ext/rapidjson/rapidjson/include/rapidjson/rapidjson.h +741 -0
  44. data/ext/rapidjson/rapidjson/include/rapidjson/reader.h +2246 -0
  45. data/ext/rapidjson/rapidjson/include/rapidjson/schema.h +2795 -0
  46. data/ext/rapidjson/rapidjson/include/rapidjson/stream.h +223 -0
  47. data/ext/rapidjson/rapidjson/include/rapidjson/stringbuffer.h +121 -0
  48. data/ext/rapidjson/rapidjson/include/rapidjson/uri.h +481 -0
  49. data/ext/rapidjson/rapidjson/include/rapidjson/writer.h +710 -0
  50. data/lib/rapidjson/json_gem.rb +36 -0
  51. data/lib/rapidjson/version.rb +5 -0
  52. data/lib/rapidjson.rb +9 -0
  53. metadata +98 -0
@@ -0,0 +1,299 @@
1
+ // Tencent is pleased to support the open source community by making RapidJSON available.
2
+ //
3
+ // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
4
+ //
5
+ // Licensed under the MIT License (the "License"); you may not use this file except
6
+ // in compliance with the License. You may obtain a copy of the License at
7
+ //
8
+ // http://opensource.org/licenses/MIT
9
+ //
10
+ // Unless required by applicable law or agreed to in writing, software distributed
11
+ // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12
+ // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13
+ // specific language governing permissions and limitations under the License.
14
+
15
+ #ifndef RAPIDJSON_ENCODEDSTREAM_H_
16
+ #define RAPIDJSON_ENCODEDSTREAM_H_
17
+
18
+ #include "stream.h"
19
+ #include "memorystream.h"
20
+
21
+ #ifdef __GNUC__
22
+ RAPIDJSON_DIAG_PUSH
23
+ RAPIDJSON_DIAG_OFF(effc++)
24
+ #endif
25
+
26
+ #ifdef __clang__
27
+ RAPIDJSON_DIAG_PUSH
28
+ RAPIDJSON_DIAG_OFF(padded)
29
+ #endif
30
+
31
+ RAPIDJSON_NAMESPACE_BEGIN
32
+
33
+ //! Input byte stream wrapper with a statically bound encoding.
34
+ /*!
35
+ \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
36
+ \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
37
+ */
38
+ template <typename Encoding, typename InputByteStream>
39
+ class EncodedInputStream {
40
+ RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
41
+ public:
42
+ typedef typename Encoding::Ch Ch;
43
+
44
+ EncodedInputStream(InputByteStream& is) : is_(is) {
45
+ current_ = Encoding::TakeBOM(is_);
46
+ }
47
+
48
+ Ch Peek() const { return current_; }
49
+ Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
50
+ size_t Tell() const { return is_.Tell(); }
51
+
52
+ // Not implemented
53
+ void Put(Ch) { RAPIDJSON_ASSERT(false); }
54
+ void Flush() { RAPIDJSON_ASSERT(false); }
55
+ Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
56
+ size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
57
+
58
+ private:
59
+ EncodedInputStream(const EncodedInputStream&);
60
+ EncodedInputStream& operator=(const EncodedInputStream&);
61
+
62
+ InputByteStream& is_;
63
+ Ch current_;
64
+ };
65
+
66
+ //! Specialized for UTF8 MemoryStream.
67
+ template <>
68
+ class EncodedInputStream<UTF8<>, MemoryStream> {
69
+ public:
70
+ typedef UTF8<>::Ch Ch;
71
+
72
+ EncodedInputStream(MemoryStream& is) : is_(is) {
73
+ if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
74
+ if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
75
+ if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
76
+ }
77
+ Ch Peek() const { return is_.Peek(); }
78
+ Ch Take() { return is_.Take(); }
79
+ size_t Tell() const { return is_.Tell(); }
80
+
81
+ // Not implemented
82
+ void Put(Ch) {}
83
+ void Flush() {}
84
+ Ch* PutBegin() { return 0; }
85
+ size_t PutEnd(Ch*) { return 0; }
86
+
87
+ MemoryStream& is_;
88
+
89
+ private:
90
+ EncodedInputStream(const EncodedInputStream&);
91
+ EncodedInputStream& operator=(const EncodedInputStream&);
92
+ };
93
+
94
+ //! Output byte stream wrapper with statically bound encoding.
95
+ /*!
96
+ \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
97
+ \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
98
+ */
99
+ template <typename Encoding, typename OutputByteStream>
100
+ class EncodedOutputStream {
101
+ RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
102
+ public:
103
+ typedef typename Encoding::Ch Ch;
104
+
105
+ EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) {
106
+ if (putBOM)
107
+ Encoding::PutBOM(os_);
108
+ }
109
+
110
+ void Put(Ch c) { Encoding::Put(os_, c); }
111
+ void Flush() { os_.Flush(); }
112
+
113
+ // Not implemented
114
+ Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
115
+ Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
116
+ size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
117
+ Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
118
+ size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
119
+
120
+ private:
121
+ EncodedOutputStream(const EncodedOutputStream&);
122
+ EncodedOutputStream& operator=(const EncodedOutputStream&);
123
+
124
+ OutputByteStream& os_;
125
+ };
126
+
127
+ #define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
128
+
129
+ //! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
130
+ /*!
131
+ \tparam CharType Type of character for reading.
132
+ \tparam InputByteStream type of input byte stream to be wrapped.
133
+ */
134
+ template <typename CharType, typename InputByteStream>
135
+ class AutoUTFInputStream {
136
+ RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
137
+ public:
138
+ typedef CharType Ch;
139
+
140
+ //! Constructor.
141
+ /*!
142
+ \param is input stream to be wrapped.
143
+ \param type UTF encoding type if it is not detected from the stream.
144
+ */
145
+ AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
146
+ RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
147
+ DetectType();
148
+ static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
149
+ takeFunc_ = f[type_];
150
+ current_ = takeFunc_(*is_);
151
+ }
152
+
153
+ UTFType GetType() const { return type_; }
154
+ bool HasBOM() const { return hasBOM_; }
155
+
156
+ Ch Peek() const { return current_; }
157
+ Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
158
+ size_t Tell() const { return is_->Tell(); }
159
+
160
+ // Not implemented
161
+ void Put(Ch) { RAPIDJSON_ASSERT(false); }
162
+ void Flush() { RAPIDJSON_ASSERT(false); }
163
+ Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
164
+ size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
165
+
166
+ private:
167
+ AutoUTFInputStream(const AutoUTFInputStream&);
168
+ AutoUTFInputStream& operator=(const AutoUTFInputStream&);
169
+
170
+ // Detect encoding type with BOM or RFC 4627
171
+ void DetectType() {
172
+ // BOM (Byte Order Mark):
173
+ // 00 00 FE FF UTF-32BE
174
+ // FF FE 00 00 UTF-32LE
175
+ // FE FF UTF-16BE
176
+ // FF FE UTF-16LE
177
+ // EF BB BF UTF-8
178
+
179
+ const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
180
+ if (!c)
181
+ return;
182
+
183
+ unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
184
+ hasBOM_ = false;
185
+ if (bom == 0xFFFE0000) { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
186
+ else if (bom == 0x0000FEFF) { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
187
+ else if ((bom & 0xFFFF) == 0xFFFE) { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take(); }
188
+ else if ((bom & 0xFFFF) == 0xFEFF) { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take(); }
189
+ else if ((bom & 0xFFFFFF) == 0xBFBBEF) { type_ = kUTF8; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); }
190
+
191
+ // RFC 4627: Section 3
192
+ // "Since the first two characters of a JSON text will always be ASCII
193
+ // characters [RFC0020], it is possible to determine whether an octet
194
+ // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
195
+ // at the pattern of nulls in the first four octets."
196
+ // 00 00 00 xx UTF-32BE
197
+ // 00 xx 00 xx UTF-16BE
198
+ // xx 00 00 00 UTF-32LE
199
+ // xx 00 xx 00 UTF-16LE
200
+ // xx xx xx xx UTF-8
201
+
202
+ if (!hasBOM_) {
203
+ int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
204
+ switch (pattern) {
205
+ case 0x08: type_ = kUTF32BE; break;
206
+ case 0x0A: type_ = kUTF16BE; break;
207
+ case 0x01: type_ = kUTF32LE; break;
208
+ case 0x05: type_ = kUTF16LE; break;
209
+ case 0x0F: type_ = kUTF8; break;
210
+ default: break; // Use type defined by user.
211
+ }
212
+ }
213
+
214
+ // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
215
+ if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
216
+ if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
217
+ }
218
+
219
+ typedef Ch (*TakeFunc)(InputByteStream& is);
220
+ InputByteStream* is_;
221
+ UTFType type_;
222
+ Ch current_;
223
+ TakeFunc takeFunc_;
224
+ bool hasBOM_;
225
+ };
226
+
227
+ //! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
228
+ /*!
229
+ \tparam CharType Type of character for writing.
230
+ \tparam OutputByteStream type of output byte stream to be wrapped.
231
+ */
232
+ template <typename CharType, typename OutputByteStream>
233
+ class AutoUTFOutputStream {
234
+ RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
235
+ public:
236
+ typedef CharType Ch;
237
+
238
+ //! Constructor.
239
+ /*!
240
+ \param os output stream to be wrapped.
241
+ \param type UTF encoding type.
242
+ \param putBOM Whether to write BOM at the beginning of the stream.
243
+ */
244
+ AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
245
+ RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
246
+
247
+ // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
248
+ if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
249
+ if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
250
+
251
+ static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
252
+ putFunc_ = f[type_];
253
+
254
+ if (putBOM)
255
+ PutBOM();
256
+ }
257
+
258
+ UTFType GetType() const { return type_; }
259
+
260
+ void Put(Ch c) { putFunc_(*os_, c); }
261
+ void Flush() { os_->Flush(); }
262
+
263
+ // Not implemented
264
+ Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
265
+ Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
266
+ size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
267
+ Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
268
+ size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
269
+
270
+ private:
271
+ AutoUTFOutputStream(const AutoUTFOutputStream&);
272
+ AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);
273
+
274
+ void PutBOM() {
275
+ typedef void (*PutBOMFunc)(OutputByteStream&);
276
+ static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
277
+ f[type_](*os_);
278
+ }
279
+
280
+ typedef void (*PutFunc)(OutputByteStream&, Ch);
281
+
282
+ OutputByteStream* os_;
283
+ UTFType type_;
284
+ PutFunc putFunc_;
285
+ };
286
+
287
+ #undef RAPIDJSON_ENCODINGS_FUNC
288
+
289
+ RAPIDJSON_NAMESPACE_END
290
+
291
+ #ifdef __clang__
292
+ RAPIDJSON_DIAG_POP
293
+ #endif
294
+
295
+ #ifdef __GNUC__
296
+ RAPIDJSON_DIAG_POP
297
+ #endif
298
+
299
+ #endif // RAPIDJSON_FILESTREAM_H_