1#![allow(unknown_lints)]
6#![allow(clippy::all)]
7
8#![cfg_attr(rustfmt, rustfmt_skip)]
9
10#![allow(box_pointers)]
11#![allow(dead_code)]
12#![allow(missing_docs)]
13#![allow(non_camel_case_types)]
14#![allow(non_snake_case)]
15#![allow(non_upper_case_globals)]
16#![allow(trivial_casts)]
17#![allow(unsafe_code)]
18#![allow(unused_imports)]
19#![allow(unused_results)]
20use protobuf::Message as Message_imported_for_functions;
23use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
24
25#[derive(PartialEq,Clone,Default)]
30pub struct StructuredValue {
31 pub kind: ::std::option::Option<StructuredValue_oneof_kind>,
33 pub unknown_fields: ::protobuf::UnknownFields,
35 pub cached_size: ::protobuf::CachedSize,
36}
37
38impl<'a> ::std::default::Default for &'a StructuredValue {
39 fn default() -> &'a StructuredValue {
40 <StructuredValue as ::protobuf::Message>::default_instance()
41 }
42}
43
44#[derive(Clone,PartialEq,Debug)]
45pub enum StructuredValue_oneof_kind {
46 none_value(NoneValue),
47 float64_value(f64),
48 int64_value(i64),
49 string_value(::std::string::String),
50 bool_value(bool),
51 tensor_shape_value(super::tensor_shape::TensorShapeProto),
52 tensor_dtype_value(super::types::DataType),
53 tensor_spec_value(TensorSpecProto),
54 type_spec_value(TypeSpecProto),
55 bounded_tensor_spec_value(BoundedTensorSpecProto),
56 list_value(ListValue),
57 tuple_value(TupleValue),
58 dict_value(DictValue),
59 named_tuple_value(NamedTupleValue),
60}
61
62impl StructuredValue {
63 pub fn new() -> StructuredValue {
64 ::std::default::Default::default()
65 }
66
67 pub fn get_none_value(&self) -> &NoneValue {
71 match self.kind {
72 ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(ref v)) => v,
73 _ => NoneValue::default_instance(),
74 }
75 }
76 pub fn clear_none_value(&mut self) {
77 self.kind = ::std::option::Option::None;
78 }
79
80 pub fn has_none_value(&self) -> bool {
81 match self.kind {
82 ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(..)) => true,
83 _ => false,
84 }
85 }
86
87 pub fn set_none_value(&mut self, v: NoneValue) {
89 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(v))
90 }
91
92 pub fn mut_none_value(&mut self) -> &mut NoneValue {
94 if let ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(_)) = self.kind {
95 } else {
96 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(NoneValue::new()));
97 }
98 match self.kind {
99 ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(ref mut v)) => v,
100 _ => panic!(),
101 }
102 }
103
104 pub fn take_none_value(&mut self) -> NoneValue {
106 if self.has_none_value() {
107 match self.kind.take() {
108 ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(v)) => v,
109 _ => panic!(),
110 }
111 } else {
112 NoneValue::new()
113 }
114 }
115
116 pub fn get_float64_value(&self) -> f64 {
120 match self.kind {
121 ::std::option::Option::Some(StructuredValue_oneof_kind::float64_value(v)) => v,
122 _ => 0.,
123 }
124 }
125 pub fn clear_float64_value(&mut self) {
126 self.kind = ::std::option::Option::None;
127 }
128
129 pub fn has_float64_value(&self) -> bool {
130 match self.kind {
131 ::std::option::Option::Some(StructuredValue_oneof_kind::float64_value(..)) => true,
132 _ => false,
133 }
134 }
135
136 pub fn set_float64_value(&mut self, v: f64) {
138 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::float64_value(v))
139 }
140
141 pub fn get_int64_value(&self) -> i64 {
145 match self.kind {
146 ::std::option::Option::Some(StructuredValue_oneof_kind::int64_value(v)) => v,
147 _ => 0,
148 }
149 }
150 pub fn clear_int64_value(&mut self) {
151 self.kind = ::std::option::Option::None;
152 }
153
154 pub fn has_int64_value(&self) -> bool {
155 match self.kind {
156 ::std::option::Option::Some(StructuredValue_oneof_kind::int64_value(..)) => true,
157 _ => false,
158 }
159 }
160
161 pub fn set_int64_value(&mut self, v: i64) {
163 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::int64_value(v))
164 }
165
166 pub fn get_string_value(&self) -> &str {
170 match self.kind {
171 ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(ref v)) => v,
172 _ => "",
173 }
174 }
175 pub fn clear_string_value(&mut self) {
176 self.kind = ::std::option::Option::None;
177 }
178
179 pub fn has_string_value(&self) -> bool {
180 match self.kind {
181 ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(..)) => true,
182 _ => false,
183 }
184 }
185
186 pub fn set_string_value(&mut self, v: ::std::string::String) {
188 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(v))
189 }
190
191 pub fn mut_string_value(&mut self) -> &mut ::std::string::String {
193 if let ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(_)) = self.kind {
194 } else {
195 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(::std::string::String::new()));
196 }
197 match self.kind {
198 ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(ref mut v)) => v,
199 _ => panic!(),
200 }
201 }
202
203 pub fn take_string_value(&mut self) -> ::std::string::String {
205 if self.has_string_value() {
206 match self.kind.take() {
207 ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(v)) => v,
208 _ => panic!(),
209 }
210 } else {
211 ::std::string::String::new()
212 }
213 }
214
215 pub fn get_bool_value(&self) -> bool {
219 match self.kind {
220 ::std::option::Option::Some(StructuredValue_oneof_kind::bool_value(v)) => v,
221 _ => false,
222 }
223 }
224 pub fn clear_bool_value(&mut self) {
225 self.kind = ::std::option::Option::None;
226 }
227
228 pub fn has_bool_value(&self) -> bool {
229 match self.kind {
230 ::std::option::Option::Some(StructuredValue_oneof_kind::bool_value(..)) => true,
231 _ => false,
232 }
233 }
234
235 pub fn set_bool_value(&mut self, v: bool) {
237 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bool_value(v))
238 }
239
240 pub fn get_tensor_shape_value(&self) -> &super::tensor_shape::TensorShapeProto {
244 match self.kind {
245 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(ref v)) => v,
246 _ => super::tensor_shape::TensorShapeProto::default_instance(),
247 }
248 }
249 pub fn clear_tensor_shape_value(&mut self) {
250 self.kind = ::std::option::Option::None;
251 }
252
253 pub fn has_tensor_shape_value(&self) -> bool {
254 match self.kind {
255 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(..)) => true,
256 _ => false,
257 }
258 }
259
260 pub fn set_tensor_shape_value(&mut self, v: super::tensor_shape::TensorShapeProto) {
262 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(v))
263 }
264
265 pub fn mut_tensor_shape_value(&mut self) -> &mut super::tensor_shape::TensorShapeProto {
267 if let ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(_)) = self.kind {
268 } else {
269 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(super::tensor_shape::TensorShapeProto::new()));
270 }
271 match self.kind {
272 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(ref mut v)) => v,
273 _ => panic!(),
274 }
275 }
276
277 pub fn take_tensor_shape_value(&mut self) -> super::tensor_shape::TensorShapeProto {
279 if self.has_tensor_shape_value() {
280 match self.kind.take() {
281 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(v)) => v,
282 _ => panic!(),
283 }
284 } else {
285 super::tensor_shape::TensorShapeProto::new()
286 }
287 }
288
289 pub fn get_tensor_dtype_value(&self) -> super::types::DataType {
293 match self.kind {
294 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_dtype_value(v)) => v,
295 _ => super::types::DataType::DT_INVALID,
296 }
297 }
298 pub fn clear_tensor_dtype_value(&mut self) {
299 self.kind = ::std::option::Option::None;
300 }
301
302 pub fn has_tensor_dtype_value(&self) -> bool {
303 match self.kind {
304 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_dtype_value(..)) => true,
305 _ => false,
306 }
307 }
308
309 pub fn set_tensor_dtype_value(&mut self, v: super::types::DataType) {
311 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_dtype_value(v))
312 }
313
314 pub fn get_tensor_spec_value(&self) -> &TensorSpecProto {
318 match self.kind {
319 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(ref v)) => v,
320 _ => TensorSpecProto::default_instance(),
321 }
322 }
323 pub fn clear_tensor_spec_value(&mut self) {
324 self.kind = ::std::option::Option::None;
325 }
326
327 pub fn has_tensor_spec_value(&self) -> bool {
328 match self.kind {
329 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(..)) => true,
330 _ => false,
331 }
332 }
333
334 pub fn set_tensor_spec_value(&mut self, v: TensorSpecProto) {
336 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(v))
337 }
338
339 pub fn mut_tensor_spec_value(&mut self) -> &mut TensorSpecProto {
341 if let ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(_)) = self.kind {
342 } else {
343 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(TensorSpecProto::new()));
344 }
345 match self.kind {
346 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(ref mut v)) => v,
347 _ => panic!(),
348 }
349 }
350
351 pub fn take_tensor_spec_value(&mut self) -> TensorSpecProto {
353 if self.has_tensor_spec_value() {
354 match self.kind.take() {
355 ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(v)) => v,
356 _ => panic!(),
357 }
358 } else {
359 TensorSpecProto::new()
360 }
361 }
362
363 pub fn get_type_spec_value(&self) -> &TypeSpecProto {
367 match self.kind {
368 ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(ref v)) => v,
369 _ => TypeSpecProto::default_instance(),
370 }
371 }
372 pub fn clear_type_spec_value(&mut self) {
373 self.kind = ::std::option::Option::None;
374 }
375
376 pub fn has_type_spec_value(&self) -> bool {
377 match self.kind {
378 ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(..)) => true,
379 _ => false,
380 }
381 }
382
383 pub fn set_type_spec_value(&mut self, v: TypeSpecProto) {
385 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(v))
386 }
387
388 pub fn mut_type_spec_value(&mut self) -> &mut TypeSpecProto {
390 if let ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(_)) = self.kind {
391 } else {
392 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(TypeSpecProto::new()));
393 }
394 match self.kind {
395 ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(ref mut v)) => v,
396 _ => panic!(),
397 }
398 }
399
400 pub fn take_type_spec_value(&mut self) -> TypeSpecProto {
402 if self.has_type_spec_value() {
403 match self.kind.take() {
404 ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(v)) => v,
405 _ => panic!(),
406 }
407 } else {
408 TypeSpecProto::new()
409 }
410 }
411
412 pub fn get_bounded_tensor_spec_value(&self) -> &BoundedTensorSpecProto {
416 match self.kind {
417 ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(ref v)) => v,
418 _ => BoundedTensorSpecProto::default_instance(),
419 }
420 }
421 pub fn clear_bounded_tensor_spec_value(&mut self) {
422 self.kind = ::std::option::Option::None;
423 }
424
425 pub fn has_bounded_tensor_spec_value(&self) -> bool {
426 match self.kind {
427 ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(..)) => true,
428 _ => false,
429 }
430 }
431
432 pub fn set_bounded_tensor_spec_value(&mut self, v: BoundedTensorSpecProto) {
434 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(v))
435 }
436
437 pub fn mut_bounded_tensor_spec_value(&mut self) -> &mut BoundedTensorSpecProto {
439 if let ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(_)) = self.kind {
440 } else {
441 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(BoundedTensorSpecProto::new()));
442 }
443 match self.kind {
444 ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(ref mut v)) => v,
445 _ => panic!(),
446 }
447 }
448
449 pub fn take_bounded_tensor_spec_value(&mut self) -> BoundedTensorSpecProto {
451 if self.has_bounded_tensor_spec_value() {
452 match self.kind.take() {
453 ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(v)) => v,
454 _ => panic!(),
455 }
456 } else {
457 BoundedTensorSpecProto::new()
458 }
459 }
460
461 pub fn get_list_value(&self) -> &ListValue {
465 match self.kind {
466 ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(ref v)) => v,
467 _ => ListValue::default_instance(),
468 }
469 }
470 pub fn clear_list_value(&mut self) {
471 self.kind = ::std::option::Option::None;
472 }
473
474 pub fn has_list_value(&self) -> bool {
475 match self.kind {
476 ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(..)) => true,
477 _ => false,
478 }
479 }
480
481 pub fn set_list_value(&mut self, v: ListValue) {
483 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(v))
484 }
485
486 pub fn mut_list_value(&mut self) -> &mut ListValue {
488 if let ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(_)) = self.kind {
489 } else {
490 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(ListValue::new()));
491 }
492 match self.kind {
493 ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(ref mut v)) => v,
494 _ => panic!(),
495 }
496 }
497
498 pub fn take_list_value(&mut self) -> ListValue {
500 if self.has_list_value() {
501 match self.kind.take() {
502 ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(v)) => v,
503 _ => panic!(),
504 }
505 } else {
506 ListValue::new()
507 }
508 }
509
510 pub fn get_tuple_value(&self) -> &TupleValue {
514 match self.kind {
515 ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(ref v)) => v,
516 _ => TupleValue::default_instance(),
517 }
518 }
519 pub fn clear_tuple_value(&mut self) {
520 self.kind = ::std::option::Option::None;
521 }
522
523 pub fn has_tuple_value(&self) -> bool {
524 match self.kind {
525 ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(..)) => true,
526 _ => false,
527 }
528 }
529
530 pub fn set_tuple_value(&mut self, v: TupleValue) {
532 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(v))
533 }
534
535 pub fn mut_tuple_value(&mut self) -> &mut TupleValue {
537 if let ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(_)) = self.kind {
538 } else {
539 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(TupleValue::new()));
540 }
541 match self.kind {
542 ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(ref mut v)) => v,
543 _ => panic!(),
544 }
545 }
546
547 pub fn take_tuple_value(&mut self) -> TupleValue {
549 if self.has_tuple_value() {
550 match self.kind.take() {
551 ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(v)) => v,
552 _ => panic!(),
553 }
554 } else {
555 TupleValue::new()
556 }
557 }
558
559 pub fn get_dict_value(&self) -> &DictValue {
563 match self.kind {
564 ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(ref v)) => v,
565 _ => DictValue::default_instance(),
566 }
567 }
568 pub fn clear_dict_value(&mut self) {
569 self.kind = ::std::option::Option::None;
570 }
571
572 pub fn has_dict_value(&self) -> bool {
573 match self.kind {
574 ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(..)) => true,
575 _ => false,
576 }
577 }
578
579 pub fn set_dict_value(&mut self, v: DictValue) {
581 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(v))
582 }
583
584 pub fn mut_dict_value(&mut self) -> &mut DictValue {
586 if let ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(_)) = self.kind {
587 } else {
588 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(DictValue::new()));
589 }
590 match self.kind {
591 ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(ref mut v)) => v,
592 _ => panic!(),
593 }
594 }
595
596 pub fn take_dict_value(&mut self) -> DictValue {
598 if self.has_dict_value() {
599 match self.kind.take() {
600 ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(v)) => v,
601 _ => panic!(),
602 }
603 } else {
604 DictValue::new()
605 }
606 }
607
608 pub fn get_named_tuple_value(&self) -> &NamedTupleValue {
612 match self.kind {
613 ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(ref v)) => v,
614 _ => NamedTupleValue::default_instance(),
615 }
616 }
617 pub fn clear_named_tuple_value(&mut self) {
618 self.kind = ::std::option::Option::None;
619 }
620
621 pub fn has_named_tuple_value(&self) -> bool {
622 match self.kind {
623 ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(..)) => true,
624 _ => false,
625 }
626 }
627
628 pub fn set_named_tuple_value(&mut self, v: NamedTupleValue) {
630 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(v))
631 }
632
633 pub fn mut_named_tuple_value(&mut self) -> &mut NamedTupleValue {
635 if let ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(_)) = self.kind {
636 } else {
637 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(NamedTupleValue::new()));
638 }
639 match self.kind {
640 ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(ref mut v)) => v,
641 _ => panic!(),
642 }
643 }
644
645 pub fn take_named_tuple_value(&mut self) -> NamedTupleValue {
647 if self.has_named_tuple_value() {
648 match self.kind.take() {
649 ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(v)) => v,
650 _ => panic!(),
651 }
652 } else {
653 NamedTupleValue::new()
654 }
655 }
656}
657
658impl ::protobuf::Message for StructuredValue {
659 fn is_initialized(&self) -> bool {
660 if let Some(StructuredValue_oneof_kind::none_value(ref v)) = self.kind {
661 if !v.is_initialized() {
662 return false;
663 }
664 }
665 if let Some(StructuredValue_oneof_kind::tensor_shape_value(ref v)) = self.kind {
666 if !v.is_initialized() {
667 return false;
668 }
669 }
670 if let Some(StructuredValue_oneof_kind::tensor_spec_value(ref v)) = self.kind {
671 if !v.is_initialized() {
672 return false;
673 }
674 }
675 if let Some(StructuredValue_oneof_kind::type_spec_value(ref v)) = self.kind {
676 if !v.is_initialized() {
677 return false;
678 }
679 }
680 if let Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(ref v)) = self.kind {
681 if !v.is_initialized() {
682 return false;
683 }
684 }
685 if let Some(StructuredValue_oneof_kind::list_value(ref v)) = self.kind {
686 if !v.is_initialized() {
687 return false;
688 }
689 }
690 if let Some(StructuredValue_oneof_kind::tuple_value(ref v)) = self.kind {
691 if !v.is_initialized() {
692 return false;
693 }
694 }
695 if let Some(StructuredValue_oneof_kind::dict_value(ref v)) = self.kind {
696 if !v.is_initialized() {
697 return false;
698 }
699 }
700 if let Some(StructuredValue_oneof_kind::named_tuple_value(ref v)) = self.kind {
701 if !v.is_initialized() {
702 return false;
703 }
704 }
705 true
706 }
707
708 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
709 while !is.eof()? {
710 let (field_number, wire_type) = is.read_tag_unpack()?;
711 match field_number {
712 1 => {
713 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
714 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
715 }
716 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::none_value(is.read_message()?));
717 },
718 11 => {
719 if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
720 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
721 }
722 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::float64_value(is.read_double()?));
723 },
724 12 => {
725 if wire_type != ::protobuf::wire_format::WireTypeVarint {
726 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
727 }
728 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::int64_value(is.read_sint64()?));
729 },
730 13 => {
731 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
732 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
733 }
734 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::string_value(is.read_string()?));
735 },
736 14 => {
737 if wire_type != ::protobuf::wire_format::WireTypeVarint {
738 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
739 }
740 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bool_value(is.read_bool()?));
741 },
742 31 => {
743 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
744 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
745 }
746 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_shape_value(is.read_message()?));
747 },
748 32 => {
749 if wire_type != ::protobuf::wire_format::WireTypeVarint {
750 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
751 }
752 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_dtype_value(is.read_enum()?));
753 },
754 33 => {
755 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
756 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
757 }
758 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tensor_spec_value(is.read_message()?));
759 },
760 34 => {
761 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
762 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
763 }
764 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::type_spec_value(is.read_message()?));
765 },
766 35 => {
767 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
768 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
769 }
770 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::bounded_tensor_spec_value(is.read_message()?));
771 },
772 51 => {
773 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
774 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
775 }
776 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::list_value(is.read_message()?));
777 },
778 52 => {
779 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
780 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
781 }
782 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::tuple_value(is.read_message()?));
783 },
784 53 => {
785 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
786 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
787 }
788 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::dict_value(is.read_message()?));
789 },
790 54 => {
791 if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
792 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
793 }
794 self.kind = ::std::option::Option::Some(StructuredValue_oneof_kind::named_tuple_value(is.read_message()?));
795 },
796 _ => {
797 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
798 },
799 };
800 }
801 ::std::result::Result::Ok(())
802 }
803
804 #[allow(unused_variables)]
806 fn compute_size(&self) -> u32 {
807 let mut my_size = 0;
808 if let ::std::option::Option::Some(ref v) = self.kind {
809 match v {
810 &StructuredValue_oneof_kind::none_value(ref v) => {
811 let len = v.compute_size();
812 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
813 },
814 &StructuredValue_oneof_kind::float64_value(v) => {
815 my_size += 9;
816 },
817 &StructuredValue_oneof_kind::int64_value(v) => {
818 my_size += ::protobuf::rt::value_varint_zigzag_size(12, v);
819 },
820 &StructuredValue_oneof_kind::string_value(ref v) => {
821 my_size += ::protobuf::rt::string_size(13, &v);
822 },
823 &StructuredValue_oneof_kind::bool_value(v) => {
824 my_size += 2;
825 },
826 &StructuredValue_oneof_kind::tensor_shape_value(ref v) => {
827 let len = v.compute_size();
828 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
829 },
830 &StructuredValue_oneof_kind::tensor_dtype_value(v) => {
831 my_size += ::protobuf::rt::enum_size(32, v);
832 },
833 &StructuredValue_oneof_kind::tensor_spec_value(ref v) => {
834 let len = v.compute_size();
835 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
836 },
837 &StructuredValue_oneof_kind::type_spec_value(ref v) => {
838 let len = v.compute_size();
839 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
840 },
841 &StructuredValue_oneof_kind::bounded_tensor_spec_value(ref v) => {
842 let len = v.compute_size();
843 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
844 },
845 &StructuredValue_oneof_kind::list_value(ref v) => {
846 let len = v.compute_size();
847 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
848 },
849 &StructuredValue_oneof_kind::tuple_value(ref v) => {
850 let len = v.compute_size();
851 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
852 },
853 &StructuredValue_oneof_kind::dict_value(ref v) => {
854 let len = v.compute_size();
855 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
856 },
857 &StructuredValue_oneof_kind::named_tuple_value(ref v) => {
858 let len = v.compute_size();
859 my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
860 },
861 };
862 }
863 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
864 self.cached_size.set(my_size);
865 my_size
866 }
867
868 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
869 if let ::std::option::Option::Some(ref v) = self.kind {
870 match v {
871 &StructuredValue_oneof_kind::none_value(ref v) => {
872 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
873 os.write_raw_varint32(v.get_cached_size())?;
874 v.write_to_with_cached_sizes(os)?;
875 },
876 &StructuredValue_oneof_kind::float64_value(v) => {
877 os.write_double(11, v)?;
878 },
879 &StructuredValue_oneof_kind::int64_value(v) => {
880 os.write_sint64(12, v)?;
881 },
882 &StructuredValue_oneof_kind::string_value(ref v) => {
883 os.write_string(13, v)?;
884 },
885 &StructuredValue_oneof_kind::bool_value(v) => {
886 os.write_bool(14, v)?;
887 },
888 &StructuredValue_oneof_kind::tensor_shape_value(ref v) => {
889 os.write_tag(31, ::protobuf::wire_format::WireTypeLengthDelimited)?;
890 os.write_raw_varint32(v.get_cached_size())?;
891 v.write_to_with_cached_sizes(os)?;
892 },
893 &StructuredValue_oneof_kind::tensor_dtype_value(v) => {
894 os.write_enum(32, v.value())?;
895 },
896 &StructuredValue_oneof_kind::tensor_spec_value(ref v) => {
897 os.write_tag(33, ::protobuf::wire_format::WireTypeLengthDelimited)?;
898 os.write_raw_varint32(v.get_cached_size())?;
899 v.write_to_with_cached_sizes(os)?;
900 },
901 &StructuredValue_oneof_kind::type_spec_value(ref v) => {
902 os.write_tag(34, ::protobuf::wire_format::WireTypeLengthDelimited)?;
903 os.write_raw_varint32(v.get_cached_size())?;
904 v.write_to_with_cached_sizes(os)?;
905 },
906 &StructuredValue_oneof_kind::bounded_tensor_spec_value(ref v) => {
907 os.write_tag(35, ::protobuf::wire_format::WireTypeLengthDelimited)?;
908 os.write_raw_varint32(v.get_cached_size())?;
909 v.write_to_with_cached_sizes(os)?;
910 },
911 &StructuredValue_oneof_kind::list_value(ref v) => {
912 os.write_tag(51, ::protobuf::wire_format::WireTypeLengthDelimited)?;
913 os.write_raw_varint32(v.get_cached_size())?;
914 v.write_to_with_cached_sizes(os)?;
915 },
916 &StructuredValue_oneof_kind::tuple_value(ref v) => {
917 os.write_tag(52, ::protobuf::wire_format::WireTypeLengthDelimited)?;
918 os.write_raw_varint32(v.get_cached_size())?;
919 v.write_to_with_cached_sizes(os)?;
920 },
921 &StructuredValue_oneof_kind::dict_value(ref v) => {
922 os.write_tag(53, ::protobuf::wire_format::WireTypeLengthDelimited)?;
923 os.write_raw_varint32(v.get_cached_size())?;
924 v.write_to_with_cached_sizes(os)?;
925 },
926 &StructuredValue_oneof_kind::named_tuple_value(ref v) => {
927 os.write_tag(54, ::protobuf::wire_format::WireTypeLengthDelimited)?;
928 os.write_raw_varint32(v.get_cached_size())?;
929 v.write_to_with_cached_sizes(os)?;
930 },
931 };
932 }
933 os.write_unknown_fields(self.get_unknown_fields())?;
934 ::std::result::Result::Ok(())
935 }
936
937 fn get_cached_size(&self) -> u32 {
938 self.cached_size.get()
939 }
940
941 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
942 &self.unknown_fields
943 }
944
945 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
946 &mut self.unknown_fields
947 }
948
949 fn as_any(&self) -> &dyn (::std::any::Any) {
950 self as &dyn (::std::any::Any)
951 }
952 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
953 self as &mut dyn (::std::any::Any)
954 }
955 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
956 self
957 }
958
959 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
960 Self::descriptor_static()
961 }
962
963 fn new() -> StructuredValue {
964 StructuredValue::new()
965 }
966
967 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
968 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
969 unsafe {
970 descriptor.get(|| {
971 let mut fields = ::std::vec::Vec::new();
972 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, NoneValue>(
973 "none_value",
974 StructuredValue::has_none_value,
975 StructuredValue::get_none_value,
976 ));
977 fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>(
978 "float64_value",
979 StructuredValue::has_float64_value,
980 StructuredValue::get_float64_value,
981 ));
982 fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
983 "int64_value",
984 StructuredValue::has_int64_value,
985 StructuredValue::get_int64_value,
986 ));
987 fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
988 "string_value",
989 StructuredValue::has_string_value,
990 StructuredValue::get_string_value,
991 ));
992 fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
993 "bool_value",
994 StructuredValue::has_bool_value,
995 StructuredValue::get_bool_value,
996 ));
997 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::tensor_shape::TensorShapeProto>(
998 "tensor_shape_value",
999 StructuredValue::has_tensor_shape_value,
1000 StructuredValue::get_tensor_shape_value,
1001 ));
1002 fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor::<_, super::types::DataType>(
1003 "tensor_dtype_value",
1004 StructuredValue::has_tensor_dtype_value,
1005 StructuredValue::get_tensor_dtype_value,
1006 ));
1007 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TensorSpecProto>(
1008 "tensor_spec_value",
1009 StructuredValue::has_tensor_spec_value,
1010 StructuredValue::get_tensor_spec_value,
1011 ));
1012 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TypeSpecProto>(
1013 "type_spec_value",
1014 StructuredValue::has_type_spec_value,
1015 StructuredValue::get_type_spec_value,
1016 ));
1017 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, BoundedTensorSpecProto>(
1018 "bounded_tensor_spec_value",
1019 StructuredValue::has_bounded_tensor_spec_value,
1020 StructuredValue::get_bounded_tensor_spec_value,
1021 ));
1022 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ListValue>(
1023 "list_value",
1024 StructuredValue::has_list_value,
1025 StructuredValue::get_list_value,
1026 ));
1027 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TupleValue>(
1028 "tuple_value",
1029 StructuredValue::has_tuple_value,
1030 StructuredValue::get_tuple_value,
1031 ));
1032 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, DictValue>(
1033 "dict_value",
1034 StructuredValue::has_dict_value,
1035 StructuredValue::get_dict_value,
1036 ));
1037 fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, NamedTupleValue>(
1038 "named_tuple_value",
1039 StructuredValue::has_named_tuple_value,
1040 StructuredValue::get_named_tuple_value,
1041 ));
1042 ::protobuf::reflect::MessageDescriptor::new_pb_name::<StructuredValue>(
1043 "StructuredValue",
1044 fields,
1045 file_descriptor_proto()
1046 )
1047 })
1048 }
1049 }
1050
1051 fn default_instance() -> &'static StructuredValue {
1052 static mut instance: ::protobuf::lazy::Lazy<StructuredValue> = ::protobuf::lazy::Lazy::INIT;
1053 unsafe {
1054 instance.get(StructuredValue::new)
1055 }
1056 }
1057}
1058
1059impl ::protobuf::Clear for StructuredValue {
1060 fn clear(&mut self) {
1061 self.kind = ::std::option::Option::None;
1062 self.kind = ::std::option::Option::None;
1063 self.kind = ::std::option::Option::None;
1064 self.kind = ::std::option::Option::None;
1065 self.kind = ::std::option::Option::None;
1066 self.kind = ::std::option::Option::None;
1067 self.kind = ::std::option::Option::None;
1068 self.kind = ::std::option::Option::None;
1069 self.kind = ::std::option::Option::None;
1070 self.kind = ::std::option::Option::None;
1071 self.kind = ::std::option::Option::None;
1072 self.kind = ::std::option::Option::None;
1073 self.kind = ::std::option::Option::None;
1074 self.kind = ::std::option::Option::None;
1075 self.unknown_fields.clear();
1076 }
1077}
1078
1079impl ::std::fmt::Debug for StructuredValue {
1080 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1081 ::protobuf::text_format::fmt(self, f)
1082 }
1083}
1084
1085impl ::protobuf::reflect::ProtobufValue for StructuredValue {
1086 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1087 ::protobuf::reflect::ReflectValueRef::Message(self)
1088 }
1089}
1090
1091#[derive(PartialEq,Clone,Default)]
1092pub struct NoneValue {
1093 pub unknown_fields: ::protobuf::UnknownFields,
1095 pub cached_size: ::protobuf::CachedSize,
1096}
1097
1098impl<'a> ::std::default::Default for &'a NoneValue {
1099 fn default() -> &'a NoneValue {
1100 <NoneValue as ::protobuf::Message>::default_instance()
1101 }
1102}
1103
1104impl NoneValue {
1105 pub fn new() -> NoneValue {
1106 ::std::default::Default::default()
1107 }
1108}
1109
1110impl ::protobuf::Message for NoneValue {
1111 fn is_initialized(&self) -> bool {
1112 true
1113 }
1114
1115 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1116 while !is.eof()? {
1117 let (field_number, wire_type) = is.read_tag_unpack()?;
1118 match field_number {
1119 _ => {
1120 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1121 },
1122 };
1123 }
1124 ::std::result::Result::Ok(())
1125 }
1126
1127 #[allow(unused_variables)]
1129 fn compute_size(&self) -> u32 {
1130 let mut my_size = 0;
1131 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1132 self.cached_size.set(my_size);
1133 my_size
1134 }
1135
1136 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1137 os.write_unknown_fields(self.get_unknown_fields())?;
1138 ::std::result::Result::Ok(())
1139 }
1140
1141 fn get_cached_size(&self) -> u32 {
1142 self.cached_size.get()
1143 }
1144
1145 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1146 &self.unknown_fields
1147 }
1148
1149 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1150 &mut self.unknown_fields
1151 }
1152
1153 fn as_any(&self) -> &dyn (::std::any::Any) {
1154 self as &dyn (::std::any::Any)
1155 }
1156 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1157 self as &mut dyn (::std::any::Any)
1158 }
1159 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1160 self
1161 }
1162
1163 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1164 Self::descriptor_static()
1165 }
1166
1167 fn new() -> NoneValue {
1168 NoneValue::new()
1169 }
1170
1171 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1172 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
1173 unsafe {
1174 descriptor.get(|| {
1175 let fields = ::std::vec::Vec::new();
1176 ::protobuf::reflect::MessageDescriptor::new_pb_name::<NoneValue>(
1177 "NoneValue",
1178 fields,
1179 file_descriptor_proto()
1180 )
1181 })
1182 }
1183 }
1184
1185 fn default_instance() -> &'static NoneValue {
1186 static mut instance: ::protobuf::lazy::Lazy<NoneValue> = ::protobuf::lazy::Lazy::INIT;
1187 unsafe {
1188 instance.get(NoneValue::new)
1189 }
1190 }
1191}
1192
1193impl ::protobuf::Clear for NoneValue {
1194 fn clear(&mut self) {
1195 self.unknown_fields.clear();
1196 }
1197}
1198
1199impl ::std::fmt::Debug for NoneValue {
1200 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1201 ::protobuf::text_format::fmt(self, f)
1202 }
1203}
1204
1205impl ::protobuf::reflect::ProtobufValue for NoneValue {
1206 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1207 ::protobuf::reflect::ReflectValueRef::Message(self)
1208 }
1209}
1210
1211#[derive(PartialEq,Clone,Default)]
1212pub struct ListValue {
1213 pub values: ::protobuf::RepeatedField<StructuredValue>,
1215 pub unknown_fields: ::protobuf::UnknownFields,
1217 pub cached_size: ::protobuf::CachedSize,
1218}
1219
1220impl<'a> ::std::default::Default for &'a ListValue {
1221 fn default() -> &'a ListValue {
1222 <ListValue as ::protobuf::Message>::default_instance()
1223 }
1224}
1225
1226impl ListValue {
1227 pub fn new() -> ListValue {
1228 ::std::default::Default::default()
1229 }
1230
1231 pub fn get_values(&self) -> &[StructuredValue] {
1235 &self.values
1236 }
1237 pub fn clear_values(&mut self) {
1238 self.values.clear();
1239 }
1240
1241 pub fn set_values(&mut self, v: ::protobuf::RepeatedField<StructuredValue>) {
1243 self.values = v;
1244 }
1245
1246 pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<StructuredValue> {
1248 &mut self.values
1249 }
1250
1251 pub fn take_values(&mut self) -> ::protobuf::RepeatedField<StructuredValue> {
1253 ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new())
1254 }
1255}
1256
1257impl ::protobuf::Message for ListValue {
1258 fn is_initialized(&self) -> bool {
1259 for v in &self.values {
1260 if !v.is_initialized() {
1261 return false;
1262 }
1263 };
1264 true
1265 }
1266
1267 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1268 while !is.eof()? {
1269 let (field_number, wire_type) = is.read_tag_unpack()?;
1270 match field_number {
1271 1 => {
1272 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
1273 },
1274 _ => {
1275 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1276 },
1277 };
1278 }
1279 ::std::result::Result::Ok(())
1280 }
1281
1282 #[allow(unused_variables)]
1284 fn compute_size(&self) -> u32 {
1285 let mut my_size = 0;
1286 for value in &self.values {
1287 let len = value.compute_size();
1288 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1289 };
1290 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1291 self.cached_size.set(my_size);
1292 my_size
1293 }
1294
1295 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1296 for v in &self.values {
1297 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1298 os.write_raw_varint32(v.get_cached_size())?;
1299 v.write_to_with_cached_sizes(os)?;
1300 };
1301 os.write_unknown_fields(self.get_unknown_fields())?;
1302 ::std::result::Result::Ok(())
1303 }
1304
1305 fn get_cached_size(&self) -> u32 {
1306 self.cached_size.get()
1307 }
1308
1309 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1310 &self.unknown_fields
1311 }
1312
1313 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1314 &mut self.unknown_fields
1315 }
1316
1317 fn as_any(&self) -> &dyn (::std::any::Any) {
1318 self as &dyn (::std::any::Any)
1319 }
1320 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1321 self as &mut dyn (::std::any::Any)
1322 }
1323 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1324 self
1325 }
1326
1327 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1328 Self::descriptor_static()
1329 }
1330
1331 fn new() -> ListValue {
1332 ListValue::new()
1333 }
1334
1335 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1336 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
1337 unsafe {
1338 descriptor.get(|| {
1339 let mut fields = ::std::vec::Vec::new();
1340 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
1341 "values",
1342 |m: &ListValue| { &m.values },
1343 |m: &mut ListValue| { &mut m.values },
1344 ));
1345 ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListValue>(
1346 "ListValue",
1347 fields,
1348 file_descriptor_proto()
1349 )
1350 })
1351 }
1352 }
1353
1354 fn default_instance() -> &'static ListValue {
1355 static mut instance: ::protobuf::lazy::Lazy<ListValue> = ::protobuf::lazy::Lazy::INIT;
1356 unsafe {
1357 instance.get(ListValue::new)
1358 }
1359 }
1360}
1361
1362impl ::protobuf::Clear for ListValue {
1363 fn clear(&mut self) {
1364 self.values.clear();
1365 self.unknown_fields.clear();
1366 }
1367}
1368
1369impl ::std::fmt::Debug for ListValue {
1370 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1371 ::protobuf::text_format::fmt(self, f)
1372 }
1373}
1374
1375impl ::protobuf::reflect::ProtobufValue for ListValue {
1376 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1377 ::protobuf::reflect::ReflectValueRef::Message(self)
1378 }
1379}
1380
1381#[derive(PartialEq,Clone,Default)]
1382pub struct TupleValue {
1383 pub values: ::protobuf::RepeatedField<StructuredValue>,
1385 pub unknown_fields: ::protobuf::UnknownFields,
1387 pub cached_size: ::protobuf::CachedSize,
1388}
1389
1390impl<'a> ::std::default::Default for &'a TupleValue {
1391 fn default() -> &'a TupleValue {
1392 <TupleValue as ::protobuf::Message>::default_instance()
1393 }
1394}
1395
1396impl TupleValue {
1397 pub fn new() -> TupleValue {
1398 ::std::default::Default::default()
1399 }
1400
1401 pub fn get_values(&self) -> &[StructuredValue] {
1405 &self.values
1406 }
1407 pub fn clear_values(&mut self) {
1408 self.values.clear();
1409 }
1410
1411 pub fn set_values(&mut self, v: ::protobuf::RepeatedField<StructuredValue>) {
1413 self.values = v;
1414 }
1415
1416 pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<StructuredValue> {
1418 &mut self.values
1419 }
1420
1421 pub fn take_values(&mut self) -> ::protobuf::RepeatedField<StructuredValue> {
1423 ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new())
1424 }
1425}
1426
1427impl ::protobuf::Message for TupleValue {
1428 fn is_initialized(&self) -> bool {
1429 for v in &self.values {
1430 if !v.is_initialized() {
1431 return false;
1432 }
1433 };
1434 true
1435 }
1436
1437 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1438 while !is.eof()? {
1439 let (field_number, wire_type) = is.read_tag_unpack()?;
1440 match field_number {
1441 1 => {
1442 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
1443 },
1444 _ => {
1445 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1446 },
1447 };
1448 }
1449 ::std::result::Result::Ok(())
1450 }
1451
1452 #[allow(unused_variables)]
1454 fn compute_size(&self) -> u32 {
1455 let mut my_size = 0;
1456 for value in &self.values {
1457 let len = value.compute_size();
1458 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1459 };
1460 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1461 self.cached_size.set(my_size);
1462 my_size
1463 }
1464
1465 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1466 for v in &self.values {
1467 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1468 os.write_raw_varint32(v.get_cached_size())?;
1469 v.write_to_with_cached_sizes(os)?;
1470 };
1471 os.write_unknown_fields(self.get_unknown_fields())?;
1472 ::std::result::Result::Ok(())
1473 }
1474
1475 fn get_cached_size(&self) -> u32 {
1476 self.cached_size.get()
1477 }
1478
1479 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1480 &self.unknown_fields
1481 }
1482
1483 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1484 &mut self.unknown_fields
1485 }
1486
1487 fn as_any(&self) -> &dyn (::std::any::Any) {
1488 self as &dyn (::std::any::Any)
1489 }
1490 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1491 self as &mut dyn (::std::any::Any)
1492 }
1493 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1494 self
1495 }
1496
1497 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1498 Self::descriptor_static()
1499 }
1500
1501 fn new() -> TupleValue {
1502 TupleValue::new()
1503 }
1504
1505 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1506 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
1507 unsafe {
1508 descriptor.get(|| {
1509 let mut fields = ::std::vec::Vec::new();
1510 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
1511 "values",
1512 |m: &TupleValue| { &m.values },
1513 |m: &mut TupleValue| { &mut m.values },
1514 ));
1515 ::protobuf::reflect::MessageDescriptor::new_pb_name::<TupleValue>(
1516 "TupleValue",
1517 fields,
1518 file_descriptor_proto()
1519 )
1520 })
1521 }
1522 }
1523
1524 fn default_instance() -> &'static TupleValue {
1525 static mut instance: ::protobuf::lazy::Lazy<TupleValue> = ::protobuf::lazy::Lazy::INIT;
1526 unsafe {
1527 instance.get(TupleValue::new)
1528 }
1529 }
1530}
1531
1532impl ::protobuf::Clear for TupleValue {
1533 fn clear(&mut self) {
1534 self.values.clear();
1535 self.unknown_fields.clear();
1536 }
1537}
1538
1539impl ::std::fmt::Debug for TupleValue {
1540 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1541 ::protobuf::text_format::fmt(self, f)
1542 }
1543}
1544
1545impl ::protobuf::reflect::ProtobufValue for TupleValue {
1546 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1547 ::protobuf::reflect::ReflectValueRef::Message(self)
1548 }
1549}
1550
1551#[derive(PartialEq,Clone,Default)]
1552pub struct DictValue {
1553 pub fields: ::std::collections::HashMap<::std::string::String, StructuredValue>,
1555 pub unknown_fields: ::protobuf::UnknownFields,
1557 pub cached_size: ::protobuf::CachedSize,
1558}
1559
1560impl<'a> ::std::default::Default for &'a DictValue {
1561 fn default() -> &'a DictValue {
1562 <DictValue as ::protobuf::Message>::default_instance()
1563 }
1564}
1565
1566impl DictValue {
1567 pub fn new() -> DictValue {
1568 ::std::default::Default::default()
1569 }
1570
1571 pub fn get_fields(&self) -> &::std::collections::HashMap<::std::string::String, StructuredValue> {
1575 &self.fields
1576 }
1577 pub fn clear_fields(&mut self) {
1578 self.fields.clear();
1579 }
1580
1581 pub fn set_fields(&mut self, v: ::std::collections::HashMap<::std::string::String, StructuredValue>) {
1583 self.fields = v;
1584 }
1585
1586 pub fn mut_fields(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, StructuredValue> {
1588 &mut self.fields
1589 }
1590
1591 pub fn take_fields(&mut self) -> ::std::collections::HashMap<::std::string::String, StructuredValue> {
1593 ::std::mem::replace(&mut self.fields, ::std::collections::HashMap::new())
1594 }
1595}
1596
1597impl ::protobuf::Message for DictValue {
1598 fn is_initialized(&self) -> bool {
1599 true
1600 }
1601
1602 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1603 while !is.eof()? {
1604 let (field_number, wire_type) = is.read_tag_unpack()?;
1605 match field_number {
1606 1 => {
1607 ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(wire_type, is, &mut self.fields)?;
1608 },
1609 _ => {
1610 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1611 },
1612 };
1613 }
1614 ::std::result::Result::Ok(())
1615 }
1616
1617 #[allow(unused_variables)]
1619 fn compute_size(&self) -> u32 {
1620 let mut my_size = 0;
1621 my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(1, &self.fields);
1622 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1623 self.cached_size.set(my_size);
1624 my_size
1625 }
1626
1627 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1628 ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(1, &self.fields, os)?;
1629 os.write_unknown_fields(self.get_unknown_fields())?;
1630 ::std::result::Result::Ok(())
1631 }
1632
1633 fn get_cached_size(&self) -> u32 {
1634 self.cached_size.get()
1635 }
1636
1637 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1638 &self.unknown_fields
1639 }
1640
1641 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1642 &mut self.unknown_fields
1643 }
1644
1645 fn as_any(&self) -> &dyn (::std::any::Any) {
1646 self as &dyn (::std::any::Any)
1647 }
1648 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1649 self as &mut dyn (::std::any::Any)
1650 }
1651 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1652 self
1653 }
1654
1655 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1656 Self::descriptor_static()
1657 }
1658
1659 fn new() -> DictValue {
1660 DictValue::new()
1661 }
1662
1663 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1664 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
1665 unsafe {
1666 descriptor.get(|| {
1667 let mut fields = ::std::vec::Vec::new();
1668 fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
1669 "fields",
1670 |m: &DictValue| { &m.fields },
1671 |m: &mut DictValue| { &mut m.fields },
1672 ));
1673 ::protobuf::reflect::MessageDescriptor::new_pb_name::<DictValue>(
1674 "DictValue",
1675 fields,
1676 file_descriptor_proto()
1677 )
1678 })
1679 }
1680 }
1681
1682 fn default_instance() -> &'static DictValue {
1683 static mut instance: ::protobuf::lazy::Lazy<DictValue> = ::protobuf::lazy::Lazy::INIT;
1684 unsafe {
1685 instance.get(DictValue::new)
1686 }
1687 }
1688}
1689
1690impl ::protobuf::Clear for DictValue {
1691 fn clear(&mut self) {
1692 self.fields.clear();
1693 self.unknown_fields.clear();
1694 }
1695}
1696
1697impl ::std::fmt::Debug for DictValue {
1698 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1699 ::protobuf::text_format::fmt(self, f)
1700 }
1701}
1702
1703impl ::protobuf::reflect::ProtobufValue for DictValue {
1704 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1705 ::protobuf::reflect::ReflectValueRef::Message(self)
1706 }
1707}
1708
1709#[derive(PartialEq,Clone,Default)]
1710pub struct PairValue {
1711 pub key: ::std::string::String,
1713 pub value: ::protobuf::SingularPtrField<StructuredValue>,
1714 pub unknown_fields: ::protobuf::UnknownFields,
1716 pub cached_size: ::protobuf::CachedSize,
1717}
1718
1719impl<'a> ::std::default::Default for &'a PairValue {
1720 fn default() -> &'a PairValue {
1721 <PairValue as ::protobuf::Message>::default_instance()
1722 }
1723}
1724
1725impl PairValue {
1726 pub fn new() -> PairValue {
1727 ::std::default::Default::default()
1728 }
1729
1730 pub fn get_key(&self) -> &str {
1734 &self.key
1735 }
1736 pub fn clear_key(&mut self) {
1737 self.key.clear();
1738 }
1739
1740 pub fn set_key(&mut self, v: ::std::string::String) {
1742 self.key = v;
1743 }
1744
1745 pub fn mut_key(&mut self) -> &mut ::std::string::String {
1748 &mut self.key
1749 }
1750
1751 pub fn take_key(&mut self) -> ::std::string::String {
1753 ::std::mem::replace(&mut self.key, ::std::string::String::new())
1754 }
1755
1756 pub fn get_value(&self) -> &StructuredValue {
1760 self.value.as_ref().unwrap_or_else(|| StructuredValue::default_instance())
1761 }
1762 pub fn clear_value(&mut self) {
1763 self.value.clear();
1764 }
1765
1766 pub fn has_value(&self) -> bool {
1767 self.value.is_some()
1768 }
1769
1770 pub fn set_value(&mut self, v: StructuredValue) {
1772 self.value = ::protobuf::SingularPtrField::some(v);
1773 }
1774
1775 pub fn mut_value(&mut self) -> &mut StructuredValue {
1778 if self.value.is_none() {
1779 self.value.set_default();
1780 }
1781 self.value.as_mut().unwrap()
1782 }
1783
1784 pub fn take_value(&mut self) -> StructuredValue {
1786 self.value.take().unwrap_or_else(|| StructuredValue::new())
1787 }
1788}
1789
1790impl ::protobuf::Message for PairValue {
1791 fn is_initialized(&self) -> bool {
1792 for v in &self.value {
1793 if !v.is_initialized() {
1794 return false;
1795 }
1796 };
1797 true
1798 }
1799
1800 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1801 while !is.eof()? {
1802 let (field_number, wire_type) = is.read_tag_unpack()?;
1803 match field_number {
1804 1 => {
1805 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.key)?;
1806 },
1807 2 => {
1808 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
1809 },
1810 _ => {
1811 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1812 },
1813 };
1814 }
1815 ::std::result::Result::Ok(())
1816 }
1817
1818 #[allow(unused_variables)]
1820 fn compute_size(&self) -> u32 {
1821 let mut my_size = 0;
1822 if !self.key.is_empty() {
1823 my_size += ::protobuf::rt::string_size(1, &self.key);
1824 }
1825 if let Some(ref v) = self.value.as_ref() {
1826 let len = v.compute_size();
1827 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1828 }
1829 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1830 self.cached_size.set(my_size);
1831 my_size
1832 }
1833
1834 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1835 if !self.key.is_empty() {
1836 os.write_string(1, &self.key)?;
1837 }
1838 if let Some(ref v) = self.value.as_ref() {
1839 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1840 os.write_raw_varint32(v.get_cached_size())?;
1841 v.write_to_with_cached_sizes(os)?;
1842 }
1843 os.write_unknown_fields(self.get_unknown_fields())?;
1844 ::std::result::Result::Ok(())
1845 }
1846
1847 fn get_cached_size(&self) -> u32 {
1848 self.cached_size.get()
1849 }
1850
1851 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1852 &self.unknown_fields
1853 }
1854
1855 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1856 &mut self.unknown_fields
1857 }
1858
1859 fn as_any(&self) -> &dyn (::std::any::Any) {
1860 self as &dyn (::std::any::Any)
1861 }
1862 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1863 self as &mut dyn (::std::any::Any)
1864 }
1865 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1866 self
1867 }
1868
1869 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1870 Self::descriptor_static()
1871 }
1872
1873 fn new() -> PairValue {
1874 PairValue::new()
1875 }
1876
1877 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1878 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
1879 unsafe {
1880 descriptor.get(|| {
1881 let mut fields = ::std::vec::Vec::new();
1882 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1883 "key",
1884 |m: &PairValue| { &m.key },
1885 |m: &mut PairValue| { &mut m.key },
1886 ));
1887 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
1888 "value",
1889 |m: &PairValue| { &m.value },
1890 |m: &mut PairValue| { &mut m.value },
1891 ));
1892 ::protobuf::reflect::MessageDescriptor::new_pb_name::<PairValue>(
1893 "PairValue",
1894 fields,
1895 file_descriptor_proto()
1896 )
1897 })
1898 }
1899 }
1900
1901 fn default_instance() -> &'static PairValue {
1902 static mut instance: ::protobuf::lazy::Lazy<PairValue> = ::protobuf::lazy::Lazy::INIT;
1903 unsafe {
1904 instance.get(PairValue::new)
1905 }
1906 }
1907}
1908
1909impl ::protobuf::Clear for PairValue {
1910 fn clear(&mut self) {
1911 self.key.clear();
1912 self.value.clear();
1913 self.unknown_fields.clear();
1914 }
1915}
1916
1917impl ::std::fmt::Debug for PairValue {
1918 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1919 ::protobuf::text_format::fmt(self, f)
1920 }
1921}
1922
1923impl ::protobuf::reflect::ProtobufValue for PairValue {
1924 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1925 ::protobuf::reflect::ReflectValueRef::Message(self)
1926 }
1927}
1928
1929#[derive(PartialEq,Clone,Default)]
1930pub struct NamedTupleValue {
1931 pub name: ::std::string::String,
1933 pub values: ::protobuf::RepeatedField<PairValue>,
1934 pub unknown_fields: ::protobuf::UnknownFields,
1936 pub cached_size: ::protobuf::CachedSize,
1937}
1938
1939impl<'a> ::std::default::Default for &'a NamedTupleValue {
1940 fn default() -> &'a NamedTupleValue {
1941 <NamedTupleValue as ::protobuf::Message>::default_instance()
1942 }
1943}
1944
1945impl NamedTupleValue {
1946 pub fn new() -> NamedTupleValue {
1947 ::std::default::Default::default()
1948 }
1949
1950 pub fn get_name(&self) -> &str {
1954 &self.name
1955 }
1956 pub fn clear_name(&mut self) {
1957 self.name.clear();
1958 }
1959
1960 pub fn set_name(&mut self, v: ::std::string::String) {
1962 self.name = v;
1963 }
1964
1965 pub fn mut_name(&mut self) -> &mut ::std::string::String {
1968 &mut self.name
1969 }
1970
1971 pub fn take_name(&mut self) -> ::std::string::String {
1973 ::std::mem::replace(&mut self.name, ::std::string::String::new())
1974 }
1975
1976 pub fn get_values(&self) -> &[PairValue] {
1980 &self.values
1981 }
1982 pub fn clear_values(&mut self) {
1983 self.values.clear();
1984 }
1985
1986 pub fn set_values(&mut self, v: ::protobuf::RepeatedField<PairValue>) {
1988 self.values = v;
1989 }
1990
1991 pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<PairValue> {
1993 &mut self.values
1994 }
1995
1996 pub fn take_values(&mut self) -> ::protobuf::RepeatedField<PairValue> {
1998 ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new())
1999 }
2000}
2001
2002impl ::protobuf::Message for NamedTupleValue {
2003 fn is_initialized(&self) -> bool {
2004 for v in &self.values {
2005 if !v.is_initialized() {
2006 return false;
2007 }
2008 };
2009 true
2010 }
2011
2012 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2013 while !is.eof()? {
2014 let (field_number, wire_type) = is.read_tag_unpack()?;
2015 match field_number {
2016 1 => {
2017 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2018 },
2019 2 => {
2020 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
2021 },
2022 _ => {
2023 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2024 },
2025 };
2026 }
2027 ::std::result::Result::Ok(())
2028 }
2029
2030 #[allow(unused_variables)]
2032 fn compute_size(&self) -> u32 {
2033 let mut my_size = 0;
2034 if !self.name.is_empty() {
2035 my_size += ::protobuf::rt::string_size(1, &self.name);
2036 }
2037 for value in &self.values {
2038 let len = value.compute_size();
2039 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2040 };
2041 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2042 self.cached_size.set(my_size);
2043 my_size
2044 }
2045
2046 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2047 if !self.name.is_empty() {
2048 os.write_string(1, &self.name)?;
2049 }
2050 for v in &self.values {
2051 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2052 os.write_raw_varint32(v.get_cached_size())?;
2053 v.write_to_with_cached_sizes(os)?;
2054 };
2055 os.write_unknown_fields(self.get_unknown_fields())?;
2056 ::std::result::Result::Ok(())
2057 }
2058
2059 fn get_cached_size(&self) -> u32 {
2060 self.cached_size.get()
2061 }
2062
2063 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2064 &self.unknown_fields
2065 }
2066
2067 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2068 &mut self.unknown_fields
2069 }
2070
2071 fn as_any(&self) -> &dyn (::std::any::Any) {
2072 self as &dyn (::std::any::Any)
2073 }
2074 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2075 self as &mut dyn (::std::any::Any)
2076 }
2077 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2078 self
2079 }
2080
2081 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2082 Self::descriptor_static()
2083 }
2084
2085 fn new() -> NamedTupleValue {
2086 NamedTupleValue::new()
2087 }
2088
2089 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2090 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
2091 unsafe {
2092 descriptor.get(|| {
2093 let mut fields = ::std::vec::Vec::new();
2094 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2095 "name",
2096 |m: &NamedTupleValue| { &m.name },
2097 |m: &mut NamedTupleValue| { &mut m.name },
2098 ));
2099 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PairValue>>(
2100 "values",
2101 |m: &NamedTupleValue| { &m.values },
2102 |m: &mut NamedTupleValue| { &mut m.values },
2103 ));
2104 ::protobuf::reflect::MessageDescriptor::new_pb_name::<NamedTupleValue>(
2105 "NamedTupleValue",
2106 fields,
2107 file_descriptor_proto()
2108 )
2109 })
2110 }
2111 }
2112
2113 fn default_instance() -> &'static NamedTupleValue {
2114 static mut instance: ::protobuf::lazy::Lazy<NamedTupleValue> = ::protobuf::lazy::Lazy::INIT;
2115 unsafe {
2116 instance.get(NamedTupleValue::new)
2117 }
2118 }
2119}
2120
2121impl ::protobuf::Clear for NamedTupleValue {
2122 fn clear(&mut self) {
2123 self.name.clear();
2124 self.values.clear();
2125 self.unknown_fields.clear();
2126 }
2127}
2128
2129impl ::std::fmt::Debug for NamedTupleValue {
2130 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2131 ::protobuf::text_format::fmt(self, f)
2132 }
2133}
2134
2135impl ::protobuf::reflect::ProtobufValue for NamedTupleValue {
2136 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2137 ::protobuf::reflect::ReflectValueRef::Message(self)
2138 }
2139}
2140
2141#[derive(PartialEq,Clone,Default)]
2142pub struct TensorSpecProto {
2143 pub name: ::std::string::String,
2145 pub shape: ::protobuf::SingularPtrField<super::tensor_shape::TensorShapeProto>,
2146 pub dtype: super::types::DataType,
2147 pub unknown_fields: ::protobuf::UnknownFields,
2149 pub cached_size: ::protobuf::CachedSize,
2150}
2151
2152impl<'a> ::std::default::Default for &'a TensorSpecProto {
2153 fn default() -> &'a TensorSpecProto {
2154 <TensorSpecProto as ::protobuf::Message>::default_instance()
2155 }
2156}
2157
2158impl TensorSpecProto {
2159 pub fn new() -> TensorSpecProto {
2160 ::std::default::Default::default()
2161 }
2162
2163 pub fn get_name(&self) -> &str {
2167 &self.name
2168 }
2169 pub fn clear_name(&mut self) {
2170 self.name.clear();
2171 }
2172
2173 pub fn set_name(&mut self, v: ::std::string::String) {
2175 self.name = v;
2176 }
2177
2178 pub fn mut_name(&mut self) -> &mut ::std::string::String {
2181 &mut self.name
2182 }
2183
2184 pub fn take_name(&mut self) -> ::std::string::String {
2186 ::std::mem::replace(&mut self.name, ::std::string::String::new())
2187 }
2188
2189 pub fn get_shape(&self) -> &super::tensor_shape::TensorShapeProto {
2193 self.shape.as_ref().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::default_instance())
2194 }
2195 pub fn clear_shape(&mut self) {
2196 self.shape.clear();
2197 }
2198
2199 pub fn has_shape(&self) -> bool {
2200 self.shape.is_some()
2201 }
2202
2203 pub fn set_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
2205 self.shape = ::protobuf::SingularPtrField::some(v);
2206 }
2207
2208 pub fn mut_shape(&mut self) -> &mut super::tensor_shape::TensorShapeProto {
2211 if self.shape.is_none() {
2212 self.shape.set_default();
2213 }
2214 self.shape.as_mut().unwrap()
2215 }
2216
2217 pub fn take_shape(&mut self) -> super::tensor_shape::TensorShapeProto {
2219 self.shape.take().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::new())
2220 }
2221
2222 pub fn get_dtype(&self) -> super::types::DataType {
2226 self.dtype
2227 }
2228 pub fn clear_dtype(&mut self) {
2229 self.dtype = super::types::DataType::DT_INVALID;
2230 }
2231
2232 pub fn set_dtype(&mut self, v: super::types::DataType) {
2234 self.dtype = v;
2235 }
2236}
2237
2238impl ::protobuf::Message for TensorSpecProto {
2239 fn is_initialized(&self) -> bool {
2240 for v in &self.shape {
2241 if !v.is_initialized() {
2242 return false;
2243 }
2244 };
2245 true
2246 }
2247
2248 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2249 while !is.eof()? {
2250 let (field_number, wire_type) = is.read_tag_unpack()?;
2251 match field_number {
2252 1 => {
2253 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2254 },
2255 2 => {
2256 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.shape)?;
2257 },
2258 3 => {
2259 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.dtype, 3, &mut self.unknown_fields)?
2260 },
2261 _ => {
2262 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2263 },
2264 };
2265 }
2266 ::std::result::Result::Ok(())
2267 }
2268
2269 #[allow(unused_variables)]
2271 fn compute_size(&self) -> u32 {
2272 let mut my_size = 0;
2273 if !self.name.is_empty() {
2274 my_size += ::protobuf::rt::string_size(1, &self.name);
2275 }
2276 if let Some(ref v) = self.shape.as_ref() {
2277 let len = v.compute_size();
2278 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2279 }
2280 if self.dtype != super::types::DataType::DT_INVALID {
2281 my_size += ::protobuf::rt::enum_size(3, self.dtype);
2282 }
2283 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2284 self.cached_size.set(my_size);
2285 my_size
2286 }
2287
2288 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2289 if !self.name.is_empty() {
2290 os.write_string(1, &self.name)?;
2291 }
2292 if let Some(ref v) = self.shape.as_ref() {
2293 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2294 os.write_raw_varint32(v.get_cached_size())?;
2295 v.write_to_with_cached_sizes(os)?;
2296 }
2297 if self.dtype != super::types::DataType::DT_INVALID {
2298 os.write_enum(3, self.dtype.value())?;
2299 }
2300 os.write_unknown_fields(self.get_unknown_fields())?;
2301 ::std::result::Result::Ok(())
2302 }
2303
2304 fn get_cached_size(&self) -> u32 {
2305 self.cached_size.get()
2306 }
2307
2308 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2309 &self.unknown_fields
2310 }
2311
2312 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2313 &mut self.unknown_fields
2314 }
2315
2316 fn as_any(&self) -> &dyn (::std::any::Any) {
2317 self as &dyn (::std::any::Any)
2318 }
2319 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2320 self as &mut dyn (::std::any::Any)
2321 }
2322 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2323 self
2324 }
2325
2326 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2327 Self::descriptor_static()
2328 }
2329
2330 fn new() -> TensorSpecProto {
2331 TensorSpecProto::new()
2332 }
2333
2334 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2335 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
2336 unsafe {
2337 descriptor.get(|| {
2338 let mut fields = ::std::vec::Vec::new();
2339 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2340 "name",
2341 |m: &TensorSpecProto| { &m.name },
2342 |m: &mut TensorSpecProto| { &mut m.name },
2343 ));
2344 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor_shape::TensorShapeProto>>(
2345 "shape",
2346 |m: &TensorSpecProto| { &m.shape },
2347 |m: &mut TensorSpecProto| { &mut m.shape },
2348 ));
2349 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::types::DataType>>(
2350 "dtype",
2351 |m: &TensorSpecProto| { &m.dtype },
2352 |m: &mut TensorSpecProto| { &mut m.dtype },
2353 ));
2354 ::protobuf::reflect::MessageDescriptor::new_pb_name::<TensorSpecProto>(
2355 "TensorSpecProto",
2356 fields,
2357 file_descriptor_proto()
2358 )
2359 })
2360 }
2361 }
2362
2363 fn default_instance() -> &'static TensorSpecProto {
2364 static mut instance: ::protobuf::lazy::Lazy<TensorSpecProto> = ::protobuf::lazy::Lazy::INIT;
2365 unsafe {
2366 instance.get(TensorSpecProto::new)
2367 }
2368 }
2369}
2370
2371impl ::protobuf::Clear for TensorSpecProto {
2372 fn clear(&mut self) {
2373 self.name.clear();
2374 self.shape.clear();
2375 self.dtype = super::types::DataType::DT_INVALID;
2376 self.unknown_fields.clear();
2377 }
2378}
2379
2380impl ::std::fmt::Debug for TensorSpecProto {
2381 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2382 ::protobuf::text_format::fmt(self, f)
2383 }
2384}
2385
2386impl ::protobuf::reflect::ProtobufValue for TensorSpecProto {
2387 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2388 ::protobuf::reflect::ReflectValueRef::Message(self)
2389 }
2390}
2391
2392#[derive(PartialEq,Clone,Default)]
2393pub struct BoundedTensorSpecProto {
2394 pub name: ::std::string::String,
2396 pub shape: ::protobuf::SingularPtrField<super::tensor_shape::TensorShapeProto>,
2397 pub dtype: super::types::DataType,
2398 pub minimum: ::protobuf::SingularPtrField<super::tensor::TensorProto>,
2399 pub maximum: ::protobuf::SingularPtrField<super::tensor::TensorProto>,
2400 pub unknown_fields: ::protobuf::UnknownFields,
2402 pub cached_size: ::protobuf::CachedSize,
2403}
2404
2405impl<'a> ::std::default::Default for &'a BoundedTensorSpecProto {
2406 fn default() -> &'a BoundedTensorSpecProto {
2407 <BoundedTensorSpecProto as ::protobuf::Message>::default_instance()
2408 }
2409}
2410
2411impl BoundedTensorSpecProto {
2412 pub fn new() -> BoundedTensorSpecProto {
2413 ::std::default::Default::default()
2414 }
2415
2416 pub fn get_name(&self) -> &str {
2420 &self.name
2421 }
2422 pub fn clear_name(&mut self) {
2423 self.name.clear();
2424 }
2425
2426 pub fn set_name(&mut self, v: ::std::string::String) {
2428 self.name = v;
2429 }
2430
2431 pub fn mut_name(&mut self) -> &mut ::std::string::String {
2434 &mut self.name
2435 }
2436
2437 pub fn take_name(&mut self) -> ::std::string::String {
2439 ::std::mem::replace(&mut self.name, ::std::string::String::new())
2440 }
2441
2442 pub fn get_shape(&self) -> &super::tensor_shape::TensorShapeProto {
2446 self.shape.as_ref().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::default_instance())
2447 }
2448 pub fn clear_shape(&mut self) {
2449 self.shape.clear();
2450 }
2451
2452 pub fn has_shape(&self) -> bool {
2453 self.shape.is_some()
2454 }
2455
2456 pub fn set_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
2458 self.shape = ::protobuf::SingularPtrField::some(v);
2459 }
2460
2461 pub fn mut_shape(&mut self) -> &mut super::tensor_shape::TensorShapeProto {
2464 if self.shape.is_none() {
2465 self.shape.set_default();
2466 }
2467 self.shape.as_mut().unwrap()
2468 }
2469
2470 pub fn take_shape(&mut self) -> super::tensor_shape::TensorShapeProto {
2472 self.shape.take().unwrap_or_else(|| super::tensor_shape::TensorShapeProto::new())
2473 }
2474
2475 pub fn get_dtype(&self) -> super::types::DataType {
2479 self.dtype
2480 }
2481 pub fn clear_dtype(&mut self) {
2482 self.dtype = super::types::DataType::DT_INVALID;
2483 }
2484
2485 pub fn set_dtype(&mut self, v: super::types::DataType) {
2487 self.dtype = v;
2488 }
2489
2490 pub fn get_minimum(&self) -> &super::tensor::TensorProto {
2494 self.minimum.as_ref().unwrap_or_else(|| super::tensor::TensorProto::default_instance())
2495 }
2496 pub fn clear_minimum(&mut self) {
2497 self.minimum.clear();
2498 }
2499
2500 pub fn has_minimum(&self) -> bool {
2501 self.minimum.is_some()
2502 }
2503
2504 pub fn set_minimum(&mut self, v: super::tensor::TensorProto) {
2506 self.minimum = ::protobuf::SingularPtrField::some(v);
2507 }
2508
2509 pub fn mut_minimum(&mut self) -> &mut super::tensor::TensorProto {
2512 if self.minimum.is_none() {
2513 self.minimum.set_default();
2514 }
2515 self.minimum.as_mut().unwrap()
2516 }
2517
2518 pub fn take_minimum(&mut self) -> super::tensor::TensorProto {
2520 self.minimum.take().unwrap_or_else(|| super::tensor::TensorProto::new())
2521 }
2522
2523 pub fn get_maximum(&self) -> &super::tensor::TensorProto {
2527 self.maximum.as_ref().unwrap_or_else(|| super::tensor::TensorProto::default_instance())
2528 }
2529 pub fn clear_maximum(&mut self) {
2530 self.maximum.clear();
2531 }
2532
2533 pub fn has_maximum(&self) -> bool {
2534 self.maximum.is_some()
2535 }
2536
2537 pub fn set_maximum(&mut self, v: super::tensor::TensorProto) {
2539 self.maximum = ::protobuf::SingularPtrField::some(v);
2540 }
2541
2542 pub fn mut_maximum(&mut self) -> &mut super::tensor::TensorProto {
2545 if self.maximum.is_none() {
2546 self.maximum.set_default();
2547 }
2548 self.maximum.as_mut().unwrap()
2549 }
2550
2551 pub fn take_maximum(&mut self) -> super::tensor::TensorProto {
2553 self.maximum.take().unwrap_or_else(|| super::tensor::TensorProto::new())
2554 }
2555}
2556
2557impl ::protobuf::Message for BoundedTensorSpecProto {
2558 fn is_initialized(&self) -> bool {
2559 for v in &self.shape {
2560 if !v.is_initialized() {
2561 return false;
2562 }
2563 };
2564 for v in &self.minimum {
2565 if !v.is_initialized() {
2566 return false;
2567 }
2568 };
2569 for v in &self.maximum {
2570 if !v.is_initialized() {
2571 return false;
2572 }
2573 };
2574 true
2575 }
2576
2577 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2578 while !is.eof()? {
2579 let (field_number, wire_type) = is.read_tag_unpack()?;
2580 match field_number {
2581 1 => {
2582 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2583 },
2584 2 => {
2585 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.shape)?;
2586 },
2587 3 => {
2588 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.dtype, 3, &mut self.unknown_fields)?
2589 },
2590 4 => {
2591 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.minimum)?;
2592 },
2593 5 => {
2594 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.maximum)?;
2595 },
2596 _ => {
2597 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2598 },
2599 };
2600 }
2601 ::std::result::Result::Ok(())
2602 }
2603
2604 #[allow(unused_variables)]
2606 fn compute_size(&self) -> u32 {
2607 let mut my_size = 0;
2608 if !self.name.is_empty() {
2609 my_size += ::protobuf::rt::string_size(1, &self.name);
2610 }
2611 if let Some(ref v) = self.shape.as_ref() {
2612 let len = v.compute_size();
2613 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2614 }
2615 if self.dtype != super::types::DataType::DT_INVALID {
2616 my_size += ::protobuf::rt::enum_size(3, self.dtype);
2617 }
2618 if let Some(ref v) = self.minimum.as_ref() {
2619 let len = v.compute_size();
2620 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2621 }
2622 if let Some(ref v) = self.maximum.as_ref() {
2623 let len = v.compute_size();
2624 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2625 }
2626 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2627 self.cached_size.set(my_size);
2628 my_size
2629 }
2630
2631 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2632 if !self.name.is_empty() {
2633 os.write_string(1, &self.name)?;
2634 }
2635 if let Some(ref v) = self.shape.as_ref() {
2636 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2637 os.write_raw_varint32(v.get_cached_size())?;
2638 v.write_to_with_cached_sizes(os)?;
2639 }
2640 if self.dtype != super::types::DataType::DT_INVALID {
2641 os.write_enum(3, self.dtype.value())?;
2642 }
2643 if let Some(ref v) = self.minimum.as_ref() {
2644 os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2645 os.write_raw_varint32(v.get_cached_size())?;
2646 v.write_to_with_cached_sizes(os)?;
2647 }
2648 if let Some(ref v) = self.maximum.as_ref() {
2649 os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2650 os.write_raw_varint32(v.get_cached_size())?;
2651 v.write_to_with_cached_sizes(os)?;
2652 }
2653 os.write_unknown_fields(self.get_unknown_fields())?;
2654 ::std::result::Result::Ok(())
2655 }
2656
2657 fn get_cached_size(&self) -> u32 {
2658 self.cached_size.get()
2659 }
2660
2661 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2662 &self.unknown_fields
2663 }
2664
2665 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2666 &mut self.unknown_fields
2667 }
2668
2669 fn as_any(&self) -> &dyn (::std::any::Any) {
2670 self as &dyn (::std::any::Any)
2671 }
2672 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2673 self as &mut dyn (::std::any::Any)
2674 }
2675 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2676 self
2677 }
2678
2679 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2680 Self::descriptor_static()
2681 }
2682
2683 fn new() -> BoundedTensorSpecProto {
2684 BoundedTensorSpecProto::new()
2685 }
2686
2687 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2688 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
2689 unsafe {
2690 descriptor.get(|| {
2691 let mut fields = ::std::vec::Vec::new();
2692 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2693 "name",
2694 |m: &BoundedTensorSpecProto| { &m.name },
2695 |m: &mut BoundedTensorSpecProto| { &mut m.name },
2696 ));
2697 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor_shape::TensorShapeProto>>(
2698 "shape",
2699 |m: &BoundedTensorSpecProto| { &m.shape },
2700 |m: &mut BoundedTensorSpecProto| { &mut m.shape },
2701 ));
2702 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::types::DataType>>(
2703 "dtype",
2704 |m: &BoundedTensorSpecProto| { &m.dtype },
2705 |m: &mut BoundedTensorSpecProto| { &mut m.dtype },
2706 ));
2707 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor::TensorProto>>(
2708 "minimum",
2709 |m: &BoundedTensorSpecProto| { &m.minimum },
2710 |m: &mut BoundedTensorSpecProto| { &mut m.minimum },
2711 ));
2712 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::tensor::TensorProto>>(
2713 "maximum",
2714 |m: &BoundedTensorSpecProto| { &m.maximum },
2715 |m: &mut BoundedTensorSpecProto| { &mut m.maximum },
2716 ));
2717 ::protobuf::reflect::MessageDescriptor::new_pb_name::<BoundedTensorSpecProto>(
2718 "BoundedTensorSpecProto",
2719 fields,
2720 file_descriptor_proto()
2721 )
2722 })
2723 }
2724 }
2725
2726 fn default_instance() -> &'static BoundedTensorSpecProto {
2727 static mut instance: ::protobuf::lazy::Lazy<BoundedTensorSpecProto> = ::protobuf::lazy::Lazy::INIT;
2728 unsafe {
2729 instance.get(BoundedTensorSpecProto::new)
2730 }
2731 }
2732}
2733
2734impl ::protobuf::Clear for BoundedTensorSpecProto {
2735 fn clear(&mut self) {
2736 self.name.clear();
2737 self.shape.clear();
2738 self.dtype = super::types::DataType::DT_INVALID;
2739 self.minimum.clear();
2740 self.maximum.clear();
2741 self.unknown_fields.clear();
2742 }
2743}
2744
2745impl ::std::fmt::Debug for BoundedTensorSpecProto {
2746 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2747 ::protobuf::text_format::fmt(self, f)
2748 }
2749}
2750
2751impl ::protobuf::reflect::ProtobufValue for BoundedTensorSpecProto {
2752 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2753 ::protobuf::reflect::ReflectValueRef::Message(self)
2754 }
2755}
2756
2757#[derive(PartialEq,Clone,Default)]
2758pub struct TypeSpecProto {
2759 pub type_spec_class: TypeSpecProto_TypeSpecClass,
2761 pub type_state: ::protobuf::SingularPtrField<StructuredValue>,
2762 pub type_spec_class_name: ::std::string::String,
2763 pub unknown_fields: ::protobuf::UnknownFields,
2765 pub cached_size: ::protobuf::CachedSize,
2766}
2767
2768impl<'a> ::std::default::Default for &'a TypeSpecProto {
2769 fn default() -> &'a TypeSpecProto {
2770 <TypeSpecProto as ::protobuf::Message>::default_instance()
2771 }
2772}
2773
2774impl TypeSpecProto {
2775 pub fn new() -> TypeSpecProto {
2776 ::std::default::Default::default()
2777 }
2778
2779 pub fn get_type_spec_class(&self) -> TypeSpecProto_TypeSpecClass {
2783 self.type_spec_class
2784 }
2785 pub fn clear_type_spec_class(&mut self) {
2786 self.type_spec_class = TypeSpecProto_TypeSpecClass::UNKNOWN;
2787 }
2788
2789 pub fn set_type_spec_class(&mut self, v: TypeSpecProto_TypeSpecClass) {
2791 self.type_spec_class = v;
2792 }
2793
2794 pub fn get_type_state(&self) -> &StructuredValue {
2798 self.type_state.as_ref().unwrap_or_else(|| StructuredValue::default_instance())
2799 }
2800 pub fn clear_type_state(&mut self) {
2801 self.type_state.clear();
2802 }
2803
2804 pub fn has_type_state(&self) -> bool {
2805 self.type_state.is_some()
2806 }
2807
2808 pub fn set_type_state(&mut self, v: StructuredValue) {
2810 self.type_state = ::protobuf::SingularPtrField::some(v);
2811 }
2812
2813 pub fn mut_type_state(&mut self) -> &mut StructuredValue {
2816 if self.type_state.is_none() {
2817 self.type_state.set_default();
2818 }
2819 self.type_state.as_mut().unwrap()
2820 }
2821
2822 pub fn take_type_state(&mut self) -> StructuredValue {
2824 self.type_state.take().unwrap_or_else(|| StructuredValue::new())
2825 }
2826
2827 pub fn get_type_spec_class_name(&self) -> &str {
2831 &self.type_spec_class_name
2832 }
2833 pub fn clear_type_spec_class_name(&mut self) {
2834 self.type_spec_class_name.clear();
2835 }
2836
2837 pub fn set_type_spec_class_name(&mut self, v: ::std::string::String) {
2839 self.type_spec_class_name = v;
2840 }
2841
2842 pub fn mut_type_spec_class_name(&mut self) -> &mut ::std::string::String {
2845 &mut self.type_spec_class_name
2846 }
2847
2848 pub fn take_type_spec_class_name(&mut self) -> ::std::string::String {
2850 ::std::mem::replace(&mut self.type_spec_class_name, ::std::string::String::new())
2851 }
2852}
2853
2854impl ::protobuf::Message for TypeSpecProto {
2855 fn is_initialized(&self) -> bool {
2856 for v in &self.type_state {
2857 if !v.is_initialized() {
2858 return false;
2859 }
2860 };
2861 true
2862 }
2863
2864 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2865 while !is.eof()? {
2866 let (field_number, wire_type) = is.read_tag_unpack()?;
2867 match field_number {
2868 1 => {
2869 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.type_spec_class, 1, &mut self.unknown_fields)?
2870 },
2871 2 => {
2872 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.type_state)?;
2873 },
2874 3 => {
2875 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_spec_class_name)?;
2876 },
2877 _ => {
2878 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2879 },
2880 };
2881 }
2882 ::std::result::Result::Ok(())
2883 }
2884
2885 #[allow(unused_variables)]
2887 fn compute_size(&self) -> u32 {
2888 let mut my_size = 0;
2889 if self.type_spec_class != TypeSpecProto_TypeSpecClass::UNKNOWN {
2890 my_size += ::protobuf::rt::enum_size(1, self.type_spec_class);
2891 }
2892 if let Some(ref v) = self.type_state.as_ref() {
2893 let len = v.compute_size();
2894 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2895 }
2896 if !self.type_spec_class_name.is_empty() {
2897 my_size += ::protobuf::rt::string_size(3, &self.type_spec_class_name);
2898 }
2899 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2900 self.cached_size.set(my_size);
2901 my_size
2902 }
2903
2904 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2905 if self.type_spec_class != TypeSpecProto_TypeSpecClass::UNKNOWN {
2906 os.write_enum(1, self.type_spec_class.value())?;
2907 }
2908 if let Some(ref v) = self.type_state.as_ref() {
2909 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2910 os.write_raw_varint32(v.get_cached_size())?;
2911 v.write_to_with_cached_sizes(os)?;
2912 }
2913 if !self.type_spec_class_name.is_empty() {
2914 os.write_string(3, &self.type_spec_class_name)?;
2915 }
2916 os.write_unknown_fields(self.get_unknown_fields())?;
2917 ::std::result::Result::Ok(())
2918 }
2919
2920 fn get_cached_size(&self) -> u32 {
2921 self.cached_size.get()
2922 }
2923
2924 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2925 &self.unknown_fields
2926 }
2927
2928 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2929 &mut self.unknown_fields
2930 }
2931
2932 fn as_any(&self) -> &dyn (::std::any::Any) {
2933 self as &dyn (::std::any::Any)
2934 }
2935 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2936 self as &mut dyn (::std::any::Any)
2937 }
2938 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2939 self
2940 }
2941
2942 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2943 Self::descriptor_static()
2944 }
2945
2946 fn new() -> TypeSpecProto {
2947 TypeSpecProto::new()
2948 }
2949
2950 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2951 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
2952 unsafe {
2953 descriptor.get(|| {
2954 let mut fields = ::std::vec::Vec::new();
2955 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<TypeSpecProto_TypeSpecClass>>(
2956 "type_spec_class",
2957 |m: &TypeSpecProto| { &m.type_spec_class },
2958 |m: &mut TypeSpecProto| { &mut m.type_spec_class },
2959 ));
2960 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StructuredValue>>(
2961 "type_state",
2962 |m: &TypeSpecProto| { &m.type_state },
2963 |m: &mut TypeSpecProto| { &mut m.type_state },
2964 ));
2965 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2966 "type_spec_class_name",
2967 |m: &TypeSpecProto| { &m.type_spec_class_name },
2968 |m: &mut TypeSpecProto| { &mut m.type_spec_class_name },
2969 ));
2970 ::protobuf::reflect::MessageDescriptor::new_pb_name::<TypeSpecProto>(
2971 "TypeSpecProto",
2972 fields,
2973 file_descriptor_proto()
2974 )
2975 })
2976 }
2977 }
2978
2979 fn default_instance() -> &'static TypeSpecProto {
2980 static mut instance: ::protobuf::lazy::Lazy<TypeSpecProto> = ::protobuf::lazy::Lazy::INIT;
2981 unsafe {
2982 instance.get(TypeSpecProto::new)
2983 }
2984 }
2985}
2986
2987impl ::protobuf::Clear for TypeSpecProto {
2988 fn clear(&mut self) {
2989 self.type_spec_class = TypeSpecProto_TypeSpecClass::UNKNOWN;
2990 self.type_state.clear();
2991 self.type_spec_class_name.clear();
2992 self.unknown_fields.clear();
2993 }
2994}
2995
2996impl ::std::fmt::Debug for TypeSpecProto {
2997 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2998 ::protobuf::text_format::fmt(self, f)
2999 }
3000}
3001
3002impl ::protobuf::reflect::ProtobufValue for TypeSpecProto {
3003 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
3004 ::protobuf::reflect::ReflectValueRef::Message(self)
3005 }
3006}
3007
3008#[derive(Clone,PartialEq,Eq,Debug,Hash)]
3009pub enum TypeSpecProto_TypeSpecClass {
3010 UNKNOWN = 0,
3011 SPARSE_TENSOR_SPEC = 1,
3012 INDEXED_SLICES_SPEC = 2,
3013 RAGGED_TENSOR_SPEC = 3,
3014 TENSOR_ARRAY_SPEC = 4,
3015 DATA_DATASET_SPEC = 5,
3016 DATA_ITERATOR_SPEC = 6,
3017 OPTIONAL_SPEC = 7,
3018 PER_REPLICA_SPEC = 8,
3019 VARIABLE_SPEC = 9,
3020 ROW_PARTITION_SPEC = 10,
3021}
3022
3023impl ::protobuf::ProtobufEnum for TypeSpecProto_TypeSpecClass {
3024 fn value(&self) -> i32 {
3025 *self as i32
3026 }
3027
3028 fn from_i32(value: i32) -> ::std::option::Option<TypeSpecProto_TypeSpecClass> {
3029 match value {
3030 0 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::UNKNOWN),
3031 1 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::SPARSE_TENSOR_SPEC),
3032 2 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::INDEXED_SLICES_SPEC),
3033 3 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::RAGGED_TENSOR_SPEC),
3034 4 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::TENSOR_ARRAY_SPEC),
3035 5 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::DATA_DATASET_SPEC),
3036 6 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::DATA_ITERATOR_SPEC),
3037 7 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::OPTIONAL_SPEC),
3038 8 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::PER_REPLICA_SPEC),
3039 9 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::VARIABLE_SPEC),
3040 10 => ::std::option::Option::Some(TypeSpecProto_TypeSpecClass::ROW_PARTITION_SPEC),
3041 _ => ::std::option::Option::None
3042 }
3043 }
3044
3045 fn values() -> &'static [Self] {
3046 static values: &'static [TypeSpecProto_TypeSpecClass] = &[
3047 TypeSpecProto_TypeSpecClass::UNKNOWN,
3048 TypeSpecProto_TypeSpecClass::SPARSE_TENSOR_SPEC,
3049 TypeSpecProto_TypeSpecClass::INDEXED_SLICES_SPEC,
3050 TypeSpecProto_TypeSpecClass::RAGGED_TENSOR_SPEC,
3051 TypeSpecProto_TypeSpecClass::TENSOR_ARRAY_SPEC,
3052 TypeSpecProto_TypeSpecClass::DATA_DATASET_SPEC,
3053 TypeSpecProto_TypeSpecClass::DATA_ITERATOR_SPEC,
3054 TypeSpecProto_TypeSpecClass::OPTIONAL_SPEC,
3055 TypeSpecProto_TypeSpecClass::PER_REPLICA_SPEC,
3056 TypeSpecProto_TypeSpecClass::VARIABLE_SPEC,
3057 TypeSpecProto_TypeSpecClass::ROW_PARTITION_SPEC,
3058 ];
3059 values
3060 }
3061
3062 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
3063 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT;
3064 unsafe {
3065 descriptor.get(|| {
3066 ::protobuf::reflect::EnumDescriptor::new_pb_name::<TypeSpecProto_TypeSpecClass>("TypeSpecProto.TypeSpecClass", file_descriptor_proto())
3067 })
3068 }
3069 }
3070}
3071
3072impl ::std::marker::Copy for TypeSpecProto_TypeSpecClass {
3073}
3074
3075impl ::std::default::Default for TypeSpecProto_TypeSpecClass {
3076 fn default() -> Self {
3077 TypeSpecProto_TypeSpecClass::UNKNOWN
3078 }
3079}
3080
3081impl ::protobuf::reflect::ProtobufValue for TypeSpecProto_TypeSpecClass {
3082 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
3083 ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor())
3084 }
3085}
3086
3087static file_descriptor_proto_data: &'static [u8] = b"\
3088 \n%tensorflow/core/protobuf/struct.proto\x12\ntensorflow\x1a&tensorflow/\
3089 core/framework/tensor.proto\x1a,tensorflow/core/framework/tensor_shape.p\
3090 roto\x1a%tensorflow/core/framework/types.proto\"\xdc\x06\n\x0fStructured\
3091 Value\x126\n\nnone_value\x18\x01\x20\x01(\x0b2\x15.tensorflow.NoneValueH\
3092 \0R\tnoneValue\x12%\n\rfloat64_value\x18\x0b\x20\x01(\x01H\0R\x0cfloat64\
3093 Value\x12!\n\x0bint64_value\x18\x0c\x20\x01(\x12H\0R\nint64Value\x12#\n\
3094 \x0cstring_value\x18\r\x20\x01(\tH\0R\x0bstringValue\x12\x1f\n\nbool_val\
3095 ue\x18\x0e\x20\x01(\x08H\0R\tboolValue\x12L\n\x12tensor_shape_value\x18\
3096 \x1f\x20\x01(\x0b2\x1c.tensorflow.TensorShapeProtoH\0R\x10tensorShapeVal\
3097 ue\x12D\n\x12tensor_dtype_value\x18\x20\x20\x01(\x0e2\x14.tensorflow.Dat\
3098 aTypeH\0R\x10tensorDtypeValue\x12I\n\x11tensor_spec_value\x18!\x20\x01(\
3099 \x0b2\x1b.tensorflow.TensorSpecProtoH\0R\x0ftensorSpecValue\x12C\n\x0fty\
3100 pe_spec_value\x18\"\x20\x01(\x0b2\x19.tensorflow.TypeSpecProtoH\0R\rtype\
3101 SpecValue\x12_\n\x19bounded_tensor_spec_value\x18#\x20\x01(\x0b2\".tenso\
3102 rflow.BoundedTensorSpecProtoH\0R\x16boundedTensorSpecValue\x126\n\nlist_\
3103 value\x183\x20\x01(\x0b2\x15.tensorflow.ListValueH\0R\tlistValue\x129\n\
3104 \x0btuple_value\x184\x20\x01(\x0b2\x16.tensorflow.TupleValueH\0R\ntupleV\
3105 alue\x126\n\ndict_value\x185\x20\x01(\x0b2\x15.tensorflow.DictValueH\0R\
3106 \tdictValue\x12I\n\x11named_tuple_value\x186\x20\x01(\x0b2\x1b.tensorflo\
3107 w.NamedTupleValueH\0R\x0fnamedTupleValueB\x06\n\x04kind\"\x0b\n\tNoneVal\
3108 ue\"@\n\tListValue\x123\n\x06values\x18\x01\x20\x03(\x0b2\x1b.tensorflow\
3109 .StructuredValueR\x06values\"A\n\nTupleValue\x123\n\x06values\x18\x01\
3110 \x20\x03(\x0b2\x1b.tensorflow.StructuredValueR\x06values\"\x9e\x01\n\tDi\
3111 ctValue\x129\n\x06fields\x18\x01\x20\x03(\x0b2!.tensorflow.DictValue.Fie\
3112 ldsEntryR\x06fields\x1aV\n\x0bFieldsEntry\x12\x10\n\x03key\x18\x01\x20\
3113 \x01(\tR\x03key\x121\n\x05value\x18\x02\x20\x01(\x0b2\x1b.tensorflow.Str\
3114 ucturedValueR\x05value:\x028\x01\"P\n\tPairValue\x12\x10\n\x03key\x18\
3115 \x01\x20\x01(\tR\x03key\x121\n\x05value\x18\x02\x20\x01(\x0b2\x1b.tensor\
3116 flow.StructuredValueR\x05value\"T\n\x0fNamedTupleValue\x12\x12\n\x04name\
3117 \x18\x01\x20\x01(\tR\x04name\x12-\n\x06values\x18\x02\x20\x03(\x0b2\x15.\
3118 tensorflow.PairValueR\x06values\"\x85\x01\n\x0fTensorSpecProto\x12\x12\n\
3119 \x04name\x18\x01\x20\x01(\tR\x04name\x122\n\x05shape\x18\x02\x20\x01(\
3120 \x0b2\x1c.tensorflow.TensorShapeProtoR\x05shape\x12*\n\x05dtype\x18\x03\
3121 \x20\x01(\x0e2\x14.tensorflow.DataTypeR\x05dtype\"\xf2\x01\n\x16BoundedT\
3122 ensorSpecProto\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x122\n\x05s\
3123 hape\x18\x02\x20\x01(\x0b2\x1c.tensorflow.TensorShapeProtoR\x05shape\x12\
3124 *\n\x05dtype\x18\x03\x20\x01(\x0e2\x14.tensorflow.DataTypeR\x05dtype\x12\
3125 1\n\x07minimum\x18\x04\x20\x01(\x0b2\x17.tensorflow.TensorProtoR\x07mini\
3126 mum\x121\n\x07maximum\x18\x05\x20\x01(\x0b2\x17.tensorflow.TensorProtoR\
3127 \x07maximum\"\xcf\x03\n\rTypeSpecProto\x12O\n\x0ftype_spec_class\x18\x01\
3128 \x20\x01(\x0e2'.tensorflow.TypeSpecProto.TypeSpecClassR\rtypeSpecClass\
3129 \x12:\n\ntype_state\x18\x02\x20\x01(\x0b2\x1b.tensorflow.StructuredValue\
3130 R\ttypeState\x12/\n\x14type_spec_class_name\x18\x03\x20\x01(\tR\x11typeS\
3131 pecClassName\"\xff\x01\n\rTypeSpecClass\x12\x0b\n\x07UNKNOWN\x10\0\x12\
3132 \x16\n\x12SPARSE_TENSOR_SPEC\x10\x01\x12\x17\n\x13INDEXED_SLICES_SPEC\
3133 \x10\x02\x12\x16\n\x12RAGGED_TENSOR_SPEC\x10\x03\x12\x15\n\x11TENSOR_ARR\
3134 AY_SPEC\x10\x04\x12\x15\n\x11DATA_DATASET_SPEC\x10\x05\x12\x16\n\x12DATA\
3135 _ITERATOR_SPEC\x10\x06\x12\x11\n\rOPTIONAL_SPEC\x10\x07\x12\x14\n\x10PER\
3136 _REPLICA_SPEC\x10\x08\x12\x11\n\rVARIABLE_SPEC\x10\t\x12\x16\n\x12ROW_PA\
3137 RTITION_SPEC\x10\nBJZHgithub.com/tensorflow/tensorflow/tensorflow/go/cor\
3138 e/core_protos_go_protoJ\xa40\n\x07\x12\x05\0\0\x95\x01\x01\n\x08\n\x01\
3139 \x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x02\0\x13\n\t\n\x02\x03\0\
3140 \x12\x03\x04\00\n\t\n\x02\x03\x01\x12\x03\x05\06\n\t\n\x02\x03\x02\x12\
3141 \x03\x06\0/\n\x08\n\x01\x08\x12\x03\x08\0_\n\t\n\x02\x08\x0b\x12\x03\x08\
3142 \0_\n\x96\x0b\n\x02\x04\0\x12\x04\"\0K\x01\x1a\x89\x0b\x20`StructuredVal\
3143 ue`\x20represents\x20a\x20dynamically\x20typed\x20value\x20representing\
3144 \x20various\n\x20data\x20structures\x20that\x20are\x20inspired\x20by\x20\
3145 Python\x20data\x20structures\x20typically\x20used\x20in\n\x20TensorFlow\
3146 \x20functions\x20as\x20inputs\x20and\x20outputs.\n\n\x20For\x20example\
3147 \x20when\x20saving\x20a\x20Layer\x20there\x20may\x20be\x20a\x20`training\
3148 `\x20argument.\x20If\x20the\n\x20user\x20passes\x20a\x20boolean\x20True/\
3149 False,\x20that\x20switches\x20between\x20two\x20concrete\n\x20TensorFlow\
3150 \x20functions.\x20In\x20order\x20to\x20switch\x20between\x20them\x20in\
3151 \x20the\x20same\x20way\x20after\n\x20loading\x20the\x20SavedModel,\x20we\
3152 \x20need\x20to\x20represent\x20\"True\"\x20and\x20\"False\".\n\n\x20A\
3153 \x20more\x20advanced\x20example\x20might\x20be\x20a\x20function\x20which\
3154 \x20takes\x20a\x20list\x20of\n\x20dictionaries\x20mapping\x20from\x20str\
3155 ings\x20to\x20Tensors.\x20In\x20order\x20to\x20map\x20from\n\x20user-spe\
3156 cified\x20arguments\x20`[{\"a\":\x20tf.constant(1.)},\x20{\"q\":\x20tf.c\
3157 onstant(3.)}]`\n\x20after\x20load\x20to\x20the\x20right\x20saved\x20Tens\
3158 orFlow\x20function,\x20we\x20need\x20to\x20represent\x20the\n\x20nested\
3159 \x20structure\x20and\x20the\x20strings,\x20recording\x20that\x20we\x20ha\
3160 ve\x20a\x20trace\x20for\x20anything\n\x20matching\x20`[{\"a\":\x20tf.Ten\
3161 sorSpec(None,\x20tf.float32)},\x20{\"q\":\x20tf.TensorSpec([],\n\x20tf.f\
3162 loat64)}]`\x20as\x20an\x20example.\n\n\x20Likewise\x20functions\x20may\
3163 \x20return\x20nested\x20structures\x20of\x20Tensors,\x20for\x20example\n\
3164 \x20returning\x20a\x20dictionary\x20mapping\x20from\x20strings\x20to\x20\
3165 Tensors.\x20In\x20order\x20for\x20the\n\x20loaded\x20function\x20to\x20r\
3166 eturn\x20the\x20same\x20structure\x20we\x20need\x20to\x20serialize\x20it\
3167 .\n\n\x20This\x20is\x20an\x20ergonomic\x20aid\x20for\x20working\x20with\
3168 \x20loaded\x20SavedModels,\x20not\x20a\x20promise\n\x20to\x20serialize\
3169 \x20all\x20possible\x20function\x20signatures.\x20For\x20example\x20we\
3170 \x20do\x20not\x20expect\n\x20to\x20pickle\x20generic\x20Python\x20object\
3171 s,\x20and\x20ideally\x20we'd\x20stay\x20language-agnostic.\n\n\n\n\x03\
3172 \x04\0\x01\x12\x03\"\x08\x17\n\"\n\x04\x04\0\x08\0\x12\x04$\x02J\x03\x1a\
3173 \x14\x20The\x20kind\x20of\x20value.\n\n\x0c\n\x05\x04\0\x08\0\x01\x12\
3174 \x03$\x08\x0c\n\x1f\n\x04\x04\0\x02\0\x12\x03&\x04\x1d\x1a\x12\x20Repres\
3175 ents\x20None.\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03&\x04\r\n\x0c\n\x05\
3176 \x04\0\x02\0\x01\x12\x03&\x0e\x18\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03&\
3177 \x1b\x1c\nU\n\x04\x04\0\x02\x01\x12\x03)\x04\x1e\x1aH\x20Represents\x20a\
3178 \x20double-precision\x20floating-point\x20value\x20(a\x20Python\x20`floa\
3179 t`).\n\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03)\x04\n\n\x0c\n\x05\x04\0\
3180 \x02\x01\x01\x12\x03)\x0b\x18\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03)\x1b\
3181 \x1d\n\x91\x01\n\x04\x04\0\x02\x02\x12\x03,\x04\x1c\x1a\x83\x01\x20Repre\
3182 sents\x20a\x20signed\x20integer\x20value,\x20limited\x20to\x2064\x20bits\
3183 .\n\x20Larger\x20values\x20from\x20Python's\x20arbitrary-precision\x20in\
3184 tegers\x20are\x20unsupported.\n\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03,\
3185 \x04\n\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03,\x0b\x16\n\x0c\n\x05\x04\0\
3186 \x02\x02\x03\x12\x03,\x19\x1b\n\x92\x03\n\x04\x04\0\x02\x03\x12\x033\x04\
3187 \x1d\x1a\x84\x03\x20Represents\x20a\x20string\x20of\x20Unicode\x20charac\
3188 ters\x20stored\x20in\x20a\x20Python\x20`str`.\n\x20In\x20Python\x203,\
3189 \x20this\x20is\x20exactly\x20what\x20type\x20`str`\x20is.\n\x20In\x20Pyt\
3190 hon\x202,\x20this\x20is\x20the\x20UTF-8\x20encoding\x20of\x20the\x20char\
3191 acters.\n\x20For\x20strings\x20with\x20ASCII\x20characters\x20only\x20(a\
3192 s\x20often\x20used\x20in\x20TensorFlow\x20code)\n\x20there\x20is\x20effe\
3193 ctively\x20no\x20difference\x20between\x20the\x20language\x20versions.\n\
3194 \x20The\x20obsolescent\x20`unicode`\x20type\x20of\x20Python\x202\x20is\
3195 \x20not\x20supported\x20here.\n\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x033\
3196 \x04\n\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x033\x0b\x17\n\x0c\n\x05\x04\0\
3197 \x02\x03\x03\x12\x033\x1a\x1c\n*\n\x04\x04\0\x02\x04\x12\x035\x04\x19\
3198 \x1a\x1d\x20Represents\x20a\x20boolean\x20value.\n\n\x0c\n\x05\x04\0\x02\
3199 \x04\x05\x12\x035\x04\x08\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x035\t\x13\n\
3200 \x0c\n\x05\x04\0\x02\x04\x03\x12\x035\x16\x18\n(\n\x04\x04\0\x02\x05\x12\
3201 \x038\x048\x1a\x1b\x20Represents\x20a\x20TensorShape.\n\n\x0c\n\x05\x04\
3202 \0\x02\x05\x06\x12\x038\x04\x1f\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x038\
3203 \x202\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03857\n2\n\x04\x04\0\x02\x06\
3204 \x12\x03:\x040\x1a%\x20Represents\x20an\x20enum\x20value\x20for\x20dtype\
3205 .\n\n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03:\x04\x17\n\x0c\n\x05\x04\0\x02\
3206 \x06\x01\x12\x03:\x18*\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03:-/\n4\n\x04\
3207 \x04\0\x02\x07\x12\x03<\x04+\x1a'\x20Represents\x20a\x20value\x20for\x20\
3208 tf.TensorSpec.\n\n\x0c\n\x05\x04\0\x02\x07\x06\x12\x03<\x04\x13\n\x0c\n\
3209 \x05\x04\0\x02\x07\x01\x12\x03<\x14%\n\x0c\n\x05\x04\0\x02\x07\x03\x12\
3210 \x03<(*\n2\n\x04\x04\0\x02\x08\x12\x03>\x04'\x1a%\x20Represents\x20a\x20\
3211 value\x20for\x20tf.TypeSpec.\n\n\x0c\n\x05\x04\0\x02\x08\x06\x12\x03>\
3212 \x04\x11\n\x0c\n\x05\x04\0\x02\x08\x01\x12\x03>\x12!\n\x0c\n\x05\x04\0\
3213 \x02\x08\x03\x12\x03>$&\n;\n\x04\x04\0\x02\t\x12\x03@\x04:\x1a.\x20Repre\
3214 sents\x20a\x20value\x20for\x20tf.BoundedTensorSpec.\n\n\x0c\n\x05\x04\0\
3215 \x02\t\x06\x12\x03@\x04\x1a\n\x0c\n\x05\x04\0\x02\t\x01\x12\x03@\x1b4\n\
3216 \x0c\n\x05\x04\0\x02\t\x03\x12\x03@79\n,\n\x04\x04\0\x02\n\x12\x03C\x04\
3217 \x1e\x1a\x1f\x20Represents\x20a\x20list\x20of\x20`Value`.\n\n\x0c\n\x05\
3218 \x04\0\x02\n\x06\x12\x03C\x04\r\n\x0c\n\x05\x04\0\x02\n\x01\x12\x03C\x0e\
3219 \x18\n\x0c\n\x05\x04\0\x02\n\x03\x12\x03C\x1b\x1d\n-\n\x04\x04\0\x02\x0b\
3220 \x12\x03E\x04\x20\x1a\x20\x20Represents\x20a\x20tuple\x20of\x20`Value`.\
3221 \n\n\x0c\n\x05\x04\0\x02\x0b\x06\x12\x03E\x04\x0e\n\x0c\n\x05\x04\0\x02\
3222 \x0b\x01\x12\x03E\x0f\x1a\n\x0c\n\x05\x04\0\x02\x0b\x03\x12\x03E\x1d\x1f\
3223 \n)\n\x04\x04\0\x02\x0c\x12\x03G\x04\x1e\x1a\x1c\x20Represents\x20a\x20d\
3224 ict\x20`Value`.\n\n\x0c\n\x05\x04\0\x02\x0c\x06\x12\x03G\x04\r\n\x0c\n\
3225 \x05\x04\0\x02\x0c\x01\x12\x03G\x0e\x18\n\x0c\n\x05\x04\0\x02\x0c\x03\
3226 \x12\x03G\x1b\x1d\n.\n\x04\x04\0\x02\r\x12\x03I\x04+\x1a!\x20Represents\
3227 \x20Python's\x20namedtuple.\n\n\x0c\n\x05\x04\0\x02\r\x06\x12\x03I\x04\
3228 \x13\n\x0c\n\x05\x04\0\x02\r\x01\x12\x03I\x14%\n\x0c\n\x05\x04\0\x02\r\
3229 \x03\x12\x03I(*\n\x1d\n\x02\x04\x01\x12\x03N\0\x14\x1a\x12\x20Represents\
3230 \x20None.\n\n\n\n\x03\x04\x01\x01\x12\x03N\x08\x11\n'\n\x02\x04\x02\x12\
3231 \x04Q\0S\x01\x1a\x1b\x20Represents\x20a\x20Python\x20list.\n\n\n\n\x03\
3232 \x04\x02\x01\x12\x03Q\x08\x11\n\x0b\n\x04\x04\x02\x02\0\x12\x03R\x02&\n\
3233 \x0c\n\x05\x04\x02\x02\0\x04\x12\x03R\x02\n\n\x0c\n\x05\x04\x02\x02\0\
3234 \x06\x12\x03R\x0b\x1a\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03R\x1b!\n\x0c\
3235 \n\x05\x04\x02\x02\0\x03\x12\x03R$%\n(\n\x02\x04\x03\x12\x04V\0X\x01\x1a\
3236 \x1c\x20Represents\x20a\x20Python\x20tuple.\n\n\n\n\x03\x04\x03\x01\x12\
3237 \x03V\x08\x12\n\x0b\n\x04\x04\x03\x02\0\x12\x03W\x02&\n\x0c\n\x05\x04\
3238 \x03\x02\0\x04\x12\x03W\x02\n\n\x0c\n\x05\x04\x03\x02\0\x06\x12\x03W\x0b\
3239 \x1a\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03W\x1b!\n\x0c\n\x05\x04\x03\x02\
3240 \0\x03\x12\x03W$%\n{\n\x02\x04\x04\x12\x04\\\0^\x01\x1ao\x20Represents\
3241 \x20a\x20Python\x20dict\x20keyed\x20by\x20`str`.\n\x20The\x20comment\x20\
3242 on\x20Unicode\x20from\x20Value.string_value\x20applies\x20analogously.\n\
3243 \n\n\n\x03\x04\x04\x01\x12\x03\\\x08\x11\n\x0b\n\x04\x04\x04\x02\0\x12\
3244 \x03]\x02*\n\x0c\n\x05\x04\x04\x02\0\x06\x12\x03]\x02\x1e\n\x0c\n\x05\
3245 \x04\x04\x02\0\x01\x12\x03]\x1f%\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03](\
3246 )\n-\n\x02\x04\x05\x12\x04a\0d\x01\x1a!\x20Represents\x20a\x20(key,\x20v\
3247 alue)\x20pair.\n\n\n\n\x03\x04\x05\x01\x12\x03a\x08\x11\n\x0b\n\x04\x04\
3248 \x05\x02\0\x12\x03b\x02\x11\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03b\x02\
3249 \x08\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03b\t\x0c\n\x0c\n\x05\x04\x05\
3250 \x02\0\x03\x12\x03b\x0f\x10\n\x0b\n\x04\x04\x05\x02\x01\x12\x03c\x02\x1c\
3251 \n\x0c\n\x05\x04\x05\x02\x01\x06\x12\x03c\x02\x11\n\x0c\n\x05\x04\x05\
3252 \x02\x01\x01\x12\x03c\x12\x17\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03c\
3253 \x1a\x1b\n-\n\x02\x04\x06\x12\x04g\0j\x01\x1a!\x20Represents\x20Python's\
3254 \x20namedtuple.\n\n\n\n\x03\x04\x06\x01\x12\x03g\x08\x17\n\x0b\n\x04\x04\
3255 \x06\x02\0\x12\x03h\x02\x12\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03h\x02\
3256 \x08\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03h\t\r\n\x0c\n\x05\x04\x06\x02\
3257 \0\x03\x12\x03h\x10\x11\n\x0b\n\x04\x04\x06\x02\x01\x12\x03i\x02\x20\n\
3258 \x0c\n\x05\x04\x06\x02\x01\x04\x12\x03i\x02\n\n\x0c\n\x05\x04\x06\x02\
3259 \x01\x06\x12\x03i\x0b\x14\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03i\x15\
3260 \x1b\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03i\x1e\x1f\n4\n\x02\x04\x07\
3261 \x12\x04m\0q\x01\x1a(\x20A\x20protobuf\x20to\x20represent\x20tf.TensorSp\
3262 ec.\n\n\n\n\x03\x04\x07\x01\x12\x03m\x08\x17\n\x0b\n\x04\x04\x07\x02\0\
3263 \x12\x03n\x02\x12\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03n\x02\x08\n\x0c\n\
3264 \x05\x04\x07\x02\0\x01\x12\x03n\t\r\n\x0c\n\x05\x04\x07\x02\0\x03\x12\
3265 \x03n\x10\x11\n\x0b\n\x04\x04\x07\x02\x01\x12\x03o\x02(\n\x0c\n\x05\x04\
3266 \x07\x02\x01\x06\x12\x03o\x02\x1d\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\
3267 \x03o\x1e#\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03o&'\n\x0b\n\x04\x04\
3268 \x07\x02\x02\x12\x03p\x02\x20\n\x0c\n\x05\x04\x07\x02\x02\x06\x12\x03p\
3269 \x02\x15\n\x0c\n\x05\x04\x07\x02\x02\x01\x12\x03p\x16\x1b\n\x0c\n\x05\
3270 \x04\x07\x02\x02\x03\x12\x03p\x1e\x1f\n;\n\x02\x04\x08\x12\x04t\0z\x01\
3271 \x1a/\x20A\x20protobuf\x20to\x20represent\x20tf.BoundedTensorSpec.\n\n\n\
3272 \n\x03\x04\x08\x01\x12\x03t\x08\x1e\n\x0b\n\x04\x04\x08\x02\0\x12\x03u\
3273 \x02\x12\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03u\x02\x08\n\x0c\n\x05\x04\
3274 \x08\x02\0\x01\x12\x03u\t\r\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x03u\x10\
3275 \x11\n\x0b\n\x04\x04\x08\x02\x01\x12\x03v\x02(\n\x0c\n\x05\x04\x08\x02\
3276 \x01\x06\x12\x03v\x02\x1d\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03v\x1e#\
3277 \n\x0c\n\x05\x04\x08\x02\x01\x03\x12\x03v&'\n\x0b\n\x04\x04\x08\x02\x02\
3278 \x12\x03w\x02\x20\n\x0c\n\x05\x04\x08\x02\x02\x06\x12\x03w\x02\x15\n\x0c\
3279 \n\x05\x04\x08\x02\x02\x01\x12\x03w\x16\x1b\n\x0c\n\x05\x04\x08\x02\x02\
3280 \x03\x12\x03w\x1e\x1f\n\x0b\n\x04\x04\x08\x02\x03\x12\x03x\x02%\n\x0c\n\
3281 \x05\x04\x08\x02\x03\x06\x12\x03x\x02\x18\n\x0c\n\x05\x04\x08\x02\x03\
3282 \x01\x12\x03x\x19\x20\n\x0c\n\x05\x04\x08\x02\x03\x03\x12\x03x#$\n\x0b\n\
3283 \x04\x04\x08\x02\x04\x12\x03y\x02%\n\x0c\n\x05\x04\x08\x02\x04\x06\x12\
3284 \x03y\x02\x18\n\x0c\n\x05\x04\x08\x02\x04\x01\x12\x03y\x19\x20\n\x0c\n\
3285 \x05\x04\x08\x02\x04\x03\x12\x03y#$\n'\n\x02\x04\t\x12\x05}\0\x95\x01\
3286 \x01\x1a\x1a\x20Represents\x20a\x20tf.TypeSpec\n\n\n\n\x03\x04\t\x01\x12\
3287 \x03}\x08\x15\n\r\n\x04\x04\t\x04\0\x12\x05~\x02\x8a\x01\x03\n\x0c\n\x05\
3288 \x04\t\x04\0\x01\x12\x03~\x07\x14\n\r\n\x06\x04\t\x04\0\x02\0\x12\x03\
3289 \x7f\x04\x10\n\x0e\n\x07\x04\t\x04\0\x02\0\x01\x12\x03\x7f\x04\x0b\n\x0e\
3290 \n\x07\x04\t\x04\0\x02\0\x02\x12\x03\x7f\x0e\x0f\n%\n\x06\x04\t\x04\0\
3291 \x02\x01\x12\x04\x80\x01\x04\x1b\"\x15\x20tf.SparseTensorSpec\n\n\x0f\n\
3292 \x07\x04\t\x04\0\x02\x01\x01\x12\x04\x80\x01\x04\x16\n\x0f\n\x07\x04\t\
3293 \x04\0\x02\x01\x02\x12\x04\x80\x01\x19\x1a\n&\n\x06\x04\t\x04\0\x02\x02\
3294 \x12\x04\x81\x01\x04\x1c\"\x16\x20tf.IndexedSlicesSpec\n\n\x0f\n\x07\x04\
3295 \t\x04\0\x02\x02\x01\x12\x04\x81\x01\x04\x17\n\x0f\n\x07\x04\t\x04\0\x02\
3296 \x02\x02\x12\x04\x81\x01\x1a\x1b\n%\n\x06\x04\t\x04\0\x02\x03\x12\x04\
3297 \x82\x01\x04\x1b\"\x15\x20tf.RaggedTensorSpec\n\n\x0f\n\x07\x04\t\x04\0\
3298 \x02\x03\x01\x12\x04\x82\x01\x04\x16\n\x0f\n\x07\x04\t\x04\0\x02\x03\x02\
3299 \x12\x04\x82\x01\x19\x1a\n$\n\x06\x04\t\x04\0\x02\x04\x12\x04\x83\x01\
3300 \x04\x1a\"\x14\x20tf.TensorArraySpec\n\n\x0f\n\x07\x04\t\x04\0\x02\x04\
3301 \x01\x12\x04\x83\x01\x04\x15\n\x0f\n\x07\x04\t\x04\0\x02\x04\x02\x12\x04\
3302 \x83\x01\x18\x19\n%\n\x06\x04\t\x04\0\x02\x05\x12\x04\x84\x01\x04\x1a\"\
3303 \x15\x20tf.data.DatasetSpec\n\n\x0f\n\x07\x04\t\x04\0\x02\x05\x01\x12\
3304 \x04\x84\x01\x04\x15\n\x0f\n\x07\x04\t\x04\0\x02\x05\x02\x12\x04\x84\x01\
3305 \x18\x19\n<\n\x06\x04\t\x04\0\x02\x06\x12\x04\x85\x01\x04\x1b\",\x20Iter\
3306 atorSpec\x20from\x20data/ops/iterator_ops.py\n\n\x0f\n\x07\x04\t\x04\0\
3307 \x02\x06\x01\x12\x04\x85\x01\x04\x16\n\x0f\n\x07\x04\t\x04\0\x02\x06\x02\
3308 \x12\x04\x85\x01\x19\x1a\n!\n\x06\x04\t\x04\0\x02\x07\x12\x04\x86\x01\
3309 \x04\x16\"\x11\x20tf.OptionalSpec\n\n\x0f\n\x07\x04\t\x04\0\x02\x07\x01\
3310 \x12\x04\x86\x01\x04\x11\n\x0f\n\x07\x04\t\x04\0\x02\x07\x02\x12\x04\x86\
3311 \x01\x14\x15\n:\n\x06\x04\t\x04\0\x02\x08\x12\x04\x87\x01\x04\x19\"*\x20\
3312 PerReplicaSpec\x20from\x20distribute/values.py\n\n\x0f\n\x07\x04\t\x04\0\
3313 \x02\x08\x01\x12\x04\x87\x01\x04\x14\n\x0f\n\x07\x04\t\x04\0\x02\x08\x02\
3314 \x12\x04\x87\x01\x17\x18\n!\n\x06\x04\t\x04\0\x02\t\x12\x04\x88\x01\x04\
3315 \x16\"\x11\x20tf.VariableSpec\n\n\x0f\n\x07\x04\t\x04\0\x02\t\x01\x12\
3316 \x04\x88\x01\x04\x11\n\x0f\n\x07\x04\t\x04\0\x02\t\x02\x12\x04\x88\x01\
3317 \x14\x15\n?\n\x06\x04\t\x04\0\x02\n\x12\x04\x89\x01\x04\x1c\"/\x20RowPar\
3318 titionSpec\x20from\x20ragged/row_partition.py\n\n\x0f\n\x07\x04\t\x04\0\
3319 \x02\n\x01\x12\x04\x89\x01\x04\x16\n\x0f\n\x07\x04\t\x04\0\x02\n\x02\x12\
3320 \x04\x89\x01\x19\x1b\n\x0c\n\x04\x04\t\x02\0\x12\x04\x8b\x01\x02$\n\r\n\
3321 \x05\x04\t\x02\0\x06\x12\x04\x8b\x01\x02\x0f\n\r\n\x05\x04\t\x02\0\x01\
3322 \x12\x04\x8b\x01\x10\x1f\n\r\n\x05\x04\t\x02\0\x03\x12\x04\x8b\x01\"#\n<\
3323 \n\x04\x04\t\x02\x01\x12\x04\x8e\x01\x02!\x1a.\x20The\x20value\x20return\
3324 ed\x20by\x20TypeSpec._serialize().\n\n\r\n\x05\x04\t\x02\x01\x06\x12\x04\
3325 \x8e\x01\x02\x11\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\x8e\x01\x12\x1c\n\r\
3326 \n\x05\x04\t\x02\x01\x03\x12\x04\x8e\x01\x1f\x20\n\xb2\x02\n\x04\x04\t\
3327 \x02\x02\x12\x04\x94\x01\x02\"\x1a\xa3\x02\x20This\x20is\x20currently\
3328 \x20redundant\x20with\x20the\x20type_spec_class\x20enum,\x20and\x20is\
3329 \x20only\n\x20used\x20for\x20error\x20reporting.\x20\x20In\x20particular\
3330 ,\x20if\x20you\x20use\x20an\x20older\x20binary\x20to\n\x20load\x20a\x20n\
3331 ewer\x20model,\x20and\x20the\x20model\x20uses\x20a\x20TypeSpecClass\x20t\
3332 hat\x20the\x20older\n\x20binary\x20doesn't\x20support,\x20then\x20this\
3333 \x20lets\x20us\x20display\x20a\x20useful\x20error\x20message.\n\n\r\n\
3334 \x05\x04\t\x02\x02\x05\x12\x04\x94\x01\x02\x08\n\r\n\x05\x04\t\x02\x02\
3335 \x01\x12\x04\x94\x01\t\x1d\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\x94\x01\
3336 \x20!b\x06proto3\
3337";
3338
3339static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
3340
3341fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
3342 ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
3343}
3344
3345pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
3346 unsafe {
3347 file_descriptor_proto_lazy.get(|| {
3348 parse_descriptor_proto()
3349 })
3350 }
3351}