]>
Commit | Line | Data |
---|---|---|
20effc67 TL |
1 | // |
2 | // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com) | |
3 | // | |
4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
6 | // | |
7 | // Official repository: https://github.com/boostorg/json | |
8 | // | |
9 | ||
10 | #include <boost/json.hpp> | |
20effc67 | 11 | #include <boost/container/pmr/vector.hpp> |
20effc67 TL |
12 | #include <iostream> |
13 | ||
14 | #include "test_suite.hpp" | |
15 | ||
16 | BOOST_JSON_NS_BEGIN | |
17 | ||
18 | static void set1() { | |
19 | ||
20 | //---------------------------------------------------------- | |
21 | { | |
22 | //[doc_quick_look_1 | |
23 | object obj; // construct an empty object | |
24 | obj[ "pi" ] = 3.141; // insert a double | |
25 | obj[ "happy" ] = true; // insert a bool | |
26 | obj[ "name" ] = "Boost"; // insert a string | |
27 | obj[ "nothing" ] = nullptr; // insert a null | |
28 | obj[ "answer" ].emplace_object()["everything"] = 42; // insert an object with 1 element | |
29 | obj[ "list" ] = { 1, 0, 2 }; // insert an array with 3 elements | |
30 | obj[ "object" ] = { {"currency", "USD"}, {"value", 42.99} }; // insert an object with 2 elements | |
31 | //] | |
32 | } | |
33 | //---------------------------------------------------------- | |
34 | { | |
35 | //[doc_quick_look_2 | |
36 | value jv = { | |
37 | { "pi", 3.141 }, | |
38 | { "happy", true }, | |
39 | { "name", "Boost" }, | |
40 | { "nothing", nullptr }, | |
41 | { "answer", { | |
42 | { "everything", 42 } } }, | |
43 | {"list", {1, 0, 2}}, | |
44 | {"object", { | |
45 | { "currency", "USD" }, | |
46 | { "value", 42.99 } | |
47 | } } | |
48 | }; | |
49 | //] | |
50 | } | |
51 | //---------------------------------------------------------- | |
52 | { | |
53 | //[doc_quick_look_3 | |
54 | array arr; // construct an empty array | |
55 | arr = { 1, 2, 3 }; // replace the contents with 3 elements | |
56 | value jv1( arr ); // this makes a copy of the array | |
57 | value jv2( std::move(arr) ); // this performs a move-construction | |
58 | ||
59 | assert( arr.empty() ); // moved-from arrays become empty | |
60 | arr = { nullptr, true, "boost" }; // fill in the array again | |
61 | //] | |
62 | } | |
63 | //---------------------------------------------------------- | |
64 | { | |
65 | //[doc_quick_look_4 | |
66 | { | |
67 | unsigned char buf[ 4096 ]; // storage for our array | |
68 | static_resource mr( buf ); // memory resource which uses buf | |
69 | array arr( &mr ); // construct using the memory resource | |
70 | arr = { 1, 2, 3 }; // all allocated memory comes from `buf` | |
71 | } | |
72 | //] | |
73 | } | |
74 | //---------------------------------------------------------- | |
75 | { | |
76 | //[doc_quick_look_5 | |
77 | { | |
78 | monotonic_resource mr; // memory resource optimized for insertion | |
79 | array arr( &mr ); // construct using the memory resource | |
80 | arr.resize( 1 ); // make space for one element | |
81 | arr[ 0 ] = { 1, 2, 3 }; // assign an array to element 0 | |
82 | assert( *arr[0].storage() == *arr.storage() ); // same memory resource | |
83 | } | |
84 | //] | |
85 | } | |
86 | //---------------------------------------------------------- | |
87 | { | |
20effc67 TL |
88 | //[doc_quick_look_6 |
89 | { | |
90 | monotonic_resource mr; | |
91 | boost::container::pmr::vector< value > vv( &mr ); | |
92 | vv.resize( 3 ); | |
93 | ||
94 | // The memory resource of the container is propagated to each element | |
95 | assert( *vv.get_allocator().resource() == *vv[0].storage() ); | |
96 | assert( *vv.get_allocator().resource() == *vv[1].storage() ); | |
97 | assert( *vv.get_allocator().resource() == *vv[2].storage() ); | |
98 | } | |
99 | //] | |
20effc67 TL |
100 | } |
101 | //---------------------------------------------------------- | |
102 | ||
103 | } // set1() | |
104 | ||
105 | //---------------------------------------------------------- | |
106 | ||
107 | //[doc_quick_look_7 | |
108 | value f() | |
109 | { | |
110 | // create a reference-counted memory resource | |
111 | storage_ptr sp = make_shared_resource< monotonic_resource >(); | |
112 | ||
113 | // construct with shared ownership of the resource | |
114 | value jv( sp ); | |
115 | ||
116 | // assign an array with 3 elements, the monotonic resource will be used | |
117 | jv = { 1, 2, 3 }; | |
118 | ||
119 | // The caller receives the value, which still owns the resource | |
120 | return jv; | |
121 | } | |
122 | //] | |
123 | //---------------------------------------------------------- | |
124 | ||
125 | static void set2() { | |
126 | ||
127 | //---------------------------------------------------------- | |
128 | { | |
129 | //[doc_quick_look_8 | |
130 | value jv = parse( "[1, 2, 3]" ); | |
131 | //] | |
132 | } | |
133 | //---------------------------------------------------------- | |
134 | { | |
135 | //[doc_quick_look_9 | |
136 | error_code ec; | |
137 | value jv = parse( R"( "Hello, world!" )", ec ); | |
138 | //] | |
139 | } | |
140 | //---------------------------------------------------------- | |
141 | { | |
142 | //[doc_quick_look_10 | |
143 | unsigned char buf[ 4096 ]; | |
144 | static_resource mr( buf ); | |
145 | parse_options opt; | |
146 | opt.allow_comments = true; | |
147 | opt.allow_trailing_commas = true; | |
148 | value jv = parse( "[1, 2, 3, ] // array ", &mr, opt ); | |
149 | //] | |
150 | } | |
151 | //---------------------------------------------------------- | |
152 | { | |
153 | //[doc_quick_look_11 | |
154 | stream_parser p; | |
155 | error_code ec; | |
156 | p.reset(); | |
157 | p.write( "[1, 2 ", ec ); | |
158 | if( ! ec ) | |
159 | p.write( ", 3]", ec ); | |
160 | if( ! ec ) | |
161 | p.finish( ec ); | |
162 | if( ec ) | |
163 | return; | |
164 | value jv = p.release(); | |
165 | //] | |
166 | } | |
167 | //---------------------------------------------------------- | |
168 | { | |
169 | //[doc_quick_look_12 | |
170 | value jv = { 1, 2, 3 }; | |
171 | std::string s = serialize( jv ); // produces "[1,2,3]" | |
172 | //] | |
173 | } | |
174 | //---------------------------------------------------------- | |
175 | { | |
176 | value jv; | |
177 | //[doc_quick_look_13 | |
178 | serializer sr; | |
179 | sr.reset( &jv ); // prepare to output `jv` | |
180 | do | |
181 | { | |
182 | char buf[ 16 ]; | |
183 | std::cout << sr.read( buf ); | |
184 | } | |
185 | while( ! sr.done() ); | |
186 | //] | |
187 | } | |
188 | //---------------------------------------------------------- | |
189 | ||
190 | } // set2() | |
191 | ||
192 | //---------------------------------------------------------- | |
193 | ||
194 | //[doc_quick_look_14 | |
195 | namespace my_app { | |
196 | ||
197 | struct customer | |
198 | { | |
199 | int id; | |
200 | std::string name; | |
201 | bool current; | |
202 | }; | |
203 | ||
204 | } // namespace my_app | |
205 | //] | |
206 | ||
207 | //---------------------------------------------------------- | |
208 | ||
209 | //[doc_quick_look_15 | |
210 | namespace my_app { | |
211 | ||
212 | void tag_invoke( value_from_tag, value& jv, customer const& c ) | |
213 | { | |
214 | jv = { | |
215 | { "id" , c.id }, | |
216 | { "name", c.name }, | |
217 | { "current", c.current } | |
218 | }; | |
219 | } | |
220 | ||
221 | } // namespace my_app | |
222 | //] | |
223 | ||
224 | static void set3() { | |
225 | ||
226 | //---------------------------------------------------------- | |
227 | { | |
228 | //[doc_quick_look_16 | |
229 | my_app::customer c{ 1001, "Boost", true }; | |
230 | std::cout << serialize( value_from( c ) ); | |
231 | //] | |
232 | } | |
233 | //---------------------------------------------------------- | |
234 | { | |
235 | //[doc_quick_look_17 | |
236 | std::vector< my_app::customer > vc; | |
237 | //... | |
238 | value jv = value_from( vc ); | |
239 | //] | |
240 | } | |
241 | //---------------------------------------------------------- | |
242 | ||
243 | } // set3() | |
244 | ||
245 | //---------------------------------------------------------- | |
246 | ||
247 | //[doc_quick_look_18 | |
248 | namespace my_app { | |
249 | ||
250 | // This helper function deduces the type and assigns the value with the matching key | |
251 | template<class T> | |
252 | void extract( object const& obj, T& t, string_view key ) | |
253 | { | |
254 | t = value_to<T>( obj.at( key ) ); | |
255 | } | |
256 | ||
257 | customer tag_invoke( value_to_tag< customer >, value const& jv ) | |
258 | { | |
259 | customer c; | |
260 | object const& obj = jv.as_object(); | |
261 | extract( obj, c.id, "id" ); | |
262 | extract( obj, c.name, "name" ); | |
263 | extract( obj, c.current, "current" ); | |
264 | return c; | |
265 | } | |
266 | ||
267 | } // namespace my_app | |
268 | //] | |
269 | ||
270 | //---------------------------------------------------------- | |
271 | ||
272 | namespace my_app_2 { | |
273 | namespace my_app { using boost::json::my_app::customer; } | |
274 | //[doc_quick_look_19 | |
275 | namespace my_app { | |
276 | ||
277 | customer tag_invoke( value_to_tag< customer >, value const& jv ) | |
278 | { | |
279 | object const& obj = jv.as_object(); | |
280 | return customer { | |
281 | value_to<int>( obj.at( "id" ) ), | |
282 | value_to<std::string>( obj.at( "name" ) ), | |
283 | value_to<bool>( obj.at( "current" ) ) | |
284 | }; | |
285 | } | |
286 | ||
287 | } // namespace my_app | |
288 | //] | |
289 | } // my_app_2 | |
290 | ||
291 | //---------------------------------------------------------- | |
292 | ||
293 | static void set4() { | |
294 | using namespace my_app; | |
295 | ||
296 | //---------------------------------------------------------- | |
297 | { | |
298 | //[doc_quick_look_20 | |
299 | json::value jv; | |
300 | //... | |
301 | customer c( value_to<customer>(jv) ); | |
302 | //] | |
303 | } | |
304 | //---------------------------------------------------------- | |
305 | { | |
306 | json::value jv; | |
307 | //[doc_quick_look_21 | |
308 | std::vector< customer > vc = value_to< std::vector< customer > >( jv ); | |
309 | //] | |
310 | } | |
311 | //---------------------------------------------------------- | |
312 | ||
313 | //---------------------------------------------------------- | |
314 | ||
315 | } // set4 | |
316 | ||
317 | class doc_quick_look_test | |
318 | { | |
319 | public: | |
320 | void | |
321 | run() | |
322 | { | |
323 | (void)&set1; | |
324 | (void)&set2; | |
325 | (void)&set3; | |
326 | (void)&set4; | |
327 | BOOST_TEST_PASS(); | |
328 | } | |
329 | }; | |
330 | ||
331 | TEST_SUITE(doc_quick_look_test, "boost.json.doc_quick_look"); | |
332 | ||
333 | BOOST_JSON_NS_END |