1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
|
### jsoncons::decode_json, try_decode_json
Decodes a JSON data format to a C++ data structure. `decode_json` will
work for all C++ classes that support jsoncons reflection traits.
```cpp
#include <jsoncons/decode_json.hpp>
template <typename T,typename CharsLike>
T decode_json(const CharsLike& s,
const basic_json_decode_options<CharsLike::value_type>& options
= basic_json_decode_options<CharsLike::value_type>()); (1)
template <typename T,typename CharT>
T decode_json(std::basic_istream<CharT>& is,
const basic_json_decode_options<CharT>& options = basic_json_decode_options<CharT>()); (2)
template <typename T,typename CharsLike,typename Alloc,typename TempAlloc>
T decode_json(const allocator_set<Alloc,TempAlloc>& aset,
const CharsLike& s,
const basic_json_decode_options<CharsLike::value_type>& options
= basic_json_decode_options<CharsLike::value_type>()); (3) (since 0.171.0)
template <typename T,typename CharT,typename Alloc,typename TempAlloc>
T decode_json(const allocator_set<Alloc,TempAlloc>& aset,
std::basic_istream<CharT>& is,
const basic_json_decode_options<CharT>& options = basic_json_decode_options<CharT>()); (4) (since 0.171.0)
template <typename T,typename Iterator>
T decode_json(Iterator first, Iterator last,
const basic_json_decode_options<CharT>& options = basic_json_decode_options<CharT>()); (5)
template <typename T,typename CharsLike>
read_result<T> try_decode_json(const CharsLike& s,
const basic_json_decode_options<CharsLike::value_type>& options
= basic_json_decode_options<CharsLike::value_type>()); (6) since 1.4.0
template <typename T,typename CharT>
read_result<T> try_decode_json(std::basic_istream<CharT>& is,
const basic_json_decode_options<CharT>& options = basic_json_decode_options<CharT>()); (7) since 1.4.0
template <typename T,typename CharsLike,typename Alloc,typename TempAlloc>
read_result<T> try_decode_json(const allocator_set<Alloc,TempAlloc>& aset,
const CharsLike& s,
const basic_json_decode_options<CharsLike::value_type>& options
= basic_json_decode_options<CharsLike::value_type>()); (8) (since 1.4.0)
template <typename T,typename CharT,typename Alloc,typename TempAlloc>
read_result<T> try_decode_json(const allocator_set<Alloc,TempAlloc>& aset,
std::basic_istream<CharT>& is,
const basic_json_decode_options<CharT>& options = basic_json_decode_options<CharT>()); (9) (since 1.4.0)
template <typename T,typename Iterator>
read_result<T> try_decode_json(Iterator first, Iterator last,
const basic_json_decode_options<CharT>& options = basic_json_decode_options<CharT>()); (10) since 1.4.0
```
(1) Reads JSON from a contiguous character sequence provided by `s` into a type T, using the specified (or defaulted) [options](basic_json_options.md).
Type 'T' must be an instantiation of [basic_json](basic_json.md)
or support [json_type_traits](../json_type_traits/json_type_traits.md).
(2) Reads JSON from an input stream into a type T, using the specified (or defaulted) [options](basic_json_options.md).
Type 'T' must be an instantiation of [basic_json](basic_json.md)
or support [json_type_traits](../json_type_traits/json_type_traits.md).
(3)-(4) are identical to (1)-(2) except an [allocator_set](allocator_set.md) is passed as an additional argument and
provides allocators for result data and temporary allocations.
(5) Reads JSON from the range [first,last) into a type T, using the specified (or defaulted) [options](basic_json_options.md).
Type 'T' must be an instantiation of [basic_json](basic_json.md)
or support [json_type_traits](json_type_traits/json_type_traits.md).
(6)-(10) Non-throwing versions of (1)-(5)
#### Parameters
<table>
<tr>
<td>aset</td>
<td>[allocator_set](allocator_set.md)</td>
</tr>
<tr>
<td>s</td>
<td>Character sequence</td>
</tr>
<tr>
<td>is</td>
<td>Input stream</td>
</tr>
<tr>
<td>options</td>
<td>Deserialization options</td>
</tr>
</table>
#### Return value
(1)-(5) Deserialized value
(6)-(10) [read_result<T>](read_result.md)
#### Exceptions
(1)-(5) Throw [ser_error](ser_error.md) if decode fails.
Any overload may throw `std::bad_alloc` if memory allocation fails.
### Examples
#### Throwing overload
```cpp
#include <iostream>
#include <map>
#include <tuple>
#include <jsoncons/json.hpp>
int main()
{
using employee_collection = std::map<std::string,std::tuple<std::string,std::string,double>>;
std::string s = R"(
{
"Jane Doe": ["Commission","Sales",20000.0],
"John Smith": ["Hourly","Software Engineer",10000.0]
}
)";
employee_collection employees = jsoncons::decode_json<employee_collection>(s);
for (const auto& pair : employees)
{
std::cout << pair.first << ": " << std::get<1>(pair.second) << '\n';
}
}
```
Output:
```
Jane Doe: Sales
John Smith: Software Engineer
```
#### Non-throwing overload
```cpp
#include <jsoncons/json.hpp>
#include <iostream>
namespace ns {
struct book
{
std::string author;
std::string title;
double price{0};
};
} // namespace ns
JSONCONS_ALL_MEMBER_TRAITS(ns::book, author, title, price)
int main()
{
// Parsing error
{
std::string input = R"(
{
"author" : "Haruki Murakami",
"title" : "Kafka on the Shore",
"price" 25.17
}
)";
auto result = jsoncons::try_decode_json<ns::book>(input);
if (!result)
std::cout << "(1) " << result.error().message() << "\n\n";
}
// Unexpected JSON
{
std::string input = R"(["Haruki Murakami", "Kafka on the Shore", 25.17])";
auto result = jsoncons::try_decode_json<ns::book>(input);
if (!result)
std::cout << "(2) " << result.error() .message() << "\n\n";
}
// Missing required member
{
std::string input = R"(
{
"author" : "Haruki Murakami",
"title" : "Kafka on the Shore"
}
)";
auto result = jsoncons::try_decode_json<ns::book>(input);
if (!result)
std::cout << "(3) " << result.error() .message() << "\n\n";
}
// Invalid JSON
{
std::string input = R"(
{
"author" : "Haruki Murakami",
"title" : "Kafka on the Shore",
"price" : "foo"
}
)";
auto result = jsoncons::try_decode_json<ns::book>(input);
if (!result)
std::cout << "(4) " << result.error() .message() << "\n\n";
}
// Success
{
std::string input = R"(
{
"author" : "Haruki Murakami",
"title" : "Kafka on the Shore",
"price" : 25.17
}
)";
auto result = jsoncons::try_decode_json<ns::book>(input);
if (result)
{
ns::book& book{result.value()};
std::cout << "(5) " << book.author << ", " << book.title << ", " << book.price << "\n\n";
}
}
}
```
Output:
```
(1) Expected name separator ':' at line 5 and column 13
(2) ns::book: Expected source object at line 1 and column 2
(3) ns::book::price: Missing required JSON object member at line 2 and column 2
(4) ns::book::price: Unable to convert into the provided type at line 2 and column 2
(5) Haruki Murakami, Kafka on the Shore, 25.17
```
### See also
[allocator_set](allocator_set.md)
[encode_json](encode_json.md)
|
