tensorflow_serving_client/
struct_pb.rs

1// This file is generated by rust-protobuf 2.14.0. Do not edit
2// @generated
3
4// https://github.com/rust-lang/rust-clippy/issues/702
5#![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)]
20//! Generated file from `tensorflow/core/protobuf/struct.proto`
21
22use protobuf::Message as Message_imported_for_functions;
23use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
24
25/// Generated files are compatible only with the same version
26/// of protobuf runtime.
27// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_14_0;
28
29#[derive(PartialEq,Clone,Default)]
30pub struct StructuredValue {
31    // message oneof groups
32    pub kind: ::std::option::Option<StructuredValue_oneof_kind>,
33    // special fields
34    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    // .tensorflow.NoneValue none_value = 1;
68
69
70    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    // Param is passed by value, moved
88    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    // Mutable pointer to the field.
93    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    // Take field
105    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    // double float64_value = 11;
117
118
119    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    // Param is passed by value, moved
137    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    // sint64 int64_value = 12;
142
143
144    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    // Param is passed by value, moved
162    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    // string string_value = 13;
167
168
169    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    // Param is passed by value, moved
187    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    // Mutable pointer to the field.
192    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    // Take field
204    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    // bool bool_value = 14;
216
217
218    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    // Param is passed by value, moved
236    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    // .tensorflow.TensorShapeProto tensor_shape_value = 31;
241
242
243    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    // Param is passed by value, moved
261    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    // Mutable pointer to the field.
266    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    // Take field
278    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    // .tensorflow.DataType tensor_dtype_value = 32;
290
291
292    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    // Param is passed by value, moved
310    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    // .tensorflow.TensorSpecProto tensor_spec_value = 33;
315
316
317    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    // Param is passed by value, moved
335    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    // Mutable pointer to the field.
340    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    // Take field
352    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    // .tensorflow.TypeSpecProto type_spec_value = 34;
364
365
366    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    // Param is passed by value, moved
384    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    // Mutable pointer to the field.
389    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    // Take field
401    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    // .tensorflow.BoundedTensorSpecProto bounded_tensor_spec_value = 35;
413
414
415    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    // Param is passed by value, moved
433    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    // Mutable pointer to the field.
438    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    // Take field
450    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    // .tensorflow.ListValue list_value = 51;
462
463
464    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    // Param is passed by value, moved
482    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    // Mutable pointer to the field.
487    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    // Take field
499    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    // .tensorflow.TupleValue tuple_value = 52;
511
512
513    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    // Param is passed by value, moved
531    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    // Mutable pointer to the field.
536    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    // Take field
548    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    // .tensorflow.DictValue dict_value = 53;
560
561
562    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    // Param is passed by value, moved
580    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    // Mutable pointer to the field.
585    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    // Take field
597    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    // .tensorflow.NamedTupleValue named_tuple_value = 54;
609
610
611    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    // Param is passed by value, moved
629    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    // Mutable pointer to the field.
634    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    // Take field
646    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    // Compute sizes of nested messages
805    #[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    // special fields
1094    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    // Compute sizes of nested messages
1128    #[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    // message fields
1214    pub values: ::protobuf::RepeatedField<StructuredValue>,
1215    // special fields
1216    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    // repeated .tensorflow.StructuredValue values = 1;
1232
1233
1234    pub fn get_values(&self) -> &[StructuredValue] {
1235        &self.values
1236    }
1237    pub fn clear_values(&mut self) {
1238        self.values.clear();
1239    }
1240
1241    // Param is passed by value, moved
1242    pub fn set_values(&mut self, v: ::protobuf::RepeatedField<StructuredValue>) {
1243        self.values = v;
1244    }
1245
1246    // Mutable pointer to the field.
1247    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<StructuredValue> {
1248        &mut self.values
1249    }
1250
1251    // Take field
1252    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    // Compute sizes of nested messages
1283    #[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    // message fields
1384    pub values: ::protobuf::RepeatedField<StructuredValue>,
1385    // special fields
1386    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    // repeated .tensorflow.StructuredValue values = 1;
1402
1403
1404    pub fn get_values(&self) -> &[StructuredValue] {
1405        &self.values
1406    }
1407    pub fn clear_values(&mut self) {
1408        self.values.clear();
1409    }
1410
1411    // Param is passed by value, moved
1412    pub fn set_values(&mut self, v: ::protobuf::RepeatedField<StructuredValue>) {
1413        self.values = v;
1414    }
1415
1416    // Mutable pointer to the field.
1417    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<StructuredValue> {
1418        &mut self.values
1419    }
1420
1421    // Take field
1422    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    // Compute sizes of nested messages
1453    #[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    // message fields
1554    pub fields: ::std::collections::HashMap<::std::string::String, StructuredValue>,
1555    // special fields
1556    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    // repeated .tensorflow.DictValue.FieldsEntry fields = 1;
1572
1573
1574    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    // Param is passed by value, moved
1582    pub fn set_fields(&mut self, v: ::std::collections::HashMap<::std::string::String, StructuredValue>) {
1583        self.fields = v;
1584    }
1585
1586    // Mutable pointer to the field.
1587    pub fn mut_fields(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, StructuredValue> {
1588        &mut self.fields
1589    }
1590
1591    // Take field
1592    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    // Compute sizes of nested messages
1618    #[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    // message fields
1712    pub key: ::std::string::String,
1713    pub value: ::protobuf::SingularPtrField<StructuredValue>,
1714    // special fields
1715    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    // string key = 1;
1731
1732
1733    pub fn get_key(&self) -> &str {
1734        &self.key
1735    }
1736    pub fn clear_key(&mut self) {
1737        self.key.clear();
1738    }
1739
1740    // Param is passed by value, moved
1741    pub fn set_key(&mut self, v: ::std::string::String) {
1742        self.key = v;
1743    }
1744
1745    // Mutable pointer to the field.
1746    // If field is not initialized, it is initialized with default value first.
1747    pub fn mut_key(&mut self) -> &mut ::std::string::String {
1748        &mut self.key
1749    }
1750
1751    // Take field
1752    pub fn take_key(&mut self) -> ::std::string::String {
1753        ::std::mem::replace(&mut self.key, ::std::string::String::new())
1754    }
1755
1756    // .tensorflow.StructuredValue value = 2;
1757
1758
1759    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    // Param is passed by value, moved
1771    pub fn set_value(&mut self, v: StructuredValue) {
1772        self.value = ::protobuf::SingularPtrField::some(v);
1773    }
1774
1775    // Mutable pointer to the field.
1776    // If field is not initialized, it is initialized with default value first.
1777    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    // Take field
1785    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    // Compute sizes of nested messages
1819    #[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    // message fields
1932    pub name: ::std::string::String,
1933    pub values: ::protobuf::RepeatedField<PairValue>,
1934    // special fields
1935    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    // string name = 1;
1951
1952
1953    pub fn get_name(&self) -> &str {
1954        &self.name
1955    }
1956    pub fn clear_name(&mut self) {
1957        self.name.clear();
1958    }
1959
1960    // Param is passed by value, moved
1961    pub fn set_name(&mut self, v: ::std::string::String) {
1962        self.name = v;
1963    }
1964
1965    // Mutable pointer to the field.
1966    // If field is not initialized, it is initialized with default value first.
1967    pub fn mut_name(&mut self) -> &mut ::std::string::String {
1968        &mut self.name
1969    }
1970
1971    // Take field
1972    pub fn take_name(&mut self) -> ::std::string::String {
1973        ::std::mem::replace(&mut self.name, ::std::string::String::new())
1974    }
1975
1976    // repeated .tensorflow.PairValue values = 2;
1977
1978
1979    pub fn get_values(&self) -> &[PairValue] {
1980        &self.values
1981    }
1982    pub fn clear_values(&mut self) {
1983        self.values.clear();
1984    }
1985
1986    // Param is passed by value, moved
1987    pub fn set_values(&mut self, v: ::protobuf::RepeatedField<PairValue>) {
1988        self.values = v;
1989    }
1990
1991    // Mutable pointer to the field.
1992    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<PairValue> {
1993        &mut self.values
1994    }
1995
1996    // Take field
1997    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    // Compute sizes of nested messages
2031    #[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    // message fields
2144    pub name: ::std::string::String,
2145    pub shape: ::protobuf::SingularPtrField<super::tensor_shape::TensorShapeProto>,
2146    pub dtype: super::types::DataType,
2147    // special fields
2148    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    // string name = 1;
2164
2165
2166    pub fn get_name(&self) -> &str {
2167        &self.name
2168    }
2169    pub fn clear_name(&mut self) {
2170        self.name.clear();
2171    }
2172
2173    // Param is passed by value, moved
2174    pub fn set_name(&mut self, v: ::std::string::String) {
2175        self.name = v;
2176    }
2177
2178    // Mutable pointer to the field.
2179    // If field is not initialized, it is initialized with default value first.
2180    pub fn mut_name(&mut self) -> &mut ::std::string::String {
2181        &mut self.name
2182    }
2183
2184    // Take field
2185    pub fn take_name(&mut self) -> ::std::string::String {
2186        ::std::mem::replace(&mut self.name, ::std::string::String::new())
2187    }
2188
2189    // .tensorflow.TensorShapeProto shape = 2;
2190
2191
2192    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    // Param is passed by value, moved
2204    pub fn set_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
2205        self.shape = ::protobuf::SingularPtrField::some(v);
2206    }
2207
2208    // Mutable pointer to the field.
2209    // If field is not initialized, it is initialized with default value first.
2210    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    // Take field
2218    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    // .tensorflow.DataType dtype = 3;
2223
2224
2225    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    // Param is passed by value, moved
2233    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    // Compute sizes of nested messages
2270    #[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    // message fields
2395    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    // special fields
2401    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    // string name = 1;
2417
2418
2419    pub fn get_name(&self) -> &str {
2420        &self.name
2421    }
2422    pub fn clear_name(&mut self) {
2423        self.name.clear();
2424    }
2425
2426    // Param is passed by value, moved
2427    pub fn set_name(&mut self, v: ::std::string::String) {
2428        self.name = v;
2429    }
2430
2431    // Mutable pointer to the field.
2432    // If field is not initialized, it is initialized with default value first.
2433    pub fn mut_name(&mut self) -> &mut ::std::string::String {
2434        &mut self.name
2435    }
2436
2437    // Take field
2438    pub fn take_name(&mut self) -> ::std::string::String {
2439        ::std::mem::replace(&mut self.name, ::std::string::String::new())
2440    }
2441
2442    // .tensorflow.TensorShapeProto shape = 2;
2443
2444
2445    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    // Param is passed by value, moved
2457    pub fn set_shape(&mut self, v: super::tensor_shape::TensorShapeProto) {
2458        self.shape = ::protobuf::SingularPtrField::some(v);
2459    }
2460
2461    // Mutable pointer to the field.
2462    // If field is not initialized, it is initialized with default value first.
2463    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    // Take field
2471    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    // .tensorflow.DataType dtype = 3;
2476
2477
2478    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    // Param is passed by value, moved
2486    pub fn set_dtype(&mut self, v: super::types::DataType) {
2487        self.dtype = v;
2488    }
2489
2490    // .tensorflow.TensorProto minimum = 4;
2491
2492
2493    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    // Param is passed by value, moved
2505    pub fn set_minimum(&mut self, v: super::tensor::TensorProto) {
2506        self.minimum = ::protobuf::SingularPtrField::some(v);
2507    }
2508
2509    // Mutable pointer to the field.
2510    // If field is not initialized, it is initialized with default value first.
2511    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    // Take field
2519    pub fn take_minimum(&mut self) -> super::tensor::TensorProto {
2520        self.minimum.take().unwrap_or_else(|| super::tensor::TensorProto::new())
2521    }
2522
2523    // .tensorflow.TensorProto maximum = 5;
2524
2525
2526    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    // Param is passed by value, moved
2538    pub fn set_maximum(&mut self, v: super::tensor::TensorProto) {
2539        self.maximum = ::protobuf::SingularPtrField::some(v);
2540    }
2541
2542    // Mutable pointer to the field.
2543    // If field is not initialized, it is initialized with default value first.
2544    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    // Take field
2552    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    // Compute sizes of nested messages
2605    #[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    // message fields
2760    pub type_spec_class: TypeSpecProto_TypeSpecClass,
2761    pub type_state: ::protobuf::SingularPtrField<StructuredValue>,
2762    pub type_spec_class_name: ::std::string::String,
2763    // special fields
2764    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    // .tensorflow.TypeSpecProto.TypeSpecClass type_spec_class = 1;
2780
2781
2782    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    // Param is passed by value, moved
2790    pub fn set_type_spec_class(&mut self, v: TypeSpecProto_TypeSpecClass) {
2791        self.type_spec_class = v;
2792    }
2793
2794    // .tensorflow.StructuredValue type_state = 2;
2795
2796
2797    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    // Param is passed by value, moved
2809    pub fn set_type_state(&mut self, v: StructuredValue) {
2810        self.type_state = ::protobuf::SingularPtrField::some(v);
2811    }
2812
2813    // Mutable pointer to the field.
2814    // If field is not initialized, it is initialized with default value first.
2815    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    // Take field
2823    pub fn take_type_state(&mut self) -> StructuredValue {
2824        self.type_state.take().unwrap_or_else(|| StructuredValue::new())
2825    }
2826
2827    // string type_spec_class_name = 3;
2828
2829
2830    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    // Param is passed by value, moved
2838    pub fn set_type_spec_class_name(&mut self, v: ::std::string::String) {
2839        self.type_spec_class_name = v;
2840    }
2841
2842    // Mutable pointer to the field.
2843    // If field is not initialized, it is initialized with default value first.
2844    pub fn mut_type_spec_class_name(&mut self) -> &mut ::std::string::String {
2845        &mut self.type_spec_class_name
2846    }
2847
2848    // Take field
2849    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    // Compute sizes of nested messages
2886    #[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}