xref: /aosp_15_r20/external/tensorflow/tensorflow/core/framework/attr_value.pb_text.cc (revision b6fb3261f9314811a0f4371741dbb8839866f948) 
1 // GENERATED FILE - DO NOT MODIFY
2 
3 #include <algorithm>
4 
5 #include "tensorflow/core/framework/attr_value.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::AttrValue_ListValue & msg)13 string ProtoDebugString(
14     const ::tensorflow::AttrValue_ListValue& 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::AttrValue_ListValue & msg)22 string ProtoShortDebugString(
23     const ::tensorflow::AttrValue_ListValue& 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::AttrValue_ListValue & msg)33 void AppendProtoDebugString(
34     ::tensorflow::strings::ProtoTextOutput* o,
35     const ::tensorflow::AttrValue_ListValue& msg) {
36   for (int i = 0; i < msg.s_size(); ++i) {
37     o->AppendString("s", ProtobufStringToString(msg.s(i)));
38   }
39   for (int i = 0; i < msg.i_size(); ++i) {
40     o->AppendNumeric("i", msg.i(i));
41   }
42   for (int i = 0; i < msg.f_size(); ++i) {
43     o->AppendNumeric("f", msg.f(i));
44   }
45   for (int i = 0; i < msg.b_size(); ++i) {
46     o->AppendBool("b", msg.b(i));
47   }
48   for (int i = 0; i < msg.type_size(); ++i) {
49     const char* enum_name = ::tensorflow::EnumName_DataType(msg.type(i));
50     if (enum_name[0]) {
51       o->AppendEnumName("type", enum_name);
52     } else {
53       o->AppendNumeric("type", msg.type(i));
54     }
55   }
56   for (int i = 0; i < msg.shape_size(); ++i) {
57     o->OpenNestedMessage("shape");
58     ::tensorflow::internal::AppendProtoDebugString(o, msg.shape(i));
59     o->CloseNestedMessage();
60   }
61   for (int i = 0; i < msg.tensor_size(); ++i) {
62     o->OpenNestedMessage("tensor");
63     ::tensorflow::internal::AppendProtoDebugString(o, msg.tensor(i));
64     o->CloseNestedMessage();
65   }
66   for (int i = 0; i < msg.func_size(); ++i) {
67     o->OpenNestedMessage("func");
68     ::tensorflow::internal::AppendProtoDebugString(o, msg.func(i));
69     o->CloseNestedMessage();
70   }
71 }
72 
73 }  // namespace internal
74 
ProtoParseFromString(const string & s,::tensorflow::AttrValue_ListValue * msg)75 bool ProtoParseFromString(
76     const string& s,
77     ::tensorflow::AttrValue_ListValue* msg) {
78   msg->Clear();
79   Scanner scanner(s);
80   if (!internal::ProtoParseFromScanner(&scanner, false, false, msg)) return false;
81   scanner.Eos();
82   return scanner.GetResult();
83 }
84 
85 namespace internal {
86 
ProtoParseFromScanner(::tensorflow::strings::Scanner * scanner,bool nested,bool close_curly,::tensorflow::AttrValue_ListValue * msg)87 bool ProtoParseFromScanner(
88     ::tensorflow::strings::Scanner* scanner, bool nested, bool close_curly,
89     ::tensorflow::AttrValue_ListValue* msg) {
90   std::vector<bool> has_seen(8, false);
91   while(true) {
92     ProtoSpaceAndComments(scanner);
93     if (nested && (scanner->Peek() == (close_curly ? '}' : '>'))) {
94       scanner->One(Scanner::ALL);
95       ProtoSpaceAndComments(scanner);
96       return true;
97     }
98     if (!nested && scanner->empty()) { return true; }
99     scanner->RestartCapture()
100         .Many(Scanner::LETTER_DIGIT_UNDERSCORE)
101         .StopCapture();
102     StringPiece identifier;
103     if (!scanner->GetResult(nullptr, &identifier)) return false;
104     bool parsed_colon = false;
105     (void)parsed_colon;
106     ProtoSpaceAndComments(scanner);
107     if (scanner->Peek() == ':') {
108       parsed_colon = true;
109       scanner->One(Scanner::ALL);
110       ProtoSpaceAndComments(scanner);
111     }
112     if (identifier == "s") {
113       const bool is_list = (scanner->Peek() == '[');
114       do {
115         if (is_list) {
116           scanner->One(Scanner::ALL);
117           ProtoSpaceAndComments(scanner);
118         }
119         string str_value;
120         if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner(
121             scanner, &str_value)) return false;
122         SetProtobufStringSwapAllowed(&str_value, msg->add_s());
123       } while (is_list && scanner->Peek() == ',');
124       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
125     }
126     else if (identifier == "i") {
127       const bool is_list = (scanner->Peek() == '[');
128       do {
129         if (is_list) {
130           scanner->One(Scanner::ALL);
131           ProtoSpaceAndComments(scanner);
132         }
133         int64 value;
134         if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false;
135         msg->add_i(value);
136       } while (is_list && scanner->Peek() == ',');
137       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
138     }
139     else if (identifier == "f") {
140       const bool is_list = (scanner->Peek() == '[');
141       do {
142         if (is_list) {
143           scanner->One(Scanner::ALL);
144           ProtoSpaceAndComments(scanner);
145         }
146         float value;
147         if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false;
148         msg->add_f(value);
149       } while (is_list && scanner->Peek() == ',');
150       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
151     }
152     else if (identifier == "b") {
153       const bool is_list = (scanner->Peek() == '[');
154       do {
155         if (is_list) {
156           scanner->One(Scanner::ALL);
157           ProtoSpaceAndComments(scanner);
158         }
159         bool value;
160         if (!parsed_colon || !::tensorflow::strings::ProtoParseBoolFromScanner(scanner, &value)) return false;
161         msg->add_b(value);
162       } while (is_list && scanner->Peek() == ',');
163       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
164     }
165     else if (identifier == "type") {
166       const bool is_list = (scanner->Peek() == '[');
167       do {
168         if (is_list) {
169           scanner->One(Scanner::ALL);
170           ProtoSpaceAndComments(scanner);
171         }
172         StringPiece value;
173         if (!parsed_colon || !scanner->RestartCapture().Many(Scanner::LETTER_DIGIT_DASH_UNDERSCORE).GetResult(nullptr, &value)) return false;
174         if (value == "DT_INVALID") {
175           msg->add_type(::tensorflow::DT_INVALID);
176         } else if (value == "DT_FLOAT") {
177           msg->add_type(::tensorflow::DT_FLOAT);
178         } else if (value == "DT_DOUBLE") {
179           msg->add_type(::tensorflow::DT_DOUBLE);
180         } else if (value == "DT_INT32") {
181           msg->add_type(::tensorflow::DT_INT32);
182         } else if (value == "DT_UINT8") {
183           msg->add_type(::tensorflow::DT_UINT8);
184         } else if (value == "DT_INT16") {
185           msg->add_type(::tensorflow::DT_INT16);
186         } else if (value == "DT_INT8") {
187           msg->add_type(::tensorflow::DT_INT8);
188         } else if (value == "DT_STRING") {
189           msg->add_type(::tensorflow::DT_STRING);
190         } else if (value == "DT_COMPLEX64") {
191           msg->add_type(::tensorflow::DT_COMPLEX64);
192         } else if (value == "DT_INT64") {
193           msg->add_type(::tensorflow::DT_INT64);
194         } else if (value == "DT_BOOL") {
195           msg->add_type(::tensorflow::DT_BOOL);
196         } else if (value == "DT_QINT8") {
197           msg->add_type(::tensorflow::DT_QINT8);
198         } else if (value == "DT_QUINT8") {
199           msg->add_type(::tensorflow::DT_QUINT8);
200         } else if (value == "DT_QINT32") {
201           msg->add_type(::tensorflow::DT_QINT32);
202         } else if (value == "DT_BFLOAT16") {
203           msg->add_type(::tensorflow::DT_BFLOAT16);
204         } else if (value == "DT_QINT16") {
205           msg->add_type(::tensorflow::DT_QINT16);
206         } else if (value == "DT_QUINT16") {
207           msg->add_type(::tensorflow::DT_QUINT16);
208         } else if (value == "DT_UINT16") {
209           msg->add_type(::tensorflow::DT_UINT16);
210         } else if (value == "DT_COMPLEX128") {
211           msg->add_type(::tensorflow::DT_COMPLEX128);
212         } else if (value == "DT_HALF") {
213           msg->add_type(::tensorflow::DT_HALF);
214         } else if (value == "DT_RESOURCE") {
215           msg->add_type(::tensorflow::DT_RESOURCE);
216         } else if (value == "DT_VARIANT") {
217           msg->add_type(::tensorflow::DT_VARIANT);
218         } else if (value == "DT_UINT32") {
219           msg->add_type(::tensorflow::DT_UINT32);
220         } else if (value == "DT_UINT64") {
221           msg->add_type(::tensorflow::DT_UINT64);
222         } else if (value == "DT_FLOAT_REF") {
223           msg->add_type(::tensorflow::DT_FLOAT_REF);
224         } else if (value == "DT_DOUBLE_REF") {
225           msg->add_type(::tensorflow::DT_DOUBLE_REF);
226         } else if (value == "DT_INT32_REF") {
227           msg->add_type(::tensorflow::DT_INT32_REF);
228         } else if (value == "DT_UINT8_REF") {
229           msg->add_type(::tensorflow::DT_UINT8_REF);
230         } else if (value == "DT_INT16_REF") {
231           msg->add_type(::tensorflow::DT_INT16_REF);
232         } else if (value == "DT_INT8_REF") {
233           msg->add_type(::tensorflow::DT_INT8_REF);
234         } else if (value == "DT_STRING_REF") {
235           msg->add_type(::tensorflow::DT_STRING_REF);
236         } else if (value == "DT_COMPLEX64_REF") {
237           msg->add_type(::tensorflow::DT_COMPLEX64_REF);
238         } else if (value == "DT_INT64_REF") {
239           msg->add_type(::tensorflow::DT_INT64_REF);
240         } else if (value == "DT_BOOL_REF") {
241           msg->add_type(::tensorflow::DT_BOOL_REF);
242         } else if (value == "DT_QINT8_REF") {
243           msg->add_type(::tensorflow::DT_QINT8_REF);
244         } else if (value == "DT_QUINT8_REF") {
245           msg->add_type(::tensorflow::DT_QUINT8_REF);
246         } else if (value == "DT_QINT32_REF") {
247           msg->add_type(::tensorflow::DT_QINT32_REF);
248         } else if (value == "DT_BFLOAT16_REF") {
249           msg->add_type(::tensorflow::DT_BFLOAT16_REF);
250         } else if (value == "DT_QINT16_REF") {
251           msg->add_type(::tensorflow::DT_QINT16_REF);
252         } else if (value == "DT_QUINT16_REF") {
253           msg->add_type(::tensorflow::DT_QUINT16_REF);
254         } else if (value == "DT_UINT16_REF") {
255           msg->add_type(::tensorflow::DT_UINT16_REF);
256         } else if (value == "DT_COMPLEX128_REF") {
257           msg->add_type(::tensorflow::DT_COMPLEX128_REF);
258         } else if (value == "DT_HALF_REF") {
259           msg->add_type(::tensorflow::DT_HALF_REF);
260         } else if (value == "DT_RESOURCE_REF") {
261           msg->add_type(::tensorflow::DT_RESOURCE_REF);
262         } else if (value == "DT_VARIANT_REF") {
263           msg->add_type(::tensorflow::DT_VARIANT_REF);
264         } else if (value == "DT_UINT32_REF") {
265           msg->add_type(::tensorflow::DT_UINT32_REF);
266         } else if (value == "DT_UINT64_REF") {
267           msg->add_type(::tensorflow::DT_UINT64_REF);
268         } else {
269           int32 int_value;
270           if (strings::SafeStringToNumeric(value, &int_value)) {
271             msg->add_type(static_cast<::tensorflow::DataType>(int_value));
272           } else {
273             return false;
274           }
275         }
276       } while (is_list && scanner->Peek() == ',');
277       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
278     }
279     else if (identifier == "shape") {
280       const bool is_list = (scanner->Peek() == '[');
281       do {
282         if (is_list) {
283           scanner->One(Scanner::ALL);
284           ProtoSpaceAndComments(scanner);
285         }
286         const char open_char = scanner->Peek();
287         if (open_char != '{' && open_char != '<') return false;
288         scanner->One(Scanner::ALL);
289         ProtoSpaceAndComments(scanner);
290         if (!::tensorflow::internal::ProtoParseFromScanner(
291             scanner, true, open_char == '{', msg->add_shape())) return false;
292       } while (is_list && scanner->Peek() == ',');
293       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
294     }
295     else if (identifier == "tensor") {
296       const bool is_list = (scanner->Peek() == '[');
297       do {
298         if (is_list) {
299           scanner->One(Scanner::ALL);
300           ProtoSpaceAndComments(scanner);
301         }
302         const char open_char = scanner->Peek();
303         if (open_char != '{' && open_char != '<') return false;
304         scanner->One(Scanner::ALL);
305         ProtoSpaceAndComments(scanner);
306         if (!::tensorflow::internal::ProtoParseFromScanner(
307             scanner, true, open_char == '{', msg->add_tensor())) return false;
308       } while (is_list && scanner->Peek() == ',');
309       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
310     }
311     else if (identifier == "func") {
312       const bool is_list = (scanner->Peek() == '[');
313       do {
314         if (is_list) {
315           scanner->One(Scanner::ALL);
316           ProtoSpaceAndComments(scanner);
317         }
318         const char open_char = scanner->Peek();
319         if (open_char != '{' && open_char != '<') return false;
320         scanner->One(Scanner::ALL);
321         ProtoSpaceAndComments(scanner);
322         if (!::tensorflow::internal::ProtoParseFromScanner(
323             scanner, true, open_char == '{', msg->add_func())) return false;
324       } while (is_list && scanner->Peek() == ',');
325       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
326     }
327   }
328 }
329 
330 }  // namespace internal
331 
ProtoDebugString(const::tensorflow::AttrValue & msg)332 string ProtoDebugString(
333     const ::tensorflow::AttrValue& msg) {
334   string s;
335   ::tensorflow::strings::ProtoTextOutput o(&s, false);
336   internal::AppendProtoDebugString(&o, msg);
337   o.CloseTopMessage();
338   return s;
339 }
340 
ProtoShortDebugString(const::tensorflow::AttrValue & msg)341 string ProtoShortDebugString(
342     const ::tensorflow::AttrValue& msg) {
343   string s;
344   ::tensorflow::strings::ProtoTextOutput o(&s, true);
345   internal::AppendProtoDebugString(&o, msg);
346   o.CloseTopMessage();
347   return s;
348 }
349 
350 namespace internal {
351 
AppendProtoDebugString(::tensorflow::strings::ProtoTextOutput * o,const::tensorflow::AttrValue & msg)352 void AppendProtoDebugString(
353     ::tensorflow::strings::ProtoTextOutput* o,
354     const ::tensorflow::AttrValue& msg) {
355   if (msg.value_case() == ::tensorflow::AttrValue::kList) {
356     o->OpenNestedMessage("list");
357     ::tensorflow::internal::AppendProtoDebugString(o, msg.list());
358     o->CloseNestedMessage();
359   }
360   if (msg.value_case() == ::tensorflow::AttrValue::kS) {
361     o->AppendString("s", ProtobufStringToString(msg.s()));
362   }
363   if (msg.value_case() == ::tensorflow::AttrValue::kI) {
364     o->AppendNumeric("i", msg.i());
365   }
366   if (msg.value_case() == ::tensorflow::AttrValue::kF) {
367     o->AppendNumeric("f", msg.f());
368   }
369   if (msg.value_case() == ::tensorflow::AttrValue::kB) {
370     o->AppendBool("b", msg.b());
371   }
372   if (msg.value_case() == ::tensorflow::AttrValue::kType) {
373     const char* enum_name = ::tensorflow::EnumName_DataType(msg.type());
374     if (enum_name[0]) {
375       o->AppendEnumName("type", enum_name);
376     } else {
377       o->AppendNumeric("type", msg.type());
378     }
379   }
380   if (msg.value_case() == ::tensorflow::AttrValue::kShape) {
381     o->OpenNestedMessage("shape");
382     ::tensorflow::internal::AppendProtoDebugString(o, msg.shape());
383     o->CloseNestedMessage();
384   }
385   if (msg.value_case() == ::tensorflow::AttrValue::kTensor) {
386     o->OpenNestedMessage("tensor");
387     ::tensorflow::internal::AppendProtoDebugString(o, msg.tensor());
388     o->CloseNestedMessage();
389   }
390   if (msg.value_case() == ::tensorflow::AttrValue::kPlaceholder) {
391     o->AppendString("placeholder", ProtobufStringToString(msg.placeholder()));
392   }
393   if (msg.value_case() == ::tensorflow::AttrValue::kFunc) {
394     o->OpenNestedMessage("func");
395     ::tensorflow::internal::AppendProtoDebugString(o, msg.func());
396     o->CloseNestedMessage();
397   }
398 }
399 
400 }  // namespace internal
401 
ProtoParseFromString(const string & s,::tensorflow::AttrValue * msg)402 bool ProtoParseFromString(
403     const string& s,
404     ::tensorflow::AttrValue* msg) {
405   msg->Clear();
406   Scanner scanner(s);
407   if (!internal::ProtoParseFromScanner(&scanner, false, false, msg)) return false;
408   scanner.Eos();
409   return scanner.GetResult();
410 }
411 
412 namespace internal {
413 
ProtoParseFromScanner(::tensorflow::strings::Scanner * scanner,bool nested,bool close_curly,::tensorflow::AttrValue * msg)414 bool ProtoParseFromScanner(
415     ::tensorflow::strings::Scanner* scanner, bool nested, bool close_curly,
416     ::tensorflow::AttrValue* msg) {
417   std::vector<bool> has_seen(10, false);
418   while(true) {
419     ProtoSpaceAndComments(scanner);
420     if (nested && (scanner->Peek() == (close_curly ? '}' : '>'))) {
421       scanner->One(Scanner::ALL);
422       ProtoSpaceAndComments(scanner);
423       return true;
424     }
425     if (!nested && scanner->empty()) { return true; }
426     scanner->RestartCapture()
427         .Many(Scanner::LETTER_DIGIT_UNDERSCORE)
428         .StopCapture();
429     StringPiece identifier;
430     if (!scanner->GetResult(nullptr, &identifier)) return false;
431     bool parsed_colon = false;
432     (void)parsed_colon;
433     ProtoSpaceAndComments(scanner);
434     if (scanner->Peek() == ':') {
435       parsed_colon = true;
436       scanner->One(Scanner::ALL);
437       ProtoSpaceAndComments(scanner);
438     }
439     if (identifier == "s") {
440       if (msg->value_case() != 0) return false;
441       if (has_seen[0]) return false;
442       has_seen[0] = true;
443       string str_value;
444       if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner(
445           scanner, &str_value)) return false;
446       SetProtobufStringSwapAllowed(&str_value, msg->mutable_s());
447     }
448     else if (identifier == "i") {
449       if (msg->value_case() != 0) return false;
450       if (has_seen[1]) return false;
451       has_seen[1] = true;
452       int64 value;
453       if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false;
454       msg->set_i(value);
455     }
456     else if (identifier == "f") {
457       if (msg->value_case() != 0) return false;
458       if (has_seen[2]) return false;
459       has_seen[2] = true;
460       float value;
461       if (!parsed_colon || !::tensorflow::strings::ProtoParseNumericFromScanner(scanner, &value)) return false;
462       msg->set_f(value);
463     }
464     else if (identifier == "b") {
465       if (msg->value_case() != 0) return false;
466       if (has_seen[3]) return false;
467       has_seen[3] = true;
468       bool value;
469       if (!parsed_colon || !::tensorflow::strings::ProtoParseBoolFromScanner(scanner, &value)) return false;
470       msg->set_b(value);
471     }
472     else if (identifier == "type") {
473       if (msg->value_case() != 0) return false;
474       if (has_seen[4]) return false;
475       has_seen[4] = true;
476       StringPiece value;
477       if (!parsed_colon || !scanner->RestartCapture().Many(Scanner::LETTER_DIGIT_DASH_UNDERSCORE).GetResult(nullptr, &value)) return false;
478       if (value == "DT_INVALID") {
479         msg->set_type(::tensorflow::DT_INVALID);
480       } else if (value == "DT_FLOAT") {
481         msg->set_type(::tensorflow::DT_FLOAT);
482       } else if (value == "DT_DOUBLE") {
483         msg->set_type(::tensorflow::DT_DOUBLE);
484       } else if (value == "DT_INT32") {
485         msg->set_type(::tensorflow::DT_INT32);
486       } else if (value == "DT_UINT8") {
487         msg->set_type(::tensorflow::DT_UINT8);
488       } else if (value == "DT_INT16") {
489         msg->set_type(::tensorflow::DT_INT16);
490       } else if (value == "DT_INT8") {
491         msg->set_type(::tensorflow::DT_INT8);
492       } else if (value == "DT_STRING") {
493         msg->set_type(::tensorflow::DT_STRING);
494       } else if (value == "DT_COMPLEX64") {
495         msg->set_type(::tensorflow::DT_COMPLEX64);
496       } else if (value == "DT_INT64") {
497         msg->set_type(::tensorflow::DT_INT64);
498       } else if (value == "DT_BOOL") {
499         msg->set_type(::tensorflow::DT_BOOL);
500       } else if (value == "DT_QINT8") {
501         msg->set_type(::tensorflow::DT_QINT8);
502       } else if (value == "DT_QUINT8") {
503         msg->set_type(::tensorflow::DT_QUINT8);
504       } else if (value == "DT_QINT32") {
505         msg->set_type(::tensorflow::DT_QINT32);
506       } else if (value == "DT_BFLOAT16") {
507         msg->set_type(::tensorflow::DT_BFLOAT16);
508       } else if (value == "DT_QINT16") {
509         msg->set_type(::tensorflow::DT_QINT16);
510       } else if (value == "DT_QUINT16") {
511         msg->set_type(::tensorflow::DT_QUINT16);
512       } else if (value == "DT_UINT16") {
513         msg->set_type(::tensorflow::DT_UINT16);
514       } else if (value == "DT_COMPLEX128") {
515         msg->set_type(::tensorflow::DT_COMPLEX128);
516       } else if (value == "DT_HALF") {
517         msg->set_type(::tensorflow::DT_HALF);
518       } else if (value == "DT_RESOURCE") {
519         msg->set_type(::tensorflow::DT_RESOURCE);
520       } else if (value == "DT_VARIANT") {
521         msg->set_type(::tensorflow::DT_VARIANT);
522       } else if (value == "DT_UINT32") {
523         msg->set_type(::tensorflow::DT_UINT32);
524       } else if (value == "DT_UINT64") {
525         msg->set_type(::tensorflow::DT_UINT64);
526       } else if (value == "DT_FLOAT_REF") {
527         msg->set_type(::tensorflow::DT_FLOAT_REF);
528       } else if (value == "DT_DOUBLE_REF") {
529         msg->set_type(::tensorflow::DT_DOUBLE_REF);
530       } else if (value == "DT_INT32_REF") {
531         msg->set_type(::tensorflow::DT_INT32_REF);
532       } else if (value == "DT_UINT8_REF") {
533         msg->set_type(::tensorflow::DT_UINT8_REF);
534       } else if (value == "DT_INT16_REF") {
535         msg->set_type(::tensorflow::DT_INT16_REF);
536       } else if (value == "DT_INT8_REF") {
537         msg->set_type(::tensorflow::DT_INT8_REF);
538       } else if (value == "DT_STRING_REF") {
539         msg->set_type(::tensorflow::DT_STRING_REF);
540       } else if (value == "DT_COMPLEX64_REF") {
541         msg->set_type(::tensorflow::DT_COMPLEX64_REF);
542       } else if (value == "DT_INT64_REF") {
543         msg->set_type(::tensorflow::DT_INT64_REF);
544       } else if (value == "DT_BOOL_REF") {
545         msg->set_type(::tensorflow::DT_BOOL_REF);
546       } else if (value == "DT_QINT8_REF") {
547         msg->set_type(::tensorflow::DT_QINT8_REF);
548       } else if (value == "DT_QUINT8_REF") {
549         msg->set_type(::tensorflow::DT_QUINT8_REF);
550       } else if (value == "DT_QINT32_REF") {
551         msg->set_type(::tensorflow::DT_QINT32_REF);
552       } else if (value == "DT_BFLOAT16_REF") {
553         msg->set_type(::tensorflow::DT_BFLOAT16_REF);
554       } else if (value == "DT_QINT16_REF") {
555         msg->set_type(::tensorflow::DT_QINT16_REF);
556       } else if (value == "DT_QUINT16_REF") {
557         msg->set_type(::tensorflow::DT_QUINT16_REF);
558       } else if (value == "DT_UINT16_REF") {
559         msg->set_type(::tensorflow::DT_UINT16_REF);
560       } else if (value == "DT_COMPLEX128_REF") {
561         msg->set_type(::tensorflow::DT_COMPLEX128_REF);
562       } else if (value == "DT_HALF_REF") {
563         msg->set_type(::tensorflow::DT_HALF_REF);
564       } else if (value == "DT_RESOURCE_REF") {
565         msg->set_type(::tensorflow::DT_RESOURCE_REF);
566       } else if (value == "DT_VARIANT_REF") {
567         msg->set_type(::tensorflow::DT_VARIANT_REF);
568       } else if (value == "DT_UINT32_REF") {
569         msg->set_type(::tensorflow::DT_UINT32_REF);
570       } else if (value == "DT_UINT64_REF") {
571         msg->set_type(::tensorflow::DT_UINT64_REF);
572       } else {
573         int32 int_value;
574         if (strings::SafeStringToNumeric(value, &int_value)) {
575           msg->set_type(static_cast<::tensorflow::DataType>(int_value));
576         } else {
577           return false;
578         }
579       }
580     }
581     else if (identifier == "shape") {
582       if (msg->value_case() != 0) return false;
583       if (has_seen[5]) return false;
584       has_seen[5] = true;
585       const char open_char = scanner->Peek();
586       if (open_char != '{' && open_char != '<') return false;
587       scanner->One(Scanner::ALL);
588       ProtoSpaceAndComments(scanner);
589       if (!::tensorflow::internal::ProtoParseFromScanner(
590           scanner, true, open_char == '{', msg->mutable_shape())) return false;
591     }
592     else if (identifier == "tensor") {
593       if (msg->value_case() != 0) return false;
594       if (has_seen[6]) return false;
595       has_seen[6] = true;
596       const char open_char = scanner->Peek();
597       if (open_char != '{' && open_char != '<') return false;
598       scanner->One(Scanner::ALL);
599       ProtoSpaceAndComments(scanner);
600       if (!::tensorflow::internal::ProtoParseFromScanner(
601           scanner, true, open_char == '{', msg->mutable_tensor())) return false;
602     }
603     else if (identifier == "list") {
604       if (msg->value_case() != 0) return false;
605       if (has_seen[7]) return false;
606       has_seen[7] = true;
607       const char open_char = scanner->Peek();
608       if (open_char != '{' && open_char != '<') return false;
609       scanner->One(Scanner::ALL);
610       ProtoSpaceAndComments(scanner);
611       if (!::tensorflow::internal::ProtoParseFromScanner(
612           scanner, true, open_char == '{', msg->mutable_list())) return false;
613     }
614     else if (identifier == "func") {
615       if (msg->value_case() != 0) return false;
616       if (has_seen[8]) return false;
617       has_seen[8] = true;
618       const char open_char = scanner->Peek();
619       if (open_char != '{' && open_char != '<') return false;
620       scanner->One(Scanner::ALL);
621       ProtoSpaceAndComments(scanner);
622       if (!::tensorflow::internal::ProtoParseFromScanner(
623           scanner, true, open_char == '{', msg->mutable_func())) return false;
624     }
625     else if (identifier == "placeholder") {
626       if (msg->value_case() != 0) return false;
627       if (has_seen[9]) return false;
628       has_seen[9] = true;
629       string str_value;
630       if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner(
631           scanner, &str_value)) return false;
632       SetProtobufStringSwapAllowed(&str_value, msg->mutable_placeholder());
633     }
634   }
635 }
636 
637 }  // namespace internal
638 
639 namespace internal {
640 namespace {
641 
ProtoParseFromScanner(::tensorflow::strings::Scanner * scanner,bool nested,bool close_curly,::tensorflow::protobuf::Map<string,::tensorflow::AttrValue> * map)642 bool ProtoParseFromScanner(
643     ::tensorflow::strings::Scanner* scanner, bool nested, bool close_curly,
644     ::tensorflow::protobuf::Map<string, ::tensorflow::AttrValue>* map) {
645   string map_key;
646   bool set_map_key = false;
647   ::tensorflow::AttrValue map_value;
648   bool set_map_value = false;
649   std::vector<bool> has_seen(2, false);
650   while(true) {
651     ProtoSpaceAndComments(scanner);
652     if (nested && (scanner->Peek() == (close_curly ? '}' : '>'))) {
653       scanner->One(Scanner::ALL);
654       ProtoSpaceAndComments(scanner);
655       if (!set_map_key || !set_map_value) return false;
656       (*map)[map_key] = map_value;
657       return true;
658     }
659     if (!nested && scanner->empty()) { return true; }
660     scanner->RestartCapture()
661         .Many(Scanner::LETTER_DIGIT_UNDERSCORE)
662         .StopCapture();
663     StringPiece identifier;
664     if (!scanner->GetResult(nullptr, &identifier)) return false;
665     bool parsed_colon = false;
666     (void)parsed_colon;
667     ProtoSpaceAndComments(scanner);
668     if (scanner->Peek() == ':') {
669       parsed_colon = true;
670       scanner->One(Scanner::ALL);
671       ProtoSpaceAndComments(scanner);
672     }
673     if (identifier == "key") {
674       string str_value;
675       if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner(
676           scanner, &str_value)) return false;
677       SetProtobufStringSwapAllowed(&str_value, &map_key);
678       set_map_key = true;
679     }
680     else if (identifier == "value") {
681       const char open_char = scanner->Peek();
682       if (open_char != '{' && open_char != '<') return false;
683       scanner->One(Scanner::ALL);
684       ProtoSpaceAndComments(scanner);
685       if (!::tensorflow::internal::ProtoParseFromScanner(
686           scanner, true, open_char == '{', &map_value)) return false;
687       set_map_value = true;
688     }
689   }
690 }
691 
692 }  // namespace
693 }  // namespace internal
694 
ProtoDebugString(const::tensorflow::NameAttrList & msg)695 string ProtoDebugString(
696     const ::tensorflow::NameAttrList& msg) {
697   string s;
698   ::tensorflow::strings::ProtoTextOutput o(&s, false);
699   internal::AppendProtoDebugString(&o, msg);
700   o.CloseTopMessage();
701   return s;
702 }
703 
ProtoShortDebugString(const::tensorflow::NameAttrList & msg)704 string ProtoShortDebugString(
705     const ::tensorflow::NameAttrList& msg) {
706   string s;
707   ::tensorflow::strings::ProtoTextOutput o(&s, true);
708   internal::AppendProtoDebugString(&o, msg);
709   o.CloseTopMessage();
710   return s;
711 }
712 
713 namespace internal {
714 
AppendProtoDebugString(::tensorflow::strings::ProtoTextOutput * o,const::tensorflow::NameAttrList & msg)715 void AppendProtoDebugString(
716     ::tensorflow::strings::ProtoTextOutput* o,
717     const ::tensorflow::NameAttrList& msg) {
718   o->AppendStringIfNotEmpty("name", ProtobufStringToString(msg.name()));
719   {
720     std::vector<string> keys;
721     for (const auto& e : msg.attr()) keys.push_back(e.first);
722     std::stable_sort(keys.begin(), keys.end());
723     for (const auto& key : keys) {
724       o->OpenNestedMessage("attr");
725       o->AppendString("key", ProtobufStringToString(key));
726       o->OpenNestedMessage("value");
727       ::tensorflow::internal::AppendProtoDebugString(o, msg.attr().at(key));
728       o->CloseNestedMessage();
729       o->CloseNestedMessage();
730     }
731   }
732 }
733 
734 }  // namespace internal
735 
ProtoParseFromString(const string & s,::tensorflow::NameAttrList * msg)736 bool ProtoParseFromString(
737     const string& s,
738     ::tensorflow::NameAttrList* msg) {
739   msg->Clear();
740   Scanner scanner(s);
741   if (!internal::ProtoParseFromScanner(&scanner, false, false, msg)) return false;
742   scanner.Eos();
743   return scanner.GetResult();
744 }
745 
746 namespace internal {
747 
ProtoParseFromScanner(::tensorflow::strings::Scanner * scanner,bool nested,bool close_curly,::tensorflow::NameAttrList * msg)748 bool ProtoParseFromScanner(
749     ::tensorflow::strings::Scanner* scanner, bool nested, bool close_curly,
750     ::tensorflow::NameAttrList* msg) {
751   std::vector<bool> has_seen(2, false);
752   while(true) {
753     ProtoSpaceAndComments(scanner);
754     if (nested && (scanner->Peek() == (close_curly ? '}' : '>'))) {
755       scanner->One(Scanner::ALL);
756       ProtoSpaceAndComments(scanner);
757       return true;
758     }
759     if (!nested && scanner->empty()) { return true; }
760     scanner->RestartCapture()
761         .Many(Scanner::LETTER_DIGIT_UNDERSCORE)
762         .StopCapture();
763     StringPiece identifier;
764     if (!scanner->GetResult(nullptr, &identifier)) return false;
765     bool parsed_colon = false;
766     (void)parsed_colon;
767     ProtoSpaceAndComments(scanner);
768     if (scanner->Peek() == ':') {
769       parsed_colon = true;
770       scanner->One(Scanner::ALL);
771       ProtoSpaceAndComments(scanner);
772     }
773     if (identifier == "name") {
774       if (has_seen[0]) return false;
775       has_seen[0] = true;
776       string str_value;
777       if (!parsed_colon || !::tensorflow::strings::ProtoParseStringLiteralFromScanner(
778           scanner, &str_value)) return false;
779       SetProtobufStringSwapAllowed(&str_value, msg->mutable_name());
780     }
781     else if (identifier == "attr") {
782       const bool is_list = (scanner->Peek() == '[');
783       do {
784         if (is_list) {
785           scanner->One(Scanner::ALL);
786           ProtoSpaceAndComments(scanner);
787         }
788         const char open_char = scanner->Peek();
789         if (open_char != '{' && open_char != '<') return false;
790         scanner->One(Scanner::ALL);
791         ProtoSpaceAndComments(scanner);
792         if (!ProtoParseFromScanner(
793             scanner, true, open_char == '{', msg->mutable_attr())) return false;
794       } while (is_list && scanner->Peek() == ',');
795       if (is_list && !scanner->OneLiteral("]").GetResult()) return false;
796     }
797   }
798 }
799 
800 }  // namespace internal
801 
802 }  // namespace tensorflow