xref: /aosp_15_r20/external/tensorflow/tensorflow/core/framework/tensor.pb_text.cc (revision b6fb3261f9314811a0f4371741dbb8839866f948) 
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 
ProtoDebugString(const::tensorflow::TensorProto & msg)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 
ProtoShortDebugString(const::tensorflow::TensorProto & msg)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 
AppendProtoDebugString(::tensorflow::strings::ProtoTextOutput * o,const::tensorflow::TensorProto & msg)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 
ProtoParseFromString(const string & s,::tensorflow::TensorProto * msg)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 
ProtoParseFromScanner(::tensorflow::strings::Scanner * scanner,bool nested,bool close_curly,::tensorflow::TensorProto * msg)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 
ProtoDebugString(const::tensorflow::VariantTensorDataProto & msg)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 
ProtoShortDebugString(const::tensorflow::VariantTensorDataProto & msg)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 
AppendProtoDebugString(::tensorflow::strings::ProtoTextOutput * o,const::tensorflow::VariantTensorDataProto & msg)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 
ProtoParseFromString(const string & s,::tensorflow::VariantTensorDataProto * msg)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 
ProtoParseFromScanner(::tensorflow::strings::Scanner * scanner,bool nested,bool close_curly,::tensorflow::VariantTensorDataProto * msg)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