1// GENERATED FILE
2// This file generated by DomDistillerJs protoc plugin.
3#include "test_sample.pb.h"
4
5// base dependencies
6#include "base/values.h"
7
8#include <memory>
9#include <string>
10#include <utility>
11
12namespace dom_distiller {
13  namespace test_sample {
14    namespace proto {
15      namespace json {
16        class TypeTest {
17         public:
18          class Message {
19           public:
20            static bool ReadFromValue(const base::Value* json, dom_distiller::test_sample::proto::TypeTest::Message* message) {
21              const base::DictionaryValue* dict;
22              if (!json->GetAsDictionary(&dict)) goto error;
23              if (dict->HasKey("1")) {
24                bool field_value;
25                if (!dict->GetBoolean("1", &field_value)) {
26                  goto error;
27                }
28                message->set_dummy(field_value);
29              }
30              return true;
31
32            error:
33              return false;
34            }
35
36            static std::unique_ptr<base::DictionaryValue> WriteToValue(const dom_distiller::test_sample::proto::TypeTest::Message& message) {
37              std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
38              if (message.has_dummy()) {
39                dict->SetBoolean("1", message.dummy());
40              }
41              return dict;
42            }
43          };
44
45          static bool ReadFromValue(const base::Value* json, dom_distiller::test_sample::proto::TypeTest* message) {
46            const base::DictionaryValue* dict;
47            if (!json->GetAsDictionary(&dict)) goto error;
48            if (dict->HasKey("1")) {
49              float field_value;
50              if (!dict->GetDouble("1", &field_value)) {
51                goto error;
52              }
53              message->set_float_value(field_value);
54            }
55            if (dict->HasKey("2")) {
56              double field_value;
57              if (!dict->GetDouble("2", &field_value)) {
58                goto error;
59              }
60              message->set_double_value(field_value);
61            }
62            if (dict->HasKey("3")) {
63              int field_value;
64              if (!dict->GetInteger("3", &field_value)) {
65                goto error;
66              }
67              message->set_int32_value(field_value);
68            }
69            if (dict->HasKey("4")) {
70              bool field_value;
71              if (!dict->GetBoolean("4", &field_value)) {
72                goto error;
73              }
74              message->set_bool_value(field_value);
75            }
76            if (dict->HasKey("5")) {
77              std::string field_value;
78              if (!dict->GetString("5", &field_value)) {
79                goto error;
80              }
81              message->set_string_value(field_value);
82            }
83            if (dict->HasKey("6")) {
84              const base::Value* inner_message_value;
85              if (!dict->Get("6", &inner_message_value)) {
86                goto error;
87              }
88              if (!dom_distiller::test_sample::proto::json::TypeTest::Message::ReadFromValue(inner_message_value, message->mutable_message_value())) {
89                goto error;
90              }
91            }
92            return true;
93
94          error:
95            return false;
96          }
97
98          static std::unique_ptr<base::DictionaryValue> WriteToValue(const dom_distiller::test_sample::proto::TypeTest& message) {
99            std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
100            if (message.has_float_value()) {
101              dict->SetDouble("1", message.float_value());
102            }
103            if (message.has_double_value()) {
104              dict->SetDouble("2", message.double_value());
105            }
106            if (message.has_int32_value()) {
107              dict->SetInteger("3", message.int32_value());
108            }
109            if (message.has_bool_value()) {
110              dict->SetBoolean("4", message.bool_value());
111            }
112            if (message.has_string_value()) {
113              dict->SetString("5", message.string_value());
114            }
115            if (message.has_message_value()) {
116              std::unique_ptr<base::Value> inner_message_value =
117                  dom_distiller::test_sample::proto::json::TypeTest::Message::WriteToValue(message.message_value());
118              dict->Set("6", std::move(inner_message_value));
119            }
120            return dict;
121          }
122        };
123
124        class Repeated {
125         public:
126          class Message {
127           public:
128            static bool ReadFromValue(const base::Value* json, dom_distiller::test_sample::proto::Repeated::Message* message) {
129              const base::DictionaryValue* dict;
130              if (!json->GetAsDictionary(&dict)) goto error;
131              if (dict->HasKey("1")) {
132                const base::ListValue* field_list;
133                if (!dict->GetList("1", &field_list)) {
134                  goto error;
135                }
136                for (size_t i = 0; i < field_list->GetSize(); ++i) {
137                  bool field_value;
138                  if (!field_list->GetBoolean(i, &field_value)) {
139                    goto error;
140                  }
141                  message->add_dummy(field_value);
142                }
143              }
144              return true;
145
146            error:
147              return false;
148            }
149
150            static std::unique_ptr<base::DictionaryValue> WriteToValue(const dom_distiller::test_sample::proto::Repeated::Message& message) {
151              std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
152              {
153                auto field_list = std::make_unique<base::ListValue>();
154                for (int i = 0; i < message.dummy_size(); ++i) {
155                  field_list->AppendBoolean(message.dummy(i));
156                }
157                dict->Set("1", std::move(field_list));
158              }
159              return dict;
160            }
161          };
162
163          static bool ReadFromValue(const base::Value* json, dom_distiller::test_sample::proto::Repeated* message) {
164            const base::DictionaryValue* dict;
165            if (!json->GetAsDictionary(&dict)) goto error;
166            if (dict->HasKey("1")) {
167              const base::ListValue* field_list;
168              if (!dict->GetList("1", &field_list)) {
169                goto error;
170              }
171              for (size_t i = 0; i < field_list->GetSize(); ++i) {
172                float field_value;
173                if (!field_list->GetDouble(i, &field_value)) {
174                  goto error;
175                }
176                message->add_float_value(field_value);
177              }
178            }
179            if (dict->HasKey("2")) {
180              const base::ListValue* field_list;
181              if (!dict->GetList("2", &field_list)) {
182                goto error;
183              }
184              for (size_t i = 0; i < field_list->GetSize(); ++i) {
185                double field_value;
186                if (!field_list->GetDouble(i, &field_value)) {
187                  goto error;
188                }
189                message->add_double_value(field_value);
190              }
191            }
192            if (dict->HasKey("3")) {
193              const base::ListValue* field_list;
194              if (!dict->GetList("3", &field_list)) {
195                goto error;
196              }
197              for (size_t i = 0; i < field_list->GetSize(); ++i) {
198                int field_value;
199                if (!field_list->GetInteger(i, &field_value)) {
200                  goto error;
201                }
202                message->add_int32_value(field_value);
203              }
204            }
205            if (dict->HasKey("4")) {
206              const base::ListValue* field_list;
207              if (!dict->GetList("4", &field_list)) {
208                goto error;
209              }
210              for (size_t i = 0; i < field_list->GetSize(); ++i) {
211                bool field_value;
212                if (!field_list->GetBoolean(i, &field_value)) {
213                  goto error;
214                }
215                message->add_bool_value(field_value);
216              }
217            }
218            if (dict->HasKey("5")) {
219              const base::ListValue* field_list;
220              if (!dict->GetList("5", &field_list)) {
221                goto error;
222              }
223              for (size_t i = 0; i < field_list->GetSize(); ++i) {
224                std::string field_value;
225                if (!field_list->GetString(i, &field_value)) {
226                  goto error;
227                }
228                message->add_string_value(field_value);
229              }
230            }
231            if (dict->HasKey("6")) {
232              const base::ListValue* field_list;
233              if (!dict->GetList("6", &field_list)) {
234                goto error;
235              }
236              for (size_t i = 0; i < field_list->GetSize(); ++i) {
237                const base::Value* inner_message_value;
238                if (!field_list->Get(i, &inner_message_value)) {
239                  goto error;
240                }
241                if (!dom_distiller::test_sample::proto::json::Repeated::Message::ReadFromValue(inner_message_value, message->add_message_value())) {
242                  goto error;
243                }
244              }
245            }
246            return true;
247
248          error:
249            return false;
250          }
251
252          static std::unique_ptr<base::DictionaryValue> WriteToValue(const dom_distiller::test_sample::proto::Repeated& message) {
253            std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
254            {
255              auto field_list = std::make_unique<base::ListValue>();
256              for (int i = 0; i < message.float_value_size(); ++i) {
257                field_list->AppendDouble(message.float_value(i));
258              }
259              dict->Set("1", std::move(field_list));
260            }
261            {
262              auto field_list = std::make_unique<base::ListValue>();
263              for (int i = 0; i < message.double_value_size(); ++i) {
264                field_list->AppendDouble(message.double_value(i));
265              }
266              dict->Set("2", std::move(field_list));
267            }
268            {
269              auto field_list = std::make_unique<base::ListValue>();
270              for (int i = 0; i < message.int32_value_size(); ++i) {
271                field_list->AppendInteger(message.int32_value(i));
272              }
273              dict->Set("3", std::move(field_list));
274            }
275            {
276              auto field_list = std::make_unique<base::ListValue>();
277              for (int i = 0; i < message.bool_value_size(); ++i) {
278                field_list->AppendBoolean(message.bool_value(i));
279              }
280              dict->Set("4", std::move(field_list));
281            }
282            {
283              auto field_list = std::make_unique<base::ListValue>();
284              for (int i = 0; i < message.string_value_size(); ++i) {
285                field_list->AppendString(message.string_value(i));
286              }
287              dict->Set("5", std::move(field_list));
288            }
289            {
290              auto field_list = std::make_unique<base::ListValue>();
291              for (int i = 0; i < message.message_value_size(); ++i) {
292                std::unique_ptr<base::Value> inner_message_value =
293                    dom_distiller::test_sample::proto::json::Repeated::Message::WriteToValue(message.message_value(i));
294                field_list->Append(std::move(inner_message_value));
295              }
296              dict->Set("6", std::move(field_list));
297            }
298            return dict;
299          }
300        };
301
302      }
303    }
304  }
305}
306