1// GENERATED FILE - DO NOT MODIFY
2
3#include <algorithm>
4
5#include "tensorflow/core/framework/tensor.pb_text-impl.h"
6
7using ::tensorflow::strings::ProtoSpaceAndComments;
8using ::tensorflow::strings::Scanner;
9using ::tensorflow::strings::StrCat;
10
11namespace tensorflow {
12
13string 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
22string 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
31namespace internal {
32
33void 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
98bool 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
108namespace internal {
109
110bool 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
449string 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
458string 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
467namespace internal {
468
469void 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
483bool 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
493namespace internal {
494
495bool 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