1#![allow(unknown_lints)]
6#![allow(clippy)]
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
21use protobuf::Message as Message_imported_for_functions;
22use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
23
24#[derive(PartialEq,Clone,Default)]
25pub struct Request {
26 pub service: ::std::string::String,
28 pub procedure: ::std::string::String,
29 pub arguments: ::protobuf::RepeatedField<Argument>,
30 unknown_fields: ::protobuf::UnknownFields,
32 cached_size: ::protobuf::CachedSize,
33}
34
35unsafe impl ::std::marker::Sync for Request {}
37
38impl Request {
39 pub fn new() -> Request {
40 ::std::default::Default::default()
41 }
42
43 pub fn default_instance() -> &'static Request {
44 static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
45 lock: ::protobuf::lazy::ONCE_INIT,
46 ptr: 0 as *const Request,
47 };
48 unsafe {
49 instance.get(Request::new)
50 }
51 }
52
53 pub fn clear_service(&mut self) {
56 self.service.clear();
57 }
58
59 pub fn set_service(&mut self, v: ::std::string::String) {
61 self.service = v;
62 }
63
64 pub fn mut_service(&mut self) -> &mut ::std::string::String {
67 &mut self.service
68 }
69
70 pub fn take_service(&mut self) -> ::std::string::String {
72 ::std::mem::replace(&mut self.service, ::std::string::String::new())
73 }
74
75 pub fn get_service(&self) -> &str {
76 &self.service
77 }
78
79 fn get_service_for_reflect(&self) -> &::std::string::String {
80 &self.service
81 }
82
83 fn mut_service_for_reflect(&mut self) -> &mut ::std::string::String {
84 &mut self.service
85 }
86
87 pub fn clear_procedure(&mut self) {
90 self.procedure.clear();
91 }
92
93 pub fn set_procedure(&mut self, v: ::std::string::String) {
95 self.procedure = v;
96 }
97
98 pub fn mut_procedure(&mut self) -> &mut ::std::string::String {
101 &mut self.procedure
102 }
103
104 pub fn take_procedure(&mut self) -> ::std::string::String {
106 ::std::mem::replace(&mut self.procedure, ::std::string::String::new())
107 }
108
109 pub fn get_procedure(&self) -> &str {
110 &self.procedure
111 }
112
113 fn get_procedure_for_reflect(&self) -> &::std::string::String {
114 &self.procedure
115 }
116
117 fn mut_procedure_for_reflect(&mut self) -> &mut ::std::string::String {
118 &mut self.procedure
119 }
120
121 pub fn clear_arguments(&mut self) {
124 self.arguments.clear();
125 }
126
127 pub fn set_arguments(&mut self, v: ::protobuf::RepeatedField<Argument>) {
129 self.arguments = v;
130 }
131
132 pub fn mut_arguments(&mut self) -> &mut ::protobuf::RepeatedField<Argument> {
134 &mut self.arguments
135 }
136
137 pub fn take_arguments(&mut self) -> ::protobuf::RepeatedField<Argument> {
139 ::std::mem::replace(&mut self.arguments, ::protobuf::RepeatedField::new())
140 }
141
142 pub fn get_arguments(&self) -> &[Argument] {
143 &self.arguments
144 }
145
146 fn get_arguments_for_reflect(&self) -> &::protobuf::RepeatedField<Argument> {
147 &self.arguments
148 }
149
150 fn mut_arguments_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<Argument> {
151 &mut self.arguments
152 }
153}
154
155impl ::protobuf::Message for Request {
156 fn is_initialized(&self) -> bool {
157 for v in &self.arguments {
158 if !v.is_initialized() {
159 return false;
160 }
161 };
162 true
163 }
164
165 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
166 while !is.eof()? {
167 let (field_number, wire_type) = is.read_tag_unpack()?;
168 match field_number {
169 1 => {
170 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.service)?;
171 },
172 2 => {
173 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.procedure)?;
174 },
175 3 => {
176 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.arguments)?;
177 },
178 _ => {
179 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
180 },
181 };
182 }
183 ::std::result::Result::Ok(())
184 }
185
186 #[allow(unused_variables)]
188 fn compute_size(&self) -> u32 {
189 let mut my_size = 0;
190 if !self.service.is_empty() {
191 my_size += ::protobuf::rt::string_size(1, &self.service);
192 }
193 if !self.procedure.is_empty() {
194 my_size += ::protobuf::rt::string_size(2, &self.procedure);
195 }
196 for value in &self.arguments {
197 let len = value.compute_size();
198 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
199 };
200 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
201 self.cached_size.set(my_size);
202 my_size
203 }
204
205 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
206 if !self.service.is_empty() {
207 os.write_string(1, &self.service)?;
208 }
209 if !self.procedure.is_empty() {
210 os.write_string(2, &self.procedure)?;
211 }
212 for v in &self.arguments {
213 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
214 os.write_raw_varint32(v.get_cached_size())?;
215 v.write_to_with_cached_sizes(os)?;
216 };
217 os.write_unknown_fields(self.get_unknown_fields())?;
218 ::std::result::Result::Ok(())
219 }
220
221 fn get_cached_size(&self) -> u32 {
222 self.cached_size.get()
223 }
224
225 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
226 &self.unknown_fields
227 }
228
229 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
230 &mut self.unknown_fields
231 }
232
233 fn as_any(&self) -> &::std::any::Any {
234 self as &::std::any::Any
235 }
236 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
237 self as &mut ::std::any::Any
238 }
239 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
240 self
241 }
242
243 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
244 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
245 }
246}
247
248impl ::protobuf::MessageStatic for Request {
249 fn new() -> Request {
250 Request::new()
251 }
252
253 fn descriptor_static(_: ::std::option::Option<Request>) -> &'static ::protobuf::reflect::MessageDescriptor {
254 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
255 lock: ::protobuf::lazy::ONCE_INIT,
256 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
257 };
258 unsafe {
259 descriptor.get(|| {
260 let mut fields = ::std::vec::Vec::new();
261 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
262 "service",
263 Request::get_service_for_reflect,
264 Request::mut_service_for_reflect,
265 ));
266 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
267 "procedure",
268 Request::get_procedure_for_reflect,
269 Request::mut_procedure_for_reflect,
270 ));
271 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Argument>>(
272 "arguments",
273 Request::get_arguments_for_reflect,
274 Request::mut_arguments_for_reflect,
275 ));
276 ::protobuf::reflect::MessageDescriptor::new::<Request>(
277 "Request",
278 fields,
279 file_descriptor_proto()
280 )
281 })
282 }
283 }
284}
285
286impl ::protobuf::Clear for Request {
287 fn clear(&mut self) {
288 self.clear_service();
289 self.clear_procedure();
290 self.clear_arguments();
291 self.unknown_fields.clear();
292 }
293}
294
295impl ::std::fmt::Debug for Request {
296 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
297 ::protobuf::text_format::fmt(self, f)
298 }
299}
300
301impl ::protobuf::reflect::ProtobufValue for Request {
302 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
303 ::protobuf::reflect::ProtobufValueRef::Message(self)
304 }
305}
306
307#[derive(PartialEq,Clone,Default)]
308pub struct Argument {
309 pub position: u32,
311 pub value: ::std::vec::Vec<u8>,
312 unknown_fields: ::protobuf::UnknownFields,
314 cached_size: ::protobuf::CachedSize,
315}
316
317unsafe impl ::std::marker::Sync for Argument {}
319
320impl Argument {
321 pub fn new() -> Argument {
322 ::std::default::Default::default()
323 }
324
325 pub fn default_instance() -> &'static Argument {
326 static mut instance: ::protobuf::lazy::Lazy<Argument> = ::protobuf::lazy::Lazy {
327 lock: ::protobuf::lazy::ONCE_INIT,
328 ptr: 0 as *const Argument,
329 };
330 unsafe {
331 instance.get(Argument::new)
332 }
333 }
334
335 pub fn clear_position(&mut self) {
338 self.position = 0;
339 }
340
341 pub fn set_position(&mut self, v: u32) {
343 self.position = v;
344 }
345
346 pub fn get_position(&self) -> u32 {
347 self.position
348 }
349
350 fn get_position_for_reflect(&self) -> &u32 {
351 &self.position
352 }
353
354 fn mut_position_for_reflect(&mut self) -> &mut u32 {
355 &mut self.position
356 }
357
358 pub fn clear_value(&mut self) {
361 self.value.clear();
362 }
363
364 pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
366 self.value = v;
367 }
368
369 pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
372 &mut self.value
373 }
374
375 pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
377 ::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
378 }
379
380 pub fn get_value(&self) -> &[u8] {
381 &self.value
382 }
383
384 fn get_value_for_reflect(&self) -> &::std::vec::Vec<u8> {
385 &self.value
386 }
387
388 fn mut_value_for_reflect(&mut self) -> &mut ::std::vec::Vec<u8> {
389 &mut self.value
390 }
391}
392
393impl ::protobuf::Message for Argument {
394 fn is_initialized(&self) -> bool {
395 true
396 }
397
398 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
399 while !is.eof()? {
400 let (field_number, wire_type) = is.read_tag_unpack()?;
401 match field_number {
402 1 => {
403 if wire_type != ::protobuf::wire_format::WireTypeVarint {
404 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
405 }
406 let tmp = is.read_uint32()?;
407 self.position = tmp;
408 },
409 2 => {
410 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
411 },
412 _ => {
413 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
414 },
415 };
416 }
417 ::std::result::Result::Ok(())
418 }
419
420 #[allow(unused_variables)]
422 fn compute_size(&self) -> u32 {
423 let mut my_size = 0;
424 if self.position != 0 {
425 my_size += ::protobuf::rt::value_size(1, self.position, ::protobuf::wire_format::WireTypeVarint);
426 }
427 if !self.value.is_empty() {
428 my_size += ::protobuf::rt::bytes_size(2, &self.value);
429 }
430 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
431 self.cached_size.set(my_size);
432 my_size
433 }
434
435 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
436 if self.position != 0 {
437 os.write_uint32(1, self.position)?;
438 }
439 if !self.value.is_empty() {
440 os.write_bytes(2, &self.value)?;
441 }
442 os.write_unknown_fields(self.get_unknown_fields())?;
443 ::std::result::Result::Ok(())
444 }
445
446 fn get_cached_size(&self) -> u32 {
447 self.cached_size.get()
448 }
449
450 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
451 &self.unknown_fields
452 }
453
454 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
455 &mut self.unknown_fields
456 }
457
458 fn as_any(&self) -> &::std::any::Any {
459 self as &::std::any::Any
460 }
461 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
462 self as &mut ::std::any::Any
463 }
464 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
465 self
466 }
467
468 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
469 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
470 }
471}
472
473impl ::protobuf::MessageStatic for Argument {
474 fn new() -> Argument {
475 Argument::new()
476 }
477
478 fn descriptor_static(_: ::std::option::Option<Argument>) -> &'static ::protobuf::reflect::MessageDescriptor {
479 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
480 lock: ::protobuf::lazy::ONCE_INIT,
481 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
482 };
483 unsafe {
484 descriptor.get(|| {
485 let mut fields = ::std::vec::Vec::new();
486 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
487 "position",
488 Argument::get_position_for_reflect,
489 Argument::mut_position_for_reflect,
490 ));
491 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
492 "value",
493 Argument::get_value_for_reflect,
494 Argument::mut_value_for_reflect,
495 ));
496 ::protobuf::reflect::MessageDescriptor::new::<Argument>(
497 "Argument",
498 fields,
499 file_descriptor_proto()
500 )
501 })
502 }
503 }
504}
505
506impl ::protobuf::Clear for Argument {
507 fn clear(&mut self) {
508 self.clear_position();
509 self.clear_value();
510 self.unknown_fields.clear();
511 }
512}
513
514impl ::std::fmt::Debug for Argument {
515 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
516 ::protobuf::text_format::fmt(self, f)
517 }
518}
519
520impl ::protobuf::reflect::ProtobufValue for Argument {
521 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
522 ::protobuf::reflect::ProtobufValueRef::Message(self)
523 }
524}
525
526#[derive(PartialEq,Clone,Default)]
527pub struct Response {
528 pub time: f64,
530 pub has_error: bool,
531 pub error: ::std::string::String,
532 pub has_return_value: bool,
533 pub return_value: ::std::vec::Vec<u8>,
534 unknown_fields: ::protobuf::UnknownFields,
536 cached_size: ::protobuf::CachedSize,
537}
538
539unsafe impl ::std::marker::Sync for Response {}
541
542impl Response {
543 pub fn new() -> Response {
544 ::std::default::Default::default()
545 }
546
547 pub fn default_instance() -> &'static Response {
548 static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
549 lock: ::protobuf::lazy::ONCE_INIT,
550 ptr: 0 as *const Response,
551 };
552 unsafe {
553 instance.get(Response::new)
554 }
555 }
556
557 pub fn clear_time(&mut self) {
560 self.time = 0.;
561 }
562
563 pub fn set_time(&mut self, v: f64) {
565 self.time = v;
566 }
567
568 pub fn get_time(&self) -> f64 {
569 self.time
570 }
571
572 fn get_time_for_reflect(&self) -> &f64 {
573 &self.time
574 }
575
576 fn mut_time_for_reflect(&mut self) -> &mut f64 {
577 &mut self.time
578 }
579
580 pub fn clear_has_error(&mut self) {
583 self.has_error = false;
584 }
585
586 pub fn set_has_error(&mut self, v: bool) {
588 self.has_error = v;
589 }
590
591 pub fn get_has_error(&self) -> bool {
592 self.has_error
593 }
594
595 fn get_has_error_for_reflect(&self) -> &bool {
596 &self.has_error
597 }
598
599 fn mut_has_error_for_reflect(&mut self) -> &mut bool {
600 &mut self.has_error
601 }
602
603 pub fn clear_error(&mut self) {
606 self.error.clear();
607 }
608
609 pub fn set_error(&mut self, v: ::std::string::String) {
611 self.error = v;
612 }
613
614 pub fn mut_error(&mut self) -> &mut ::std::string::String {
617 &mut self.error
618 }
619
620 pub fn take_error(&mut self) -> ::std::string::String {
622 ::std::mem::replace(&mut self.error, ::std::string::String::new())
623 }
624
625 pub fn get_error(&self) -> &str {
626 &self.error
627 }
628
629 fn get_error_for_reflect(&self) -> &::std::string::String {
630 &self.error
631 }
632
633 fn mut_error_for_reflect(&mut self) -> &mut ::std::string::String {
634 &mut self.error
635 }
636
637 pub fn clear_has_return_value(&mut self) {
640 self.has_return_value = false;
641 }
642
643 pub fn set_has_return_value(&mut self, v: bool) {
645 self.has_return_value = v;
646 }
647
648 pub fn get_has_return_value(&self) -> bool {
649 self.has_return_value
650 }
651
652 fn get_has_return_value_for_reflect(&self) -> &bool {
653 &self.has_return_value
654 }
655
656 fn mut_has_return_value_for_reflect(&mut self) -> &mut bool {
657 &mut self.has_return_value
658 }
659
660 pub fn clear_return_value(&mut self) {
663 self.return_value.clear();
664 }
665
666 pub fn set_return_value(&mut self, v: ::std::vec::Vec<u8>) {
668 self.return_value = v;
669 }
670
671 pub fn mut_return_value(&mut self) -> &mut ::std::vec::Vec<u8> {
674 &mut self.return_value
675 }
676
677 pub fn take_return_value(&mut self) -> ::std::vec::Vec<u8> {
679 ::std::mem::replace(&mut self.return_value, ::std::vec::Vec::new())
680 }
681
682 pub fn get_return_value(&self) -> &[u8] {
683 &self.return_value
684 }
685
686 fn get_return_value_for_reflect(&self) -> &::std::vec::Vec<u8> {
687 &self.return_value
688 }
689
690 fn mut_return_value_for_reflect(&mut self) -> &mut ::std::vec::Vec<u8> {
691 &mut self.return_value
692 }
693}
694
695impl ::protobuf::Message for Response {
696 fn is_initialized(&self) -> bool {
697 true
698 }
699
700 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
701 while !is.eof()? {
702 let (field_number, wire_type) = is.read_tag_unpack()?;
703 match field_number {
704 1 => {
705 if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
706 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
707 }
708 let tmp = is.read_double()?;
709 self.time = tmp;
710 },
711 2 => {
712 if wire_type != ::protobuf::wire_format::WireTypeVarint {
713 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
714 }
715 let tmp = is.read_bool()?;
716 self.has_error = tmp;
717 },
718 3 => {
719 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.error)?;
720 },
721 4 => {
722 if wire_type != ::protobuf::wire_format::WireTypeVarint {
723 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
724 }
725 let tmp = is.read_bool()?;
726 self.has_return_value = tmp;
727 },
728 5 => {
729 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.return_value)?;
730 },
731 _ => {
732 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
733 },
734 };
735 }
736 ::std::result::Result::Ok(())
737 }
738
739 #[allow(unused_variables)]
741 fn compute_size(&self) -> u32 {
742 let mut my_size = 0;
743 if self.time != 0. {
744 my_size += 9;
745 }
746 if self.has_error != false {
747 my_size += 2;
748 }
749 if !self.error.is_empty() {
750 my_size += ::protobuf::rt::string_size(3, &self.error);
751 }
752 if self.has_return_value != false {
753 my_size += 2;
754 }
755 if !self.return_value.is_empty() {
756 my_size += ::protobuf::rt::bytes_size(5, &self.return_value);
757 }
758 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
759 self.cached_size.set(my_size);
760 my_size
761 }
762
763 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
764 if self.time != 0. {
765 os.write_double(1, self.time)?;
766 }
767 if self.has_error != false {
768 os.write_bool(2, self.has_error)?;
769 }
770 if !self.error.is_empty() {
771 os.write_string(3, &self.error)?;
772 }
773 if self.has_return_value != false {
774 os.write_bool(4, self.has_return_value)?;
775 }
776 if !self.return_value.is_empty() {
777 os.write_bytes(5, &self.return_value)?;
778 }
779 os.write_unknown_fields(self.get_unknown_fields())?;
780 ::std::result::Result::Ok(())
781 }
782
783 fn get_cached_size(&self) -> u32 {
784 self.cached_size.get()
785 }
786
787 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
788 &self.unknown_fields
789 }
790
791 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
792 &mut self.unknown_fields
793 }
794
795 fn as_any(&self) -> &::std::any::Any {
796 self as &::std::any::Any
797 }
798 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
799 self as &mut ::std::any::Any
800 }
801 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
802 self
803 }
804
805 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
806 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
807 }
808}
809
810impl ::protobuf::MessageStatic for Response {
811 fn new() -> Response {
812 Response::new()
813 }
814
815 fn descriptor_static(_: ::std::option::Option<Response>) -> &'static ::protobuf::reflect::MessageDescriptor {
816 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
817 lock: ::protobuf::lazy::ONCE_INIT,
818 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
819 };
820 unsafe {
821 descriptor.get(|| {
822 let mut fields = ::std::vec::Vec::new();
823 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
824 "time",
825 Response::get_time_for_reflect,
826 Response::mut_time_for_reflect,
827 ));
828 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
829 "has_error",
830 Response::get_has_error_for_reflect,
831 Response::mut_has_error_for_reflect,
832 ));
833 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
834 "error",
835 Response::get_error_for_reflect,
836 Response::mut_error_for_reflect,
837 ));
838 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
839 "has_return_value",
840 Response::get_has_return_value_for_reflect,
841 Response::mut_has_return_value_for_reflect,
842 ));
843 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
844 "return_value",
845 Response::get_return_value_for_reflect,
846 Response::mut_return_value_for_reflect,
847 ));
848 ::protobuf::reflect::MessageDescriptor::new::<Response>(
849 "Response",
850 fields,
851 file_descriptor_proto()
852 )
853 })
854 }
855 }
856}
857
858impl ::protobuf::Clear for Response {
859 fn clear(&mut self) {
860 self.clear_time();
861 self.clear_has_error();
862 self.clear_error();
863 self.clear_has_return_value();
864 self.clear_return_value();
865 self.unknown_fields.clear();
866 }
867}
868
869impl ::std::fmt::Debug for Response {
870 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
871 ::protobuf::text_format::fmt(self, f)
872 }
873}
874
875impl ::protobuf::reflect::ProtobufValue for Response {
876 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
877 ::protobuf::reflect::ProtobufValueRef::Message(self)
878 }
879}
880
881#[derive(PartialEq,Clone,Default)]
882pub struct StreamMessage {
883 pub responses: ::protobuf::RepeatedField<StreamResponse>,
885 unknown_fields: ::protobuf::UnknownFields,
887 cached_size: ::protobuf::CachedSize,
888}
889
890unsafe impl ::std::marker::Sync for StreamMessage {}
892
893impl StreamMessage {
894 pub fn new() -> StreamMessage {
895 ::std::default::Default::default()
896 }
897
898 pub fn default_instance() -> &'static StreamMessage {
899 static mut instance: ::protobuf::lazy::Lazy<StreamMessage> = ::protobuf::lazy::Lazy {
900 lock: ::protobuf::lazy::ONCE_INIT,
901 ptr: 0 as *const StreamMessage,
902 };
903 unsafe {
904 instance.get(StreamMessage::new)
905 }
906 }
907
908 pub fn clear_responses(&mut self) {
911 self.responses.clear();
912 }
913
914 pub fn set_responses(&mut self, v: ::protobuf::RepeatedField<StreamResponse>) {
916 self.responses = v;
917 }
918
919 pub fn mut_responses(&mut self) -> &mut ::protobuf::RepeatedField<StreamResponse> {
921 &mut self.responses
922 }
923
924 pub fn take_responses(&mut self) -> ::protobuf::RepeatedField<StreamResponse> {
926 ::std::mem::replace(&mut self.responses, ::protobuf::RepeatedField::new())
927 }
928
929 pub fn get_responses(&self) -> &[StreamResponse] {
930 &self.responses
931 }
932
933 fn get_responses_for_reflect(&self) -> &::protobuf::RepeatedField<StreamResponse> {
934 &self.responses
935 }
936
937 fn mut_responses_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<StreamResponse> {
938 &mut self.responses
939 }
940}
941
942impl ::protobuf::Message for StreamMessage {
943 fn is_initialized(&self) -> bool {
944 for v in &self.responses {
945 if !v.is_initialized() {
946 return false;
947 }
948 };
949 true
950 }
951
952 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
953 while !is.eof()? {
954 let (field_number, wire_type) = is.read_tag_unpack()?;
955 match field_number {
956 1 => {
957 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.responses)?;
958 },
959 _ => {
960 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
961 },
962 };
963 }
964 ::std::result::Result::Ok(())
965 }
966
967 #[allow(unused_variables)]
969 fn compute_size(&self) -> u32 {
970 let mut my_size = 0;
971 for value in &self.responses {
972 let len = value.compute_size();
973 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
974 };
975 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
976 self.cached_size.set(my_size);
977 my_size
978 }
979
980 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
981 for v in &self.responses {
982 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
983 os.write_raw_varint32(v.get_cached_size())?;
984 v.write_to_with_cached_sizes(os)?;
985 };
986 os.write_unknown_fields(self.get_unknown_fields())?;
987 ::std::result::Result::Ok(())
988 }
989
990 fn get_cached_size(&self) -> u32 {
991 self.cached_size.get()
992 }
993
994 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
995 &self.unknown_fields
996 }
997
998 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
999 &mut self.unknown_fields
1000 }
1001
1002 fn as_any(&self) -> &::std::any::Any {
1003 self as &::std::any::Any
1004 }
1005 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
1006 self as &mut ::std::any::Any
1007 }
1008 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
1009 self
1010 }
1011
1012 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1013 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
1014 }
1015}
1016
1017impl ::protobuf::MessageStatic for StreamMessage {
1018 fn new() -> StreamMessage {
1019 StreamMessage::new()
1020 }
1021
1022 fn descriptor_static(_: ::std::option::Option<StreamMessage>) -> &'static ::protobuf::reflect::MessageDescriptor {
1023 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1024 lock: ::protobuf::lazy::ONCE_INIT,
1025 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1026 };
1027 unsafe {
1028 descriptor.get(|| {
1029 let mut fields = ::std::vec::Vec::new();
1030 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<StreamResponse>>(
1031 "responses",
1032 StreamMessage::get_responses_for_reflect,
1033 StreamMessage::mut_responses_for_reflect,
1034 ));
1035 ::protobuf::reflect::MessageDescriptor::new::<StreamMessage>(
1036 "StreamMessage",
1037 fields,
1038 file_descriptor_proto()
1039 )
1040 })
1041 }
1042 }
1043}
1044
1045impl ::protobuf::Clear for StreamMessage {
1046 fn clear(&mut self) {
1047 self.clear_responses();
1048 self.unknown_fields.clear();
1049 }
1050}
1051
1052impl ::std::fmt::Debug for StreamMessage {
1053 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1054 ::protobuf::text_format::fmt(self, f)
1055 }
1056}
1057
1058impl ::protobuf::reflect::ProtobufValue for StreamMessage {
1059 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1060 ::protobuf::reflect::ProtobufValueRef::Message(self)
1061 }
1062}
1063
1064#[derive(PartialEq,Clone,Default)]
1065pub struct StreamResponse {
1066 pub id: u32,
1068 pub response: ::protobuf::SingularPtrField<Response>,
1069 unknown_fields: ::protobuf::UnknownFields,
1071 cached_size: ::protobuf::CachedSize,
1072}
1073
1074unsafe impl ::std::marker::Sync for StreamResponse {}
1076
1077impl StreamResponse {
1078 pub fn new() -> StreamResponse {
1079 ::std::default::Default::default()
1080 }
1081
1082 pub fn default_instance() -> &'static StreamResponse {
1083 static mut instance: ::protobuf::lazy::Lazy<StreamResponse> = ::protobuf::lazy::Lazy {
1084 lock: ::protobuf::lazy::ONCE_INIT,
1085 ptr: 0 as *const StreamResponse,
1086 };
1087 unsafe {
1088 instance.get(StreamResponse::new)
1089 }
1090 }
1091
1092 pub fn clear_id(&mut self) {
1095 self.id = 0;
1096 }
1097
1098 pub fn set_id(&mut self, v: u32) {
1100 self.id = v;
1101 }
1102
1103 pub fn get_id(&self) -> u32 {
1104 self.id
1105 }
1106
1107 fn get_id_for_reflect(&self) -> &u32 {
1108 &self.id
1109 }
1110
1111 fn mut_id_for_reflect(&mut self) -> &mut u32 {
1112 &mut self.id
1113 }
1114
1115 pub fn clear_response(&mut self) {
1118 self.response.clear();
1119 }
1120
1121 pub fn has_response(&self) -> bool {
1122 self.response.is_some()
1123 }
1124
1125 pub fn set_response(&mut self, v: Response) {
1127 self.response = ::protobuf::SingularPtrField::some(v);
1128 }
1129
1130 pub fn mut_response(&mut self) -> &mut Response {
1133 if self.response.is_none() {
1134 self.response.set_default();
1135 }
1136 self.response.as_mut().unwrap()
1137 }
1138
1139 pub fn take_response(&mut self) -> Response {
1141 self.response.take().unwrap_or_else(|| Response::new())
1142 }
1143
1144 pub fn get_response(&self) -> &Response {
1145 self.response.as_ref().unwrap_or_else(|| Response::default_instance())
1146 }
1147
1148 fn get_response_for_reflect(&self) -> &::protobuf::SingularPtrField<Response> {
1149 &self.response
1150 }
1151
1152 fn mut_response_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField<Response> {
1153 &mut self.response
1154 }
1155}
1156
1157impl ::protobuf::Message for StreamResponse {
1158 fn is_initialized(&self) -> bool {
1159 for v in &self.response {
1160 if !v.is_initialized() {
1161 return false;
1162 }
1163 };
1164 true
1165 }
1166
1167 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
1168 while !is.eof()? {
1169 let (field_number, wire_type) = is.read_tag_unpack()?;
1170 match field_number {
1171 1 => {
1172 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1173 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1174 }
1175 let tmp = is.read_uint32()?;
1176 self.id = tmp;
1177 },
1178 2 => {
1179 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.response)?;
1180 },
1181 _ => {
1182 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1183 },
1184 };
1185 }
1186 ::std::result::Result::Ok(())
1187 }
1188
1189 #[allow(unused_variables)]
1191 fn compute_size(&self) -> u32 {
1192 let mut my_size = 0;
1193 if self.id != 0 {
1194 my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
1195 }
1196 if let Some(ref v) = self.response.as_ref() {
1197 let len = v.compute_size();
1198 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1199 }
1200 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1201 self.cached_size.set(my_size);
1202 my_size
1203 }
1204
1205 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
1206 if self.id != 0 {
1207 os.write_uint32(1, self.id)?;
1208 }
1209 if let Some(ref v) = self.response.as_ref() {
1210 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1211 os.write_raw_varint32(v.get_cached_size())?;
1212 v.write_to_with_cached_sizes(os)?;
1213 }
1214 os.write_unknown_fields(self.get_unknown_fields())?;
1215 ::std::result::Result::Ok(())
1216 }
1217
1218 fn get_cached_size(&self) -> u32 {
1219 self.cached_size.get()
1220 }
1221
1222 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1223 &self.unknown_fields
1224 }
1225
1226 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1227 &mut self.unknown_fields
1228 }
1229
1230 fn as_any(&self) -> &::std::any::Any {
1231 self as &::std::any::Any
1232 }
1233 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
1234 self as &mut ::std::any::Any
1235 }
1236 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
1237 self
1238 }
1239
1240 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1241 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
1242 }
1243}
1244
1245impl ::protobuf::MessageStatic for StreamResponse {
1246 fn new() -> StreamResponse {
1247 StreamResponse::new()
1248 }
1249
1250 fn descriptor_static(_: ::std::option::Option<StreamResponse>) -> &'static ::protobuf::reflect::MessageDescriptor {
1251 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1252 lock: ::protobuf::lazy::ONCE_INIT,
1253 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1254 };
1255 unsafe {
1256 descriptor.get(|| {
1257 let mut fields = ::std::vec::Vec::new();
1258 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
1259 "id",
1260 StreamResponse::get_id_for_reflect,
1261 StreamResponse::mut_id_for_reflect,
1262 ));
1263 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Response>>(
1264 "response",
1265 StreamResponse::get_response_for_reflect,
1266 StreamResponse::mut_response_for_reflect,
1267 ));
1268 ::protobuf::reflect::MessageDescriptor::new::<StreamResponse>(
1269 "StreamResponse",
1270 fields,
1271 file_descriptor_proto()
1272 )
1273 })
1274 }
1275 }
1276}
1277
1278impl ::protobuf::Clear for StreamResponse {
1279 fn clear(&mut self) {
1280 self.clear_id();
1281 self.clear_response();
1282 self.unknown_fields.clear();
1283 }
1284}
1285
1286impl ::std::fmt::Debug for StreamResponse {
1287 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1288 ::protobuf::text_format::fmt(self, f)
1289 }
1290}
1291
1292impl ::protobuf::reflect::ProtobufValue for StreamResponse {
1293 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1294 ::protobuf::reflect::ProtobufValueRef::Message(self)
1295 }
1296}
1297
1298#[derive(PartialEq,Clone,Default)]
1299pub struct Services {
1300 pub services: ::protobuf::RepeatedField<Service>,
1302 unknown_fields: ::protobuf::UnknownFields,
1304 cached_size: ::protobuf::CachedSize,
1305}
1306
1307unsafe impl ::std::marker::Sync for Services {}
1309
1310impl Services {
1311 pub fn new() -> Services {
1312 ::std::default::Default::default()
1313 }
1314
1315 pub fn default_instance() -> &'static Services {
1316 static mut instance: ::protobuf::lazy::Lazy<Services> = ::protobuf::lazy::Lazy {
1317 lock: ::protobuf::lazy::ONCE_INIT,
1318 ptr: 0 as *const Services,
1319 };
1320 unsafe {
1321 instance.get(Services::new)
1322 }
1323 }
1324
1325 pub fn clear_services(&mut self) {
1328 self.services.clear();
1329 }
1330
1331 pub fn set_services(&mut self, v: ::protobuf::RepeatedField<Service>) {
1333 self.services = v;
1334 }
1335
1336 pub fn mut_services(&mut self) -> &mut ::protobuf::RepeatedField<Service> {
1338 &mut self.services
1339 }
1340
1341 pub fn take_services(&mut self) -> ::protobuf::RepeatedField<Service> {
1343 ::std::mem::replace(&mut self.services, ::protobuf::RepeatedField::new())
1344 }
1345
1346 pub fn get_services(&self) -> &[Service] {
1347 &self.services
1348 }
1349
1350 fn get_services_for_reflect(&self) -> &::protobuf::RepeatedField<Service> {
1351 &self.services
1352 }
1353
1354 fn mut_services_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<Service> {
1355 &mut self.services
1356 }
1357}
1358
1359impl ::protobuf::Message for Services {
1360 fn is_initialized(&self) -> bool {
1361 for v in &self.services {
1362 if !v.is_initialized() {
1363 return false;
1364 }
1365 };
1366 true
1367 }
1368
1369 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
1370 while !is.eof()? {
1371 let (field_number, wire_type) = is.read_tag_unpack()?;
1372 match field_number {
1373 1 => {
1374 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.services)?;
1375 },
1376 _ => {
1377 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1378 },
1379 };
1380 }
1381 ::std::result::Result::Ok(())
1382 }
1383
1384 #[allow(unused_variables)]
1386 fn compute_size(&self) -> u32 {
1387 let mut my_size = 0;
1388 for value in &self.services {
1389 let len = value.compute_size();
1390 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1391 };
1392 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1393 self.cached_size.set(my_size);
1394 my_size
1395 }
1396
1397 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
1398 for v in &self.services {
1399 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1400 os.write_raw_varint32(v.get_cached_size())?;
1401 v.write_to_with_cached_sizes(os)?;
1402 };
1403 os.write_unknown_fields(self.get_unknown_fields())?;
1404 ::std::result::Result::Ok(())
1405 }
1406
1407 fn get_cached_size(&self) -> u32 {
1408 self.cached_size.get()
1409 }
1410
1411 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1412 &self.unknown_fields
1413 }
1414
1415 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1416 &mut self.unknown_fields
1417 }
1418
1419 fn as_any(&self) -> &::std::any::Any {
1420 self as &::std::any::Any
1421 }
1422 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
1423 self as &mut ::std::any::Any
1424 }
1425 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
1426 self
1427 }
1428
1429 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1430 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
1431 }
1432}
1433
1434impl ::protobuf::MessageStatic for Services {
1435 fn new() -> Services {
1436 Services::new()
1437 }
1438
1439 fn descriptor_static(_: ::std::option::Option<Services>) -> &'static ::protobuf::reflect::MessageDescriptor {
1440 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1441 lock: ::protobuf::lazy::ONCE_INIT,
1442 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1443 };
1444 unsafe {
1445 descriptor.get(|| {
1446 let mut fields = ::std::vec::Vec::new();
1447 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Service>>(
1448 "services",
1449 Services::get_services_for_reflect,
1450 Services::mut_services_for_reflect,
1451 ));
1452 ::protobuf::reflect::MessageDescriptor::new::<Services>(
1453 "Services",
1454 fields,
1455 file_descriptor_proto()
1456 )
1457 })
1458 }
1459 }
1460}
1461
1462impl ::protobuf::Clear for Services {
1463 fn clear(&mut self) {
1464 self.clear_services();
1465 self.unknown_fields.clear();
1466 }
1467}
1468
1469impl ::std::fmt::Debug for Services {
1470 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1471 ::protobuf::text_format::fmt(self, f)
1472 }
1473}
1474
1475impl ::protobuf::reflect::ProtobufValue for Services {
1476 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1477 ::protobuf::reflect::ProtobufValueRef::Message(self)
1478 }
1479}
1480
1481#[derive(PartialEq,Clone,Default)]
1482pub struct Service {
1483 pub name: ::std::string::String,
1485 pub procedures: ::protobuf::RepeatedField<Procedure>,
1486 pub classes: ::protobuf::RepeatedField<Class>,
1487 pub enumerations: ::protobuf::RepeatedField<Enumeration>,
1488 pub documentation: ::std::string::String,
1489 unknown_fields: ::protobuf::UnknownFields,
1491 cached_size: ::protobuf::CachedSize,
1492}
1493
1494unsafe impl ::std::marker::Sync for Service {}
1496
1497impl Service {
1498 pub fn new() -> Service {
1499 ::std::default::Default::default()
1500 }
1501
1502 pub fn default_instance() -> &'static Service {
1503 static mut instance: ::protobuf::lazy::Lazy<Service> = ::protobuf::lazy::Lazy {
1504 lock: ::protobuf::lazy::ONCE_INIT,
1505 ptr: 0 as *const Service,
1506 };
1507 unsafe {
1508 instance.get(Service::new)
1509 }
1510 }
1511
1512 pub fn clear_name(&mut self) {
1515 self.name.clear();
1516 }
1517
1518 pub fn set_name(&mut self, v: ::std::string::String) {
1520 self.name = v;
1521 }
1522
1523 pub fn mut_name(&mut self) -> &mut ::std::string::String {
1526 &mut self.name
1527 }
1528
1529 pub fn take_name(&mut self) -> ::std::string::String {
1531 ::std::mem::replace(&mut self.name, ::std::string::String::new())
1532 }
1533
1534 pub fn get_name(&self) -> &str {
1535 &self.name
1536 }
1537
1538 fn get_name_for_reflect(&self) -> &::std::string::String {
1539 &self.name
1540 }
1541
1542 fn mut_name_for_reflect(&mut self) -> &mut ::std::string::String {
1543 &mut self.name
1544 }
1545
1546 pub fn clear_procedures(&mut self) {
1549 self.procedures.clear();
1550 }
1551
1552 pub fn set_procedures(&mut self, v: ::protobuf::RepeatedField<Procedure>) {
1554 self.procedures = v;
1555 }
1556
1557 pub fn mut_procedures(&mut self) -> &mut ::protobuf::RepeatedField<Procedure> {
1559 &mut self.procedures
1560 }
1561
1562 pub fn take_procedures(&mut self) -> ::protobuf::RepeatedField<Procedure> {
1564 ::std::mem::replace(&mut self.procedures, ::protobuf::RepeatedField::new())
1565 }
1566
1567 pub fn get_procedures(&self) -> &[Procedure] {
1568 &self.procedures
1569 }
1570
1571 fn get_procedures_for_reflect(&self) -> &::protobuf::RepeatedField<Procedure> {
1572 &self.procedures
1573 }
1574
1575 fn mut_procedures_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<Procedure> {
1576 &mut self.procedures
1577 }
1578
1579 pub fn clear_classes(&mut self) {
1582 self.classes.clear();
1583 }
1584
1585 pub fn set_classes(&mut self, v: ::protobuf::RepeatedField<Class>) {
1587 self.classes = v;
1588 }
1589
1590 pub fn mut_classes(&mut self) -> &mut ::protobuf::RepeatedField<Class> {
1592 &mut self.classes
1593 }
1594
1595 pub fn take_classes(&mut self) -> ::protobuf::RepeatedField<Class> {
1597 ::std::mem::replace(&mut self.classes, ::protobuf::RepeatedField::new())
1598 }
1599
1600 pub fn get_classes(&self) -> &[Class] {
1601 &self.classes
1602 }
1603
1604 fn get_classes_for_reflect(&self) -> &::protobuf::RepeatedField<Class> {
1605 &self.classes
1606 }
1607
1608 fn mut_classes_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<Class> {
1609 &mut self.classes
1610 }
1611
1612 pub fn clear_enumerations(&mut self) {
1615 self.enumerations.clear();
1616 }
1617
1618 pub fn set_enumerations(&mut self, v: ::protobuf::RepeatedField<Enumeration>) {
1620 self.enumerations = v;
1621 }
1622
1623 pub fn mut_enumerations(&mut self) -> &mut ::protobuf::RepeatedField<Enumeration> {
1625 &mut self.enumerations
1626 }
1627
1628 pub fn take_enumerations(&mut self) -> ::protobuf::RepeatedField<Enumeration> {
1630 ::std::mem::replace(&mut self.enumerations, ::protobuf::RepeatedField::new())
1631 }
1632
1633 pub fn get_enumerations(&self) -> &[Enumeration] {
1634 &self.enumerations
1635 }
1636
1637 fn get_enumerations_for_reflect(&self) -> &::protobuf::RepeatedField<Enumeration> {
1638 &self.enumerations
1639 }
1640
1641 fn mut_enumerations_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<Enumeration> {
1642 &mut self.enumerations
1643 }
1644
1645 pub fn clear_documentation(&mut self) {
1648 self.documentation.clear();
1649 }
1650
1651 pub fn set_documentation(&mut self, v: ::std::string::String) {
1653 self.documentation = v;
1654 }
1655
1656 pub fn mut_documentation(&mut self) -> &mut ::std::string::String {
1659 &mut self.documentation
1660 }
1661
1662 pub fn take_documentation(&mut self) -> ::std::string::String {
1664 ::std::mem::replace(&mut self.documentation, ::std::string::String::new())
1665 }
1666
1667 pub fn get_documentation(&self) -> &str {
1668 &self.documentation
1669 }
1670
1671 fn get_documentation_for_reflect(&self) -> &::std::string::String {
1672 &self.documentation
1673 }
1674
1675 fn mut_documentation_for_reflect(&mut self) -> &mut ::std::string::String {
1676 &mut self.documentation
1677 }
1678}
1679
1680impl ::protobuf::Message for Service {
1681 fn is_initialized(&self) -> bool {
1682 for v in &self.procedures {
1683 if !v.is_initialized() {
1684 return false;
1685 }
1686 };
1687 for v in &self.classes {
1688 if !v.is_initialized() {
1689 return false;
1690 }
1691 };
1692 for v in &self.enumerations {
1693 if !v.is_initialized() {
1694 return false;
1695 }
1696 };
1697 true
1698 }
1699
1700 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
1701 while !is.eof()? {
1702 let (field_number, wire_type) = is.read_tag_unpack()?;
1703 match field_number {
1704 1 => {
1705 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
1706 },
1707 2 => {
1708 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.procedures)?;
1709 },
1710 3 => {
1711 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.classes)?;
1712 },
1713 4 => {
1714 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.enumerations)?;
1715 },
1716 5 => {
1717 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.documentation)?;
1718 },
1719 _ => {
1720 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1721 },
1722 };
1723 }
1724 ::std::result::Result::Ok(())
1725 }
1726
1727 #[allow(unused_variables)]
1729 fn compute_size(&self) -> u32 {
1730 let mut my_size = 0;
1731 if !self.name.is_empty() {
1732 my_size += ::protobuf::rt::string_size(1, &self.name);
1733 }
1734 for value in &self.procedures {
1735 let len = value.compute_size();
1736 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1737 };
1738 for value in &self.classes {
1739 let len = value.compute_size();
1740 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1741 };
1742 for value in &self.enumerations {
1743 let len = value.compute_size();
1744 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1745 };
1746 if !self.documentation.is_empty() {
1747 my_size += ::protobuf::rt::string_size(5, &self.documentation);
1748 }
1749 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1750 self.cached_size.set(my_size);
1751 my_size
1752 }
1753
1754 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
1755 if !self.name.is_empty() {
1756 os.write_string(1, &self.name)?;
1757 }
1758 for v in &self.procedures {
1759 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1760 os.write_raw_varint32(v.get_cached_size())?;
1761 v.write_to_with_cached_sizes(os)?;
1762 };
1763 for v in &self.classes {
1764 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1765 os.write_raw_varint32(v.get_cached_size())?;
1766 v.write_to_with_cached_sizes(os)?;
1767 };
1768 for v in &self.enumerations {
1769 os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1770 os.write_raw_varint32(v.get_cached_size())?;
1771 v.write_to_with_cached_sizes(os)?;
1772 };
1773 if !self.documentation.is_empty() {
1774 os.write_string(5, &self.documentation)?;
1775 }
1776 os.write_unknown_fields(self.get_unknown_fields())?;
1777 ::std::result::Result::Ok(())
1778 }
1779
1780 fn get_cached_size(&self) -> u32 {
1781 self.cached_size.get()
1782 }
1783
1784 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1785 &self.unknown_fields
1786 }
1787
1788 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1789 &mut self.unknown_fields
1790 }
1791
1792 fn as_any(&self) -> &::std::any::Any {
1793 self as &::std::any::Any
1794 }
1795 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
1796 self as &mut ::std::any::Any
1797 }
1798 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
1799 self
1800 }
1801
1802 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1803 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
1804 }
1805}
1806
1807impl ::protobuf::MessageStatic for Service {
1808 fn new() -> Service {
1809 Service::new()
1810 }
1811
1812 fn descriptor_static(_: ::std::option::Option<Service>) -> &'static ::protobuf::reflect::MessageDescriptor {
1813 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1814 lock: ::protobuf::lazy::ONCE_INIT,
1815 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1816 };
1817 unsafe {
1818 descriptor.get(|| {
1819 let mut fields = ::std::vec::Vec::new();
1820 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1821 "name",
1822 Service::get_name_for_reflect,
1823 Service::mut_name_for_reflect,
1824 ));
1825 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Procedure>>(
1826 "procedures",
1827 Service::get_procedures_for_reflect,
1828 Service::mut_procedures_for_reflect,
1829 ));
1830 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Class>>(
1831 "classes",
1832 Service::get_classes_for_reflect,
1833 Service::mut_classes_for_reflect,
1834 ));
1835 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Enumeration>>(
1836 "enumerations",
1837 Service::get_enumerations_for_reflect,
1838 Service::mut_enumerations_for_reflect,
1839 ));
1840 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1841 "documentation",
1842 Service::get_documentation_for_reflect,
1843 Service::mut_documentation_for_reflect,
1844 ));
1845 ::protobuf::reflect::MessageDescriptor::new::<Service>(
1846 "Service",
1847 fields,
1848 file_descriptor_proto()
1849 )
1850 })
1851 }
1852 }
1853}
1854
1855impl ::protobuf::Clear for Service {
1856 fn clear(&mut self) {
1857 self.clear_name();
1858 self.clear_procedures();
1859 self.clear_classes();
1860 self.clear_enumerations();
1861 self.clear_documentation();
1862 self.unknown_fields.clear();
1863 }
1864}
1865
1866impl ::std::fmt::Debug for Service {
1867 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1868 ::protobuf::text_format::fmt(self, f)
1869 }
1870}
1871
1872impl ::protobuf::reflect::ProtobufValue for Service {
1873 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1874 ::protobuf::reflect::ProtobufValueRef::Message(self)
1875 }
1876}
1877
1878#[derive(PartialEq,Clone,Default)]
1879pub struct Procedure {
1880 pub name: ::std::string::String,
1882 pub parameters: ::protobuf::RepeatedField<Parameter>,
1883 pub has_return_type: bool,
1884 pub return_type: ::std::string::String,
1885 pub attributes: ::protobuf::RepeatedField<::std::string::String>,
1886 pub documentation: ::std::string::String,
1887 unknown_fields: ::protobuf::UnknownFields,
1889 cached_size: ::protobuf::CachedSize,
1890}
1891
1892unsafe impl ::std::marker::Sync for Procedure {}
1894
1895impl Procedure {
1896 pub fn new() -> Procedure {
1897 ::std::default::Default::default()
1898 }
1899
1900 pub fn default_instance() -> &'static Procedure {
1901 static mut instance: ::protobuf::lazy::Lazy<Procedure> = ::protobuf::lazy::Lazy {
1902 lock: ::protobuf::lazy::ONCE_INIT,
1903 ptr: 0 as *const Procedure,
1904 };
1905 unsafe {
1906 instance.get(Procedure::new)
1907 }
1908 }
1909
1910 pub fn clear_name(&mut self) {
1913 self.name.clear();
1914 }
1915
1916 pub fn set_name(&mut self, v: ::std::string::String) {
1918 self.name = v;
1919 }
1920
1921 pub fn mut_name(&mut self) -> &mut ::std::string::String {
1924 &mut self.name
1925 }
1926
1927 pub fn take_name(&mut self) -> ::std::string::String {
1929 ::std::mem::replace(&mut self.name, ::std::string::String::new())
1930 }
1931
1932 pub fn get_name(&self) -> &str {
1933 &self.name
1934 }
1935
1936 fn get_name_for_reflect(&self) -> &::std::string::String {
1937 &self.name
1938 }
1939
1940 fn mut_name_for_reflect(&mut self) -> &mut ::std::string::String {
1941 &mut self.name
1942 }
1943
1944 pub fn clear_parameters(&mut self) {
1947 self.parameters.clear();
1948 }
1949
1950 pub fn set_parameters(&mut self, v: ::protobuf::RepeatedField<Parameter>) {
1952 self.parameters = v;
1953 }
1954
1955 pub fn mut_parameters(&mut self) -> &mut ::protobuf::RepeatedField<Parameter> {
1957 &mut self.parameters
1958 }
1959
1960 pub fn take_parameters(&mut self) -> ::protobuf::RepeatedField<Parameter> {
1962 ::std::mem::replace(&mut self.parameters, ::protobuf::RepeatedField::new())
1963 }
1964
1965 pub fn get_parameters(&self) -> &[Parameter] {
1966 &self.parameters
1967 }
1968
1969 fn get_parameters_for_reflect(&self) -> &::protobuf::RepeatedField<Parameter> {
1970 &self.parameters
1971 }
1972
1973 fn mut_parameters_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<Parameter> {
1974 &mut self.parameters
1975 }
1976
1977 pub fn clear_has_return_type(&mut self) {
1980 self.has_return_type = false;
1981 }
1982
1983 pub fn set_has_return_type(&mut self, v: bool) {
1985 self.has_return_type = v;
1986 }
1987
1988 pub fn get_has_return_type(&self) -> bool {
1989 self.has_return_type
1990 }
1991
1992 fn get_has_return_type_for_reflect(&self) -> &bool {
1993 &self.has_return_type
1994 }
1995
1996 fn mut_has_return_type_for_reflect(&mut self) -> &mut bool {
1997 &mut self.has_return_type
1998 }
1999
2000 pub fn clear_return_type(&mut self) {
2003 self.return_type.clear();
2004 }
2005
2006 pub fn set_return_type(&mut self, v: ::std::string::String) {
2008 self.return_type = v;
2009 }
2010
2011 pub fn mut_return_type(&mut self) -> &mut ::std::string::String {
2014 &mut self.return_type
2015 }
2016
2017 pub fn take_return_type(&mut self) -> ::std::string::String {
2019 ::std::mem::replace(&mut self.return_type, ::std::string::String::new())
2020 }
2021
2022 pub fn get_return_type(&self) -> &str {
2023 &self.return_type
2024 }
2025
2026 fn get_return_type_for_reflect(&self) -> &::std::string::String {
2027 &self.return_type
2028 }
2029
2030 fn mut_return_type_for_reflect(&mut self) -> &mut ::std::string::String {
2031 &mut self.return_type
2032 }
2033
2034 pub fn clear_attributes(&mut self) {
2037 self.attributes.clear();
2038 }
2039
2040 pub fn set_attributes(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
2042 self.attributes = v;
2043 }
2044
2045 pub fn mut_attributes(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
2047 &mut self.attributes
2048 }
2049
2050 pub fn take_attributes(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
2052 ::std::mem::replace(&mut self.attributes, ::protobuf::RepeatedField::new())
2053 }
2054
2055 pub fn get_attributes(&self) -> &[::std::string::String] {
2056 &self.attributes
2057 }
2058
2059 fn get_attributes_for_reflect(&self) -> &::protobuf::RepeatedField<::std::string::String> {
2060 &self.attributes
2061 }
2062
2063 fn mut_attributes_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
2064 &mut self.attributes
2065 }
2066
2067 pub fn clear_documentation(&mut self) {
2070 self.documentation.clear();
2071 }
2072
2073 pub fn set_documentation(&mut self, v: ::std::string::String) {
2075 self.documentation = v;
2076 }
2077
2078 pub fn mut_documentation(&mut self) -> &mut ::std::string::String {
2081 &mut self.documentation
2082 }
2083
2084 pub fn take_documentation(&mut self) -> ::std::string::String {
2086 ::std::mem::replace(&mut self.documentation, ::std::string::String::new())
2087 }
2088
2089 pub fn get_documentation(&self) -> &str {
2090 &self.documentation
2091 }
2092
2093 fn get_documentation_for_reflect(&self) -> &::std::string::String {
2094 &self.documentation
2095 }
2096
2097 fn mut_documentation_for_reflect(&mut self) -> &mut ::std::string::String {
2098 &mut self.documentation
2099 }
2100}
2101
2102impl ::protobuf::Message for Procedure {
2103 fn is_initialized(&self) -> bool {
2104 for v in &self.parameters {
2105 if !v.is_initialized() {
2106 return false;
2107 }
2108 };
2109 true
2110 }
2111
2112 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
2113 while !is.eof()? {
2114 let (field_number, wire_type) = is.read_tag_unpack()?;
2115 match field_number {
2116 1 => {
2117 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2118 },
2119 2 => {
2120 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.parameters)?;
2121 },
2122 3 => {
2123 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2124 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2125 }
2126 let tmp = is.read_bool()?;
2127 self.has_return_type = tmp;
2128 },
2129 4 => {
2130 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.return_type)?;
2131 },
2132 5 => {
2133 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.attributes)?;
2134 },
2135 6 => {
2136 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.documentation)?;
2137 },
2138 _ => {
2139 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2140 },
2141 };
2142 }
2143 ::std::result::Result::Ok(())
2144 }
2145
2146 #[allow(unused_variables)]
2148 fn compute_size(&self) -> u32 {
2149 let mut my_size = 0;
2150 if !self.name.is_empty() {
2151 my_size += ::protobuf::rt::string_size(1, &self.name);
2152 }
2153 for value in &self.parameters {
2154 let len = value.compute_size();
2155 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2156 };
2157 if self.has_return_type != false {
2158 my_size += 2;
2159 }
2160 if !self.return_type.is_empty() {
2161 my_size += ::protobuf::rt::string_size(4, &self.return_type);
2162 }
2163 for value in &self.attributes {
2164 my_size += ::protobuf::rt::string_size(5, &value);
2165 };
2166 if !self.documentation.is_empty() {
2167 my_size += ::protobuf::rt::string_size(6, &self.documentation);
2168 }
2169 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2170 self.cached_size.set(my_size);
2171 my_size
2172 }
2173
2174 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
2175 if !self.name.is_empty() {
2176 os.write_string(1, &self.name)?;
2177 }
2178 for v in &self.parameters {
2179 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2180 os.write_raw_varint32(v.get_cached_size())?;
2181 v.write_to_with_cached_sizes(os)?;
2182 };
2183 if self.has_return_type != false {
2184 os.write_bool(3, self.has_return_type)?;
2185 }
2186 if !self.return_type.is_empty() {
2187 os.write_string(4, &self.return_type)?;
2188 }
2189 for v in &self.attributes {
2190 os.write_string(5, &v)?;
2191 };
2192 if !self.documentation.is_empty() {
2193 os.write_string(6, &self.documentation)?;
2194 }
2195 os.write_unknown_fields(self.get_unknown_fields())?;
2196 ::std::result::Result::Ok(())
2197 }
2198
2199 fn get_cached_size(&self) -> u32 {
2200 self.cached_size.get()
2201 }
2202
2203 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2204 &self.unknown_fields
2205 }
2206
2207 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2208 &mut self.unknown_fields
2209 }
2210
2211 fn as_any(&self) -> &::std::any::Any {
2212 self as &::std::any::Any
2213 }
2214 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
2215 self as &mut ::std::any::Any
2216 }
2217 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
2218 self
2219 }
2220
2221 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2222 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
2223 }
2224}
2225
2226impl ::protobuf::MessageStatic for Procedure {
2227 fn new() -> Procedure {
2228 Procedure::new()
2229 }
2230
2231 fn descriptor_static(_: ::std::option::Option<Procedure>) -> &'static ::protobuf::reflect::MessageDescriptor {
2232 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2233 lock: ::protobuf::lazy::ONCE_INIT,
2234 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2235 };
2236 unsafe {
2237 descriptor.get(|| {
2238 let mut fields = ::std::vec::Vec::new();
2239 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2240 "name",
2241 Procedure::get_name_for_reflect,
2242 Procedure::mut_name_for_reflect,
2243 ));
2244 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Parameter>>(
2245 "parameters",
2246 Procedure::get_parameters_for_reflect,
2247 Procedure::mut_parameters_for_reflect,
2248 ));
2249 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
2250 "has_return_type",
2251 Procedure::get_has_return_type_for_reflect,
2252 Procedure::mut_has_return_type_for_reflect,
2253 ));
2254 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2255 "return_type",
2256 Procedure::get_return_type_for_reflect,
2257 Procedure::mut_return_type_for_reflect,
2258 ));
2259 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2260 "attributes",
2261 Procedure::get_attributes_for_reflect,
2262 Procedure::mut_attributes_for_reflect,
2263 ));
2264 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2265 "documentation",
2266 Procedure::get_documentation_for_reflect,
2267 Procedure::mut_documentation_for_reflect,
2268 ));
2269 ::protobuf::reflect::MessageDescriptor::new::<Procedure>(
2270 "Procedure",
2271 fields,
2272 file_descriptor_proto()
2273 )
2274 })
2275 }
2276 }
2277}
2278
2279impl ::protobuf::Clear for Procedure {
2280 fn clear(&mut self) {
2281 self.clear_name();
2282 self.clear_parameters();
2283 self.clear_has_return_type();
2284 self.clear_return_type();
2285 self.clear_attributes();
2286 self.clear_documentation();
2287 self.unknown_fields.clear();
2288 }
2289}
2290
2291impl ::std::fmt::Debug for Procedure {
2292 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2293 ::protobuf::text_format::fmt(self, f)
2294 }
2295}
2296
2297impl ::protobuf::reflect::ProtobufValue for Procedure {
2298 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2299 ::protobuf::reflect::ProtobufValueRef::Message(self)
2300 }
2301}
2302
2303#[derive(PartialEq,Clone,Default)]
2304pub struct Parameter {
2305 pub name: ::std::string::String,
2307 pub field_type: ::std::string::String,
2308 pub has_default_value: bool,
2309 pub default_value: ::std::vec::Vec<u8>,
2310 unknown_fields: ::protobuf::UnknownFields,
2312 cached_size: ::protobuf::CachedSize,
2313}
2314
2315unsafe impl ::std::marker::Sync for Parameter {}
2317
2318impl Parameter {
2319 pub fn new() -> Parameter {
2320 ::std::default::Default::default()
2321 }
2322
2323 pub fn default_instance() -> &'static Parameter {
2324 static mut instance: ::protobuf::lazy::Lazy<Parameter> = ::protobuf::lazy::Lazy {
2325 lock: ::protobuf::lazy::ONCE_INIT,
2326 ptr: 0 as *const Parameter,
2327 };
2328 unsafe {
2329 instance.get(Parameter::new)
2330 }
2331 }
2332
2333 pub fn clear_name(&mut self) {
2336 self.name.clear();
2337 }
2338
2339 pub fn set_name(&mut self, v: ::std::string::String) {
2341 self.name = v;
2342 }
2343
2344 pub fn mut_name(&mut self) -> &mut ::std::string::String {
2347 &mut self.name
2348 }
2349
2350 pub fn take_name(&mut self) -> ::std::string::String {
2352 ::std::mem::replace(&mut self.name, ::std::string::String::new())
2353 }
2354
2355 pub fn get_name(&self) -> &str {
2356 &self.name
2357 }
2358
2359 fn get_name_for_reflect(&self) -> &::std::string::String {
2360 &self.name
2361 }
2362
2363 fn mut_name_for_reflect(&mut self) -> &mut ::std::string::String {
2364 &mut self.name
2365 }
2366
2367 pub fn clear_field_type(&mut self) {
2370 self.field_type.clear();
2371 }
2372
2373 pub fn set_field_type(&mut self, v: ::std::string::String) {
2375 self.field_type = v;
2376 }
2377
2378 pub fn mut_field_type(&mut self) -> &mut ::std::string::String {
2381 &mut self.field_type
2382 }
2383
2384 pub fn take_field_type(&mut self) -> ::std::string::String {
2386 ::std::mem::replace(&mut self.field_type, ::std::string::String::new())
2387 }
2388
2389 pub fn get_field_type(&self) -> &str {
2390 &self.field_type
2391 }
2392
2393 fn get_field_type_for_reflect(&self) -> &::std::string::String {
2394 &self.field_type
2395 }
2396
2397 fn mut_field_type_for_reflect(&mut self) -> &mut ::std::string::String {
2398 &mut self.field_type
2399 }
2400
2401 pub fn clear_has_default_value(&mut self) {
2404 self.has_default_value = false;
2405 }
2406
2407 pub fn set_has_default_value(&mut self, v: bool) {
2409 self.has_default_value = v;
2410 }
2411
2412 pub fn get_has_default_value(&self) -> bool {
2413 self.has_default_value
2414 }
2415
2416 fn get_has_default_value_for_reflect(&self) -> &bool {
2417 &self.has_default_value
2418 }
2419
2420 fn mut_has_default_value_for_reflect(&mut self) -> &mut bool {
2421 &mut self.has_default_value
2422 }
2423
2424 pub fn clear_default_value(&mut self) {
2427 self.default_value.clear();
2428 }
2429
2430 pub fn set_default_value(&mut self, v: ::std::vec::Vec<u8>) {
2432 self.default_value = v;
2433 }
2434
2435 pub fn mut_default_value(&mut self) -> &mut ::std::vec::Vec<u8> {
2438 &mut self.default_value
2439 }
2440
2441 pub fn take_default_value(&mut self) -> ::std::vec::Vec<u8> {
2443 ::std::mem::replace(&mut self.default_value, ::std::vec::Vec::new())
2444 }
2445
2446 pub fn get_default_value(&self) -> &[u8] {
2447 &self.default_value
2448 }
2449
2450 fn get_default_value_for_reflect(&self) -> &::std::vec::Vec<u8> {
2451 &self.default_value
2452 }
2453
2454 fn mut_default_value_for_reflect(&mut self) -> &mut ::std::vec::Vec<u8> {
2455 &mut self.default_value
2456 }
2457}
2458
2459impl ::protobuf::Message for Parameter {
2460 fn is_initialized(&self) -> bool {
2461 true
2462 }
2463
2464 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
2465 while !is.eof()? {
2466 let (field_number, wire_type) = is.read_tag_unpack()?;
2467 match field_number {
2468 1 => {
2469 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2470 },
2471 2 => {
2472 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_type)?;
2473 },
2474 3 => {
2475 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2476 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2477 }
2478 let tmp = is.read_bool()?;
2479 self.has_default_value = tmp;
2480 },
2481 4 => {
2482 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.default_value)?;
2483 },
2484 _ => {
2485 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2486 },
2487 };
2488 }
2489 ::std::result::Result::Ok(())
2490 }
2491
2492 #[allow(unused_variables)]
2494 fn compute_size(&self) -> u32 {
2495 let mut my_size = 0;
2496 if !self.name.is_empty() {
2497 my_size += ::protobuf::rt::string_size(1, &self.name);
2498 }
2499 if !self.field_type.is_empty() {
2500 my_size += ::protobuf::rt::string_size(2, &self.field_type);
2501 }
2502 if self.has_default_value != false {
2503 my_size += 2;
2504 }
2505 if !self.default_value.is_empty() {
2506 my_size += ::protobuf::rt::bytes_size(4, &self.default_value);
2507 }
2508 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2509 self.cached_size.set(my_size);
2510 my_size
2511 }
2512
2513 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
2514 if !self.name.is_empty() {
2515 os.write_string(1, &self.name)?;
2516 }
2517 if !self.field_type.is_empty() {
2518 os.write_string(2, &self.field_type)?;
2519 }
2520 if self.has_default_value != false {
2521 os.write_bool(3, self.has_default_value)?;
2522 }
2523 if !self.default_value.is_empty() {
2524 os.write_bytes(4, &self.default_value)?;
2525 }
2526 os.write_unknown_fields(self.get_unknown_fields())?;
2527 ::std::result::Result::Ok(())
2528 }
2529
2530 fn get_cached_size(&self) -> u32 {
2531 self.cached_size.get()
2532 }
2533
2534 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2535 &self.unknown_fields
2536 }
2537
2538 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2539 &mut self.unknown_fields
2540 }
2541
2542 fn as_any(&self) -> &::std::any::Any {
2543 self as &::std::any::Any
2544 }
2545 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
2546 self as &mut ::std::any::Any
2547 }
2548 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
2549 self
2550 }
2551
2552 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2553 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
2554 }
2555}
2556
2557impl ::protobuf::MessageStatic for Parameter {
2558 fn new() -> Parameter {
2559 Parameter::new()
2560 }
2561
2562 fn descriptor_static(_: ::std::option::Option<Parameter>) -> &'static ::protobuf::reflect::MessageDescriptor {
2563 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2564 lock: ::protobuf::lazy::ONCE_INIT,
2565 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2566 };
2567 unsafe {
2568 descriptor.get(|| {
2569 let mut fields = ::std::vec::Vec::new();
2570 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2571 "name",
2572 Parameter::get_name_for_reflect,
2573 Parameter::mut_name_for_reflect,
2574 ));
2575 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2576 "type",
2577 Parameter::get_field_type_for_reflect,
2578 Parameter::mut_field_type_for_reflect,
2579 ));
2580 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
2581 "has_default_value",
2582 Parameter::get_has_default_value_for_reflect,
2583 Parameter::mut_has_default_value_for_reflect,
2584 ));
2585 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
2586 "default_value",
2587 Parameter::get_default_value_for_reflect,
2588 Parameter::mut_default_value_for_reflect,
2589 ));
2590 ::protobuf::reflect::MessageDescriptor::new::<Parameter>(
2591 "Parameter",
2592 fields,
2593 file_descriptor_proto()
2594 )
2595 })
2596 }
2597 }
2598}
2599
2600impl ::protobuf::Clear for Parameter {
2601 fn clear(&mut self) {
2602 self.clear_name();
2603 self.clear_field_type();
2604 self.clear_has_default_value();
2605 self.clear_default_value();
2606 self.unknown_fields.clear();
2607 }
2608}
2609
2610impl ::std::fmt::Debug for Parameter {
2611 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2612 ::protobuf::text_format::fmt(self, f)
2613 }
2614}
2615
2616impl ::protobuf::reflect::ProtobufValue for Parameter {
2617 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2618 ::protobuf::reflect::ProtobufValueRef::Message(self)
2619 }
2620}
2621
2622#[derive(PartialEq,Clone,Default)]
2623pub struct Class {
2624 pub name: ::std::string::String,
2626 pub documentation: ::std::string::String,
2627 unknown_fields: ::protobuf::UnknownFields,
2629 cached_size: ::protobuf::CachedSize,
2630}
2631
2632unsafe impl ::std::marker::Sync for Class {}
2634
2635impl Class {
2636 pub fn new() -> Class {
2637 ::std::default::Default::default()
2638 }
2639
2640 pub fn default_instance() -> &'static Class {
2641 static mut instance: ::protobuf::lazy::Lazy<Class> = ::protobuf::lazy::Lazy {
2642 lock: ::protobuf::lazy::ONCE_INIT,
2643 ptr: 0 as *const Class,
2644 };
2645 unsafe {
2646 instance.get(Class::new)
2647 }
2648 }
2649
2650 pub fn clear_name(&mut self) {
2653 self.name.clear();
2654 }
2655
2656 pub fn set_name(&mut self, v: ::std::string::String) {
2658 self.name = v;
2659 }
2660
2661 pub fn mut_name(&mut self) -> &mut ::std::string::String {
2664 &mut self.name
2665 }
2666
2667 pub fn take_name(&mut self) -> ::std::string::String {
2669 ::std::mem::replace(&mut self.name, ::std::string::String::new())
2670 }
2671
2672 pub fn get_name(&self) -> &str {
2673 &self.name
2674 }
2675
2676 fn get_name_for_reflect(&self) -> &::std::string::String {
2677 &self.name
2678 }
2679
2680 fn mut_name_for_reflect(&mut self) -> &mut ::std::string::String {
2681 &mut self.name
2682 }
2683
2684 pub fn clear_documentation(&mut self) {
2687 self.documentation.clear();
2688 }
2689
2690 pub fn set_documentation(&mut self, v: ::std::string::String) {
2692 self.documentation = v;
2693 }
2694
2695 pub fn mut_documentation(&mut self) -> &mut ::std::string::String {
2698 &mut self.documentation
2699 }
2700
2701 pub fn take_documentation(&mut self) -> ::std::string::String {
2703 ::std::mem::replace(&mut self.documentation, ::std::string::String::new())
2704 }
2705
2706 pub fn get_documentation(&self) -> &str {
2707 &self.documentation
2708 }
2709
2710 fn get_documentation_for_reflect(&self) -> &::std::string::String {
2711 &self.documentation
2712 }
2713
2714 fn mut_documentation_for_reflect(&mut self) -> &mut ::std::string::String {
2715 &mut self.documentation
2716 }
2717}
2718
2719impl ::protobuf::Message for Class {
2720 fn is_initialized(&self) -> bool {
2721 true
2722 }
2723
2724 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
2725 while !is.eof()? {
2726 let (field_number, wire_type) = is.read_tag_unpack()?;
2727 match field_number {
2728 1 => {
2729 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2730 },
2731 2 => {
2732 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.documentation)?;
2733 },
2734 _ => {
2735 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2736 },
2737 };
2738 }
2739 ::std::result::Result::Ok(())
2740 }
2741
2742 #[allow(unused_variables)]
2744 fn compute_size(&self) -> u32 {
2745 let mut my_size = 0;
2746 if !self.name.is_empty() {
2747 my_size += ::protobuf::rt::string_size(1, &self.name);
2748 }
2749 if !self.documentation.is_empty() {
2750 my_size += ::protobuf::rt::string_size(2, &self.documentation);
2751 }
2752 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2753 self.cached_size.set(my_size);
2754 my_size
2755 }
2756
2757 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
2758 if !self.name.is_empty() {
2759 os.write_string(1, &self.name)?;
2760 }
2761 if !self.documentation.is_empty() {
2762 os.write_string(2, &self.documentation)?;
2763 }
2764 os.write_unknown_fields(self.get_unknown_fields())?;
2765 ::std::result::Result::Ok(())
2766 }
2767
2768 fn get_cached_size(&self) -> u32 {
2769 self.cached_size.get()
2770 }
2771
2772 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2773 &self.unknown_fields
2774 }
2775
2776 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2777 &mut self.unknown_fields
2778 }
2779
2780 fn as_any(&self) -> &::std::any::Any {
2781 self as &::std::any::Any
2782 }
2783 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
2784 self as &mut ::std::any::Any
2785 }
2786 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
2787 self
2788 }
2789
2790 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2791 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
2792 }
2793}
2794
2795impl ::protobuf::MessageStatic for Class {
2796 fn new() -> Class {
2797 Class::new()
2798 }
2799
2800 fn descriptor_static(_: ::std::option::Option<Class>) -> &'static ::protobuf::reflect::MessageDescriptor {
2801 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2802 lock: ::protobuf::lazy::ONCE_INIT,
2803 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2804 };
2805 unsafe {
2806 descriptor.get(|| {
2807 let mut fields = ::std::vec::Vec::new();
2808 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2809 "name",
2810 Class::get_name_for_reflect,
2811 Class::mut_name_for_reflect,
2812 ));
2813 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2814 "documentation",
2815 Class::get_documentation_for_reflect,
2816 Class::mut_documentation_for_reflect,
2817 ));
2818 ::protobuf::reflect::MessageDescriptor::new::<Class>(
2819 "Class",
2820 fields,
2821 file_descriptor_proto()
2822 )
2823 })
2824 }
2825 }
2826}
2827
2828impl ::protobuf::Clear for Class {
2829 fn clear(&mut self) {
2830 self.clear_name();
2831 self.clear_documentation();
2832 self.unknown_fields.clear();
2833 }
2834}
2835
2836impl ::std::fmt::Debug for Class {
2837 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
2838 ::protobuf::text_format::fmt(self, f)
2839 }
2840}
2841
2842impl ::protobuf::reflect::ProtobufValue for Class {
2843 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2844 ::protobuf::reflect::ProtobufValueRef::Message(self)
2845 }
2846}
2847
2848#[derive(PartialEq,Clone,Default)]
2849pub struct Enumeration {
2850 pub name: ::std::string::String,
2852 pub values: ::protobuf::RepeatedField<EnumerationValue>,
2853 pub documentation: ::std::string::String,
2854 unknown_fields: ::protobuf::UnknownFields,
2856 cached_size: ::protobuf::CachedSize,
2857}
2858
2859unsafe impl ::std::marker::Sync for Enumeration {}
2861
2862impl Enumeration {
2863 pub fn new() -> Enumeration {
2864 ::std::default::Default::default()
2865 }
2866
2867 pub fn default_instance() -> &'static Enumeration {
2868 static mut instance: ::protobuf::lazy::Lazy<Enumeration> = ::protobuf::lazy::Lazy {
2869 lock: ::protobuf::lazy::ONCE_INIT,
2870 ptr: 0 as *const Enumeration,
2871 };
2872 unsafe {
2873 instance.get(Enumeration::new)
2874 }
2875 }
2876
2877 pub fn clear_name(&mut self) {
2880 self.name.clear();
2881 }
2882
2883 pub fn set_name(&mut self, v: ::std::string::String) {
2885 self.name = v;
2886 }
2887
2888 pub fn mut_name(&mut self) -> &mut ::std::string::String {
2891 &mut self.name
2892 }
2893
2894 pub fn take_name(&mut self) -> ::std::string::String {
2896 ::std::mem::replace(&mut self.name, ::std::string::String::new())
2897 }
2898
2899 pub fn get_name(&self) -> &str {
2900 &self.name
2901 }
2902
2903 fn get_name_for_reflect(&self) -> &::std::string::String {
2904 &self.name
2905 }
2906
2907 fn mut_name_for_reflect(&mut self) -> &mut ::std::string::String {
2908 &mut self.name
2909 }
2910
2911 pub fn clear_values(&mut self) {
2914 self.values.clear();
2915 }
2916
2917 pub fn set_values(&mut self, v: ::protobuf::RepeatedField<EnumerationValue>) {
2919 self.values = v;
2920 }
2921
2922 pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<EnumerationValue> {
2924 &mut self.values
2925 }
2926
2927 pub fn take_values(&mut self) -> ::protobuf::RepeatedField<EnumerationValue> {
2929 ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new())
2930 }
2931
2932 pub fn get_values(&self) -> &[EnumerationValue] {
2933 &self.values
2934 }
2935
2936 fn get_values_for_reflect(&self) -> &::protobuf::RepeatedField<EnumerationValue> {
2937 &self.values
2938 }
2939
2940 fn mut_values_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<EnumerationValue> {
2941 &mut self.values
2942 }
2943
2944 pub fn clear_documentation(&mut self) {
2947 self.documentation.clear();
2948 }
2949
2950 pub fn set_documentation(&mut self, v: ::std::string::String) {
2952 self.documentation = v;
2953 }
2954
2955 pub fn mut_documentation(&mut self) -> &mut ::std::string::String {
2958 &mut self.documentation
2959 }
2960
2961 pub fn take_documentation(&mut self) -> ::std::string::String {
2963 ::std::mem::replace(&mut self.documentation, ::std::string::String::new())
2964 }
2965
2966 pub fn get_documentation(&self) -> &str {
2967 &self.documentation
2968 }
2969
2970 fn get_documentation_for_reflect(&self) -> &::std::string::String {
2971 &self.documentation
2972 }
2973
2974 fn mut_documentation_for_reflect(&mut self) -> &mut ::std::string::String {
2975 &mut self.documentation
2976 }
2977}
2978
2979impl ::protobuf::Message for Enumeration {
2980 fn is_initialized(&self) -> bool {
2981 for v in &self.values {
2982 if !v.is_initialized() {
2983 return false;
2984 }
2985 };
2986 true
2987 }
2988
2989 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
2990 while !is.eof()? {
2991 let (field_number, wire_type) = is.read_tag_unpack()?;
2992 match field_number {
2993 1 => {
2994 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
2995 },
2996 2 => {
2997 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
2998 },
2999 3 => {
3000 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.documentation)?;
3001 },
3002 _ => {
3003 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3004 },
3005 };
3006 }
3007 ::std::result::Result::Ok(())
3008 }
3009
3010 #[allow(unused_variables)]
3012 fn compute_size(&self) -> u32 {
3013 let mut my_size = 0;
3014 if !self.name.is_empty() {
3015 my_size += ::protobuf::rt::string_size(1, &self.name);
3016 }
3017 for value in &self.values {
3018 let len = value.compute_size();
3019 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
3020 };
3021 if !self.documentation.is_empty() {
3022 my_size += ::protobuf::rt::string_size(3, &self.documentation);
3023 }
3024 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3025 self.cached_size.set(my_size);
3026 my_size
3027 }
3028
3029 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
3030 if !self.name.is_empty() {
3031 os.write_string(1, &self.name)?;
3032 }
3033 for v in &self.values {
3034 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
3035 os.write_raw_varint32(v.get_cached_size())?;
3036 v.write_to_with_cached_sizes(os)?;
3037 };
3038 if !self.documentation.is_empty() {
3039 os.write_string(3, &self.documentation)?;
3040 }
3041 os.write_unknown_fields(self.get_unknown_fields())?;
3042 ::std::result::Result::Ok(())
3043 }
3044
3045 fn get_cached_size(&self) -> u32 {
3046 self.cached_size.get()
3047 }
3048
3049 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3050 &self.unknown_fields
3051 }
3052
3053 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3054 &mut self.unknown_fields
3055 }
3056
3057 fn as_any(&self) -> &::std::any::Any {
3058 self as &::std::any::Any
3059 }
3060 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
3061 self as &mut ::std::any::Any
3062 }
3063 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
3064 self
3065 }
3066
3067 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3068 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
3069 }
3070}
3071
3072impl ::protobuf::MessageStatic for Enumeration {
3073 fn new() -> Enumeration {
3074 Enumeration::new()
3075 }
3076
3077 fn descriptor_static(_: ::std::option::Option<Enumeration>) -> &'static ::protobuf::reflect::MessageDescriptor {
3078 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3079 lock: ::protobuf::lazy::ONCE_INIT,
3080 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3081 };
3082 unsafe {
3083 descriptor.get(|| {
3084 let mut fields = ::std::vec::Vec::new();
3085 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3086 "name",
3087 Enumeration::get_name_for_reflect,
3088 Enumeration::mut_name_for_reflect,
3089 ));
3090 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumerationValue>>(
3091 "values",
3092 Enumeration::get_values_for_reflect,
3093 Enumeration::mut_values_for_reflect,
3094 ));
3095 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3096 "documentation",
3097 Enumeration::get_documentation_for_reflect,
3098 Enumeration::mut_documentation_for_reflect,
3099 ));
3100 ::protobuf::reflect::MessageDescriptor::new::<Enumeration>(
3101 "Enumeration",
3102 fields,
3103 file_descriptor_proto()
3104 )
3105 })
3106 }
3107 }
3108}
3109
3110impl ::protobuf::Clear for Enumeration {
3111 fn clear(&mut self) {
3112 self.clear_name();
3113 self.clear_values();
3114 self.clear_documentation();
3115 self.unknown_fields.clear();
3116 }
3117}
3118
3119impl ::std::fmt::Debug for Enumeration {
3120 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
3121 ::protobuf::text_format::fmt(self, f)
3122 }
3123}
3124
3125impl ::protobuf::reflect::ProtobufValue for Enumeration {
3126 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3127 ::protobuf::reflect::ProtobufValueRef::Message(self)
3128 }
3129}
3130
3131#[derive(PartialEq,Clone,Default)]
3132pub struct EnumerationValue {
3133 pub name: ::std::string::String,
3135 pub value: i32,
3136 pub documentation: ::std::string::String,
3137 unknown_fields: ::protobuf::UnknownFields,
3139 cached_size: ::protobuf::CachedSize,
3140}
3141
3142unsafe impl ::std::marker::Sync for EnumerationValue {}
3144
3145impl EnumerationValue {
3146 pub fn new() -> EnumerationValue {
3147 ::std::default::Default::default()
3148 }
3149
3150 pub fn default_instance() -> &'static EnumerationValue {
3151 static mut instance: ::protobuf::lazy::Lazy<EnumerationValue> = ::protobuf::lazy::Lazy {
3152 lock: ::protobuf::lazy::ONCE_INIT,
3153 ptr: 0 as *const EnumerationValue,
3154 };
3155 unsafe {
3156 instance.get(EnumerationValue::new)
3157 }
3158 }
3159
3160 pub fn clear_name(&mut self) {
3163 self.name.clear();
3164 }
3165
3166 pub fn set_name(&mut self, v: ::std::string::String) {
3168 self.name = v;
3169 }
3170
3171 pub fn mut_name(&mut self) -> &mut ::std::string::String {
3174 &mut self.name
3175 }
3176
3177 pub fn take_name(&mut self) -> ::std::string::String {
3179 ::std::mem::replace(&mut self.name, ::std::string::String::new())
3180 }
3181
3182 pub fn get_name(&self) -> &str {
3183 &self.name
3184 }
3185
3186 fn get_name_for_reflect(&self) -> &::std::string::String {
3187 &self.name
3188 }
3189
3190 fn mut_name_for_reflect(&mut self) -> &mut ::std::string::String {
3191 &mut self.name
3192 }
3193
3194 pub fn clear_value(&mut self) {
3197 self.value = 0;
3198 }
3199
3200 pub fn set_value(&mut self, v: i32) {
3202 self.value = v;
3203 }
3204
3205 pub fn get_value(&self) -> i32 {
3206 self.value
3207 }
3208
3209 fn get_value_for_reflect(&self) -> &i32 {
3210 &self.value
3211 }
3212
3213 fn mut_value_for_reflect(&mut self) -> &mut i32 {
3214 &mut self.value
3215 }
3216
3217 pub fn clear_documentation(&mut self) {
3220 self.documentation.clear();
3221 }
3222
3223 pub fn set_documentation(&mut self, v: ::std::string::String) {
3225 self.documentation = v;
3226 }
3227
3228 pub fn mut_documentation(&mut self) -> &mut ::std::string::String {
3231 &mut self.documentation
3232 }
3233
3234 pub fn take_documentation(&mut self) -> ::std::string::String {
3236 ::std::mem::replace(&mut self.documentation, ::std::string::String::new())
3237 }
3238
3239 pub fn get_documentation(&self) -> &str {
3240 &self.documentation
3241 }
3242
3243 fn get_documentation_for_reflect(&self) -> &::std::string::String {
3244 &self.documentation
3245 }
3246
3247 fn mut_documentation_for_reflect(&mut self) -> &mut ::std::string::String {
3248 &mut self.documentation
3249 }
3250}
3251
3252impl ::protobuf::Message for EnumerationValue {
3253 fn is_initialized(&self) -> bool {
3254 true
3255 }
3256
3257 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
3258 while !is.eof()? {
3259 let (field_number, wire_type) = is.read_tag_unpack()?;
3260 match field_number {
3261 1 => {
3262 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
3263 },
3264 2 => {
3265 if wire_type != ::protobuf::wire_format::WireTypeVarint {
3266 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3267 }
3268 let tmp = is.read_int32()?;
3269 self.value = tmp;
3270 },
3271 3 => {
3272 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.documentation)?;
3273 },
3274 _ => {
3275 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3276 },
3277 };
3278 }
3279 ::std::result::Result::Ok(())
3280 }
3281
3282 #[allow(unused_variables)]
3284 fn compute_size(&self) -> u32 {
3285 let mut my_size = 0;
3286 if !self.name.is_empty() {
3287 my_size += ::protobuf::rt::string_size(1, &self.name);
3288 }
3289 if self.value != 0 {
3290 my_size += ::protobuf::rt::value_size(2, self.value, ::protobuf::wire_format::WireTypeVarint);
3291 }
3292 if !self.documentation.is_empty() {
3293 my_size += ::protobuf::rt::string_size(3, &self.documentation);
3294 }
3295 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3296 self.cached_size.set(my_size);
3297 my_size
3298 }
3299
3300 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
3301 if !self.name.is_empty() {
3302 os.write_string(1, &self.name)?;
3303 }
3304 if self.value != 0 {
3305 os.write_int32(2, self.value)?;
3306 }
3307 if !self.documentation.is_empty() {
3308 os.write_string(3, &self.documentation)?;
3309 }
3310 os.write_unknown_fields(self.get_unknown_fields())?;
3311 ::std::result::Result::Ok(())
3312 }
3313
3314 fn get_cached_size(&self) -> u32 {
3315 self.cached_size.get()
3316 }
3317
3318 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3319 &self.unknown_fields
3320 }
3321
3322 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3323 &mut self.unknown_fields
3324 }
3325
3326 fn as_any(&self) -> &::std::any::Any {
3327 self as &::std::any::Any
3328 }
3329 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
3330 self as &mut ::std::any::Any
3331 }
3332 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
3333 self
3334 }
3335
3336 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3337 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
3338 }
3339}
3340
3341impl ::protobuf::MessageStatic for EnumerationValue {
3342 fn new() -> EnumerationValue {
3343 EnumerationValue::new()
3344 }
3345
3346 fn descriptor_static(_: ::std::option::Option<EnumerationValue>) -> &'static ::protobuf::reflect::MessageDescriptor {
3347 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3348 lock: ::protobuf::lazy::ONCE_INIT,
3349 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3350 };
3351 unsafe {
3352 descriptor.get(|| {
3353 let mut fields = ::std::vec::Vec::new();
3354 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3355 "name",
3356 EnumerationValue::get_name_for_reflect,
3357 EnumerationValue::mut_name_for_reflect,
3358 ));
3359 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
3360 "value",
3361 EnumerationValue::get_value_for_reflect,
3362 EnumerationValue::mut_value_for_reflect,
3363 ));
3364 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3365 "documentation",
3366 EnumerationValue::get_documentation_for_reflect,
3367 EnumerationValue::mut_documentation_for_reflect,
3368 ));
3369 ::protobuf::reflect::MessageDescriptor::new::<EnumerationValue>(
3370 "EnumerationValue",
3371 fields,
3372 file_descriptor_proto()
3373 )
3374 })
3375 }
3376 }
3377}
3378
3379impl ::protobuf::Clear for EnumerationValue {
3380 fn clear(&mut self) {
3381 self.clear_name();
3382 self.clear_value();
3383 self.clear_documentation();
3384 self.unknown_fields.clear();
3385 }
3386}
3387
3388impl ::std::fmt::Debug for EnumerationValue {
3389 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
3390 ::protobuf::text_format::fmt(self, f)
3391 }
3392}
3393
3394impl ::protobuf::reflect::ProtobufValue for EnumerationValue {
3395 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3396 ::protobuf::reflect::ProtobufValueRef::Message(self)
3397 }
3398}
3399
3400#[derive(PartialEq,Clone,Default)]
3401pub struct List {
3402 pub items: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
3404 unknown_fields: ::protobuf::UnknownFields,
3406 cached_size: ::protobuf::CachedSize,
3407}
3408
3409unsafe impl ::std::marker::Sync for List {}
3411
3412impl List {
3413 pub fn new() -> List {
3414 ::std::default::Default::default()
3415 }
3416
3417 pub fn default_instance() -> &'static List {
3418 static mut instance: ::protobuf::lazy::Lazy<List> = ::protobuf::lazy::Lazy {
3419 lock: ::protobuf::lazy::ONCE_INIT,
3420 ptr: 0 as *const List,
3421 };
3422 unsafe {
3423 instance.get(List::new)
3424 }
3425 }
3426
3427 pub fn clear_items(&mut self) {
3430 self.items.clear();
3431 }
3432
3433 pub fn set_items(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
3435 self.items = v;
3436 }
3437
3438 pub fn mut_items(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
3440 &mut self.items
3441 }
3442
3443 pub fn take_items(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
3445 ::std::mem::replace(&mut self.items, ::protobuf::RepeatedField::new())
3446 }
3447
3448 pub fn get_items(&self) -> &[::std::vec::Vec<u8>] {
3449 &self.items
3450 }
3451
3452 fn get_items_for_reflect(&self) -> &::protobuf::RepeatedField<::std::vec::Vec<u8>> {
3453 &self.items
3454 }
3455
3456 fn mut_items_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
3457 &mut self.items
3458 }
3459}
3460
3461impl ::protobuf::Message for List {
3462 fn is_initialized(&self) -> bool {
3463 true
3464 }
3465
3466 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
3467 while !is.eof()? {
3468 let (field_number, wire_type) = is.read_tag_unpack()?;
3469 match field_number {
3470 1 => {
3471 ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.items)?;
3472 },
3473 _ => {
3474 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3475 },
3476 };
3477 }
3478 ::std::result::Result::Ok(())
3479 }
3480
3481 #[allow(unused_variables)]
3483 fn compute_size(&self) -> u32 {
3484 let mut my_size = 0;
3485 for value in &self.items {
3486 my_size += ::protobuf::rt::bytes_size(1, &value);
3487 };
3488 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3489 self.cached_size.set(my_size);
3490 my_size
3491 }
3492
3493 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
3494 for v in &self.items {
3495 os.write_bytes(1, &v)?;
3496 };
3497 os.write_unknown_fields(self.get_unknown_fields())?;
3498 ::std::result::Result::Ok(())
3499 }
3500
3501 fn get_cached_size(&self) -> u32 {
3502 self.cached_size.get()
3503 }
3504
3505 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3506 &self.unknown_fields
3507 }
3508
3509 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3510 &mut self.unknown_fields
3511 }
3512
3513 fn as_any(&self) -> &::std::any::Any {
3514 self as &::std::any::Any
3515 }
3516 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
3517 self as &mut ::std::any::Any
3518 }
3519 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
3520 self
3521 }
3522
3523 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3524 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
3525 }
3526}
3527
3528impl ::protobuf::MessageStatic for List {
3529 fn new() -> List {
3530 List::new()
3531 }
3532
3533 fn descriptor_static(_: ::std::option::Option<List>) -> &'static ::protobuf::reflect::MessageDescriptor {
3534 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3535 lock: ::protobuf::lazy::ONCE_INIT,
3536 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3537 };
3538 unsafe {
3539 descriptor.get(|| {
3540 let mut fields = ::std::vec::Vec::new();
3541 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
3542 "items",
3543 List::get_items_for_reflect,
3544 List::mut_items_for_reflect,
3545 ));
3546 ::protobuf::reflect::MessageDescriptor::new::<List>(
3547 "List",
3548 fields,
3549 file_descriptor_proto()
3550 )
3551 })
3552 }
3553 }
3554}
3555
3556impl ::protobuf::Clear for List {
3557 fn clear(&mut self) {
3558 self.clear_items();
3559 self.unknown_fields.clear();
3560 }
3561}
3562
3563impl ::std::fmt::Debug for List {
3564 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
3565 ::protobuf::text_format::fmt(self, f)
3566 }
3567}
3568
3569impl ::protobuf::reflect::ProtobufValue for List {
3570 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3571 ::protobuf::reflect::ProtobufValueRef::Message(self)
3572 }
3573}
3574
3575#[derive(PartialEq,Clone,Default)]
3576pub struct Dictionary {
3577 pub entries: ::protobuf::RepeatedField<DictionaryEntry>,
3579 unknown_fields: ::protobuf::UnknownFields,
3581 cached_size: ::protobuf::CachedSize,
3582}
3583
3584unsafe impl ::std::marker::Sync for Dictionary {}
3586
3587impl Dictionary {
3588 pub fn new() -> Dictionary {
3589 ::std::default::Default::default()
3590 }
3591
3592 pub fn default_instance() -> &'static Dictionary {
3593 static mut instance: ::protobuf::lazy::Lazy<Dictionary> = ::protobuf::lazy::Lazy {
3594 lock: ::protobuf::lazy::ONCE_INIT,
3595 ptr: 0 as *const Dictionary,
3596 };
3597 unsafe {
3598 instance.get(Dictionary::new)
3599 }
3600 }
3601
3602 pub fn clear_entries(&mut self) {
3605 self.entries.clear();
3606 }
3607
3608 pub fn set_entries(&mut self, v: ::protobuf::RepeatedField<DictionaryEntry>) {
3610 self.entries = v;
3611 }
3612
3613 pub fn mut_entries(&mut self) -> &mut ::protobuf::RepeatedField<DictionaryEntry> {
3615 &mut self.entries
3616 }
3617
3618 pub fn take_entries(&mut self) -> ::protobuf::RepeatedField<DictionaryEntry> {
3620 ::std::mem::replace(&mut self.entries, ::protobuf::RepeatedField::new())
3621 }
3622
3623 pub fn get_entries(&self) -> &[DictionaryEntry] {
3624 &self.entries
3625 }
3626
3627 fn get_entries_for_reflect(&self) -> &::protobuf::RepeatedField<DictionaryEntry> {
3628 &self.entries
3629 }
3630
3631 fn mut_entries_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<DictionaryEntry> {
3632 &mut self.entries
3633 }
3634}
3635
3636impl ::protobuf::Message for Dictionary {
3637 fn is_initialized(&self) -> bool {
3638 for v in &self.entries {
3639 if !v.is_initialized() {
3640 return false;
3641 }
3642 };
3643 true
3644 }
3645
3646 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
3647 while !is.eof()? {
3648 let (field_number, wire_type) = is.read_tag_unpack()?;
3649 match field_number {
3650 1 => {
3651 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.entries)?;
3652 },
3653 _ => {
3654 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3655 },
3656 };
3657 }
3658 ::std::result::Result::Ok(())
3659 }
3660
3661 #[allow(unused_variables)]
3663 fn compute_size(&self) -> u32 {
3664 let mut my_size = 0;
3665 for value in &self.entries {
3666 let len = value.compute_size();
3667 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
3668 };
3669 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3670 self.cached_size.set(my_size);
3671 my_size
3672 }
3673
3674 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
3675 for v in &self.entries {
3676 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
3677 os.write_raw_varint32(v.get_cached_size())?;
3678 v.write_to_with_cached_sizes(os)?;
3679 };
3680 os.write_unknown_fields(self.get_unknown_fields())?;
3681 ::std::result::Result::Ok(())
3682 }
3683
3684 fn get_cached_size(&self) -> u32 {
3685 self.cached_size.get()
3686 }
3687
3688 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3689 &self.unknown_fields
3690 }
3691
3692 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3693 &mut self.unknown_fields
3694 }
3695
3696 fn as_any(&self) -> &::std::any::Any {
3697 self as &::std::any::Any
3698 }
3699 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
3700 self as &mut ::std::any::Any
3701 }
3702 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
3703 self
3704 }
3705
3706 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3707 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
3708 }
3709}
3710
3711impl ::protobuf::MessageStatic for Dictionary {
3712 fn new() -> Dictionary {
3713 Dictionary::new()
3714 }
3715
3716 fn descriptor_static(_: ::std::option::Option<Dictionary>) -> &'static ::protobuf::reflect::MessageDescriptor {
3717 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3718 lock: ::protobuf::lazy::ONCE_INIT,
3719 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3720 };
3721 unsafe {
3722 descriptor.get(|| {
3723 let mut fields = ::std::vec::Vec::new();
3724 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DictionaryEntry>>(
3725 "entries",
3726 Dictionary::get_entries_for_reflect,
3727 Dictionary::mut_entries_for_reflect,
3728 ));
3729 ::protobuf::reflect::MessageDescriptor::new::<Dictionary>(
3730 "Dictionary",
3731 fields,
3732 file_descriptor_proto()
3733 )
3734 })
3735 }
3736 }
3737}
3738
3739impl ::protobuf::Clear for Dictionary {
3740 fn clear(&mut self) {
3741 self.clear_entries();
3742 self.unknown_fields.clear();
3743 }
3744}
3745
3746impl ::std::fmt::Debug for Dictionary {
3747 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
3748 ::protobuf::text_format::fmt(self, f)
3749 }
3750}
3751
3752impl ::protobuf::reflect::ProtobufValue for Dictionary {
3753 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3754 ::protobuf::reflect::ProtobufValueRef::Message(self)
3755 }
3756}
3757
3758#[derive(PartialEq,Clone,Default)]
3759pub struct DictionaryEntry {
3760 pub key: ::std::vec::Vec<u8>,
3762 pub value: ::std::vec::Vec<u8>,
3763 unknown_fields: ::protobuf::UnknownFields,
3765 cached_size: ::protobuf::CachedSize,
3766}
3767
3768unsafe impl ::std::marker::Sync for DictionaryEntry {}
3770
3771impl DictionaryEntry {
3772 pub fn new() -> DictionaryEntry {
3773 ::std::default::Default::default()
3774 }
3775
3776 pub fn default_instance() -> &'static DictionaryEntry {
3777 static mut instance: ::protobuf::lazy::Lazy<DictionaryEntry> = ::protobuf::lazy::Lazy {
3778 lock: ::protobuf::lazy::ONCE_INIT,
3779 ptr: 0 as *const DictionaryEntry,
3780 };
3781 unsafe {
3782 instance.get(DictionaryEntry::new)
3783 }
3784 }
3785
3786 pub fn clear_key(&mut self) {
3789 self.key.clear();
3790 }
3791
3792 pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
3794 self.key = v;
3795 }
3796
3797 pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
3800 &mut self.key
3801 }
3802
3803 pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
3805 ::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
3806 }
3807
3808 pub fn get_key(&self) -> &[u8] {
3809 &self.key
3810 }
3811
3812 fn get_key_for_reflect(&self) -> &::std::vec::Vec<u8> {
3813 &self.key
3814 }
3815
3816 fn mut_key_for_reflect(&mut self) -> &mut ::std::vec::Vec<u8> {
3817 &mut self.key
3818 }
3819
3820 pub fn clear_value(&mut self) {
3823 self.value.clear();
3824 }
3825
3826 pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
3828 self.value = v;
3829 }
3830
3831 pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
3834 &mut self.value
3835 }
3836
3837 pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
3839 ::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
3840 }
3841
3842 pub fn get_value(&self) -> &[u8] {
3843 &self.value
3844 }
3845
3846 fn get_value_for_reflect(&self) -> &::std::vec::Vec<u8> {
3847 &self.value
3848 }
3849
3850 fn mut_value_for_reflect(&mut self) -> &mut ::std::vec::Vec<u8> {
3851 &mut self.value
3852 }
3853}
3854
3855impl ::protobuf::Message for DictionaryEntry {
3856 fn is_initialized(&self) -> bool {
3857 true
3858 }
3859
3860 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
3861 while !is.eof()? {
3862 let (field_number, wire_type) = is.read_tag_unpack()?;
3863 match field_number {
3864 1 => {
3865 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
3866 },
3867 2 => {
3868 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
3869 },
3870 _ => {
3871 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3872 },
3873 };
3874 }
3875 ::std::result::Result::Ok(())
3876 }
3877
3878 #[allow(unused_variables)]
3880 fn compute_size(&self) -> u32 {
3881 let mut my_size = 0;
3882 if !self.key.is_empty() {
3883 my_size += ::protobuf::rt::bytes_size(1, &self.key);
3884 }
3885 if !self.value.is_empty() {
3886 my_size += ::protobuf::rt::bytes_size(2, &self.value);
3887 }
3888 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3889 self.cached_size.set(my_size);
3890 my_size
3891 }
3892
3893 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
3894 if !self.key.is_empty() {
3895 os.write_bytes(1, &self.key)?;
3896 }
3897 if !self.value.is_empty() {
3898 os.write_bytes(2, &self.value)?;
3899 }
3900 os.write_unknown_fields(self.get_unknown_fields())?;
3901 ::std::result::Result::Ok(())
3902 }
3903
3904 fn get_cached_size(&self) -> u32 {
3905 self.cached_size.get()
3906 }
3907
3908 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3909 &self.unknown_fields
3910 }
3911
3912 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3913 &mut self.unknown_fields
3914 }
3915
3916 fn as_any(&self) -> &::std::any::Any {
3917 self as &::std::any::Any
3918 }
3919 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
3920 self as &mut ::std::any::Any
3921 }
3922 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
3923 self
3924 }
3925
3926 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3927 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
3928 }
3929}
3930
3931impl ::protobuf::MessageStatic for DictionaryEntry {
3932 fn new() -> DictionaryEntry {
3933 DictionaryEntry::new()
3934 }
3935
3936 fn descriptor_static(_: ::std::option::Option<DictionaryEntry>) -> &'static ::protobuf::reflect::MessageDescriptor {
3937 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3938 lock: ::protobuf::lazy::ONCE_INIT,
3939 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3940 };
3941 unsafe {
3942 descriptor.get(|| {
3943 let mut fields = ::std::vec::Vec::new();
3944 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
3945 "key",
3946 DictionaryEntry::get_key_for_reflect,
3947 DictionaryEntry::mut_key_for_reflect,
3948 ));
3949 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
3950 "value",
3951 DictionaryEntry::get_value_for_reflect,
3952 DictionaryEntry::mut_value_for_reflect,
3953 ));
3954 ::protobuf::reflect::MessageDescriptor::new::<DictionaryEntry>(
3955 "DictionaryEntry",
3956 fields,
3957 file_descriptor_proto()
3958 )
3959 })
3960 }
3961 }
3962}
3963
3964impl ::protobuf::Clear for DictionaryEntry {
3965 fn clear(&mut self) {
3966 self.clear_key();
3967 self.clear_value();
3968 self.unknown_fields.clear();
3969 }
3970}
3971
3972impl ::std::fmt::Debug for DictionaryEntry {
3973 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
3974 ::protobuf::text_format::fmt(self, f)
3975 }
3976}
3977
3978impl ::protobuf::reflect::ProtobufValue for DictionaryEntry {
3979 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3980 ::protobuf::reflect::ProtobufValueRef::Message(self)
3981 }
3982}
3983
3984#[derive(PartialEq,Clone,Default)]
3985pub struct Set {
3986 pub items: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
3988 unknown_fields: ::protobuf::UnknownFields,
3990 cached_size: ::protobuf::CachedSize,
3991}
3992
3993unsafe impl ::std::marker::Sync for Set {}
3995
3996impl Set {
3997 pub fn new() -> Set {
3998 ::std::default::Default::default()
3999 }
4000
4001 pub fn default_instance() -> &'static Set {
4002 static mut instance: ::protobuf::lazy::Lazy<Set> = ::protobuf::lazy::Lazy {
4003 lock: ::protobuf::lazy::ONCE_INIT,
4004 ptr: 0 as *const Set,
4005 };
4006 unsafe {
4007 instance.get(Set::new)
4008 }
4009 }
4010
4011 pub fn clear_items(&mut self) {
4014 self.items.clear();
4015 }
4016
4017 pub fn set_items(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
4019 self.items = v;
4020 }
4021
4022 pub fn mut_items(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4024 &mut self.items
4025 }
4026
4027 pub fn take_items(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4029 ::std::mem::replace(&mut self.items, ::protobuf::RepeatedField::new())
4030 }
4031
4032 pub fn get_items(&self) -> &[::std::vec::Vec<u8>] {
4033 &self.items
4034 }
4035
4036 fn get_items_for_reflect(&self) -> &::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4037 &self.items
4038 }
4039
4040 fn mut_items_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4041 &mut self.items
4042 }
4043}
4044
4045impl ::protobuf::Message for Set {
4046 fn is_initialized(&self) -> bool {
4047 true
4048 }
4049
4050 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
4051 while !is.eof()? {
4052 let (field_number, wire_type) = is.read_tag_unpack()?;
4053 match field_number {
4054 1 => {
4055 ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.items)?;
4056 },
4057 _ => {
4058 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4059 },
4060 };
4061 }
4062 ::std::result::Result::Ok(())
4063 }
4064
4065 #[allow(unused_variables)]
4067 fn compute_size(&self) -> u32 {
4068 let mut my_size = 0;
4069 for value in &self.items {
4070 my_size += ::protobuf::rt::bytes_size(1, &value);
4071 };
4072 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4073 self.cached_size.set(my_size);
4074 my_size
4075 }
4076
4077 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
4078 for v in &self.items {
4079 os.write_bytes(1, &v)?;
4080 };
4081 os.write_unknown_fields(self.get_unknown_fields())?;
4082 ::std::result::Result::Ok(())
4083 }
4084
4085 fn get_cached_size(&self) -> u32 {
4086 self.cached_size.get()
4087 }
4088
4089 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4090 &self.unknown_fields
4091 }
4092
4093 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4094 &mut self.unknown_fields
4095 }
4096
4097 fn as_any(&self) -> &::std::any::Any {
4098 self as &::std::any::Any
4099 }
4100 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
4101 self as &mut ::std::any::Any
4102 }
4103 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
4104 self
4105 }
4106
4107 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4108 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
4109 }
4110}
4111
4112impl ::protobuf::MessageStatic for Set {
4113 fn new() -> Set {
4114 Set::new()
4115 }
4116
4117 fn descriptor_static(_: ::std::option::Option<Set>) -> &'static ::protobuf::reflect::MessageDescriptor {
4118 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
4119 lock: ::protobuf::lazy::ONCE_INIT,
4120 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
4121 };
4122 unsafe {
4123 descriptor.get(|| {
4124 let mut fields = ::std::vec::Vec::new();
4125 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
4126 "items",
4127 Set::get_items_for_reflect,
4128 Set::mut_items_for_reflect,
4129 ));
4130 ::protobuf::reflect::MessageDescriptor::new::<Set>(
4131 "Set",
4132 fields,
4133 file_descriptor_proto()
4134 )
4135 })
4136 }
4137 }
4138}
4139
4140impl ::protobuf::Clear for Set {
4141 fn clear(&mut self) {
4142 self.clear_items();
4143 self.unknown_fields.clear();
4144 }
4145}
4146
4147impl ::std::fmt::Debug for Set {
4148 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
4149 ::protobuf::text_format::fmt(self, f)
4150 }
4151}
4152
4153impl ::protobuf::reflect::ProtobufValue for Set {
4154 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
4155 ::protobuf::reflect::ProtobufValueRef::Message(self)
4156 }
4157}
4158
4159#[derive(PartialEq,Clone,Default)]
4160pub struct Tuple {
4161 pub items: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
4163 unknown_fields: ::protobuf::UnknownFields,
4165 cached_size: ::protobuf::CachedSize,
4166}
4167
4168unsafe impl ::std::marker::Sync for Tuple {}
4170
4171impl Tuple {
4172 pub fn new() -> Tuple {
4173 ::std::default::Default::default()
4174 }
4175
4176 pub fn default_instance() -> &'static Tuple {
4177 static mut instance: ::protobuf::lazy::Lazy<Tuple> = ::protobuf::lazy::Lazy {
4178 lock: ::protobuf::lazy::ONCE_INIT,
4179 ptr: 0 as *const Tuple,
4180 };
4181 unsafe {
4182 instance.get(Tuple::new)
4183 }
4184 }
4185
4186 pub fn clear_items(&mut self) {
4189 self.items.clear();
4190 }
4191
4192 pub fn set_items(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
4194 self.items = v;
4195 }
4196
4197 pub fn mut_items(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4199 &mut self.items
4200 }
4201
4202 pub fn take_items(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4204 ::std::mem::replace(&mut self.items, ::protobuf::RepeatedField::new())
4205 }
4206
4207 pub fn get_items(&self) -> &[::std::vec::Vec<u8>] {
4208 &self.items
4209 }
4210
4211 fn get_items_for_reflect(&self) -> &::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4212 &self.items
4213 }
4214
4215 fn mut_items_for_reflect(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
4216 &mut self.items
4217 }
4218}
4219
4220impl ::protobuf::Message for Tuple {
4221 fn is_initialized(&self) -> bool {
4222 true
4223 }
4224
4225 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
4226 while !is.eof()? {
4227 let (field_number, wire_type) = is.read_tag_unpack()?;
4228 match field_number {
4229 1 => {
4230 ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.items)?;
4231 },
4232 _ => {
4233 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4234 },
4235 };
4236 }
4237 ::std::result::Result::Ok(())
4238 }
4239
4240 #[allow(unused_variables)]
4242 fn compute_size(&self) -> u32 {
4243 let mut my_size = 0;
4244 for value in &self.items {
4245 my_size += ::protobuf::rt::bytes_size(1, &value);
4246 };
4247 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4248 self.cached_size.set(my_size);
4249 my_size
4250 }
4251
4252 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
4253 for v in &self.items {
4254 os.write_bytes(1, &v)?;
4255 };
4256 os.write_unknown_fields(self.get_unknown_fields())?;
4257 ::std::result::Result::Ok(())
4258 }
4259
4260 fn get_cached_size(&self) -> u32 {
4261 self.cached_size.get()
4262 }
4263
4264 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4265 &self.unknown_fields
4266 }
4267
4268 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4269 &mut self.unknown_fields
4270 }
4271
4272 fn as_any(&self) -> &::std::any::Any {
4273 self as &::std::any::Any
4274 }
4275 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
4276 self as &mut ::std::any::Any
4277 }
4278 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
4279 self
4280 }
4281
4282 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4283 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
4284 }
4285}
4286
4287impl ::protobuf::MessageStatic for Tuple {
4288 fn new() -> Tuple {
4289 Tuple::new()
4290 }
4291
4292 fn descriptor_static(_: ::std::option::Option<Tuple>) -> &'static ::protobuf::reflect::MessageDescriptor {
4293 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
4294 lock: ::protobuf::lazy::ONCE_INIT,
4295 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
4296 };
4297 unsafe {
4298 descriptor.get(|| {
4299 let mut fields = ::std::vec::Vec::new();
4300 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
4301 "items",
4302 Tuple::get_items_for_reflect,
4303 Tuple::mut_items_for_reflect,
4304 ));
4305 ::protobuf::reflect::MessageDescriptor::new::<Tuple>(
4306 "Tuple",
4307 fields,
4308 file_descriptor_proto()
4309 )
4310 })
4311 }
4312 }
4313}
4314
4315impl ::protobuf::Clear for Tuple {
4316 fn clear(&mut self) {
4317 self.clear_items();
4318 self.unknown_fields.clear();
4319 }
4320}
4321
4322impl ::std::fmt::Debug for Tuple {
4323 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
4324 ::protobuf::text_format::fmt(self, f)
4325 }
4326}
4327
4328impl ::protobuf::reflect::ProtobufValue for Tuple {
4329 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
4330 ::protobuf::reflect::ProtobufValueRef::Message(self)
4331 }
4332}
4333
4334#[derive(PartialEq,Clone,Default)]
4335pub struct Status {
4336 pub version: ::std::string::String,
4338 pub bytes_read: u64,
4339 pub bytes_written: u64,
4340 pub bytes_read_rate: f32,
4341 pub bytes_written_rate: f32,
4342 pub rpcs_executed: u64,
4343 pub rpc_rate: f32,
4344 pub one_rpc_per_update: bool,
4345 pub max_time_per_update: u32,
4346 pub adaptive_rate_control: bool,
4347 pub blocking_recv: bool,
4348 pub recv_timeout: u32,
4349 pub time_per_rpc_update: f32,
4350 pub poll_time_per_rpc_update: f32,
4351 pub exec_time_per_rpc_update: f32,
4352 pub stream_rpcs: u32,
4353 pub stream_rpcs_executed: u64,
4354 pub stream_rpc_rate: f32,
4355 pub time_per_stream_update: f32,
4356 unknown_fields: ::protobuf::UnknownFields,
4358 cached_size: ::protobuf::CachedSize,
4359}
4360
4361unsafe impl ::std::marker::Sync for Status {}
4363
4364impl Status {
4365 pub fn new() -> Status {
4366 ::std::default::Default::default()
4367 }
4368
4369 pub fn default_instance() -> &'static Status {
4370 static mut instance: ::protobuf::lazy::Lazy<Status> = ::protobuf::lazy::Lazy {
4371 lock: ::protobuf::lazy::ONCE_INIT,
4372 ptr: 0 as *const Status,
4373 };
4374 unsafe {
4375 instance.get(Status::new)
4376 }
4377 }
4378
4379 pub fn clear_version(&mut self) {
4382 self.version.clear();
4383 }
4384
4385 pub fn set_version(&mut self, v: ::std::string::String) {
4387 self.version = v;
4388 }
4389
4390 pub fn mut_version(&mut self) -> &mut ::std::string::String {
4393 &mut self.version
4394 }
4395
4396 pub fn take_version(&mut self) -> ::std::string::String {
4398 ::std::mem::replace(&mut self.version, ::std::string::String::new())
4399 }
4400
4401 pub fn get_version(&self) -> &str {
4402 &self.version
4403 }
4404
4405 fn get_version_for_reflect(&self) -> &::std::string::String {
4406 &self.version
4407 }
4408
4409 fn mut_version_for_reflect(&mut self) -> &mut ::std::string::String {
4410 &mut self.version
4411 }
4412
4413 pub fn clear_bytes_read(&mut self) {
4416 self.bytes_read = 0;
4417 }
4418
4419 pub fn set_bytes_read(&mut self, v: u64) {
4421 self.bytes_read = v;
4422 }
4423
4424 pub fn get_bytes_read(&self) -> u64 {
4425 self.bytes_read
4426 }
4427
4428 fn get_bytes_read_for_reflect(&self) -> &u64 {
4429 &self.bytes_read
4430 }
4431
4432 fn mut_bytes_read_for_reflect(&mut self) -> &mut u64 {
4433 &mut self.bytes_read
4434 }
4435
4436 pub fn clear_bytes_written(&mut self) {
4439 self.bytes_written = 0;
4440 }
4441
4442 pub fn set_bytes_written(&mut self, v: u64) {
4444 self.bytes_written = v;
4445 }
4446
4447 pub fn get_bytes_written(&self) -> u64 {
4448 self.bytes_written
4449 }
4450
4451 fn get_bytes_written_for_reflect(&self) -> &u64 {
4452 &self.bytes_written
4453 }
4454
4455 fn mut_bytes_written_for_reflect(&mut self) -> &mut u64 {
4456 &mut self.bytes_written
4457 }
4458
4459 pub fn clear_bytes_read_rate(&mut self) {
4462 self.bytes_read_rate = 0.;
4463 }
4464
4465 pub fn set_bytes_read_rate(&mut self, v: f32) {
4467 self.bytes_read_rate = v;
4468 }
4469
4470 pub fn get_bytes_read_rate(&self) -> f32 {
4471 self.bytes_read_rate
4472 }
4473
4474 fn get_bytes_read_rate_for_reflect(&self) -> &f32 {
4475 &self.bytes_read_rate
4476 }
4477
4478 fn mut_bytes_read_rate_for_reflect(&mut self) -> &mut f32 {
4479 &mut self.bytes_read_rate
4480 }
4481
4482 pub fn clear_bytes_written_rate(&mut self) {
4485 self.bytes_written_rate = 0.;
4486 }
4487
4488 pub fn set_bytes_written_rate(&mut self, v: f32) {
4490 self.bytes_written_rate = v;
4491 }
4492
4493 pub fn get_bytes_written_rate(&self) -> f32 {
4494 self.bytes_written_rate
4495 }
4496
4497 fn get_bytes_written_rate_for_reflect(&self) -> &f32 {
4498 &self.bytes_written_rate
4499 }
4500
4501 fn mut_bytes_written_rate_for_reflect(&mut self) -> &mut f32 {
4502 &mut self.bytes_written_rate
4503 }
4504
4505 pub fn clear_rpcs_executed(&mut self) {
4508 self.rpcs_executed = 0;
4509 }
4510
4511 pub fn set_rpcs_executed(&mut self, v: u64) {
4513 self.rpcs_executed = v;
4514 }
4515
4516 pub fn get_rpcs_executed(&self) -> u64 {
4517 self.rpcs_executed
4518 }
4519
4520 fn get_rpcs_executed_for_reflect(&self) -> &u64 {
4521 &self.rpcs_executed
4522 }
4523
4524 fn mut_rpcs_executed_for_reflect(&mut self) -> &mut u64 {
4525 &mut self.rpcs_executed
4526 }
4527
4528 pub fn clear_rpc_rate(&mut self) {
4531 self.rpc_rate = 0.;
4532 }
4533
4534 pub fn set_rpc_rate(&mut self, v: f32) {
4536 self.rpc_rate = v;
4537 }
4538
4539 pub fn get_rpc_rate(&self) -> f32 {
4540 self.rpc_rate
4541 }
4542
4543 fn get_rpc_rate_for_reflect(&self) -> &f32 {
4544 &self.rpc_rate
4545 }
4546
4547 fn mut_rpc_rate_for_reflect(&mut self) -> &mut f32 {
4548 &mut self.rpc_rate
4549 }
4550
4551 pub fn clear_one_rpc_per_update(&mut self) {
4554 self.one_rpc_per_update = false;
4555 }
4556
4557 pub fn set_one_rpc_per_update(&mut self, v: bool) {
4559 self.one_rpc_per_update = v;
4560 }
4561
4562 pub fn get_one_rpc_per_update(&self) -> bool {
4563 self.one_rpc_per_update
4564 }
4565
4566 fn get_one_rpc_per_update_for_reflect(&self) -> &bool {
4567 &self.one_rpc_per_update
4568 }
4569
4570 fn mut_one_rpc_per_update_for_reflect(&mut self) -> &mut bool {
4571 &mut self.one_rpc_per_update
4572 }
4573
4574 pub fn clear_max_time_per_update(&mut self) {
4577 self.max_time_per_update = 0;
4578 }
4579
4580 pub fn set_max_time_per_update(&mut self, v: u32) {
4582 self.max_time_per_update = v;
4583 }
4584
4585 pub fn get_max_time_per_update(&self) -> u32 {
4586 self.max_time_per_update
4587 }
4588
4589 fn get_max_time_per_update_for_reflect(&self) -> &u32 {
4590 &self.max_time_per_update
4591 }
4592
4593 fn mut_max_time_per_update_for_reflect(&mut self) -> &mut u32 {
4594 &mut self.max_time_per_update
4595 }
4596
4597 pub fn clear_adaptive_rate_control(&mut self) {
4600 self.adaptive_rate_control = false;
4601 }
4602
4603 pub fn set_adaptive_rate_control(&mut self, v: bool) {
4605 self.adaptive_rate_control = v;
4606 }
4607
4608 pub fn get_adaptive_rate_control(&self) -> bool {
4609 self.adaptive_rate_control
4610 }
4611
4612 fn get_adaptive_rate_control_for_reflect(&self) -> &bool {
4613 &self.adaptive_rate_control
4614 }
4615
4616 fn mut_adaptive_rate_control_for_reflect(&mut self) -> &mut bool {
4617 &mut self.adaptive_rate_control
4618 }
4619
4620 pub fn clear_blocking_recv(&mut self) {
4623 self.blocking_recv = false;
4624 }
4625
4626 pub fn set_blocking_recv(&mut self, v: bool) {
4628 self.blocking_recv = v;
4629 }
4630
4631 pub fn get_blocking_recv(&self) -> bool {
4632 self.blocking_recv
4633 }
4634
4635 fn get_blocking_recv_for_reflect(&self) -> &bool {
4636 &self.blocking_recv
4637 }
4638
4639 fn mut_blocking_recv_for_reflect(&mut self) -> &mut bool {
4640 &mut self.blocking_recv
4641 }
4642
4643 pub fn clear_recv_timeout(&mut self) {
4646 self.recv_timeout = 0;
4647 }
4648
4649 pub fn set_recv_timeout(&mut self, v: u32) {
4651 self.recv_timeout = v;
4652 }
4653
4654 pub fn get_recv_timeout(&self) -> u32 {
4655 self.recv_timeout
4656 }
4657
4658 fn get_recv_timeout_for_reflect(&self) -> &u32 {
4659 &self.recv_timeout
4660 }
4661
4662 fn mut_recv_timeout_for_reflect(&mut self) -> &mut u32 {
4663 &mut self.recv_timeout
4664 }
4665
4666 pub fn clear_time_per_rpc_update(&mut self) {
4669 self.time_per_rpc_update = 0.;
4670 }
4671
4672 pub fn set_time_per_rpc_update(&mut self, v: f32) {
4674 self.time_per_rpc_update = v;
4675 }
4676
4677 pub fn get_time_per_rpc_update(&self) -> f32 {
4678 self.time_per_rpc_update
4679 }
4680
4681 fn get_time_per_rpc_update_for_reflect(&self) -> &f32 {
4682 &self.time_per_rpc_update
4683 }
4684
4685 fn mut_time_per_rpc_update_for_reflect(&mut self) -> &mut f32 {
4686 &mut self.time_per_rpc_update
4687 }
4688
4689 pub fn clear_poll_time_per_rpc_update(&mut self) {
4692 self.poll_time_per_rpc_update = 0.;
4693 }
4694
4695 pub fn set_poll_time_per_rpc_update(&mut self, v: f32) {
4697 self.poll_time_per_rpc_update = v;
4698 }
4699
4700 pub fn get_poll_time_per_rpc_update(&self) -> f32 {
4701 self.poll_time_per_rpc_update
4702 }
4703
4704 fn get_poll_time_per_rpc_update_for_reflect(&self) -> &f32 {
4705 &self.poll_time_per_rpc_update
4706 }
4707
4708 fn mut_poll_time_per_rpc_update_for_reflect(&mut self) -> &mut f32 {
4709 &mut self.poll_time_per_rpc_update
4710 }
4711
4712 pub fn clear_exec_time_per_rpc_update(&mut self) {
4715 self.exec_time_per_rpc_update = 0.;
4716 }
4717
4718 pub fn set_exec_time_per_rpc_update(&mut self, v: f32) {
4720 self.exec_time_per_rpc_update = v;
4721 }
4722
4723 pub fn get_exec_time_per_rpc_update(&self) -> f32 {
4724 self.exec_time_per_rpc_update
4725 }
4726
4727 fn get_exec_time_per_rpc_update_for_reflect(&self) -> &f32 {
4728 &self.exec_time_per_rpc_update
4729 }
4730
4731 fn mut_exec_time_per_rpc_update_for_reflect(&mut self) -> &mut f32 {
4732 &mut self.exec_time_per_rpc_update
4733 }
4734
4735 pub fn clear_stream_rpcs(&mut self) {
4738 self.stream_rpcs = 0;
4739 }
4740
4741 pub fn set_stream_rpcs(&mut self, v: u32) {
4743 self.stream_rpcs = v;
4744 }
4745
4746 pub fn get_stream_rpcs(&self) -> u32 {
4747 self.stream_rpcs
4748 }
4749
4750 fn get_stream_rpcs_for_reflect(&self) -> &u32 {
4751 &self.stream_rpcs
4752 }
4753
4754 fn mut_stream_rpcs_for_reflect(&mut self) -> &mut u32 {
4755 &mut self.stream_rpcs
4756 }
4757
4758 pub fn clear_stream_rpcs_executed(&mut self) {
4761 self.stream_rpcs_executed = 0;
4762 }
4763
4764 pub fn set_stream_rpcs_executed(&mut self, v: u64) {
4766 self.stream_rpcs_executed = v;
4767 }
4768
4769 pub fn get_stream_rpcs_executed(&self) -> u64 {
4770 self.stream_rpcs_executed
4771 }
4772
4773 fn get_stream_rpcs_executed_for_reflect(&self) -> &u64 {
4774 &self.stream_rpcs_executed
4775 }
4776
4777 fn mut_stream_rpcs_executed_for_reflect(&mut self) -> &mut u64 {
4778 &mut self.stream_rpcs_executed
4779 }
4780
4781 pub fn clear_stream_rpc_rate(&mut self) {
4784 self.stream_rpc_rate = 0.;
4785 }
4786
4787 pub fn set_stream_rpc_rate(&mut self, v: f32) {
4789 self.stream_rpc_rate = v;
4790 }
4791
4792 pub fn get_stream_rpc_rate(&self) -> f32 {
4793 self.stream_rpc_rate
4794 }
4795
4796 fn get_stream_rpc_rate_for_reflect(&self) -> &f32 {
4797 &self.stream_rpc_rate
4798 }
4799
4800 fn mut_stream_rpc_rate_for_reflect(&mut self) -> &mut f32 {
4801 &mut self.stream_rpc_rate
4802 }
4803
4804 pub fn clear_time_per_stream_update(&mut self) {
4807 self.time_per_stream_update = 0.;
4808 }
4809
4810 pub fn set_time_per_stream_update(&mut self, v: f32) {
4812 self.time_per_stream_update = v;
4813 }
4814
4815 pub fn get_time_per_stream_update(&self) -> f32 {
4816 self.time_per_stream_update
4817 }
4818
4819 fn get_time_per_stream_update_for_reflect(&self) -> &f32 {
4820 &self.time_per_stream_update
4821 }
4822
4823 fn mut_time_per_stream_update_for_reflect(&mut self) -> &mut f32 {
4824 &mut self.time_per_stream_update
4825 }
4826}
4827
4828impl ::protobuf::Message for Status {
4829 fn is_initialized(&self) -> bool {
4830 true
4831 }
4832
4833 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
4834 while !is.eof()? {
4835 let (field_number, wire_type) = is.read_tag_unpack()?;
4836 match field_number {
4837 1 => {
4838 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?;
4839 },
4840 2 => {
4841 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4842 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4843 }
4844 let tmp = is.read_uint64()?;
4845 self.bytes_read = tmp;
4846 },
4847 3 => {
4848 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4849 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4850 }
4851 let tmp = is.read_uint64()?;
4852 self.bytes_written = tmp;
4853 },
4854 4 => {
4855 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4856 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4857 }
4858 let tmp = is.read_float()?;
4859 self.bytes_read_rate = tmp;
4860 },
4861 5 => {
4862 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4863 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4864 }
4865 let tmp = is.read_float()?;
4866 self.bytes_written_rate = tmp;
4867 },
4868 6 => {
4869 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4870 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4871 }
4872 let tmp = is.read_uint64()?;
4873 self.rpcs_executed = tmp;
4874 },
4875 7 => {
4876 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4877 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4878 }
4879 let tmp = is.read_float()?;
4880 self.rpc_rate = tmp;
4881 },
4882 8 => {
4883 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4884 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4885 }
4886 let tmp = is.read_bool()?;
4887 self.one_rpc_per_update = tmp;
4888 },
4889 9 => {
4890 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4891 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4892 }
4893 let tmp = is.read_uint32()?;
4894 self.max_time_per_update = tmp;
4895 },
4896 10 => {
4897 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4898 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4899 }
4900 let tmp = is.read_bool()?;
4901 self.adaptive_rate_control = tmp;
4902 },
4903 11 => {
4904 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4905 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4906 }
4907 let tmp = is.read_bool()?;
4908 self.blocking_recv = tmp;
4909 },
4910 12 => {
4911 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4912 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4913 }
4914 let tmp = is.read_uint32()?;
4915 self.recv_timeout = tmp;
4916 },
4917 13 => {
4918 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4919 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4920 }
4921 let tmp = is.read_float()?;
4922 self.time_per_rpc_update = tmp;
4923 },
4924 14 => {
4925 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4926 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4927 }
4928 let tmp = is.read_float()?;
4929 self.poll_time_per_rpc_update = tmp;
4930 },
4931 15 => {
4932 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4933 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4934 }
4935 let tmp = is.read_float()?;
4936 self.exec_time_per_rpc_update = tmp;
4937 },
4938 16 => {
4939 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4940 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4941 }
4942 let tmp = is.read_uint32()?;
4943 self.stream_rpcs = tmp;
4944 },
4945 17 => {
4946 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4947 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4948 }
4949 let tmp = is.read_uint64()?;
4950 self.stream_rpcs_executed = tmp;
4951 },
4952 18 => {
4953 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4954 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4955 }
4956 let tmp = is.read_float()?;
4957 self.stream_rpc_rate = tmp;
4958 },
4959 19 => {
4960 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
4961 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4962 }
4963 let tmp = is.read_float()?;
4964 self.time_per_stream_update = tmp;
4965 },
4966 _ => {
4967 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4968 },
4969 };
4970 }
4971 ::std::result::Result::Ok(())
4972 }
4973
4974 #[allow(unused_variables)]
4976 fn compute_size(&self) -> u32 {
4977 let mut my_size = 0;
4978 if !self.version.is_empty() {
4979 my_size += ::protobuf::rt::string_size(1, &self.version);
4980 }
4981 if self.bytes_read != 0 {
4982 my_size += ::protobuf::rt::value_size(2, self.bytes_read, ::protobuf::wire_format::WireTypeVarint);
4983 }
4984 if self.bytes_written != 0 {
4985 my_size += ::protobuf::rt::value_size(3, self.bytes_written, ::protobuf::wire_format::WireTypeVarint);
4986 }
4987 if self.bytes_read_rate != 0. {
4988 my_size += 5;
4989 }
4990 if self.bytes_written_rate != 0. {
4991 my_size += 5;
4992 }
4993 if self.rpcs_executed != 0 {
4994 my_size += ::protobuf::rt::value_size(6, self.rpcs_executed, ::protobuf::wire_format::WireTypeVarint);
4995 }
4996 if self.rpc_rate != 0. {
4997 my_size += 5;
4998 }
4999 if self.one_rpc_per_update != false {
5000 my_size += 2;
5001 }
5002 if self.max_time_per_update != 0 {
5003 my_size += ::protobuf::rt::value_size(9, self.max_time_per_update, ::protobuf::wire_format::WireTypeVarint);
5004 }
5005 if self.adaptive_rate_control != false {
5006 my_size += 2;
5007 }
5008 if self.blocking_recv != false {
5009 my_size += 2;
5010 }
5011 if self.recv_timeout != 0 {
5012 my_size += ::protobuf::rt::value_size(12, self.recv_timeout, ::protobuf::wire_format::WireTypeVarint);
5013 }
5014 if self.time_per_rpc_update != 0. {
5015 my_size += 5;
5016 }
5017 if self.poll_time_per_rpc_update != 0. {
5018 my_size += 5;
5019 }
5020 if self.exec_time_per_rpc_update != 0. {
5021 my_size += 5;
5022 }
5023 if self.stream_rpcs != 0 {
5024 my_size += ::protobuf::rt::value_size(16, self.stream_rpcs, ::protobuf::wire_format::WireTypeVarint);
5025 }
5026 if self.stream_rpcs_executed != 0 {
5027 my_size += ::protobuf::rt::value_size(17, self.stream_rpcs_executed, ::protobuf::wire_format::WireTypeVarint);
5028 }
5029 if self.stream_rpc_rate != 0. {
5030 my_size += 6;
5031 }
5032 if self.time_per_stream_update != 0. {
5033 my_size += 6;
5034 }
5035 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5036 self.cached_size.set(my_size);
5037 my_size
5038 }
5039
5040 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
5041 if !self.version.is_empty() {
5042 os.write_string(1, &self.version)?;
5043 }
5044 if self.bytes_read != 0 {
5045 os.write_uint64(2, self.bytes_read)?;
5046 }
5047 if self.bytes_written != 0 {
5048 os.write_uint64(3, self.bytes_written)?;
5049 }
5050 if self.bytes_read_rate != 0. {
5051 os.write_float(4, self.bytes_read_rate)?;
5052 }
5053 if self.bytes_written_rate != 0. {
5054 os.write_float(5, self.bytes_written_rate)?;
5055 }
5056 if self.rpcs_executed != 0 {
5057 os.write_uint64(6, self.rpcs_executed)?;
5058 }
5059 if self.rpc_rate != 0. {
5060 os.write_float(7, self.rpc_rate)?;
5061 }
5062 if self.one_rpc_per_update != false {
5063 os.write_bool(8, self.one_rpc_per_update)?;
5064 }
5065 if self.max_time_per_update != 0 {
5066 os.write_uint32(9, self.max_time_per_update)?;
5067 }
5068 if self.adaptive_rate_control != false {
5069 os.write_bool(10, self.adaptive_rate_control)?;
5070 }
5071 if self.blocking_recv != false {
5072 os.write_bool(11, self.blocking_recv)?;
5073 }
5074 if self.recv_timeout != 0 {
5075 os.write_uint32(12, self.recv_timeout)?;
5076 }
5077 if self.time_per_rpc_update != 0. {
5078 os.write_float(13, self.time_per_rpc_update)?;
5079 }
5080 if self.poll_time_per_rpc_update != 0. {
5081 os.write_float(14, self.poll_time_per_rpc_update)?;
5082 }
5083 if self.exec_time_per_rpc_update != 0. {
5084 os.write_float(15, self.exec_time_per_rpc_update)?;
5085 }
5086 if self.stream_rpcs != 0 {
5087 os.write_uint32(16, self.stream_rpcs)?;
5088 }
5089 if self.stream_rpcs_executed != 0 {
5090 os.write_uint64(17, self.stream_rpcs_executed)?;
5091 }
5092 if self.stream_rpc_rate != 0. {
5093 os.write_float(18, self.stream_rpc_rate)?;
5094 }
5095 if self.time_per_stream_update != 0. {
5096 os.write_float(19, self.time_per_stream_update)?;
5097 }
5098 os.write_unknown_fields(self.get_unknown_fields())?;
5099 ::std::result::Result::Ok(())
5100 }
5101
5102 fn get_cached_size(&self) -> u32 {
5103 self.cached_size.get()
5104 }
5105
5106 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5107 &self.unknown_fields
5108 }
5109
5110 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5111 &mut self.unknown_fields
5112 }
5113
5114 fn as_any(&self) -> &::std::any::Any {
5115 self as &::std::any::Any
5116 }
5117 fn as_any_mut(&mut self) -> &mut ::std::any::Any {
5118 self as &mut ::std::any::Any
5119 }
5120 fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
5121 self
5122 }
5123
5124 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5125 ::protobuf::MessageStatic::descriptor_static(None::<Self>)
5126 }
5127}
5128
5129impl ::protobuf::MessageStatic for Status {
5130 fn new() -> Status {
5131 Status::new()
5132 }
5133
5134 fn descriptor_static(_: ::std::option::Option<Status>) -> &'static ::protobuf::reflect::MessageDescriptor {
5135 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
5136 lock: ::protobuf::lazy::ONCE_INIT,
5137 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
5138 };
5139 unsafe {
5140 descriptor.get(|| {
5141 let mut fields = ::std::vec::Vec::new();
5142 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
5143 "version",
5144 Status::get_version_for_reflect,
5145 Status::mut_version_for_reflect,
5146 ));
5147 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
5148 "bytes_read",
5149 Status::get_bytes_read_for_reflect,
5150 Status::mut_bytes_read_for_reflect,
5151 ));
5152 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
5153 "bytes_written",
5154 Status::get_bytes_written_for_reflect,
5155 Status::mut_bytes_written_for_reflect,
5156 ));
5157 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
5158 "bytes_read_rate",
5159 Status::get_bytes_read_rate_for_reflect,
5160 Status::mut_bytes_read_rate_for_reflect,
5161 ));
5162 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
5163 "bytes_written_rate",
5164 Status::get_bytes_written_rate_for_reflect,
5165 Status::mut_bytes_written_rate_for_reflect,
5166 ));
5167 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
5168 "rpcs_executed",
5169 Status::get_rpcs_executed_for_reflect,
5170 Status::mut_rpcs_executed_for_reflect,
5171 ));
5172 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
5173 "rpc_rate",
5174 Status::get_rpc_rate_for_reflect,
5175 Status::mut_rpc_rate_for_reflect,
5176 ));
5177 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
5178 "one_rpc_per_update",
5179 Status::get_one_rpc_per_update_for_reflect,
5180 Status::mut_one_rpc_per_update_for_reflect,
5181 ));
5182 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
5183 "max_time_per_update",
5184 Status::get_max_time_per_update_for_reflect,
5185 Status::mut_max_time_per_update_for_reflect,
5186 ));
5187 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
5188 "adaptive_rate_control",
5189 Status::get_adaptive_rate_control_for_reflect,
5190 Status::mut_adaptive_rate_control_for_reflect,
5191 ));
5192 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
5193 "blocking_recv",
5194 Status::get_blocking_recv_for_reflect,
5195 Status::mut_blocking_recv_for_reflect,
5196 ));
5197 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
5198 "recv_timeout",
5199 Status::get_recv_timeout_for_reflect,
5200 Status::mut_recv_timeout_for_reflect,
5201 ));
5202 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
5203 "time_per_rpc_update",
5204 Status::get_time_per_rpc_update_for_reflect,
5205 Status::mut_time_per_rpc_update_for_reflect,
5206 ));
5207 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
5208 "poll_time_per_rpc_update",
5209 Status::get_poll_time_per_rpc_update_for_reflect,
5210 Status::mut_poll_time_per_rpc_update_for_reflect,
5211 ));
5212 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
5213 "exec_time_per_rpc_update",
5214 Status::get_exec_time_per_rpc_update_for_reflect,
5215 Status::mut_exec_time_per_rpc_update_for_reflect,
5216 ));
5217 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
5218 "stream_rpcs",
5219 Status::get_stream_rpcs_for_reflect,
5220 Status::mut_stream_rpcs_for_reflect,
5221 ));
5222 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
5223 "stream_rpcs_executed",
5224 Status::get_stream_rpcs_executed_for_reflect,
5225 Status::mut_stream_rpcs_executed_for_reflect,
5226 ));
5227 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
5228 "stream_rpc_rate",
5229 Status::get_stream_rpc_rate_for_reflect,
5230 Status::mut_stream_rpc_rate_for_reflect,
5231 ));
5232 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
5233 "time_per_stream_update",
5234 Status::get_time_per_stream_update_for_reflect,
5235 Status::mut_time_per_stream_update_for_reflect,
5236 ));
5237 ::protobuf::reflect::MessageDescriptor::new::<Status>(
5238 "Status",
5239 fields,
5240 file_descriptor_proto()
5241 )
5242 })
5243 }
5244 }
5245}
5246
5247impl ::protobuf::Clear for Status {
5248 fn clear(&mut self) {
5249 self.clear_version();
5250 self.clear_bytes_read();
5251 self.clear_bytes_written();
5252 self.clear_bytes_read_rate();
5253 self.clear_bytes_written_rate();
5254 self.clear_rpcs_executed();
5255 self.clear_rpc_rate();
5256 self.clear_one_rpc_per_update();
5257 self.clear_max_time_per_update();
5258 self.clear_adaptive_rate_control();
5259 self.clear_blocking_recv();
5260 self.clear_recv_timeout();
5261 self.clear_time_per_rpc_update();
5262 self.clear_poll_time_per_rpc_update();
5263 self.clear_exec_time_per_rpc_update();
5264 self.clear_stream_rpcs();
5265 self.clear_stream_rpcs_executed();
5266 self.clear_stream_rpc_rate();
5267 self.clear_time_per_stream_update();
5268 self.unknown_fields.clear();
5269 }
5270}
5271
5272impl ::std::fmt::Debug for Status {
5273 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
5274 ::protobuf::text_format::fmt(self, f)
5275 }
5276}
5277
5278impl ::protobuf::reflect::ProtobufValue for Status {
5279 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
5280 ::protobuf::reflect::ProtobufValueRef::Message(self)
5281 }
5282}
5283
5284static file_descriptor_proto_data: &'static [u8] = b"\
5285 \n\nkrpc.proto\x12\x0bkrpc.schema\"v\n\x07Request\x12\x18\n\x07service\
5286 \x18\x01\x20\x01(\tR\x07service\x12\x1c\n\tprocedure\x18\x02\x20\x01(\tR\
5287 \tprocedure\x123\n\targuments\x18\x03\x20\x03(\x0b2\x15.krpc.schema.Argu\
5288 mentR\targuments\"<\n\x08Argument\x12\x1a\n\x08position\x18\x01\x20\x01(\
5289 \rR\x08position\x12\x14\n\x05value\x18\x02\x20\x01(\x0cR\x05value\"\x9e\
5290 \x01\n\x08Response\x12\x12\n\x04time\x18\x01\x20\x01(\x01R\x04time\x12\
5291 \x1b\n\thas_error\x18\x02\x20\x01(\x08R\x08hasError\x12\x14\n\x05error\
5292 \x18\x03\x20\x01(\tR\x05error\x12(\n\x10has_return_value\x18\x04\x20\x01\
5293 (\x08R\x0ehasReturnValue\x12!\n\x0creturn_value\x18\x05\x20\x01(\x0cR\
5294 \x0breturnValue\"J\n\rStreamMessage\x129\n\tresponses\x18\x01\x20\x03(\
5295 \x0b2\x1b.krpc.schema.StreamResponseR\tresponses\"S\n\x0eStreamResponse\
5296 \x12\x0e\n\x02id\x18\x01\x20\x01(\rR\x02id\x121\n\x08response\x18\x02\
5297 \x20\x01(\x0b2\x15.krpc.schema.ResponseR\x08response\"<\n\x08Services\
5298 \x120\n\x08services\x18\x01\x20\x03(\x0b2\x14.krpc.schema.ServiceR\x08se\
5299 rvices\"\xe7\x01\n\x07Service\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04n\
5300 ame\x126\n\nprocedures\x18\x02\x20\x03(\x0b2\x16.krpc.schema.ProcedureR\
5301 \nprocedures\x12,\n\x07classes\x18\x03\x20\x03(\x0b2\x12.krpc.schema.Cla\
5302 ssR\x07classes\x12<\n\x0cenumerations\x18\x04\x20\x03(\x0b2\x18.krpc.sch\
5303 ema.EnumerationR\x0cenumerations\x12$\n\rdocumentation\x18\x05\x20\x01(\
5304 \tR\rdocumentation\"\xe6\x01\n\tProcedure\x12\x12\n\x04name\x18\x01\x20\
5305 \x01(\tR\x04name\x126\n\nparameters\x18\x02\x20\x03(\x0b2\x16.krpc.schem\
5306 a.ParameterR\nparameters\x12&\n\x0fhas_return_type\x18\x03\x20\x01(\x08R\
5307 \rhasReturnType\x12\x1f\n\x0breturn_type\x18\x04\x20\x01(\tR\nreturnType\
5308 \x12\x1e\n\nattributes\x18\x05\x20\x03(\tR\nattributes\x12$\n\rdocumenta\
5309 tion\x18\x06\x20\x01(\tR\rdocumentation\"\x84\x01\n\tParameter\x12\x12\n\
5310 \x04name\x18\x01\x20\x01(\tR\x04name\x12\x12\n\x04type\x18\x02\x20\x01(\
5311 \tR\x04type\x12*\n\x11has_default_value\x18\x03\x20\x01(\x08R\x0fhasDefa\
5312 ultValue\x12#\n\rdefault_value\x18\x04\x20\x01(\x0cR\x0cdefaultValue\"A\
5313 \n\x05Class\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12$\n\rdocume\
5314 ntation\x18\x02\x20\x01(\tR\rdocumentation\"~\n\x0bEnumeration\x12\x12\n\
5315 \x04name\x18\x01\x20\x01(\tR\x04name\x125\n\x06values\x18\x02\x20\x03(\
5316 \x0b2\x1d.krpc.schema.EnumerationValueR\x06values\x12$\n\rdocumentation\
5317 \x18\x03\x20\x01(\tR\rdocumentation\"b\n\x10EnumerationValue\x12\x12\n\
5318 \x04name\x18\x01\x20\x01(\tR\x04name\x12\x14\n\x05value\x18\x02\x20\x01(\
5319 \x05R\x05value\x12$\n\rdocumentation\x18\x03\x20\x01(\tR\rdocumentation\
5320 \"\x1c\n\x04List\x12\x14\n\x05items\x18\x01\x20\x03(\x0cR\x05items\"D\n\
5321 \nDictionary\x126\n\x07entries\x18\x01\x20\x03(\x0b2\x1c.krpc.schema.Dic\
5322 tionaryEntryR\x07entries\"9\n\x0fDictionaryEntry\x12\x10\n\x03key\x18\
5323 \x01\x20\x01(\x0cR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\x0cR\x05va\
5324 lue\"\x1b\n\x03Set\x12\x14\n\x05items\x18\x01\x20\x03(\x0cR\x05items\"\
5325 \x1d\n\x05Tuple\x12\x14\n\x05items\x18\x01\x20\x03(\x0cR\x05items\"\xa3\
5326 \x06\n\x06Status\x12\x18\n\x07version\x18\x01\x20\x01(\tR\x07version\x12\
5327 \x1d\n\nbytes_read\x18\x02\x20\x01(\x04R\tbytesRead\x12#\n\rbytes_writte\
5328 n\x18\x03\x20\x01(\x04R\x0cbytesWritten\x12&\n\x0fbytes_read_rate\x18\
5329 \x04\x20\x01(\x02R\rbytesReadRate\x12,\n\x12bytes_written_rate\x18\x05\
5330 \x20\x01(\x02R\x10bytesWrittenRate\x12#\n\rrpcs_executed\x18\x06\x20\x01\
5331 (\x04R\x0crpcsExecuted\x12\x19\n\x08rpc_rate\x18\x07\x20\x01(\x02R\x07rp\
5332 cRate\x12+\n\x12one_rpc_per_update\x18\x08\x20\x01(\x08R\x0foneRpcPerUpd\
5333 ate\x12-\n\x13max_time_per_update\x18\t\x20\x01(\rR\x10maxTimePerUpdate\
5334 \x122\n\x15adaptive_rate_control\x18\n\x20\x01(\x08R\x13adaptiveRateCont\
5335 rol\x12#\n\rblocking_recv\x18\x0b\x20\x01(\x08R\x0cblockingRecv\x12!\n\
5336 \x0crecv_timeout\x18\x0c\x20\x01(\rR\x0brecvTimeout\x12-\n\x13time_per_r\
5337 pc_update\x18\r\x20\x01(\x02R\x10timePerRpcUpdate\x126\n\x18poll_time_pe\
5338 r_rpc_update\x18\x0e\x20\x01(\x02R\x14pollTimePerRpcUpdate\x126\n\x18exe\
5339 c_time_per_rpc_update\x18\x0f\x20\x01(\x02R\x14execTimePerRpcUpdate\x12\
5340 \x1f\n\x0bstream_rpcs\x18\x10\x20\x01(\rR\nstreamRpcs\x120\n\x14stream_r\
5341 pcs_executed\x18\x11\x20\x01(\x04R\x12streamRpcsExecuted\x12&\n\x0fstrea\
5342 m_rpc_rate\x18\x12\x20\x01(\x02R\rstreamRpcRate\x123\n\x16time_per_strea\
5343 m_update\x18\x13\x20\x01(\x02R\x13timePerStreamUpdateB&\n\x0bkrpc.schema\
5344 B\x04KRPC\xaa\x02\x10KRPC.Schema.KRPCJ\xa9'\n\x06\x12\x04\0\0x\x01\n\x08\
5345 \n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\x03\x01\x08\x13\n\x08\n\
5346 \x01\x08\x12\x03\x02\0-\n\x0b\n\x04\x08\xe7\x07\0\x12\x03\x02\0-\n\x0c\n\
5347 \x05\x08\xe7\x07\0\x02\x12\x03\x02\x07\x17\n\r\n\x06\x08\xe7\x07\0\x02\0\
5348 \x12\x03\x02\x07\x17\n\x0e\n\x07\x08\xe7\x07\0\x02\0\x01\x12\x03\x02\x07\
5349 \x17\n\x0c\n\x05\x08\xe7\x07\0\x07\x12\x03\x02\x1a,\n\x08\n\x01\x08\x12\
5350 \x03\x03\0$\n\x0b\n\x04\x08\xe7\x07\x01\x12\x03\x03\0$\n\x0c\n\x05\x08\
5351 \xe7\x07\x01\x02\x12\x03\x03\x07\x13\n\r\n\x06\x08\xe7\x07\x01\x02\0\x12\
5352 \x03\x03\x07\x13\n\x0e\n\x07\x08\xe7\x07\x01\x02\0\x01\x12\x03\x03\x07\
5353 \x13\n\x0c\n\x05\x08\xe7\x07\x01\x07\x12\x03\x03\x16#\n\x08\n\x01\x08\
5354 \x12\x03\x04\0%\n\x0b\n\x04\x08\xe7\x07\x02\x12\x03\x04\0%\n\x0c\n\x05\
5355 \x08\xe7\x07\x02\x02\x12\x03\x04\x07\x1b\n\r\n\x06\x08\xe7\x07\x02\x02\0\
5356 \x12\x03\x04\x07\x1b\n\x0e\n\x07\x08\xe7\x07\x02\x02\0\x01\x12\x03\x04\
5357 \x07\x1b\n\x0c\n\x05\x08\xe7\x07\x02\x07\x12\x03\x04\x1e$\n\n\n\x02\x04\
5358 \0\x12\x04\x06\0\n\x01\n\n\n\x03\x04\0\x01\x12\x03\x06\x08\x0f\n\x0b\n\
5359 \x04\x04\0\x02\0\x12\x03\x07\x02\x15\n\r\n\x05\x04\0\x02\0\x04\x12\x04\
5360 \x07\x02\x06\x11\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x07\x02\x08\n\x0c\n\
5361 \x05\x04\0\x02\0\x01\x12\x03\x07\t\x10\n\x0c\n\x05\x04\0\x02\0\x03\x12\
5362 \x03\x07\x13\x14\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x08\x02\x17\n\r\n\x05\
5363 \x04\0\x02\x01\x04\x12\x04\x08\x02\x07\x15\n\x0c\n\x05\x04\0\x02\x01\x05\
5364 \x12\x03\x08\x02\x08\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x08\t\x12\n\
5365 \x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x08\x15\x16\n\x0b\n\x04\x04\0\x02\
5366 \x02\x12\x03\t\x02\"\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03\t\x02\n\n\x0c\
5367 \n\x05\x04\0\x02\x02\x06\x12\x03\t\x0b\x13\n\x0c\n\x05\x04\0\x02\x02\x01\
5368 \x12\x03\t\x14\x1d\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\t\x20!\n\n\n\
5369 \x02\x04\x01\x12\x04\x0c\0\x0f\x01\n\n\n\x03\x04\x01\x01\x12\x03\x0c\x08\
5370 \x10\n\x0b\n\x04\x04\x01\x02\0\x12\x03\r\x02\x16\n\r\n\x05\x04\x01\x02\0\
5371 \x04\x12\x04\r\x02\x0c\x12\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\r\x02\
5372 \x08\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\r\t\x11\n\x0c\n\x05\x04\x01\
5373 \x02\0\x03\x12\x03\r\x14\x15\n\x0b\n\x04\x04\x01\x02\x01\x12\x03\x0e\x02\
5374 \x12\n\r\n\x05\x04\x01\x02\x01\x04\x12\x04\x0e\x02\r\x16\n\x0c\n\x05\x04\
5375 \x01\x02\x01\x05\x12\x03\x0e\x02\x07\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\
5376 \x03\x0e\x08\r\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\x0e\x10\x11\n\n\n\
5377 \x02\x04\x02\x12\x04\x11\0\x17\x01\n\n\n\x03\x04\x02\x01\x12\x03\x11\x08\
5378 \x10\n\x0b\n\x04\x04\x02\x02\0\x12\x03\x12\x02\x12\n\r\n\x05\x04\x02\x02\
5379 \0\x04\x12\x04\x12\x02\x11\x12\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x12\
5380 \x02\x08\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\x12\t\r\n\x0c\n\x05\x04\
5381 \x02\x02\0\x03\x12\x03\x12\x10\x11\n\x0b\n\x04\x04\x02\x02\x01\x12\x03\
5382 \x13\x02\x15\n\r\n\x05\x04\x02\x02\x01\x04\x12\x04\x13\x02\x12\x12\n\x0c\
5383 \n\x05\x04\x02\x02\x01\x05\x12\x03\x13\x02\x06\n\x0c\n\x05\x04\x02\x02\
5384 \x01\x01\x12\x03\x13\x07\x10\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03\x13\
5385 \x13\x14\n\x0b\n\x04\x04\x02\x02\x02\x12\x03\x14\x02\x13\n\r\n\x05\x04\
5386 \x02\x02\x02\x04\x12\x04\x14\x02\x13\x15\n\x0c\n\x05\x04\x02\x02\x02\x05\
5387 \x12\x03\x14\x02\x08\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03\x14\t\x0e\n\
5388 \x0c\n\x05\x04\x02\x02\x02\x03\x12\x03\x14\x11\x12\n\x0b\n\x04\x04\x02\
5389 \x02\x03\x12\x03\x15\x02\x1c\n\r\n\x05\x04\x02\x02\x03\x04\x12\x04\x15\
5390 \x02\x14\x13\n\x0c\n\x05\x04\x02\x02\x03\x05\x12\x03\x15\x02\x06\n\x0c\n\
5391 \x05\x04\x02\x02\x03\x01\x12\x03\x15\x07\x17\n\x0c\n\x05\x04\x02\x02\x03\
5392 \x03\x12\x03\x15\x1a\x1b\n\x0b\n\x04\x04\x02\x02\x04\x12\x03\x16\x02\x19\
5393 \n\r\n\x05\x04\x02\x02\x04\x04\x12\x04\x16\x02\x15\x1c\n\x0c\n\x05\x04\
5394 \x02\x02\x04\x05\x12\x03\x16\x02\x07\n\x0c\n\x05\x04\x02\x02\x04\x01\x12\
5395 \x03\x16\x08\x14\n\x0c\n\x05\x04\x02\x02\x04\x03\x12\x03\x16\x17\x18\n\n\
5396 \n\x02\x04\x03\x12\x04\x19\0\x1b\x01\n\n\n\x03\x04\x03\x01\x12\x03\x19\
5397 \x08\x15\n\x0b\n\x04\x04\x03\x02\0\x12\x03\x1a\x02(\n\x0c\n\x05\x04\x03\
5398 \x02\0\x04\x12\x03\x1a\x02\n\n\x0c\n\x05\x04\x03\x02\0\x06\x12\x03\x1a\
5399 \x0b\x19\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03\x1a\x1a#\n\x0c\n\x05\x04\
5400 \x03\x02\0\x03\x12\x03\x1a&'\n\n\n\x02\x04\x04\x12\x04\x1d\0\x20\x01\n\n\
5401 \n\x03\x04\x04\x01\x12\x03\x1d\x08\x16\n\x0b\n\x04\x04\x04\x02\0\x12\x03\
5402 \x1e\x02\x10\n\r\n\x05\x04\x04\x02\0\x04\x12\x04\x1e\x02\x1d\x18\n\x0c\n\
5403 \x05\x04\x04\x02\0\x05\x12\x03\x1e\x02\x08\n\x0c\n\x05\x04\x04\x02\0\x01\
5404 \x12\x03\x1e\t\x0b\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03\x1e\x0e\x0f\n\
5405 \x0b\n\x04\x04\x04\x02\x01\x12\x03\x1f\x02\x18\n\r\n\x05\x04\x04\x02\x01\
5406 \x04\x12\x04\x1f\x02\x1e\x10\n\x0c\n\x05\x04\x04\x02\x01\x06\x12\x03\x1f\
5407 \x02\n\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03\x1f\x0b\x13\n\x0c\n\x05\
5408 \x04\x04\x02\x01\x03\x12\x03\x1f\x16\x17\n\n\n\x02\x04\x05\x12\x04\"\0$\
5409 \x01\n\n\n\x03\x04\x05\x01\x12\x03\"\x08\x10\n\x0b\n\x04\x04\x05\x02\0\
5410 \x12\x03#\x02\x20\n\x0c\n\x05\x04\x05\x02\0\x04\x12\x03#\x02\n\n\x0c\n\
5411 \x05\x04\x05\x02\0\x06\x12\x03#\x0b\x12\n\x0c\n\x05\x04\x05\x02\0\x01\
5412 \x12\x03#\x13\x1b\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03#\x1e\x1f\n\n\n\
5413 \x02\x04\x06\x12\x04&\0,\x01\n\n\n\x03\x04\x06\x01\x12\x03&\x08\x0f\n\
5414 \x0b\n\x04\x04\x06\x02\0\x12\x03'\x02\x12\n\r\n\x05\x04\x06\x02\0\x04\
5415 \x12\x04'\x02&\x11\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03'\x02\x08\n\x0c\
5416 \n\x05\x04\x06\x02\0\x01\x12\x03'\t\r\n\x0c\n\x05\x04\x06\x02\0\x03\x12\
5417 \x03'\x10\x11\n\x0b\n\x04\x04\x06\x02\x01\x12\x03(\x02$\n\x0c\n\x05\x04\
5418 \x06\x02\x01\x04\x12\x03(\x02\n\n\x0c\n\x05\x04\x06\x02\x01\x06\x12\x03(\
5419 \x0b\x14\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03(\x15\x1f\n\x0c\n\x05\
5420 \x04\x06\x02\x01\x03\x12\x03(\"#\n\x0b\n\x04\x04\x06\x02\x02\x12\x03)\
5421 \x02\x1d\n\x0c\n\x05\x04\x06\x02\x02\x04\x12\x03)\x02\n\n\x0c\n\x05\x04\
5422 \x06\x02\x02\x06\x12\x03)\x0b\x10\n\x0c\n\x05\x04\x06\x02\x02\x01\x12\
5423 \x03)\x11\x18\n\x0c\n\x05\x04\x06\x02\x02\x03\x12\x03)\x1b\x1c\n\x0b\n\
5424 \x04\x04\x06\x02\x03\x12\x03*\x02(\n\x0c\n\x05\x04\x06\x02\x03\x04\x12\
5425 \x03*\x02\n\n\x0c\n\x05\x04\x06\x02\x03\x06\x12\x03*\x0b\x16\n\x0c\n\x05\
5426 \x04\x06\x02\x03\x01\x12\x03*\x17#\n\x0c\n\x05\x04\x06\x02\x03\x03\x12\
5427 \x03*&'\n\x0b\n\x04\x04\x06\x02\x04\x12\x03+\x02\x1b\n\r\n\x05\x04\x06\
5428 \x02\x04\x04\x12\x04+\x02*(\n\x0c\n\x05\x04\x06\x02\x04\x05\x12\x03+\x02\
5429 \x08\n\x0c\n\x05\x04\x06\x02\x04\x01\x12\x03+\t\x16\n\x0c\n\x05\x04\x06\
5430 \x02\x04\x03\x12\x03+\x19\x1a\n\n\n\x02\x04\x07\x12\x04.\05\x01\n\n\n\
5431 \x03\x04\x07\x01\x12\x03.\x08\x11\n\x0b\n\x04\x04\x07\x02\0\x12\x03/\x02\
5432 \x12\n\r\n\x05\x04\x07\x02\0\x04\x12\x04/\x02.\x13\n\x0c\n\x05\x04\x07\
5433 \x02\0\x05\x12\x03/\x02\x08\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x03/\t\r\n\
5434 \x0c\n\x05\x04\x07\x02\0\x03\x12\x03/\x10\x11\n\x0b\n\x04\x04\x07\x02\
5435 \x01\x12\x030\x02$\n\x0c\n\x05\x04\x07\x02\x01\x04\x12\x030\x02\n\n\x0c\
5436 \n\x05\x04\x07\x02\x01\x06\x12\x030\x0b\x14\n\x0c\n\x05\x04\x07\x02\x01\
5437 \x01\x12\x030\x15\x1f\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x030\"#\n\x0b\
5438 \n\x04\x04\x07\x02\x02\x12\x031\x02\x1b\n\r\n\x05\x04\x07\x02\x02\x04\
5439 \x12\x041\x020$\n\x0c\n\x05\x04\x07\x02\x02\x05\x12\x031\x02\x06\n\x0c\n\
5440 \x05\x04\x07\x02\x02\x01\x12\x031\x07\x16\n\x0c\n\x05\x04\x07\x02\x02\
5441 \x03\x12\x031\x19\x1a\n\x0b\n\x04\x04\x07\x02\x03\x12\x032\x02\x19\n\r\n\
5442 \x05\x04\x07\x02\x03\x04\x12\x042\x021\x1b\n\x0c\n\x05\x04\x07\x02\x03\
5443 \x05\x12\x032\x02\x08\n\x0c\n\x05\x04\x07\x02\x03\x01\x12\x032\t\x14\n\
5444 \x0c\n\x05\x04\x07\x02\x03\x03\x12\x032\x17\x18\n\x0b\n\x04\x04\x07\x02\
5445 \x04\x12\x033\x02!\n\x0c\n\x05\x04\x07\x02\x04\x04\x12\x033\x02\n\n\x0c\
5446 \n\x05\x04\x07\x02\x04\x05\x12\x033\x0b\x11\n\x0c\n\x05\x04\x07\x02\x04\
5447 \x01\x12\x033\x12\x1c\n\x0c\n\x05\x04\x07\x02\x04\x03\x12\x033\x1f\x20\n\
5448 \x0b\n\x04\x04\x07\x02\x05\x12\x034\x02\x1b\n\r\n\x05\x04\x07\x02\x05\
5449 \x04\x12\x044\x023!\n\x0c\n\x05\x04\x07\x02\x05\x05\x12\x034\x02\x08\n\
5450 \x0c\n\x05\x04\x07\x02\x05\x01\x12\x034\t\x16\n\x0c\n\x05\x04\x07\x02\
5451 \x05\x03\x12\x034\x19\x1a\n\n\n\x02\x04\x08\x12\x047\0<\x01\n\n\n\x03\
5452 \x04\x08\x01\x12\x037\x08\x11\n\x0b\n\x04\x04\x08\x02\0\x12\x038\x02\x12\
5453 \n\r\n\x05\x04\x08\x02\0\x04\x12\x048\x027\x13\n\x0c\n\x05\x04\x08\x02\0\
5454 \x05\x12\x038\x02\x08\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x038\t\r\n\x0c\n\
5455 \x05\x04\x08\x02\0\x03\x12\x038\x10\x11\n\x0b\n\x04\x04\x08\x02\x01\x12\
5456 \x039\x02\x12\n\r\n\x05\x04\x08\x02\x01\x04\x12\x049\x028\x12\n\x0c\n\
5457 \x05\x04\x08\x02\x01\x05\x12\x039\x02\x08\n\x0c\n\x05\x04\x08\x02\x01\
5458 \x01\x12\x039\t\r\n\x0c\n\x05\x04\x08\x02\x01\x03\x12\x039\x10\x11\n\x0b\
5459 \n\x04\x04\x08\x02\x02\x12\x03:\x02\x1d\n\r\n\x05\x04\x08\x02\x02\x04\
5460 \x12\x04:\x029\x12\n\x0c\n\x05\x04\x08\x02\x02\x05\x12\x03:\x02\x06\n\
5461 \x0c\n\x05\x04\x08\x02\x02\x01\x12\x03:\x07\x18\n\x0c\n\x05\x04\x08\x02\
5462 \x02\x03\x12\x03:\x1b\x1c\n\x0b\n\x04\x04\x08\x02\x03\x12\x03;\x02\x1a\n\
5463 \r\n\x05\x04\x08\x02\x03\x04\x12\x04;\x02:\x1d\n\x0c\n\x05\x04\x08\x02\
5464 \x03\x05\x12\x03;\x02\x07\n\x0c\n\x05\x04\x08\x02\x03\x01\x12\x03;\x08\
5465 \x15\n\x0c\n\x05\x04\x08\x02\x03\x03\x12\x03;\x18\x19\n\n\n\x02\x04\t\
5466 \x12\x04>\0A\x01\n\n\n\x03\x04\t\x01\x12\x03>\x08\r\n\x0b\n\x04\x04\t\
5467 \x02\0\x12\x03?\x02\x12\n\r\n\x05\x04\t\x02\0\x04\x12\x04?\x02>\x0f\n\
5468 \x0c\n\x05\x04\t\x02\0\x05\x12\x03?\x02\x08\n\x0c\n\x05\x04\t\x02\0\x01\
5469 \x12\x03?\t\r\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03?\x10\x11\n\x0b\n\x04\
5470 \x04\t\x02\x01\x12\x03@\x02\x1b\n\r\n\x05\x04\t\x02\x01\x04\x12\x04@\x02\
5471 ?\x12\n\x0c\n\x05\x04\t\x02\x01\x05\x12\x03@\x02\x08\n\x0c\n\x05\x04\t\
5472 \x02\x01\x01\x12\x03@\t\x16\n\x0c\n\x05\x04\t\x02\x01\x03\x12\x03@\x19\
5473 \x1a\n\n\n\x02\x04\n\x12\x04C\0G\x01\n\n\n\x03\x04\n\x01\x12\x03C\x08\
5474 \x13\n\x0b\n\x04\x04\n\x02\0\x12\x03D\x02\x12\n\r\n\x05\x04\n\x02\0\x04\
5475 \x12\x04D\x02C\x15\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03D\x02\x08\n\x0c\n\
5476 \x05\x04\n\x02\0\x01\x12\x03D\t\r\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03D\
5477 \x10\x11\n\x0b\n\x04\x04\n\x02\x01\x12\x03E\x02'\n\x0c\n\x05\x04\n\x02\
5478 \x01\x04\x12\x03E\x02\n\n\x0c\n\x05\x04\n\x02\x01\x06\x12\x03E\x0b\x1b\n\
5479 \x0c\n\x05\x04\n\x02\x01\x01\x12\x03E\x1c\"\n\x0c\n\x05\x04\n\x02\x01\
5480 \x03\x12\x03E%&\n\x0b\n\x04\x04\n\x02\x02\x12\x03F\x02\x1b\n\r\n\x05\x04\
5481 \n\x02\x02\x04\x12\x04F\x02E'\n\x0c\n\x05\x04\n\x02\x02\x05\x12\x03F\x02\
5482 \x08\n\x0c\n\x05\x04\n\x02\x02\x01\x12\x03F\t\x16\n\x0c\n\x05\x04\n\x02\
5483 \x02\x03\x12\x03F\x19\x1a\n\n\n\x02\x04\x0b\x12\x04I\0M\x01\n\n\n\x03\
5484 \x04\x0b\x01\x12\x03I\x08\x18\n\x0b\n\x04\x04\x0b\x02\0\x12\x03J\x02\x12\
5485 \n\r\n\x05\x04\x0b\x02\0\x04\x12\x04J\x02I\x1a\n\x0c\n\x05\x04\x0b\x02\0\
5486 \x05\x12\x03J\x02\x08\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\x03J\t\r\n\x0c\n\
5487 \x05\x04\x0b\x02\0\x03\x12\x03J\x10\x11\n\x0b\n\x04\x04\x0b\x02\x01\x12\
5488 \x03K\x02\x12\n\r\n\x05\x04\x0b\x02\x01\x04\x12\x04K\x02J\x12\n\x0c\n\
5489 \x05\x04\x0b\x02\x01\x05\x12\x03K\x02\x07\n\x0c\n\x05\x04\x0b\x02\x01\
5490 \x01\x12\x03K\x08\r\n\x0c\n\x05\x04\x0b\x02\x01\x03\x12\x03K\x10\x11\n\
5491 \x0b\n\x04\x04\x0b\x02\x02\x12\x03L\x02\x1b\n\r\n\x05\x04\x0b\x02\x02\
5492 \x04\x12\x04L\x02K\x12\n\x0c\n\x05\x04\x0b\x02\x02\x05\x12\x03L\x02\x08\
5493 \n\x0c\n\x05\x04\x0b\x02\x02\x01\x12\x03L\t\x16\n\x0c\n\x05\x04\x0b\x02\
5494 \x02\x03\x12\x03L\x19\x1a\n\n\n\x02\x04\x0c\x12\x04O\0Q\x01\n\n\n\x03\
5495 \x04\x0c\x01\x12\x03O\x08\x0c\n\x0b\n\x04\x04\x0c\x02\0\x12\x03P\x02\x1b\
5496 \n\x0c\n\x05\x04\x0c\x02\0\x04\x12\x03P\x02\n\n\x0c\n\x05\x04\x0c\x02\0\
5497 \x05\x12\x03P\x0b\x10\n\x0c\n\x05\x04\x0c\x02\0\x01\x12\x03P\x11\x16\n\
5498 \x0c\n\x05\x04\x0c\x02\0\x03\x12\x03P\x19\x1a\n\n\n\x02\x04\r\x12\x04S\0\
5499 U\x01\n\n\n\x03\x04\r\x01\x12\x03S\x08\x12\n\x0b\n\x04\x04\r\x02\0\x12\
5500 \x03T\x02'\n\x0c\n\x05\x04\r\x02\0\x04\x12\x03T\x02\n\n\x0c\n\x05\x04\r\
5501 \x02\0\x06\x12\x03T\x0b\x1a\n\x0c\n\x05\x04\r\x02\0\x01\x12\x03T\x1b\"\n\
5502 \x0c\n\x05\x04\r\x02\0\x03\x12\x03T%&\n\n\n\x02\x04\x0e\x12\x04W\0Z\x01\
5503 \n\n\n\x03\x04\x0e\x01\x12\x03W\x08\x17\n\x0b\n\x04\x04\x0e\x02\0\x12\
5504 \x03X\x02\x10\n\r\n\x05\x04\x0e\x02\0\x04\x12\x04X\x02W\x19\n\x0c\n\x05\
5505 \x04\x0e\x02\0\x05\x12\x03X\x02\x07\n\x0c\n\x05\x04\x0e\x02\0\x01\x12\
5506 \x03X\x08\x0b\n\x0c\n\x05\x04\x0e\x02\0\x03\x12\x03X\x0e\x0f\n\x0b\n\x04\
5507 \x04\x0e\x02\x01\x12\x03Y\x02\x12\n\r\n\x05\x04\x0e\x02\x01\x04\x12\x04Y\
5508 \x02X\x10\n\x0c\n\x05\x04\x0e\x02\x01\x05\x12\x03Y\x02\x07\n\x0c\n\x05\
5509 \x04\x0e\x02\x01\x01\x12\x03Y\x08\r\n\x0c\n\x05\x04\x0e\x02\x01\x03\x12\
5510 \x03Y\x10\x11\n\n\n\x02\x04\x0f\x12\x04\\\0^\x01\n\n\n\x03\x04\x0f\x01\
5511 \x12\x03\\\x08\x0b\n\x0b\n\x04\x04\x0f\x02\0\x12\x03]\x02\x1b\n\x0c\n\
5512 \x05\x04\x0f\x02\0\x04\x12\x03]\x02\n\n\x0c\n\x05\x04\x0f\x02\0\x05\x12\
5513 \x03]\x0b\x10\n\x0c\n\x05\x04\x0f\x02\0\x01\x12\x03]\x11\x16\n\x0c\n\x05\
5514 \x04\x0f\x02\0\x03\x12\x03]\x19\x1a\n\n\n\x02\x04\x10\x12\x04`\0b\x01\n\
5515 \n\n\x03\x04\x10\x01\x12\x03`\x08\r\n\x0b\n\x04\x04\x10\x02\0\x12\x03a\
5516 \x02\x1b\n\x0c\n\x05\x04\x10\x02\0\x04\x12\x03a\x02\n\n\x0c\n\x05\x04\
5517 \x10\x02\0\x05\x12\x03a\x0b\x10\n\x0c\n\x05\x04\x10\x02\0\x01\x12\x03a\
5518 \x11\x16\n\x0c\n\x05\x04\x10\x02\0\x03\x12\x03a\x19\x1a\n\n\n\x02\x04\
5519 \x11\x12\x04d\0x\x01\n\n\n\x03\x04\x11\x01\x12\x03d\x08\x0e\n\x0b\n\x04\
5520 \x04\x11\x02\0\x12\x03e\x02\x15\n\r\n\x05\x04\x11\x02\0\x04\x12\x04e\x02\
5521 d\x10\n\x0c\n\x05\x04\x11\x02\0\x05\x12\x03e\x02\x08\n\x0c\n\x05\x04\x11\
5522 \x02\0\x01\x12\x03e\t\x10\n\x0c\n\x05\x04\x11\x02\0\x03\x12\x03e\x13\x14\
5523 \n\x0b\n\x04\x04\x11\x02\x01\x12\x03f\x02\x18\n\r\n\x05\x04\x11\x02\x01\
5524 \x04\x12\x04f\x02e\x15\n\x0c\n\x05\x04\x11\x02\x01\x05\x12\x03f\x02\x08\
5525 \n\x0c\n\x05\x04\x11\x02\x01\x01\x12\x03f\t\x13\n\x0c\n\x05\x04\x11\x02\
5526 \x01\x03\x12\x03f\x16\x17\n\x0b\n\x04\x04\x11\x02\x02\x12\x03g\x02\x1b\n\
5527 \r\n\x05\x04\x11\x02\x02\x04\x12\x04g\x02f\x18\n\x0c\n\x05\x04\x11\x02\
5528 \x02\x05\x12\x03g\x02\x08\n\x0c\n\x05\x04\x11\x02\x02\x01\x12\x03g\t\x16\
5529 \n\x0c\n\x05\x04\x11\x02\x02\x03\x12\x03g\x19\x1a\n\x0b\n\x04\x04\x11\
5530 \x02\x03\x12\x03h\x02\x1c\n\r\n\x05\x04\x11\x02\x03\x04\x12\x04h\x02g\
5531 \x1b\n\x0c\n\x05\x04\x11\x02\x03\x05\x12\x03h\x02\x07\n\x0c\n\x05\x04\
5532 \x11\x02\x03\x01\x12\x03h\x08\x17\n\x0c\n\x05\x04\x11\x02\x03\x03\x12\
5533 \x03h\x1a\x1b\n\x0b\n\x04\x04\x11\x02\x04\x12\x03i\x02\x1f\n\r\n\x05\x04\
5534 \x11\x02\x04\x04\x12\x04i\x02h\x1c\n\x0c\n\x05\x04\x11\x02\x04\x05\x12\
5535 \x03i\x02\x07\n\x0c\n\x05\x04\x11\x02\x04\x01\x12\x03i\x08\x1a\n\x0c\n\
5536 \x05\x04\x11\x02\x04\x03\x12\x03i\x1d\x1e\n\x0b\n\x04\x04\x11\x02\x05\
5537 \x12\x03j\x02\x1b\n\r\n\x05\x04\x11\x02\x05\x04\x12\x04j\x02i\x1f\n\x0c\
5538 \n\x05\x04\x11\x02\x05\x05\x12\x03j\x02\x08\n\x0c\n\x05\x04\x11\x02\x05\
5539 \x01\x12\x03j\t\x16\n\x0c\n\x05\x04\x11\x02\x05\x03\x12\x03j\x19\x1a\n\
5540 \x0b\n\x04\x04\x11\x02\x06\x12\x03k\x02\x15\n\r\n\x05\x04\x11\x02\x06\
5541 \x04\x12\x04k\x02j\x1b\n\x0c\n\x05\x04\x11\x02\x06\x05\x12\x03k\x02\x07\
5542 \n\x0c\n\x05\x04\x11\x02\x06\x01\x12\x03k\x08\x10\n\x0c\n\x05\x04\x11\
5543 \x02\x06\x03\x12\x03k\x13\x14\n\x0b\n\x04\x04\x11\x02\x07\x12\x03l\x02\
5544 \x1e\n\r\n\x05\x04\x11\x02\x07\x04\x12\x04l\x02k\x15\n\x0c\n\x05\x04\x11\
5545 \x02\x07\x05\x12\x03l\x02\x06\n\x0c\n\x05\x04\x11\x02\x07\x01\x12\x03l\
5546 \x07\x19\n\x0c\n\x05\x04\x11\x02\x07\x03\x12\x03l\x1c\x1d\n\x0b\n\x04\
5547 \x04\x11\x02\x08\x12\x03m\x02!\n\r\n\x05\x04\x11\x02\x08\x04\x12\x04m\
5548 \x02l\x1e\n\x0c\n\x05\x04\x11\x02\x08\x05\x12\x03m\x02\x08\n\x0c\n\x05\
5549 \x04\x11\x02\x08\x01\x12\x03m\t\x1c\n\x0c\n\x05\x04\x11\x02\x08\x03\x12\
5550 \x03m\x1f\x20\n\x0b\n\x04\x04\x11\x02\t\x12\x03n\x02\"\n\r\n\x05\x04\x11\
5551 \x02\t\x04\x12\x04n\x02m!\n\x0c\n\x05\x04\x11\x02\t\x05\x12\x03n\x02\x06\
5552 \n\x0c\n\x05\x04\x11\x02\t\x01\x12\x03n\x07\x1c\n\x0c\n\x05\x04\x11\x02\
5553 \t\x03\x12\x03n\x1f!\n\x0b\n\x04\x04\x11\x02\n\x12\x03o\x02\x1a\n\r\n\
5554 \x05\x04\x11\x02\n\x04\x12\x04o\x02n\"\n\x0c\n\x05\x04\x11\x02\n\x05\x12\
5555 \x03o\x02\x06\n\x0c\n\x05\x04\x11\x02\n\x01\x12\x03o\x07\x14\n\x0c\n\x05\
5556 \x04\x11\x02\n\x03\x12\x03o\x17\x19\n\x0b\n\x04\x04\x11\x02\x0b\x12\x03p\
5557 \x02\x1b\n\r\n\x05\x04\x11\x02\x0b\x04\x12\x04p\x02o\x1a\n\x0c\n\x05\x04\
5558 \x11\x02\x0b\x05\x12\x03p\x02\x08\n\x0c\n\x05\x04\x11\x02\x0b\x01\x12\
5559 \x03p\t\x15\n\x0c\n\x05\x04\x11\x02\x0b\x03\x12\x03p\x18\x1a\n\x0b\n\x04\
5560 \x04\x11\x02\x0c\x12\x03q\x02!\n\r\n\x05\x04\x11\x02\x0c\x04\x12\x04q\
5561 \x02p\x1b\n\x0c\n\x05\x04\x11\x02\x0c\x05\x12\x03q\x02\x07\n\x0c\n\x05\
5562 \x04\x11\x02\x0c\x01\x12\x03q\x08\x1b\n\x0c\n\x05\x04\x11\x02\x0c\x03\
5563 \x12\x03q\x1e\x20\n\x0b\n\x04\x04\x11\x02\r\x12\x03r\x02&\n\r\n\x05\x04\
5564 \x11\x02\r\x04\x12\x04r\x02q!\n\x0c\n\x05\x04\x11\x02\r\x05\x12\x03r\x02\
5565 \x07\n\x0c\n\x05\x04\x11\x02\r\x01\x12\x03r\x08\x20\n\x0c\n\x05\x04\x11\
5566 \x02\r\x03\x12\x03r#%\n\x0b\n\x04\x04\x11\x02\x0e\x12\x03s\x02&\n\r\n\
5567 \x05\x04\x11\x02\x0e\x04\x12\x04s\x02r&\n\x0c\n\x05\x04\x11\x02\x0e\x05\
5568 \x12\x03s\x02\x07\n\x0c\n\x05\x04\x11\x02\x0e\x01\x12\x03s\x08\x20\n\x0c\
5569 \n\x05\x04\x11\x02\x0e\x03\x12\x03s#%\n\x0b\n\x04\x04\x11\x02\x0f\x12\
5570 \x03t\x02\x1a\n\r\n\x05\x04\x11\x02\x0f\x04\x12\x04t\x02s&\n\x0c\n\x05\
5571 \x04\x11\x02\x0f\x05\x12\x03t\x02\x08\n\x0c\n\x05\x04\x11\x02\x0f\x01\
5572 \x12\x03t\t\x14\n\x0c\n\x05\x04\x11\x02\x0f\x03\x12\x03t\x17\x19\n\x0b\n\
5573 \x04\x04\x11\x02\x10\x12\x03u\x02#\n\r\n\x05\x04\x11\x02\x10\x04\x12\x04\
5574 u\x02t\x1a\n\x0c\n\x05\x04\x11\x02\x10\x05\x12\x03u\x02\x08\n\x0c\n\x05\
5575 \x04\x11\x02\x10\x01\x12\x03u\t\x1d\n\x0c\n\x05\x04\x11\x02\x10\x03\x12\
5576 \x03u\x20\"\n\x0b\n\x04\x04\x11\x02\x11\x12\x03v\x02\x1d\n\r\n\x05\x04\
5577 \x11\x02\x11\x04\x12\x04v\x02u#\n\x0c\n\x05\x04\x11\x02\x11\x05\x12\x03v\
5578 \x02\x07\n\x0c\n\x05\x04\x11\x02\x11\x01\x12\x03v\x08\x17\n\x0c\n\x05\
5579 \x04\x11\x02\x11\x03\x12\x03v\x1a\x1c\n\x0b\n\x04\x04\x11\x02\x12\x12\
5580 \x03w\x02$\n\r\n\x05\x04\x11\x02\x12\x04\x12\x04w\x02v\x1d\n\x0c\n\x05\
5581 \x04\x11\x02\x12\x05\x12\x03w\x02\x07\n\x0c\n\x05\x04\x11\x02\x12\x01\
5582 \x12\x03w\x08\x1e\n\x0c\n\x05\x04\x11\x02\x12\x03\x12\x03w!#b\x06proto3\
5583";
5584
5585static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
5586 lock: ::protobuf::lazy::ONCE_INIT,
5587 ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
5588};
5589
5590fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
5591 ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
5592}
5593
5594pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
5595 unsafe {
5596 file_descriptor_proto_lazy.get(|| {
5597 parse_descriptor_proto()
5598 })
5599 }
5600}