1 | // GENERATED FILE - DO NOT MODIFY |
2 | |
3 | #include <algorithm> |
4 | |
5 | #include "tensorflow/core/framework/tensor.pb_text-impl.h" |
6 | |
7 | using ::tensorflow::strings::ProtoSpaceAndComments; |
8 | using ::tensorflow::strings::Scanner; |
9 | using ::tensorflow::strings::StrCat; |
10 | |
11 | namespace tensorflow { |
12 | |
13 | string ProtoDebugString( |
14 | const ::tensorflow::TensorProto& msg) { |
15 | string s; |
16 | ::tensorflow::strings::ProtoTextOutput o(&s, false); |
17 | internal::AppendProtoDebugString(&o, msg); |
18 | o.CloseTopMessage(); |
19 | return s; |
20 | } |
21 | |
22 | string ProtoShortDebugString( |
23 | const ::tensorflow::TensorProto& msg) { |
24 | string s; |
25 | ::tensorflow::strings::ProtoTextOutput o(&s, true); |
26 | internal::AppendProtoDebugString(&o, msg); |
27 | o.CloseTopMessage(); |
28 | return s; |
29 | } |
30 | |
31 | namespace internal { |
32 | |
33 | void AppendProtoDebugString( |
34 | ::tensorflow::strings::ProtoTextOutput* o, |
35 | const ::tensorflow::TensorProto& msg) { |
36 | if (msg.dtype() != 0) { |
37 | const char* enum_name = ::tensorflow::EnumName_DataType(msg.dtype()); |
38 | if (enum_name[0]) { |
39 | o->AppendEnumName("dtype" , enum_name); |
40 | } else { |
41 | o->AppendNumeric("dtype" , msg.dtype()); |
42 | } |
43 | } |
44 | if (msg.has_tensor_shape()) { |
45 | o->OpenNestedMessage("tensor_shape" ); |
46 | ::tensorflow::internal::AppendProtoDebugString(o, msg.tensor_shape()); |
47 | o->CloseNestedMessage(); |
48 | } |
49 | o->AppendNumericIfNotZero("version_number" , msg.version_number()); |
50 | o->AppendStringIfNotEmpty("tensor_content" , ProtobufStringToString(msg.tensor_content())); |
51 | for (int i = 0; i < msg.float_val_size(); ++i) { |
52 | o->AppendNumeric("float_val" , msg.float_val(i)); |
53 | } |
54 | for (int i = 0; i < msg.double_val_size(); ++i) { |
55 | o->AppendNumeric("double_val" , msg.double_val(i)); |
56 | } |
57 | for (int i = 0; i < msg.int_val_size(); ++i) { |
58 | o->AppendNumeric("int_val" , msg.int_val(i)); |
59 | } |
60 | for (int i = 0; i < msg.string_val_size(); ++i) { |
61 | o->AppendString("string_val" , ProtobufStringToString(msg.string_val(i))); |
62 | } |
63 | for (int i = 0; i < msg.scomplex_val_size(); ++i) { |
64 | o->AppendNumeric("scomplex_val" , msg.scomplex_val(i)); |
65 | } |
66 | for (int i = 0; i < msg.int64_val_size(); ++i) { |
67 | o->AppendNumeric("int64_val" , msg.int64_val(i)); |
68 | } |
69 | for (int i = 0; i < msg.bool_val_size(); ++i) { |
70 | o->AppendBool("bool_val" , msg.bool_val(i)); |
71 | } |
72 | for (int i = 0; i < msg.dcomplex_val_size(); ++i) { |
73 | o->AppendNumeric("dcomplex_val" , msg.dcomplex_val(i)); |
74 | } |
75 | for (int i = 0; i < msg.half_val_size(); ++i) { |
76 | o->AppendNumeric("half_val" , msg.half_val(i)); |
77 | } |
78 | for (int i = 0; i < msg.resource_handle_val_size(); ++i) { |
79 | o->OpenNestedMessage("resource_handle_val" ); |
80 | ::tensorflow::internal::AppendProtoDebugString(o, msg.resource_handle_val(i)); |
81 | o->CloseNestedMessage(); |
82 | } |
83 | for (int i = 0; i < msg.variant_val_size(); ++i) { |
84 | o->OpenNestedMessage("variant_val" ); |
85 | ::tensorflow::internal::AppendProtoDebugString(o, msg.variant_val(i)); |
86 | o->CloseNestedMessage(); |
87 | } |
88 | for (int i = 0; i < msg.uint32_val_size(); ++i) { |
89 | o->AppendNumeric("uint32_val" , msg.uint32_val(i)); |
90 | } |
91 | for (int i = 0; i < msg.uint64_val_size(); ++i) { |
92 | o->AppendNumeric("uint64_val" , msg.uint64_val(i)); |
93 | } |
94 | } |
95 | |
96 | } // namespace internal |
97 | |
98 | bool ProtoParseFromString( |
99 | const string& s, |
100 | ::tensorflow::TensorProto* msg) { |
101 | msg->Clear(); |
102 | Scanner scanner(s); |
103 | if (!internal::ProtoParseFromScanner(&scanner, false, false, msg)) return false; |
104 | scanner.Eos(); |
105 | return scanner.GetResult(); |
106 | } |
107 | |
108 | namespace internal { |
109 | |
110 | bool ProtoParseFromScanner( |
111 | ::tensorflow::strings::Scanner* scanner, bool nested, bool close_curly, |
112 | ::tensorflow::TensorProto* msg) { |
113 | std::vector<bool> has_seen(17, false); |
114 | while(true) { |
115 | ProtoSpaceAndComments(scanner); |
116 | if (nested && (scanner->Peek() == (close_curly ? '}' : '>'))) { |
117 | scanner->One(Scanner::ALL); |
118 | ProtoSpaceAndComments(scanner); |
119 | return true; |
120 | } |
121 | if (!nested && scanner->empty()) { return true; } |
122 | scanner->RestartCapture() |
123 | .Many(Scanner::LETTER_DIGIT_UNDERSCORE) |
124 | .StopCapture(); |
125 | StringPiece identifier; |
126 | if (!scanner->GetResult(nullptr, &identifier)) return false; |
127 | bool parsed_colon = false; |
128 | (void)parsed_colon; |
129 | ProtoSpaceAndComments(scanner); |
130 | if (scanner->Peek() == ':') { |
131 | parsed_colon = true; |
132 | scanner->One(Scanner::ALL); |
133 | ProtoSpaceAndComments(scanner); |
134 | } |
135 | if (identifier == "dtype" ) { |
136 | if (has_seen[0]) return false; |
137 | has_seen[0] = true; |
138 | StringPiece value; |
139 | if (!parsed_colon || !scanner->RestartCapture().Many(Scanner::LETTER_DIGIT_DASH_UNDERSCORE).GetResult(nullptr, &value)) return false; |
140 | if (value == "DT_INVALID" ) { |
141 | msg->set_dtype(::tensorflow::DT_INVALID); |
142 | } else if (value == "DT_FLOAT" ) { |
143 | msg->set_dtype(::tensorflow::DT_FLOAT); |
144 | } else if (value == "DT_DOUBLE" ) { |
145 | msg->set_dtype(::tensorflow::DT_DOUBLE); |
146 | } else if (value == "DT_INT32" ) { |
147 | msg->set_dtype(::tensorflow::DT_INT32); |
148 | } else if (value == "DT_UINT8" ) { |
149 | msg->set_dtype(::tensorflow::DT_UINT8); |
150 | } else if (value == "DT_INT16" ) { |
151 | msg->set_dtype(::tensorflow::DT_INT16); |
152 | } else if (value == "DT_INT8" ) { |
153 | msg->set_dtype(::tensorflow::DT_INT8); |
154 | } else if (value == "DT_STRING" ) { |
155 | msg->set_dtype(::tensorflow::DT_STRING); |
156 | } else if (value == "DT_COMPLEX64" ) { |
157 | msg->set_dtype(::tensorflow::DT_COMPLEX64); |
158 | } else if (value == "DT_INT64" ) { |
159 | msg->set_dtype(::tensorflow::DT_INT64); |
160 | } else if (value == "DT_BOOL" ) { |
161 | msg->set_dtype(::tensorflow::DT_BOOL); |
162 | } else if (value == "DT_QINT8" ) { |
163 | msg->set_dtype(::tensorflow::DT_QINT8); |
164 | } else if (value == "DT_QUINT8" ) { |
165 | msg->set_dtype(::tensorflow::DT_QUINT8); |
166 | } else if (value == "DT_QINT32" ) { |
167 | msg->set_dtype(::tensorflow::DT_QINT32); |
168 | } else if (value == "DT_BFLOAT16" ) { |
169 | msg->set_dtype(::tensorflow::DT_BFLOAT16); |
170 | } else if (value == "DT_QINT16" ) { |
171 | msg->set_dtype(::tensorflow::DT_QINT16); |
172 | } else if (value == "DT_QUINT16" ) { |
173 | msg->set_dtype(::tensorflow::DT_QUINT16); |
174 | } else if (value == "DT_UINT16" ) { |
175 | msg->set_dtype(::tensorflow::DT_UINT16); |
176 | } else if (value == "DT_COMPLEX128" ) { |
177 | msg->set_dtype(::tensorflow::DT_COMPLEX128); |
178 | } else if (value == "DT_HALF" ) { |
179 | msg->set_dtype(::tensorflow::DT_HALF); |
180 | } else if (value == "DT_RESOURCE" ) { |
181 | msg->set_dtype(::tensorflow::DT_RESOURCE); |
182 | } else if (value == "DT_VARIANT" ) { |
183 | msg->set_dtype(::tensorflow::DT_VARIANT); |
184 | } else if (value == "DT_UINT32" ) { |
185 | msg->set_dtype(::tensorflow::DT_UINT32); |
186 | } else if (value == "DT_UINT64" ) { |
187 | msg->set_dtype(::tensorflow::DT_UINT64); |
188 | } else if (value == "DT_FLOAT_REF" ) { |
189 | msg->set_dtype(::tensorflow::DT_FLOAT_REF); |
190 | } else if (value == "DT_DOUBLE_REF" ) { |
191 | msg->set_dtype(::tensorflow::DT_DOUBLE_REF); |
192 | } else if (value == "DT_INT32_REF" ) { |
193 | msg->set_dtype(::tensorflow::DT_INT32_REF); |
194 | } else if (value == "DT_UINT8_REF" ) { |
195 | msg->set_dtype(::tensorflow::DT_UINT8_REF); |
196 | } else if (value == "DT_INT16_REF" ) { |
197 | msg->set_dtype(::tensorflow::DT_INT16_REF); |
198 | } else if (value == "DT_INT8_REF" ) { |
199 | msg->set_dtype(::tensorflow::DT_INT8_REF); |
200 | } else if (value == "DT_STRING_REF" ) { |
201 | msg->set_dtype(::tensorflow::DT_STRING_REF); |
202 | } else if (value == "DT_COMPLEX64_REF" ) { |
203 | msg->set_dtype(::tensorflow::DT_COMPLEX64_REF); |
204 | } else if (value == "DT_INT64_REF" ) { |
205 | msg->set_dtype(::tensorflow::DT_INT64_REF); |
206 | } else if (value == "DT_BOOL_REF" ) { |
207 | msg->set_dtype(::tensorflow::DT_BOOL_REF); |
208 | } else if (value == "DT_QINT8_REF" ) { |
209 | msg->set_dtype(::tensorflow::DT_QINT8_REF); |
210 | } else if (value == "DT_QUINT8_REF" ) { |
211 | msg->set_dtype(::tensorflow::DT_QUINT8_REF); |
212 | } else if (value == "DT_QINT32_REF" ) { |
213 | msg->set_dtype(::tensorflow::DT_QINT32_REF); |
214 | } else if (value == "DT_BFLOAT16_REF" ) { |
215 | msg->set_dtype(::tensorflow::DT_BFLOAT16_REF); |
216 | } else if (value == "DT_QINT16_REF" ) { |
217 | msg->set_dtype(::tensorflow::DT_QINT16_REF); |
218 | } else if (value == "DT_QUINT16_REF" ) { |
219 | msg->set_dtype(::tensorflow::DT_QUINT16_REF); |
220 | } else if (value == "DT_UINT16_REF" ) { |
221 | msg->set_dtype(::tensorflow::DT_UINT16_REF); |
222 | } else if (value == "DT_COMPLEX128_REF" ) { |
223 | msg->set_dtype(::tensorflow::DT_COMPLEX128_REF); |
224 | } else if (value == "DT_HALF_REF" ) { |
225 | msg->set_dtype(::tensorflow::DT_HALF_REF); |
226 | } else if (value == "DT_RESOURCE_REF" ) { |
227 | msg->set_dtype(::tensorflow::DT_RESOURCE_REF); |
228 | } else if (value == "DT_VARIANT_REF" ) { |
229 | msg->set_dtype(::tensorflow::DT_VARIANT_REF); |
230 | } else if (value == "DT_UINT32_REF" ) { |
231 | msg->set_dtype(::tensorflow::DT_UINT32_REF); |
232 | } else if (value == "DT_UINT64_REF" ) { |
233 | msg->set_dtype(::tensorflow::DT_UINT64_REF); |
234 | } else { |
235 | int32 int_value; |
236 | if (strings::SafeStringToNumeric(value, &int_value)) { |
237 | msg->set_dtype(static_cast<::tensorflow::DataType>(int_value)); |
238 | } else { |
239 | return false; |
240 | } |
241 | } |
242 | } |
243 | else if (identifier == "tensor_shape" ) { |
244 | if (has_seen[1]) return false; |
245 | has_seen[1] = true; |
246 | const char open_char = scanner->Peek(); |
247 | if (open_char != '{' && open_char != '<') return false; |
248 | scanner->One(Scanner::ALL); |
249 | ProtoSpaceAndComments(scanner); |
250 | if (!::tensorflow::internal::ProtoParseFromScanner( |
251 | scanner, true, open_char == '{', msg->mutable_tensor_shape())) return false; |
252 | } |
253 | else if (identifier == "version_number" ) { |
254 | if (has_seen[2]) return false; |
255 | has_seen[2] = true; |
256 | int32 value; |
257 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
258 | msg->set_version_number(value); |
259 | } |
260 | else if (identifier == "tensor_content" ) { |
261 | if (has_seen[3]) return false; |
262 | has_seen[3] = true; |
263 | string str_value; |
264 | if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner( |
265 | scanner, &str_value)) return false; |
266 | SetProtobufStringSwapAllowed(&str_value, msg->mutable_tensor_content()); |
267 | } |
268 | else if (identifier == "half_val" ) { |
269 | const bool is_list = (scanner->Peek() == '['); |
270 | do { |
271 | if (is_list) { |
272 | scanner->One(Scanner::ALL); |
273 | ProtoSpaceAndComments(scanner); |
274 | } |
275 | int32 value; |
276 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
277 | msg->add_half_val(value); |
278 | } while (is_list && scanner->Peek() == ','); |
279 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
280 | } |
281 | else if (identifier == "float_val" ) { |
282 | const bool is_list = (scanner->Peek() == '['); |
283 | do { |
284 | if (is_list) { |
285 | scanner->One(Scanner::ALL); |
286 | ProtoSpaceAndComments(scanner); |
287 | } |
288 | float value; |
289 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
290 | msg->add_float_val(value); |
291 | } while (is_list && scanner->Peek() == ','); |
292 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
293 | } |
294 | else if (identifier == "double_val" ) { |
295 | const bool is_list = (scanner->Peek() == '['); |
296 | do { |
297 | if (is_list) { |
298 | scanner->One(Scanner::ALL); |
299 | ProtoSpaceAndComments(scanner); |
300 | } |
301 | double value; |
302 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
303 | msg->add_double_val(value); |
304 | } while (is_list && scanner->Peek() == ','); |
305 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
306 | } |
307 | else if (identifier == "int_val" ) { |
308 | const bool is_list = (scanner->Peek() == '['); |
309 | do { |
310 | if (is_list) { |
311 | scanner->One(Scanner::ALL); |
312 | ProtoSpaceAndComments(scanner); |
313 | } |
314 | int32 value; |
315 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
316 | msg->add_int_val(value); |
317 | } while (is_list && scanner->Peek() == ','); |
318 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
319 | } |
320 | else if (identifier == "string_val" ) { |
321 | const bool is_list = (scanner->Peek() == '['); |
322 | do { |
323 | if (is_list) { |
324 | scanner->One(Scanner::ALL); |
325 | ProtoSpaceAndComments(scanner); |
326 | } |
327 | string str_value; |
328 | if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner( |
329 | scanner, &str_value)) return false; |
330 | SetProtobufStringSwapAllowed(&str_value, msg->add_string_val()); |
331 | } while (is_list && scanner->Peek() == ','); |
332 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
333 | } |
334 | else if (identifier == "scomplex_val" ) { |
335 | const bool is_list = (scanner->Peek() == '['); |
336 | do { |
337 | if (is_list) { |
338 | scanner->One(Scanner::ALL); |
339 | ProtoSpaceAndComments(scanner); |
340 | } |
341 | float value; |
342 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
343 | msg->add_scomplex_val(value); |
344 | } while (is_list && scanner->Peek() == ','); |
345 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
346 | } |
347 | else if (identifier == "int64_val" ) { |
348 | const bool is_list = (scanner->Peek() == '['); |
349 | do { |
350 | if (is_list) { |
351 | scanner->One(Scanner::ALL); |
352 | ProtoSpaceAndComments(scanner); |
353 | } |
354 | int64 value; |
355 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
356 | msg->add_int64_val(value); |
357 | } while (is_list && scanner->Peek() == ','); |
358 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
359 | } |
360 | else if (identifier == "bool_val" ) { |
361 | const bool is_list = (scanner->Peek() == '['); |
362 | do { |
363 | if (is_list) { |
364 | scanner->One(Scanner::ALL); |
365 | ProtoSpaceAndComments(scanner); |
366 | } |
367 | bool value; |
368 | if (!parsed_colon || !::tensorflow::strings::ProtoParseBoolFromScanner(scanner, &value)) return false; |
369 | msg->add_bool_val(value); |
370 | } while (is_list && scanner->Peek() == ','); |
371 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
372 | } |
373 | else if (identifier == "dcomplex_val" ) { |
374 | const bool is_list = (scanner->Peek() == '['); |
375 | do { |
376 | if (is_list) { |
377 | scanner->One(Scanner::ALL); |
378 | ProtoSpaceAndComments(scanner); |
379 | } |
380 | double value; |
381 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
382 | msg->add_dcomplex_val(value); |
383 | } while (is_list && scanner->Peek() == ','); |
384 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
385 | } |
386 | else if (identifier == "resource_handle_val" ) { |
387 | const bool is_list = (scanner->Peek() == '['); |
388 | do { |
389 | if (is_list) { |
390 | scanner->One(Scanner::ALL); |
391 | ProtoSpaceAndComments(scanner); |
392 | } |
393 | const char open_char = scanner->Peek(); |
394 | if (open_char != '{' && open_char != '<') return false; |
395 | scanner->One(Scanner::ALL); |
396 | ProtoSpaceAndComments(scanner); |
397 | if (!::tensorflow::internal::ProtoParseFromScanner( |
398 | scanner, true, open_char == '{', msg->add_resource_handle_val())) return false; |
399 | } while (is_list && scanner->Peek() == ','); |
400 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
401 | } |
402 | else if (identifier == "variant_val" ) { |
403 | const bool is_list = (scanner->Peek() == '['); |
404 | do { |
405 | if (is_list) { |
406 | scanner->One(Scanner::ALL); |
407 | ProtoSpaceAndComments(scanner); |
408 | } |
409 | const char open_char = scanner->Peek(); |
410 | if (open_char != '{' && open_char != '<') return false; |
411 | scanner->One(Scanner::ALL); |
412 | ProtoSpaceAndComments(scanner); |
413 | if (!::tensorflow::internal::ProtoParseFromScanner( |
414 | scanner, true, open_char == '{', msg->add_variant_val())) return false; |
415 | } while (is_list && scanner->Peek() == ','); |
416 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
417 | } |
418 | else if (identifier == "uint32_val" ) { |
419 | const bool is_list = (scanner->Peek() == '['); |
420 | do { |
421 | if (is_list) { |
422 | scanner->One(Scanner::ALL); |
423 | ProtoSpaceAndComments(scanner); |
424 | } |
425 | uint32 value; |
426 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
427 | msg->add_uint32_val(value); |
428 | } while (is_list && scanner->Peek() == ','); |
429 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
430 | } |
431 | else if (identifier == "uint64_val" ) { |
432 | const bool is_list = (scanner->Peek() == '['); |
433 | do { |
434 | if (is_list) { |
435 | scanner->One(Scanner::ALL); |
436 | ProtoSpaceAndComments(scanner); |
437 | } |
438 | uint64 value; |
439 | if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false; |
440 | msg->add_uint64_val(value); |
441 | } while (is_list && scanner->Peek() == ','); |
442 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
443 | } |
444 | } |
445 | } |
446 | |
447 | } // namespace internal |
448 | |
449 | string ProtoDebugString( |
450 | const ::tensorflow::VariantTensorDataProto& msg) { |
451 | string s; |
452 | ::tensorflow::strings::ProtoTextOutput o(&s, false); |
453 | internal::AppendProtoDebugString(&o, msg); |
454 | o.CloseTopMessage(); |
455 | return s; |
456 | } |
457 | |
458 | string ProtoShortDebugString( |
459 | const ::tensorflow::VariantTensorDataProto& msg) { |
460 | string s; |
461 | ::tensorflow::strings::ProtoTextOutput o(&s, true); |
462 | internal::AppendProtoDebugString(&o, msg); |
463 | o.CloseTopMessage(); |
464 | return s; |
465 | } |
466 | |
467 | namespace internal { |
468 | |
469 | void AppendProtoDebugString( |
470 | ::tensorflow::strings::ProtoTextOutput* o, |
471 | const ::tensorflow::VariantTensorDataProto& msg) { |
472 | o->AppendStringIfNotEmpty("type_name" , ProtobufStringToString(msg.type_name())); |
473 | o->AppendStringIfNotEmpty("metadata" , ProtobufStringToString(msg.metadata())); |
474 | for (int i = 0; i < msg.tensors_size(); ++i) { |
475 | o->OpenNestedMessage("tensors" ); |
476 | ::tensorflow::internal::AppendProtoDebugString(o, msg.tensors(i)); |
477 | o->CloseNestedMessage(); |
478 | } |
479 | } |
480 | |
481 | } // namespace internal |
482 | |
483 | bool ProtoParseFromString( |
484 | const string& s, |
485 | ::tensorflow::VariantTensorDataProto* msg) { |
486 | msg->Clear(); |
487 | Scanner scanner(s); |
488 | if (!internal::ProtoParseFromScanner(&scanner, false, false, msg)) return false; |
489 | scanner.Eos(); |
490 | return scanner.GetResult(); |
491 | } |
492 | |
493 | namespace internal { |
494 | |
495 | bool ProtoParseFromScanner( |
496 | ::tensorflow::strings::Scanner* scanner, bool nested, bool close_curly, |
497 | ::tensorflow::VariantTensorDataProto* msg) { |
498 | std::vector<bool> has_seen(3, false); |
499 | while(true) { |
500 | ProtoSpaceAndComments(scanner); |
501 | if (nested && (scanner->Peek() == (close_curly ? '}' : '>'))) { |
502 | scanner->One(Scanner::ALL); |
503 | ProtoSpaceAndComments(scanner); |
504 | return true; |
505 | } |
506 | if (!nested && scanner->empty()) { return true; } |
507 | scanner->RestartCapture() |
508 | .Many(Scanner::LETTER_DIGIT_UNDERSCORE) |
509 | .StopCapture(); |
510 | StringPiece identifier; |
511 | if (!scanner->GetResult(nullptr, &identifier)) return false; |
512 | bool parsed_colon = false; |
513 | (void)parsed_colon; |
514 | ProtoSpaceAndComments(scanner); |
515 | if (scanner->Peek() == ':') { |
516 | parsed_colon = true; |
517 | scanner->One(Scanner::ALL); |
518 | ProtoSpaceAndComments(scanner); |
519 | } |
520 | if (identifier == "type_name" ) { |
521 | if (has_seen[0]) return false; |
522 | has_seen[0] = true; |
523 | string str_value; |
524 | if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner( |
525 | scanner, &str_value)) return false; |
526 | SetProtobufStringSwapAllowed(&str_value, msg->mutable_type_name()); |
527 | } |
528 | else if (identifier == "metadata" ) { |
529 | if (has_seen[1]) return false; |
530 | has_seen[1] = true; |
531 | string str_value; |
532 | if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner( |
533 | scanner, &str_value)) return false; |
534 | SetProtobufStringSwapAllowed(&str_value, msg->mutable_metadata()); |
535 | } |
536 | else if (identifier == "tensors" ) { |
537 | const bool is_list = (scanner->Peek() == '['); |
538 | do { |
539 | if (is_list) { |
540 | scanner->One(Scanner::ALL); |
541 | ProtoSpaceAndComments(scanner); |
542 | } |
543 | const char open_char = scanner->Peek(); |
544 | if (open_char != '{' && open_char != '<') return false; |
545 | scanner->One(Scanner::ALL); |
546 | ProtoSpaceAndComments(scanner); |
547 | if (!::tensorflow::internal::ProtoParseFromScanner( |
548 | scanner, true, open_char == '{', msg->add_tensors())) return false; |
549 | } while (is_list && scanner->Peek() == ','); |
550 | if (is_list && !scanner->OneLiteral("]" ).GetResult()) return false; |
551 | } |
552 | } |
553 | } |
554 | |
555 | } // namespace internal |
556 | |
557 | } // namespace tensorflow |
558 | |