1#![allow(unknown_lints)]
6#![allow(clippy::all)]
7
8#![cfg_attr(rustfmt, rustfmt_skip)]
9
10#![allow(box_pointers)]
11#![allow(dead_code)]
12#![allow(missing_docs)]
13#![allow(non_camel_case_types)]
14#![allow(non_snake_case)]
15#![allow(non_upper_case_globals)]
16#![allow(trivial_casts)]
17#![allow(unsafe_code)]
18#![allow(unused_imports)]
19#![allow(unused_results)]
20use protobuf::Message as Message_imported_for_functions;
23use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
24
25const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_0;
28
29#[derive(PartialEq,Clone,Default)]
30pub struct VersionRequest {
31 pub query: bool,
33 pub unknown_fields: ::protobuf::UnknownFields,
35 pub cached_size: ::protobuf::CachedSize,
36}
37
38impl<'a> ::std::default::Default for &'a VersionRequest {
39 fn default() -> &'a VersionRequest {
40 <VersionRequest as ::protobuf::Message>::default_instance()
41 }
42}
43
44impl VersionRequest {
45 pub fn new() -> VersionRequest {
46 ::std::default::Default::default()
47 }
48
49 pub fn get_query(&self) -> bool {
53 self.query
54 }
55 pub fn clear_query(&mut self) {
56 self.query = false;
57 }
58
59 pub fn set_query(&mut self, v: bool) {
61 self.query = v;
62 }
63}
64
65impl ::protobuf::Message for VersionRequest {
66 fn is_initialized(&self) -> bool {
67 true
68 }
69
70 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
71 while !is.eof()? {
72 let (field_number, wire_type) = is.read_tag_unpack()?;
73 match field_number {
74 1 => {
75 if wire_type != ::protobuf::wire_format::WireTypeVarint {
76 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
77 }
78 let tmp = is.read_bool()?;
79 self.query = tmp;
80 },
81 _ => {
82 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
83 },
84 };
85 }
86 ::std::result::Result::Ok(())
87 }
88
89 #[allow(unused_variables)]
91 fn compute_size(&self) -> u32 {
92 let mut my_size = 0;
93 if self.query != false {
94 my_size += 2;
95 }
96 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
97 self.cached_size.set(my_size);
98 my_size
99 }
100
101 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
102 if self.query != false {
103 os.write_bool(1, self.query)?;
104 }
105 os.write_unknown_fields(self.get_unknown_fields())?;
106 ::std::result::Result::Ok(())
107 }
108
109 fn get_cached_size(&self) -> u32 {
110 self.cached_size.get()
111 }
112
113 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
114 &self.unknown_fields
115 }
116
117 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
118 &mut self.unknown_fields
119 }
120
121 fn as_any(&self) -> &dyn (::std::any::Any) {
122 self as &dyn (::std::any::Any)
123 }
124 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
125 self as &mut dyn (::std::any::Any)
126 }
127 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
128 self
129 }
130
131 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
132 Self::descriptor_static()
133 }
134
135 fn new() -> VersionRequest {
136 VersionRequest::new()
137 }
138
139 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
140 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
141 lock: ::protobuf::lazy::ONCE_INIT,
142 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
143 };
144 unsafe {
145 descriptor.get(|| {
146 let mut fields = ::std::vec::Vec::new();
147 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
148 "query",
149 |m: &VersionRequest| { &m.query },
150 |m: &mut VersionRequest| { &mut m.query },
151 ));
152 ::protobuf::reflect::MessageDescriptor::new::<VersionRequest>(
153 "VersionRequest",
154 fields,
155 file_descriptor_proto()
156 )
157 })
158 }
159 }
160
161 fn default_instance() -> &'static VersionRequest {
162 static mut instance: ::protobuf::lazy::Lazy<VersionRequest> = ::protobuf::lazy::Lazy {
163 lock: ::protobuf::lazy::ONCE_INIT,
164 ptr: 0 as *const VersionRequest,
165 };
166 unsafe {
167 instance.get(VersionRequest::new)
168 }
169 }
170}
171
172impl ::protobuf::Clear for VersionRequest {
173 fn clear(&mut self) {
174 self.query = false;
175 self.unknown_fields.clear();
176 }
177}
178
179impl ::std::fmt::Debug for VersionRequest {
180 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
181 ::protobuf::text_format::fmt(self, f)
182 }
183}
184
185impl ::protobuf::reflect::ProtobufValue for VersionRequest {
186 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
187 ::protobuf::reflect::ProtobufValueRef::Message(self)
188 }
189}
190
191#[derive(PartialEq,Clone,Default)]
192pub struct VersionResponse {
193 pub version: ::std::string::String,
195 pub unknown_fields: ::protobuf::UnknownFields,
197 pub cached_size: ::protobuf::CachedSize,
198}
199
200impl<'a> ::std::default::Default for &'a VersionResponse {
201 fn default() -> &'a VersionResponse {
202 <VersionResponse as ::protobuf::Message>::default_instance()
203 }
204}
205
206impl VersionResponse {
207 pub fn new() -> VersionResponse {
208 ::std::default::Default::default()
209 }
210
211 pub fn get_version(&self) -> &str {
215 &self.version
216 }
217 pub fn clear_version(&mut self) {
218 self.version.clear();
219 }
220
221 pub fn set_version(&mut self, v: ::std::string::String) {
223 self.version = v;
224 }
225
226 pub fn mut_version(&mut self) -> &mut ::std::string::String {
229 &mut self.version
230 }
231
232 pub fn take_version(&mut self) -> ::std::string::String {
234 ::std::mem::replace(&mut self.version, ::std::string::String::new())
235 }
236}
237
238impl ::protobuf::Message for VersionResponse {
239 fn is_initialized(&self) -> bool {
240 true
241 }
242
243 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
244 while !is.eof()? {
245 let (field_number, wire_type) = is.read_tag_unpack()?;
246 match field_number {
247 1 => {
248 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?;
249 },
250 _ => {
251 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
252 },
253 };
254 }
255 ::std::result::Result::Ok(())
256 }
257
258 #[allow(unused_variables)]
260 fn compute_size(&self) -> u32 {
261 let mut my_size = 0;
262 if !self.version.is_empty() {
263 my_size += ::protobuf::rt::string_size(1, &self.version);
264 }
265 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
266 self.cached_size.set(my_size);
267 my_size
268 }
269
270 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
271 if !self.version.is_empty() {
272 os.write_string(1, &self.version)?;
273 }
274 os.write_unknown_fields(self.get_unknown_fields())?;
275 ::std::result::Result::Ok(())
276 }
277
278 fn get_cached_size(&self) -> u32 {
279 self.cached_size.get()
280 }
281
282 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
283 &self.unknown_fields
284 }
285
286 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
287 &mut self.unknown_fields
288 }
289
290 fn as_any(&self) -> &dyn (::std::any::Any) {
291 self as &dyn (::std::any::Any)
292 }
293 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
294 self as &mut dyn (::std::any::Any)
295 }
296 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
297 self
298 }
299
300 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
301 Self::descriptor_static()
302 }
303
304 fn new() -> VersionResponse {
305 VersionResponse::new()
306 }
307
308 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
309 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
310 lock: ::protobuf::lazy::ONCE_INIT,
311 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
312 };
313 unsafe {
314 descriptor.get(|| {
315 let mut fields = ::std::vec::Vec::new();
316 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
317 "version",
318 |m: &VersionResponse| { &m.version },
319 |m: &mut VersionResponse| { &mut m.version },
320 ));
321 ::protobuf::reflect::MessageDescriptor::new::<VersionResponse>(
322 "VersionResponse",
323 fields,
324 file_descriptor_proto()
325 )
326 })
327 }
328 }
329
330 fn default_instance() -> &'static VersionResponse {
331 static mut instance: ::protobuf::lazy::Lazy<VersionResponse> = ::protobuf::lazy::Lazy {
332 lock: ::protobuf::lazy::ONCE_INIT,
333 ptr: 0 as *const VersionResponse,
334 };
335 unsafe {
336 instance.get(VersionResponse::new)
337 }
338 }
339}
340
341impl ::protobuf::Clear for VersionResponse {
342 fn clear(&mut self) {
343 self.version.clear();
344 self.unknown_fields.clear();
345 }
346}
347
348impl ::std::fmt::Debug for VersionResponse {
349 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
350 ::protobuf::text_format::fmt(self, f)
351 }
352}
353
354impl ::protobuf::reflect::ProtobufValue for VersionResponse {
355 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
356 ::protobuf::reflect::ProtobufValueRef::Message(self)
357 }
358}
359
360#[derive(PartialEq,Clone,Default)]
361pub struct GetInfoRequest {
362 pub query: bool,
364 pub unknown_fields: ::protobuf::UnknownFields,
366 pub cached_size: ::protobuf::CachedSize,
367}
368
369impl<'a> ::std::default::Default for &'a GetInfoRequest {
370 fn default() -> &'a GetInfoRequest {
371 <GetInfoRequest as ::protobuf::Message>::default_instance()
372 }
373}
374
375impl GetInfoRequest {
376 pub fn new() -> GetInfoRequest {
377 ::std::default::Default::default()
378 }
379
380 pub fn get_query(&self) -> bool {
384 self.query
385 }
386 pub fn clear_query(&mut self) {
387 self.query = false;
388 }
389
390 pub fn set_query(&mut self, v: bool) {
392 self.query = v;
393 }
394}
395
396impl ::protobuf::Message for GetInfoRequest {
397 fn is_initialized(&self) -> bool {
398 true
399 }
400
401 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
402 while !is.eof()? {
403 let (field_number, wire_type) = is.read_tag_unpack()?;
404 match field_number {
405 1 => {
406 if wire_type != ::protobuf::wire_format::WireTypeVarint {
407 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
408 }
409 let tmp = is.read_bool()?;
410 self.query = tmp;
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.query != false {
425 my_size += 2;
426 }
427 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
428 self.cached_size.set(my_size);
429 my_size
430 }
431
432 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
433 if self.query != false {
434 os.write_bool(1, self.query)?;
435 }
436 os.write_unknown_fields(self.get_unknown_fields())?;
437 ::std::result::Result::Ok(())
438 }
439
440 fn get_cached_size(&self) -> u32 {
441 self.cached_size.get()
442 }
443
444 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
445 &self.unknown_fields
446 }
447
448 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
449 &mut self.unknown_fields
450 }
451
452 fn as_any(&self) -> &dyn (::std::any::Any) {
453 self as &dyn (::std::any::Any)
454 }
455 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
456 self as &mut dyn (::std::any::Any)
457 }
458 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
459 self
460 }
461
462 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
463 Self::descriptor_static()
464 }
465
466 fn new() -> GetInfoRequest {
467 GetInfoRequest::new()
468 }
469
470 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
471 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
472 lock: ::protobuf::lazy::ONCE_INIT,
473 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
474 };
475 unsafe {
476 descriptor.get(|| {
477 let mut fields = ::std::vec::Vec::new();
478 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
479 "query",
480 |m: &GetInfoRequest| { &m.query },
481 |m: &mut GetInfoRequest| { &mut m.query },
482 ));
483 ::protobuf::reflect::MessageDescriptor::new::<GetInfoRequest>(
484 "GetInfoRequest",
485 fields,
486 file_descriptor_proto()
487 )
488 })
489 }
490 }
491
492 fn default_instance() -> &'static GetInfoRequest {
493 static mut instance: ::protobuf::lazy::Lazy<GetInfoRequest> = ::protobuf::lazy::Lazy {
494 lock: ::protobuf::lazy::ONCE_INIT,
495 ptr: 0 as *const GetInfoRequest,
496 };
497 unsafe {
498 instance.get(GetInfoRequest::new)
499 }
500 }
501}
502
503impl ::protobuf::Clear for GetInfoRequest {
504 fn clear(&mut self) {
505 self.query = false;
506 self.unknown_fields.clear();
507 }
508}
509
510impl ::std::fmt::Debug for GetInfoRequest {
511 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
512 ::protobuf::text_format::fmt(self, f)
513 }
514}
515
516impl ::protobuf::reflect::ProtobufValue for GetInfoRequest {
517 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
518 ::protobuf::reflect::ProtobufValueRef::Message(self)
519 }
520}
521
522#[derive(PartialEq,Clone,Default)]
523pub struct GetInfoResponse {
524 pub query: ::std::string::String,
526 pub unknown_fields: ::protobuf::UnknownFields,
528 pub cached_size: ::protobuf::CachedSize,
529}
530
531impl<'a> ::std::default::Default for &'a GetInfoResponse {
532 fn default() -> &'a GetInfoResponse {
533 <GetInfoResponse as ::protobuf::Message>::default_instance()
534 }
535}
536
537impl GetInfoResponse {
538 pub fn new() -> GetInfoResponse {
539 ::std::default::Default::default()
540 }
541
542 pub fn get_query(&self) -> &str {
546 &self.query
547 }
548 pub fn clear_query(&mut self) {
549 self.query.clear();
550 }
551
552 pub fn set_query(&mut self, v: ::std::string::String) {
554 self.query = v;
555 }
556
557 pub fn mut_query(&mut self) -> &mut ::std::string::String {
560 &mut self.query
561 }
562
563 pub fn take_query(&mut self) -> ::std::string::String {
565 ::std::mem::replace(&mut self.query, ::std::string::String::new())
566 }
567}
568
569impl ::protobuf::Message for GetInfoResponse {
570 fn is_initialized(&self) -> bool {
571 true
572 }
573
574 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
575 while !is.eof()? {
576 let (field_number, wire_type) = is.read_tag_unpack()?;
577 match field_number {
578 1 => {
579 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
580 },
581 _ => {
582 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
583 },
584 };
585 }
586 ::std::result::Result::Ok(())
587 }
588
589 #[allow(unused_variables)]
591 fn compute_size(&self) -> u32 {
592 let mut my_size = 0;
593 if !self.query.is_empty() {
594 my_size += ::protobuf::rt::string_size(1, &self.query);
595 }
596 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
597 self.cached_size.set(my_size);
598 my_size
599 }
600
601 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
602 if !self.query.is_empty() {
603 os.write_string(1, &self.query)?;
604 }
605 os.write_unknown_fields(self.get_unknown_fields())?;
606 ::std::result::Result::Ok(())
607 }
608
609 fn get_cached_size(&self) -> u32 {
610 self.cached_size.get()
611 }
612
613 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
614 &self.unknown_fields
615 }
616
617 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
618 &mut self.unknown_fields
619 }
620
621 fn as_any(&self) -> &dyn (::std::any::Any) {
622 self as &dyn (::std::any::Any)
623 }
624 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
625 self as &mut dyn (::std::any::Any)
626 }
627 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
628 self
629 }
630
631 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
632 Self::descriptor_static()
633 }
634
635 fn new() -> GetInfoResponse {
636 GetInfoResponse::new()
637 }
638
639 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
640 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
641 lock: ::protobuf::lazy::ONCE_INIT,
642 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
643 };
644 unsafe {
645 descriptor.get(|| {
646 let mut fields = ::std::vec::Vec::new();
647 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
648 "query",
649 |m: &GetInfoResponse| { &m.query },
650 |m: &mut GetInfoResponse| { &mut m.query },
651 ));
652 ::protobuf::reflect::MessageDescriptor::new::<GetInfoResponse>(
653 "GetInfoResponse",
654 fields,
655 file_descriptor_proto()
656 )
657 })
658 }
659 }
660
661 fn default_instance() -> &'static GetInfoResponse {
662 static mut instance: ::protobuf::lazy::Lazy<GetInfoResponse> = ::protobuf::lazy::Lazy {
663 lock: ::protobuf::lazy::ONCE_INIT,
664 ptr: 0 as *const GetInfoResponse,
665 };
666 unsafe {
667 instance.get(GetInfoResponse::new)
668 }
669 }
670}
671
672impl ::protobuf::Clear for GetInfoResponse {
673 fn clear(&mut self) {
674 self.query.clear();
675 self.unknown_fields.clear();
676 }
677}
678
679impl ::std::fmt::Debug for GetInfoResponse {
680 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
681 ::protobuf::text_format::fmt(self, f)
682 }
683}
684
685impl ::protobuf::reflect::ProtobufValue for GetInfoResponse {
686 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
687 ::protobuf::reflect::ProtobufValueRef::Message(self)
688 }
689}
690
691#[derive(PartialEq,Clone,Default)]
692pub struct CreateWalletRequest {
693 pub query: bool,
695 pub unknown_fields: ::protobuf::UnknownFields,
697 pub cached_size: ::protobuf::CachedSize,
698}
699
700impl<'a> ::std::default::Default for &'a CreateWalletRequest {
701 fn default() -> &'a CreateWalletRequest {
702 <CreateWalletRequest as ::protobuf::Message>::default_instance()
703 }
704}
705
706impl CreateWalletRequest {
707 pub fn new() -> CreateWalletRequest {
708 ::std::default::Default::default()
709 }
710
711 pub fn get_query(&self) -> bool {
715 self.query
716 }
717 pub fn clear_query(&mut self) {
718 self.query = false;
719 }
720
721 pub fn set_query(&mut self, v: bool) {
723 self.query = v;
724 }
725}
726
727impl ::protobuf::Message for CreateWalletRequest {
728 fn is_initialized(&self) -> bool {
729 true
730 }
731
732 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
733 while !is.eof()? {
734 let (field_number, wire_type) = is.read_tag_unpack()?;
735 match field_number {
736 1 => {
737 if wire_type != ::protobuf::wire_format::WireTypeVarint {
738 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
739 }
740 let tmp = is.read_bool()?;
741 self.query = tmp;
742 },
743 _ => {
744 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
745 },
746 };
747 }
748 ::std::result::Result::Ok(())
749 }
750
751 #[allow(unused_variables)]
753 fn compute_size(&self) -> u32 {
754 let mut my_size = 0;
755 if self.query != false {
756 my_size += 2;
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.query != false {
765 os.write_bool(1, self.query)?;
766 }
767 os.write_unknown_fields(self.get_unknown_fields())?;
768 ::std::result::Result::Ok(())
769 }
770
771 fn get_cached_size(&self) -> u32 {
772 self.cached_size.get()
773 }
774
775 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
776 &self.unknown_fields
777 }
778
779 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
780 &mut self.unknown_fields
781 }
782
783 fn as_any(&self) -> &dyn (::std::any::Any) {
784 self as &dyn (::std::any::Any)
785 }
786 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
787 self as &mut dyn (::std::any::Any)
788 }
789 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
790 self
791 }
792
793 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
794 Self::descriptor_static()
795 }
796
797 fn new() -> CreateWalletRequest {
798 CreateWalletRequest::new()
799 }
800
801 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
802 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
803 lock: ::protobuf::lazy::ONCE_INIT,
804 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
805 };
806 unsafe {
807 descriptor.get(|| {
808 let mut fields = ::std::vec::Vec::new();
809 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
810 "query",
811 |m: &CreateWalletRequest| { &m.query },
812 |m: &mut CreateWalletRequest| { &mut m.query },
813 ));
814 ::protobuf::reflect::MessageDescriptor::new::<CreateWalletRequest>(
815 "CreateWalletRequest",
816 fields,
817 file_descriptor_proto()
818 )
819 })
820 }
821 }
822
823 fn default_instance() -> &'static CreateWalletRequest {
824 static mut instance: ::protobuf::lazy::Lazy<CreateWalletRequest> = ::protobuf::lazy::Lazy {
825 lock: ::protobuf::lazy::ONCE_INIT,
826 ptr: 0 as *const CreateWalletRequest,
827 };
828 unsafe {
829 instance.get(CreateWalletRequest::new)
830 }
831 }
832}
833
834impl ::protobuf::Clear for CreateWalletRequest {
835 fn clear(&mut self) {
836 self.query = false;
837 self.unknown_fields.clear();
838 }
839}
840
841impl ::std::fmt::Debug for CreateWalletRequest {
842 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
843 ::protobuf::text_format::fmt(self, f)
844 }
845}
846
847impl ::protobuf::reflect::ProtobufValue for CreateWalletRequest {
848 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
849 ::protobuf::reflect::ProtobufValueRef::Message(self)
850 }
851}
852
853#[derive(PartialEq,Clone,Default)]
854pub struct CreateWalletResponse {
855 pub query: ::std::string::String,
857 pub unknown_fields: ::protobuf::UnknownFields,
859 pub cached_size: ::protobuf::CachedSize,
860}
861
862impl<'a> ::std::default::Default for &'a CreateWalletResponse {
863 fn default() -> &'a CreateWalletResponse {
864 <CreateWalletResponse as ::protobuf::Message>::default_instance()
865 }
866}
867
868impl CreateWalletResponse {
869 pub fn new() -> CreateWalletResponse {
870 ::std::default::Default::default()
871 }
872
873 pub fn get_query(&self) -> &str {
877 &self.query
878 }
879 pub fn clear_query(&mut self) {
880 self.query.clear();
881 }
882
883 pub fn set_query(&mut self, v: ::std::string::String) {
885 self.query = v;
886 }
887
888 pub fn mut_query(&mut self) -> &mut ::std::string::String {
891 &mut self.query
892 }
893
894 pub fn take_query(&mut self) -> ::std::string::String {
896 ::std::mem::replace(&mut self.query, ::std::string::String::new())
897 }
898}
899
900impl ::protobuf::Message for CreateWalletResponse {
901 fn is_initialized(&self) -> bool {
902 true
903 }
904
905 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
906 while !is.eof()? {
907 let (field_number, wire_type) = is.read_tag_unpack()?;
908 match field_number {
909 1 => {
910 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
911 },
912 _ => {
913 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
914 },
915 };
916 }
917 ::std::result::Result::Ok(())
918 }
919
920 #[allow(unused_variables)]
922 fn compute_size(&self) -> u32 {
923 let mut my_size = 0;
924 if !self.query.is_empty() {
925 my_size += ::protobuf::rt::string_size(1, &self.query);
926 }
927 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
928 self.cached_size.set(my_size);
929 my_size
930 }
931
932 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
933 if !self.query.is_empty() {
934 os.write_string(1, &self.query)?;
935 }
936 os.write_unknown_fields(self.get_unknown_fields())?;
937 ::std::result::Result::Ok(())
938 }
939
940 fn get_cached_size(&self) -> u32 {
941 self.cached_size.get()
942 }
943
944 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
945 &self.unknown_fields
946 }
947
948 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
949 &mut self.unknown_fields
950 }
951
952 fn as_any(&self) -> &dyn (::std::any::Any) {
953 self as &dyn (::std::any::Any)
954 }
955 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
956 self as &mut dyn (::std::any::Any)
957 }
958 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
959 self
960 }
961
962 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
963 Self::descriptor_static()
964 }
965
966 fn new() -> CreateWalletResponse {
967 CreateWalletResponse::new()
968 }
969
970 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
971 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
972 lock: ::protobuf::lazy::ONCE_INIT,
973 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
974 };
975 unsafe {
976 descriptor.get(|| {
977 let mut fields = ::std::vec::Vec::new();
978 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
979 "query",
980 |m: &CreateWalletResponse| { &m.query },
981 |m: &mut CreateWalletResponse| { &mut m.query },
982 ));
983 ::protobuf::reflect::MessageDescriptor::new::<CreateWalletResponse>(
984 "CreateWalletResponse",
985 fields,
986 file_descriptor_proto()
987 )
988 })
989 }
990 }
991
992 fn default_instance() -> &'static CreateWalletResponse {
993 static mut instance: ::protobuf::lazy::Lazy<CreateWalletResponse> = ::protobuf::lazy::Lazy {
994 lock: ::protobuf::lazy::ONCE_INIT,
995 ptr: 0 as *const CreateWalletResponse,
996 };
997 unsafe {
998 instance.get(CreateWalletResponse::new)
999 }
1000 }
1001}
1002
1003impl ::protobuf::Clear for CreateWalletResponse {
1004 fn clear(&mut self) {
1005 self.query.clear();
1006 self.unknown_fields.clear();
1007 }
1008}
1009
1010impl ::std::fmt::Debug for CreateWalletResponse {
1011 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1012 ::protobuf::text_format::fmt(self, f)
1013 }
1014}
1015
1016impl ::protobuf::reflect::ProtobufValue for CreateWalletResponse {
1017 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1018 ::protobuf::reflect::ProtobufValueRef::Message(self)
1019 }
1020}
1021
1022#[derive(PartialEq,Clone,Default)]
1023pub struct ListWalletRequest {
1024 pub query: bool,
1026 pub unknown_fields: ::protobuf::UnknownFields,
1028 pub cached_size: ::protobuf::CachedSize,
1029}
1030
1031impl<'a> ::std::default::Default for &'a ListWalletRequest {
1032 fn default() -> &'a ListWalletRequest {
1033 <ListWalletRequest as ::protobuf::Message>::default_instance()
1034 }
1035}
1036
1037impl ListWalletRequest {
1038 pub fn new() -> ListWalletRequest {
1039 ::std::default::Default::default()
1040 }
1041
1042 pub fn get_query(&self) -> bool {
1046 self.query
1047 }
1048 pub fn clear_query(&mut self) {
1049 self.query = false;
1050 }
1051
1052 pub fn set_query(&mut self, v: bool) {
1054 self.query = v;
1055 }
1056}
1057
1058impl ::protobuf::Message for ListWalletRequest {
1059 fn is_initialized(&self) -> bool {
1060 true
1061 }
1062
1063 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1064 while !is.eof()? {
1065 let (field_number, wire_type) = is.read_tag_unpack()?;
1066 match field_number {
1067 1 => {
1068 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1069 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1070 }
1071 let tmp = is.read_bool()?;
1072 self.query = tmp;
1073 },
1074 _ => {
1075 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1076 },
1077 };
1078 }
1079 ::std::result::Result::Ok(())
1080 }
1081
1082 #[allow(unused_variables)]
1084 fn compute_size(&self) -> u32 {
1085 let mut my_size = 0;
1086 if self.query != false {
1087 my_size += 2;
1088 }
1089 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1090 self.cached_size.set(my_size);
1091 my_size
1092 }
1093
1094 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1095 if self.query != false {
1096 os.write_bool(1, self.query)?;
1097 }
1098 os.write_unknown_fields(self.get_unknown_fields())?;
1099 ::std::result::Result::Ok(())
1100 }
1101
1102 fn get_cached_size(&self) -> u32 {
1103 self.cached_size.get()
1104 }
1105
1106 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1107 &self.unknown_fields
1108 }
1109
1110 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1111 &mut self.unknown_fields
1112 }
1113
1114 fn as_any(&self) -> &dyn (::std::any::Any) {
1115 self as &dyn (::std::any::Any)
1116 }
1117 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1118 self as &mut dyn (::std::any::Any)
1119 }
1120 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1121 self
1122 }
1123
1124 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1125 Self::descriptor_static()
1126 }
1127
1128 fn new() -> ListWalletRequest {
1129 ListWalletRequest::new()
1130 }
1131
1132 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1133 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1134 lock: ::protobuf::lazy::ONCE_INIT,
1135 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1136 };
1137 unsafe {
1138 descriptor.get(|| {
1139 let mut fields = ::std::vec::Vec::new();
1140 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1141 "query",
1142 |m: &ListWalletRequest| { &m.query },
1143 |m: &mut ListWalletRequest| { &mut m.query },
1144 ));
1145 ::protobuf::reflect::MessageDescriptor::new::<ListWalletRequest>(
1146 "ListWalletRequest",
1147 fields,
1148 file_descriptor_proto()
1149 )
1150 })
1151 }
1152 }
1153
1154 fn default_instance() -> &'static ListWalletRequest {
1155 static mut instance: ::protobuf::lazy::Lazy<ListWalletRequest> = ::protobuf::lazy::Lazy {
1156 lock: ::protobuf::lazy::ONCE_INIT,
1157 ptr: 0 as *const ListWalletRequest,
1158 };
1159 unsafe {
1160 instance.get(ListWalletRequest::new)
1161 }
1162 }
1163}
1164
1165impl ::protobuf::Clear for ListWalletRequest {
1166 fn clear(&mut self) {
1167 self.query = false;
1168 self.unknown_fields.clear();
1169 }
1170}
1171
1172impl ::std::fmt::Debug for ListWalletRequest {
1173 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1174 ::protobuf::text_format::fmt(self, f)
1175 }
1176}
1177
1178impl ::protobuf::reflect::ProtobufValue for ListWalletRequest {
1179 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1180 ::protobuf::reflect::ProtobufValueRef::Message(self)
1181 }
1182}
1183
1184#[derive(PartialEq,Clone,Default)]
1185pub struct ListWalletResponse {
1186 pub query: ::std::string::String,
1188 pub unknown_fields: ::protobuf::UnknownFields,
1190 pub cached_size: ::protobuf::CachedSize,
1191}
1192
1193impl<'a> ::std::default::Default for &'a ListWalletResponse {
1194 fn default() -> &'a ListWalletResponse {
1195 <ListWalletResponse as ::protobuf::Message>::default_instance()
1196 }
1197}
1198
1199impl ListWalletResponse {
1200 pub fn new() -> ListWalletResponse {
1201 ::std::default::Default::default()
1202 }
1203
1204 pub fn get_query(&self) -> &str {
1208 &self.query
1209 }
1210 pub fn clear_query(&mut self) {
1211 self.query.clear();
1212 }
1213
1214 pub fn set_query(&mut self, v: ::std::string::String) {
1216 self.query = v;
1217 }
1218
1219 pub fn mut_query(&mut self) -> &mut ::std::string::String {
1222 &mut self.query
1223 }
1224
1225 pub fn take_query(&mut self) -> ::std::string::String {
1227 ::std::mem::replace(&mut self.query, ::std::string::String::new())
1228 }
1229}
1230
1231impl ::protobuf::Message for ListWalletResponse {
1232 fn is_initialized(&self) -> bool {
1233 true
1234 }
1235
1236 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1237 while !is.eof()? {
1238 let (field_number, wire_type) = is.read_tag_unpack()?;
1239 match field_number {
1240 1 => {
1241 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
1242 },
1243 _ => {
1244 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1245 },
1246 };
1247 }
1248 ::std::result::Result::Ok(())
1249 }
1250
1251 #[allow(unused_variables)]
1253 fn compute_size(&self) -> u32 {
1254 let mut my_size = 0;
1255 if !self.query.is_empty() {
1256 my_size += ::protobuf::rt::string_size(1, &self.query);
1257 }
1258 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1259 self.cached_size.set(my_size);
1260 my_size
1261 }
1262
1263 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1264 if !self.query.is_empty() {
1265 os.write_string(1, &self.query)?;
1266 }
1267 os.write_unknown_fields(self.get_unknown_fields())?;
1268 ::std::result::Result::Ok(())
1269 }
1270
1271 fn get_cached_size(&self) -> u32 {
1272 self.cached_size.get()
1273 }
1274
1275 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1276 &self.unknown_fields
1277 }
1278
1279 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1280 &mut self.unknown_fields
1281 }
1282
1283 fn as_any(&self) -> &dyn (::std::any::Any) {
1284 self as &dyn (::std::any::Any)
1285 }
1286 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1287 self as &mut dyn (::std::any::Any)
1288 }
1289 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1290 self
1291 }
1292
1293 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1294 Self::descriptor_static()
1295 }
1296
1297 fn new() -> ListWalletResponse {
1298 ListWalletResponse::new()
1299 }
1300
1301 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1302 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1303 lock: ::protobuf::lazy::ONCE_INIT,
1304 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1305 };
1306 unsafe {
1307 descriptor.get(|| {
1308 let mut fields = ::std::vec::Vec::new();
1309 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1310 "query",
1311 |m: &ListWalletResponse| { &m.query },
1312 |m: &mut ListWalletResponse| { &mut m.query },
1313 ));
1314 ::protobuf::reflect::MessageDescriptor::new::<ListWalletResponse>(
1315 "ListWalletResponse",
1316 fields,
1317 file_descriptor_proto()
1318 )
1319 })
1320 }
1321 }
1322
1323 fn default_instance() -> &'static ListWalletResponse {
1324 static mut instance: ::protobuf::lazy::Lazy<ListWalletResponse> = ::protobuf::lazy::Lazy {
1325 lock: ::protobuf::lazy::ONCE_INIT,
1326 ptr: 0 as *const ListWalletResponse,
1327 };
1328 unsafe {
1329 instance.get(ListWalletResponse::new)
1330 }
1331 }
1332}
1333
1334impl ::protobuf::Clear for ListWalletResponse {
1335 fn clear(&mut self) {
1336 self.query.clear();
1337 self.unknown_fields.clear();
1338 }
1339}
1340
1341impl ::std::fmt::Debug for ListWalletResponse {
1342 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1343 ::protobuf::text_format::fmt(self, f)
1344 }
1345}
1346
1347impl ::protobuf::reflect::ProtobufValue for ListWalletResponse {
1348 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1349 ::protobuf::reflect::ProtobufValueRef::Message(self)
1350 }
1351}
1352
1353#[derive(PartialEq,Clone,Default)]
1354pub struct CreateAddressRequest {
1355 pub query: bool,
1357 pub unknown_fields: ::protobuf::UnknownFields,
1359 pub cached_size: ::protobuf::CachedSize,
1360}
1361
1362impl<'a> ::std::default::Default for &'a CreateAddressRequest {
1363 fn default() -> &'a CreateAddressRequest {
1364 <CreateAddressRequest as ::protobuf::Message>::default_instance()
1365 }
1366}
1367
1368impl CreateAddressRequest {
1369 pub fn new() -> CreateAddressRequest {
1370 ::std::default::Default::default()
1371 }
1372
1373 pub fn get_query(&self) -> bool {
1377 self.query
1378 }
1379 pub fn clear_query(&mut self) {
1380 self.query = false;
1381 }
1382
1383 pub fn set_query(&mut self, v: bool) {
1385 self.query = v;
1386 }
1387}
1388
1389impl ::protobuf::Message for CreateAddressRequest {
1390 fn is_initialized(&self) -> bool {
1391 true
1392 }
1393
1394 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1395 while !is.eof()? {
1396 let (field_number, wire_type) = is.read_tag_unpack()?;
1397 match field_number {
1398 1 => {
1399 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1400 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1401 }
1402 let tmp = is.read_bool()?;
1403 self.query = tmp;
1404 },
1405 _ => {
1406 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1407 },
1408 };
1409 }
1410 ::std::result::Result::Ok(())
1411 }
1412
1413 #[allow(unused_variables)]
1415 fn compute_size(&self) -> u32 {
1416 let mut my_size = 0;
1417 if self.query != false {
1418 my_size += 2;
1419 }
1420 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1421 self.cached_size.set(my_size);
1422 my_size
1423 }
1424
1425 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1426 if self.query != false {
1427 os.write_bool(1, self.query)?;
1428 }
1429 os.write_unknown_fields(self.get_unknown_fields())?;
1430 ::std::result::Result::Ok(())
1431 }
1432
1433 fn get_cached_size(&self) -> u32 {
1434 self.cached_size.get()
1435 }
1436
1437 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1438 &self.unknown_fields
1439 }
1440
1441 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1442 &mut self.unknown_fields
1443 }
1444
1445 fn as_any(&self) -> &dyn (::std::any::Any) {
1446 self as &dyn (::std::any::Any)
1447 }
1448 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1449 self as &mut dyn (::std::any::Any)
1450 }
1451 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1452 self
1453 }
1454
1455 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1456 Self::descriptor_static()
1457 }
1458
1459 fn new() -> CreateAddressRequest {
1460 CreateAddressRequest::new()
1461 }
1462
1463 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1464 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1465 lock: ::protobuf::lazy::ONCE_INIT,
1466 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1467 };
1468 unsafe {
1469 descriptor.get(|| {
1470 let mut fields = ::std::vec::Vec::new();
1471 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1472 "query",
1473 |m: &CreateAddressRequest| { &m.query },
1474 |m: &mut CreateAddressRequest| { &mut m.query },
1475 ));
1476 ::protobuf::reflect::MessageDescriptor::new::<CreateAddressRequest>(
1477 "CreateAddressRequest",
1478 fields,
1479 file_descriptor_proto()
1480 )
1481 })
1482 }
1483 }
1484
1485 fn default_instance() -> &'static CreateAddressRequest {
1486 static mut instance: ::protobuf::lazy::Lazy<CreateAddressRequest> = ::protobuf::lazy::Lazy {
1487 lock: ::protobuf::lazy::ONCE_INIT,
1488 ptr: 0 as *const CreateAddressRequest,
1489 };
1490 unsafe {
1491 instance.get(CreateAddressRequest::new)
1492 }
1493 }
1494}
1495
1496impl ::protobuf::Clear for CreateAddressRequest {
1497 fn clear(&mut self) {
1498 self.query = false;
1499 self.unknown_fields.clear();
1500 }
1501}
1502
1503impl ::std::fmt::Debug for CreateAddressRequest {
1504 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1505 ::protobuf::text_format::fmt(self, f)
1506 }
1507}
1508
1509impl ::protobuf::reflect::ProtobufValue for CreateAddressRequest {
1510 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1511 ::protobuf::reflect::ProtobufValueRef::Message(self)
1512 }
1513}
1514
1515#[derive(PartialEq,Clone,Default)]
1516pub struct CreateAddressResponse {
1517 pub query: ::std::string::String,
1519 pub unknown_fields: ::protobuf::UnknownFields,
1521 pub cached_size: ::protobuf::CachedSize,
1522}
1523
1524impl<'a> ::std::default::Default for &'a CreateAddressResponse {
1525 fn default() -> &'a CreateAddressResponse {
1526 <CreateAddressResponse as ::protobuf::Message>::default_instance()
1527 }
1528}
1529
1530impl CreateAddressResponse {
1531 pub fn new() -> CreateAddressResponse {
1532 ::std::default::Default::default()
1533 }
1534
1535 pub fn get_query(&self) -> &str {
1539 &self.query
1540 }
1541 pub fn clear_query(&mut self) {
1542 self.query.clear();
1543 }
1544
1545 pub fn set_query(&mut self, v: ::std::string::String) {
1547 self.query = v;
1548 }
1549
1550 pub fn mut_query(&mut self) -> &mut ::std::string::String {
1553 &mut self.query
1554 }
1555
1556 pub fn take_query(&mut self) -> ::std::string::String {
1558 ::std::mem::replace(&mut self.query, ::std::string::String::new())
1559 }
1560}
1561
1562impl ::protobuf::Message for CreateAddressResponse {
1563 fn is_initialized(&self) -> bool {
1564 true
1565 }
1566
1567 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1568 while !is.eof()? {
1569 let (field_number, wire_type) = is.read_tag_unpack()?;
1570 match field_number {
1571 1 => {
1572 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
1573 },
1574 _ => {
1575 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1576 },
1577 };
1578 }
1579 ::std::result::Result::Ok(())
1580 }
1581
1582 #[allow(unused_variables)]
1584 fn compute_size(&self) -> u32 {
1585 let mut my_size = 0;
1586 if !self.query.is_empty() {
1587 my_size += ::protobuf::rt::string_size(1, &self.query);
1588 }
1589 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1590 self.cached_size.set(my_size);
1591 my_size
1592 }
1593
1594 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1595 if !self.query.is_empty() {
1596 os.write_string(1, &self.query)?;
1597 }
1598 os.write_unknown_fields(self.get_unknown_fields())?;
1599 ::std::result::Result::Ok(())
1600 }
1601
1602 fn get_cached_size(&self) -> u32 {
1603 self.cached_size.get()
1604 }
1605
1606 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1607 &self.unknown_fields
1608 }
1609
1610 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1611 &mut self.unknown_fields
1612 }
1613
1614 fn as_any(&self) -> &dyn (::std::any::Any) {
1615 self as &dyn (::std::any::Any)
1616 }
1617 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1618 self as &mut dyn (::std::any::Any)
1619 }
1620 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1621 self
1622 }
1623
1624 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1625 Self::descriptor_static()
1626 }
1627
1628 fn new() -> CreateAddressResponse {
1629 CreateAddressResponse::new()
1630 }
1631
1632 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1633 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1634 lock: ::protobuf::lazy::ONCE_INIT,
1635 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1636 };
1637 unsafe {
1638 descriptor.get(|| {
1639 let mut fields = ::std::vec::Vec::new();
1640 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1641 "query",
1642 |m: &CreateAddressResponse| { &m.query },
1643 |m: &mut CreateAddressResponse| { &mut m.query },
1644 ));
1645 ::protobuf::reflect::MessageDescriptor::new::<CreateAddressResponse>(
1646 "CreateAddressResponse",
1647 fields,
1648 file_descriptor_proto()
1649 )
1650 })
1651 }
1652 }
1653
1654 fn default_instance() -> &'static CreateAddressResponse {
1655 static mut instance: ::protobuf::lazy::Lazy<CreateAddressResponse> = ::protobuf::lazy::Lazy {
1656 lock: ::protobuf::lazy::ONCE_INIT,
1657 ptr: 0 as *const CreateAddressResponse,
1658 };
1659 unsafe {
1660 instance.get(CreateAddressResponse::new)
1661 }
1662 }
1663}
1664
1665impl ::protobuf::Clear for CreateAddressResponse {
1666 fn clear(&mut self) {
1667 self.query.clear();
1668 self.unknown_fields.clear();
1669 }
1670}
1671
1672impl ::std::fmt::Debug for CreateAddressResponse {
1673 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1674 ::protobuf::text_format::fmt(self, f)
1675 }
1676}
1677
1678impl ::protobuf::reflect::ProtobufValue for CreateAddressResponse {
1679 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1680 ::protobuf::reflect::ProtobufValueRef::Message(self)
1681 }
1682}
1683
1684#[derive(PartialEq,Clone,Default)]
1685pub struct GetAddressRequest {
1686 pub query: bool,
1688 pub unknown_fields: ::protobuf::UnknownFields,
1690 pub cached_size: ::protobuf::CachedSize,
1691}
1692
1693impl<'a> ::std::default::Default for &'a GetAddressRequest {
1694 fn default() -> &'a GetAddressRequest {
1695 <GetAddressRequest as ::protobuf::Message>::default_instance()
1696 }
1697}
1698
1699impl GetAddressRequest {
1700 pub fn new() -> GetAddressRequest {
1701 ::std::default::Default::default()
1702 }
1703
1704 pub fn get_query(&self) -> bool {
1708 self.query
1709 }
1710 pub fn clear_query(&mut self) {
1711 self.query = false;
1712 }
1713
1714 pub fn set_query(&mut self, v: bool) {
1716 self.query = v;
1717 }
1718}
1719
1720impl ::protobuf::Message for GetAddressRequest {
1721 fn is_initialized(&self) -> bool {
1722 true
1723 }
1724
1725 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1726 while !is.eof()? {
1727 let (field_number, wire_type) = is.read_tag_unpack()?;
1728 match field_number {
1729 1 => {
1730 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1731 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1732 }
1733 let tmp = is.read_bool()?;
1734 self.query = tmp;
1735 },
1736 _ => {
1737 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1738 },
1739 };
1740 }
1741 ::std::result::Result::Ok(())
1742 }
1743
1744 #[allow(unused_variables)]
1746 fn compute_size(&self) -> u32 {
1747 let mut my_size = 0;
1748 if self.query != false {
1749 my_size += 2;
1750 }
1751 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1752 self.cached_size.set(my_size);
1753 my_size
1754 }
1755
1756 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1757 if self.query != false {
1758 os.write_bool(1, self.query)?;
1759 }
1760 os.write_unknown_fields(self.get_unknown_fields())?;
1761 ::std::result::Result::Ok(())
1762 }
1763
1764 fn get_cached_size(&self) -> u32 {
1765 self.cached_size.get()
1766 }
1767
1768 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1769 &self.unknown_fields
1770 }
1771
1772 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1773 &mut self.unknown_fields
1774 }
1775
1776 fn as_any(&self) -> &dyn (::std::any::Any) {
1777 self as &dyn (::std::any::Any)
1778 }
1779 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1780 self as &mut dyn (::std::any::Any)
1781 }
1782 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1783 self
1784 }
1785
1786 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1787 Self::descriptor_static()
1788 }
1789
1790 fn new() -> GetAddressRequest {
1791 GetAddressRequest::new()
1792 }
1793
1794 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1795 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1796 lock: ::protobuf::lazy::ONCE_INIT,
1797 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1798 };
1799 unsafe {
1800 descriptor.get(|| {
1801 let mut fields = ::std::vec::Vec::new();
1802 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1803 "query",
1804 |m: &GetAddressRequest| { &m.query },
1805 |m: &mut GetAddressRequest| { &mut m.query },
1806 ));
1807 ::protobuf::reflect::MessageDescriptor::new::<GetAddressRequest>(
1808 "GetAddressRequest",
1809 fields,
1810 file_descriptor_proto()
1811 )
1812 })
1813 }
1814 }
1815
1816 fn default_instance() -> &'static GetAddressRequest {
1817 static mut instance: ::protobuf::lazy::Lazy<GetAddressRequest> = ::protobuf::lazy::Lazy {
1818 lock: ::protobuf::lazy::ONCE_INIT,
1819 ptr: 0 as *const GetAddressRequest,
1820 };
1821 unsafe {
1822 instance.get(GetAddressRequest::new)
1823 }
1824 }
1825}
1826
1827impl ::protobuf::Clear for GetAddressRequest {
1828 fn clear(&mut self) {
1829 self.query = false;
1830 self.unknown_fields.clear();
1831 }
1832}
1833
1834impl ::std::fmt::Debug for GetAddressRequest {
1835 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1836 ::protobuf::text_format::fmt(self, f)
1837 }
1838}
1839
1840impl ::protobuf::reflect::ProtobufValue for GetAddressRequest {
1841 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
1842 ::protobuf::reflect::ProtobufValueRef::Message(self)
1843 }
1844}
1845
1846#[derive(PartialEq,Clone,Default)]
1847pub struct GetAddressResponse {
1848 pub query: ::std::string::String,
1850 pub unknown_fields: ::protobuf::UnknownFields,
1852 pub cached_size: ::protobuf::CachedSize,
1853}
1854
1855impl<'a> ::std::default::Default for &'a GetAddressResponse {
1856 fn default() -> &'a GetAddressResponse {
1857 <GetAddressResponse as ::protobuf::Message>::default_instance()
1858 }
1859}
1860
1861impl GetAddressResponse {
1862 pub fn new() -> GetAddressResponse {
1863 ::std::default::Default::default()
1864 }
1865
1866 pub fn get_query(&self) -> &str {
1870 &self.query
1871 }
1872 pub fn clear_query(&mut self) {
1873 self.query.clear();
1874 }
1875
1876 pub fn set_query(&mut self, v: ::std::string::String) {
1878 self.query = v;
1879 }
1880
1881 pub fn mut_query(&mut self) -> &mut ::std::string::String {
1884 &mut self.query
1885 }
1886
1887 pub fn take_query(&mut self) -> ::std::string::String {
1889 ::std::mem::replace(&mut self.query, ::std::string::String::new())
1890 }
1891}
1892
1893impl ::protobuf::Message for GetAddressResponse {
1894 fn is_initialized(&self) -> bool {
1895 true
1896 }
1897
1898 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1899 while !is.eof()? {
1900 let (field_number, wire_type) = is.read_tag_unpack()?;
1901 match field_number {
1902 1 => {
1903 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
1904 },
1905 _ => {
1906 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1907 },
1908 };
1909 }
1910 ::std::result::Result::Ok(())
1911 }
1912
1913 #[allow(unused_variables)]
1915 fn compute_size(&self) -> u32 {
1916 let mut my_size = 0;
1917 if !self.query.is_empty() {
1918 my_size += ::protobuf::rt::string_size(1, &self.query);
1919 }
1920 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1921 self.cached_size.set(my_size);
1922 my_size
1923 }
1924
1925 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1926 if !self.query.is_empty() {
1927 os.write_string(1, &self.query)?;
1928 }
1929 os.write_unknown_fields(self.get_unknown_fields())?;
1930 ::std::result::Result::Ok(())
1931 }
1932
1933 fn get_cached_size(&self) -> u32 {
1934 self.cached_size.get()
1935 }
1936
1937 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1938 &self.unknown_fields
1939 }
1940
1941 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1942 &mut self.unknown_fields
1943 }
1944
1945 fn as_any(&self) -> &dyn (::std::any::Any) {
1946 self as &dyn (::std::any::Any)
1947 }
1948 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1949 self as &mut dyn (::std::any::Any)
1950 }
1951 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1952 self
1953 }
1954
1955 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1956 Self::descriptor_static()
1957 }
1958
1959 fn new() -> GetAddressResponse {
1960 GetAddressResponse::new()
1961 }
1962
1963 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1964 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
1965 lock: ::protobuf::lazy::ONCE_INIT,
1966 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
1967 };
1968 unsafe {
1969 descriptor.get(|| {
1970 let mut fields = ::std::vec::Vec::new();
1971 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1972 "query",
1973 |m: &GetAddressResponse| { &m.query },
1974 |m: &mut GetAddressResponse| { &mut m.query },
1975 ));
1976 ::protobuf::reflect::MessageDescriptor::new::<GetAddressResponse>(
1977 "GetAddressResponse",
1978 fields,
1979 file_descriptor_proto()
1980 )
1981 })
1982 }
1983 }
1984
1985 fn default_instance() -> &'static GetAddressResponse {
1986 static mut instance: ::protobuf::lazy::Lazy<GetAddressResponse> = ::protobuf::lazy::Lazy {
1987 lock: ::protobuf::lazy::ONCE_INIT,
1988 ptr: 0 as *const GetAddressResponse,
1989 };
1990 unsafe {
1991 instance.get(GetAddressResponse::new)
1992 }
1993 }
1994}
1995
1996impl ::protobuf::Clear for GetAddressResponse {
1997 fn clear(&mut self) {
1998 self.query.clear();
1999 self.unknown_fields.clear();
2000 }
2001}
2002
2003impl ::std::fmt::Debug for GetAddressResponse {
2004 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2005 ::protobuf::text_format::fmt(self, f)
2006 }
2007}
2008
2009impl ::protobuf::reflect::ProtobufValue for GetAddressResponse {
2010 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2011 ::protobuf::reflect::ProtobufValueRef::Message(self)
2012 }
2013}
2014
2015#[derive(PartialEq,Clone,Default)]
2016pub struct ListAddressRequest {
2017 pub query: bool,
2019 pub unknown_fields: ::protobuf::UnknownFields,
2021 pub cached_size: ::protobuf::CachedSize,
2022}
2023
2024impl<'a> ::std::default::Default for &'a ListAddressRequest {
2025 fn default() -> &'a ListAddressRequest {
2026 <ListAddressRequest as ::protobuf::Message>::default_instance()
2027 }
2028}
2029
2030impl ListAddressRequest {
2031 pub fn new() -> ListAddressRequest {
2032 ::std::default::Default::default()
2033 }
2034
2035 pub fn get_query(&self) -> bool {
2039 self.query
2040 }
2041 pub fn clear_query(&mut self) {
2042 self.query = false;
2043 }
2044
2045 pub fn set_query(&mut self, v: bool) {
2047 self.query = v;
2048 }
2049}
2050
2051impl ::protobuf::Message for ListAddressRequest {
2052 fn is_initialized(&self) -> bool {
2053 true
2054 }
2055
2056 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2057 while !is.eof()? {
2058 let (field_number, wire_type) = is.read_tag_unpack()?;
2059 match field_number {
2060 1 => {
2061 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2062 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2063 }
2064 let tmp = is.read_bool()?;
2065 self.query = tmp;
2066 },
2067 _ => {
2068 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2069 },
2070 };
2071 }
2072 ::std::result::Result::Ok(())
2073 }
2074
2075 #[allow(unused_variables)]
2077 fn compute_size(&self) -> u32 {
2078 let mut my_size = 0;
2079 if self.query != false {
2080 my_size += 2;
2081 }
2082 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2083 self.cached_size.set(my_size);
2084 my_size
2085 }
2086
2087 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2088 if self.query != false {
2089 os.write_bool(1, self.query)?;
2090 }
2091 os.write_unknown_fields(self.get_unknown_fields())?;
2092 ::std::result::Result::Ok(())
2093 }
2094
2095 fn get_cached_size(&self) -> u32 {
2096 self.cached_size.get()
2097 }
2098
2099 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2100 &self.unknown_fields
2101 }
2102
2103 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2104 &mut self.unknown_fields
2105 }
2106
2107 fn as_any(&self) -> &dyn (::std::any::Any) {
2108 self as &dyn (::std::any::Any)
2109 }
2110 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2111 self as &mut dyn (::std::any::Any)
2112 }
2113 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2114 self
2115 }
2116
2117 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2118 Self::descriptor_static()
2119 }
2120
2121 fn new() -> ListAddressRequest {
2122 ListAddressRequest::new()
2123 }
2124
2125 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2126 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2127 lock: ::protobuf::lazy::ONCE_INIT,
2128 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2129 };
2130 unsafe {
2131 descriptor.get(|| {
2132 let mut fields = ::std::vec::Vec::new();
2133 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
2134 "query",
2135 |m: &ListAddressRequest| { &m.query },
2136 |m: &mut ListAddressRequest| { &mut m.query },
2137 ));
2138 ::protobuf::reflect::MessageDescriptor::new::<ListAddressRequest>(
2139 "ListAddressRequest",
2140 fields,
2141 file_descriptor_proto()
2142 )
2143 })
2144 }
2145 }
2146
2147 fn default_instance() -> &'static ListAddressRequest {
2148 static mut instance: ::protobuf::lazy::Lazy<ListAddressRequest> = ::protobuf::lazy::Lazy {
2149 lock: ::protobuf::lazy::ONCE_INIT,
2150 ptr: 0 as *const ListAddressRequest,
2151 };
2152 unsafe {
2153 instance.get(ListAddressRequest::new)
2154 }
2155 }
2156}
2157
2158impl ::protobuf::Clear for ListAddressRequest {
2159 fn clear(&mut self) {
2160 self.query = false;
2161 self.unknown_fields.clear();
2162 }
2163}
2164
2165impl ::std::fmt::Debug for ListAddressRequest {
2166 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2167 ::protobuf::text_format::fmt(self, f)
2168 }
2169}
2170
2171impl ::protobuf::reflect::ProtobufValue for ListAddressRequest {
2172 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2173 ::protobuf::reflect::ProtobufValueRef::Message(self)
2174 }
2175}
2176
2177#[derive(PartialEq,Clone,Default)]
2178pub struct ListAddressResponse {
2179 pub query: ::std::string::String,
2181 pub unknown_fields: ::protobuf::UnknownFields,
2183 pub cached_size: ::protobuf::CachedSize,
2184}
2185
2186impl<'a> ::std::default::Default for &'a ListAddressResponse {
2187 fn default() -> &'a ListAddressResponse {
2188 <ListAddressResponse as ::protobuf::Message>::default_instance()
2189 }
2190}
2191
2192impl ListAddressResponse {
2193 pub fn new() -> ListAddressResponse {
2194 ::std::default::Default::default()
2195 }
2196
2197 pub fn get_query(&self) -> &str {
2201 &self.query
2202 }
2203 pub fn clear_query(&mut self) {
2204 self.query.clear();
2205 }
2206
2207 pub fn set_query(&mut self, v: ::std::string::String) {
2209 self.query = v;
2210 }
2211
2212 pub fn mut_query(&mut self) -> &mut ::std::string::String {
2215 &mut self.query
2216 }
2217
2218 pub fn take_query(&mut self) -> ::std::string::String {
2220 ::std::mem::replace(&mut self.query, ::std::string::String::new())
2221 }
2222}
2223
2224impl ::protobuf::Message for ListAddressResponse {
2225 fn is_initialized(&self) -> bool {
2226 true
2227 }
2228
2229 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2230 while !is.eof()? {
2231 let (field_number, wire_type) = is.read_tag_unpack()?;
2232 match field_number {
2233 1 => {
2234 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
2235 },
2236 _ => {
2237 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2238 },
2239 };
2240 }
2241 ::std::result::Result::Ok(())
2242 }
2243
2244 #[allow(unused_variables)]
2246 fn compute_size(&self) -> u32 {
2247 let mut my_size = 0;
2248 if !self.query.is_empty() {
2249 my_size += ::protobuf::rt::string_size(1, &self.query);
2250 }
2251 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2252 self.cached_size.set(my_size);
2253 my_size
2254 }
2255
2256 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2257 if !self.query.is_empty() {
2258 os.write_string(1, &self.query)?;
2259 }
2260 os.write_unknown_fields(self.get_unknown_fields())?;
2261 ::std::result::Result::Ok(())
2262 }
2263
2264 fn get_cached_size(&self) -> u32 {
2265 self.cached_size.get()
2266 }
2267
2268 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2269 &self.unknown_fields
2270 }
2271
2272 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2273 &mut self.unknown_fields
2274 }
2275
2276 fn as_any(&self) -> &dyn (::std::any::Any) {
2277 self as &dyn (::std::any::Any)
2278 }
2279 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2280 self as &mut dyn (::std::any::Any)
2281 }
2282 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2283 self
2284 }
2285
2286 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2287 Self::descriptor_static()
2288 }
2289
2290 fn new() -> ListAddressResponse {
2291 ListAddressResponse::new()
2292 }
2293
2294 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2295 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2296 lock: ::protobuf::lazy::ONCE_INIT,
2297 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2298 };
2299 unsafe {
2300 descriptor.get(|| {
2301 let mut fields = ::std::vec::Vec::new();
2302 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2303 "query",
2304 |m: &ListAddressResponse| { &m.query },
2305 |m: &mut ListAddressResponse| { &mut m.query },
2306 ));
2307 ::protobuf::reflect::MessageDescriptor::new::<ListAddressResponse>(
2308 "ListAddressResponse",
2309 fields,
2310 file_descriptor_proto()
2311 )
2312 })
2313 }
2314 }
2315
2316 fn default_instance() -> &'static ListAddressResponse {
2317 static mut instance: ::protobuf::lazy::Lazy<ListAddressResponse> = ::protobuf::lazy::Lazy {
2318 lock: ::protobuf::lazy::ONCE_INIT,
2319 ptr: 0 as *const ListAddressResponse,
2320 };
2321 unsafe {
2322 instance.get(ListAddressResponse::new)
2323 }
2324 }
2325}
2326
2327impl ::protobuf::Clear for ListAddressResponse {
2328 fn clear(&mut self) {
2329 self.query.clear();
2330 self.unknown_fields.clear();
2331 }
2332}
2333
2334impl ::std::fmt::Debug for ListAddressResponse {
2335 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2336 ::protobuf::text_format::fmt(self, f)
2337 }
2338}
2339
2340impl ::protobuf::reflect::ProtobufValue for ListAddressResponse {
2341 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2342 ::protobuf::reflect::ProtobufValueRef::Message(self)
2343 }
2344}
2345
2346#[derive(PartialEq,Clone,Default)]
2347pub struct ValidateAddressRequest {
2348 pub query: bool,
2350 pub unknown_fields: ::protobuf::UnknownFields,
2352 pub cached_size: ::protobuf::CachedSize,
2353}
2354
2355impl<'a> ::std::default::Default for &'a ValidateAddressRequest {
2356 fn default() -> &'a ValidateAddressRequest {
2357 <ValidateAddressRequest as ::protobuf::Message>::default_instance()
2358 }
2359}
2360
2361impl ValidateAddressRequest {
2362 pub fn new() -> ValidateAddressRequest {
2363 ::std::default::Default::default()
2364 }
2365
2366 pub fn get_query(&self) -> bool {
2370 self.query
2371 }
2372 pub fn clear_query(&mut self) {
2373 self.query = false;
2374 }
2375
2376 pub fn set_query(&mut self, v: bool) {
2378 self.query = v;
2379 }
2380}
2381
2382impl ::protobuf::Message for ValidateAddressRequest {
2383 fn is_initialized(&self) -> bool {
2384 true
2385 }
2386
2387 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2388 while !is.eof()? {
2389 let (field_number, wire_type) = is.read_tag_unpack()?;
2390 match field_number {
2391 1 => {
2392 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2393 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2394 }
2395 let tmp = is.read_bool()?;
2396 self.query = tmp;
2397 },
2398 _ => {
2399 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2400 },
2401 };
2402 }
2403 ::std::result::Result::Ok(())
2404 }
2405
2406 #[allow(unused_variables)]
2408 fn compute_size(&self) -> u32 {
2409 let mut my_size = 0;
2410 if self.query != false {
2411 my_size += 2;
2412 }
2413 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2414 self.cached_size.set(my_size);
2415 my_size
2416 }
2417
2418 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2419 if self.query != false {
2420 os.write_bool(1, self.query)?;
2421 }
2422 os.write_unknown_fields(self.get_unknown_fields())?;
2423 ::std::result::Result::Ok(())
2424 }
2425
2426 fn get_cached_size(&self) -> u32 {
2427 self.cached_size.get()
2428 }
2429
2430 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2431 &self.unknown_fields
2432 }
2433
2434 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2435 &mut self.unknown_fields
2436 }
2437
2438 fn as_any(&self) -> &dyn (::std::any::Any) {
2439 self as &dyn (::std::any::Any)
2440 }
2441 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2442 self as &mut dyn (::std::any::Any)
2443 }
2444 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2445 self
2446 }
2447
2448 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2449 Self::descriptor_static()
2450 }
2451
2452 fn new() -> ValidateAddressRequest {
2453 ValidateAddressRequest::new()
2454 }
2455
2456 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2457 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2458 lock: ::protobuf::lazy::ONCE_INIT,
2459 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2460 };
2461 unsafe {
2462 descriptor.get(|| {
2463 let mut fields = ::std::vec::Vec::new();
2464 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
2465 "query",
2466 |m: &ValidateAddressRequest| { &m.query },
2467 |m: &mut ValidateAddressRequest| { &mut m.query },
2468 ));
2469 ::protobuf::reflect::MessageDescriptor::new::<ValidateAddressRequest>(
2470 "ValidateAddressRequest",
2471 fields,
2472 file_descriptor_proto()
2473 )
2474 })
2475 }
2476 }
2477
2478 fn default_instance() -> &'static ValidateAddressRequest {
2479 static mut instance: ::protobuf::lazy::Lazy<ValidateAddressRequest> = ::protobuf::lazy::Lazy {
2480 lock: ::protobuf::lazy::ONCE_INIT,
2481 ptr: 0 as *const ValidateAddressRequest,
2482 };
2483 unsafe {
2484 instance.get(ValidateAddressRequest::new)
2485 }
2486 }
2487}
2488
2489impl ::protobuf::Clear for ValidateAddressRequest {
2490 fn clear(&mut self) {
2491 self.query = false;
2492 self.unknown_fields.clear();
2493 }
2494}
2495
2496impl ::std::fmt::Debug for ValidateAddressRequest {
2497 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2498 ::protobuf::text_format::fmt(self, f)
2499 }
2500}
2501
2502impl ::protobuf::reflect::ProtobufValue for ValidateAddressRequest {
2503 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2504 ::protobuf::reflect::ProtobufValueRef::Message(self)
2505 }
2506}
2507
2508#[derive(PartialEq,Clone,Default)]
2509pub struct ValidateAddressResponse {
2510 pub query: ::std::string::String,
2512 pub unknown_fields: ::protobuf::UnknownFields,
2514 pub cached_size: ::protobuf::CachedSize,
2515}
2516
2517impl<'a> ::std::default::Default for &'a ValidateAddressResponse {
2518 fn default() -> &'a ValidateAddressResponse {
2519 <ValidateAddressResponse as ::protobuf::Message>::default_instance()
2520 }
2521}
2522
2523impl ValidateAddressResponse {
2524 pub fn new() -> ValidateAddressResponse {
2525 ::std::default::Default::default()
2526 }
2527
2528 pub fn get_query(&self) -> &str {
2532 &self.query
2533 }
2534 pub fn clear_query(&mut self) {
2535 self.query.clear();
2536 }
2537
2538 pub fn set_query(&mut self, v: ::std::string::String) {
2540 self.query = v;
2541 }
2542
2543 pub fn mut_query(&mut self) -> &mut ::std::string::String {
2546 &mut self.query
2547 }
2548
2549 pub fn take_query(&mut self) -> ::std::string::String {
2551 ::std::mem::replace(&mut self.query, ::std::string::String::new())
2552 }
2553}
2554
2555impl ::protobuf::Message for ValidateAddressResponse {
2556 fn is_initialized(&self) -> bool {
2557 true
2558 }
2559
2560 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2561 while !is.eof()? {
2562 let (field_number, wire_type) = is.read_tag_unpack()?;
2563 match field_number {
2564 1 => {
2565 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
2566 },
2567 _ => {
2568 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2569 },
2570 };
2571 }
2572 ::std::result::Result::Ok(())
2573 }
2574
2575 #[allow(unused_variables)]
2577 fn compute_size(&self) -> u32 {
2578 let mut my_size = 0;
2579 if !self.query.is_empty() {
2580 my_size += ::protobuf::rt::string_size(1, &self.query);
2581 }
2582 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2583 self.cached_size.set(my_size);
2584 my_size
2585 }
2586
2587 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2588 if !self.query.is_empty() {
2589 os.write_string(1, &self.query)?;
2590 }
2591 os.write_unknown_fields(self.get_unknown_fields())?;
2592 ::std::result::Result::Ok(())
2593 }
2594
2595 fn get_cached_size(&self) -> u32 {
2596 self.cached_size.get()
2597 }
2598
2599 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2600 &self.unknown_fields
2601 }
2602
2603 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2604 &mut self.unknown_fields
2605 }
2606
2607 fn as_any(&self) -> &dyn (::std::any::Any) {
2608 self as &dyn (::std::any::Any)
2609 }
2610 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2611 self as &mut dyn (::std::any::Any)
2612 }
2613 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2614 self
2615 }
2616
2617 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2618 Self::descriptor_static()
2619 }
2620
2621 fn new() -> ValidateAddressResponse {
2622 ValidateAddressResponse::new()
2623 }
2624
2625 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2626 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2627 lock: ::protobuf::lazy::ONCE_INIT,
2628 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2629 };
2630 unsafe {
2631 descriptor.get(|| {
2632 let mut fields = ::std::vec::Vec::new();
2633 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2634 "query",
2635 |m: &ValidateAddressResponse| { &m.query },
2636 |m: &mut ValidateAddressResponse| { &mut m.query },
2637 ));
2638 ::protobuf::reflect::MessageDescriptor::new::<ValidateAddressResponse>(
2639 "ValidateAddressResponse",
2640 fields,
2641 file_descriptor_proto()
2642 )
2643 })
2644 }
2645 }
2646
2647 fn default_instance() -> &'static ValidateAddressResponse {
2648 static mut instance: ::protobuf::lazy::Lazy<ValidateAddressResponse> = ::protobuf::lazy::Lazy {
2649 lock: ::protobuf::lazy::ONCE_INIT,
2650 ptr: 0 as *const ValidateAddressResponse,
2651 };
2652 unsafe {
2653 instance.get(ValidateAddressResponse::new)
2654 }
2655 }
2656}
2657
2658impl ::protobuf::Clear for ValidateAddressResponse {
2659 fn clear(&mut self) {
2660 self.query.clear();
2661 self.unknown_fields.clear();
2662 }
2663}
2664
2665impl ::std::fmt::Debug for ValidateAddressResponse {
2666 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2667 ::protobuf::text_format::fmt(self, f)
2668 }
2669}
2670
2671impl ::protobuf::reflect::ProtobufValue for ValidateAddressResponse {
2672 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2673 ::protobuf::reflect::ProtobufValueRef::Message(self)
2674 }
2675}
2676
2677#[derive(PartialEq,Clone,Default)]
2678pub struct GetBalanceRequest {
2679 pub query: bool,
2681 pub unknown_fields: ::protobuf::UnknownFields,
2683 pub cached_size: ::protobuf::CachedSize,
2684}
2685
2686impl<'a> ::std::default::Default for &'a GetBalanceRequest {
2687 fn default() -> &'a GetBalanceRequest {
2688 <GetBalanceRequest as ::protobuf::Message>::default_instance()
2689 }
2690}
2691
2692impl GetBalanceRequest {
2693 pub fn new() -> GetBalanceRequest {
2694 ::std::default::Default::default()
2695 }
2696
2697 pub fn get_query(&self) -> bool {
2701 self.query
2702 }
2703 pub fn clear_query(&mut self) {
2704 self.query = false;
2705 }
2706
2707 pub fn set_query(&mut self, v: bool) {
2709 self.query = v;
2710 }
2711}
2712
2713impl ::protobuf::Message for GetBalanceRequest {
2714 fn is_initialized(&self) -> bool {
2715 true
2716 }
2717
2718 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2719 while !is.eof()? {
2720 let (field_number, wire_type) = is.read_tag_unpack()?;
2721 match field_number {
2722 1 => {
2723 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2724 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2725 }
2726 let tmp = is.read_bool()?;
2727 self.query = tmp;
2728 },
2729 _ => {
2730 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2731 },
2732 };
2733 }
2734 ::std::result::Result::Ok(())
2735 }
2736
2737 #[allow(unused_variables)]
2739 fn compute_size(&self) -> u32 {
2740 let mut my_size = 0;
2741 if self.query != false {
2742 my_size += 2;
2743 }
2744 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2745 self.cached_size.set(my_size);
2746 my_size
2747 }
2748
2749 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2750 if self.query != false {
2751 os.write_bool(1, self.query)?;
2752 }
2753 os.write_unknown_fields(self.get_unknown_fields())?;
2754 ::std::result::Result::Ok(())
2755 }
2756
2757 fn get_cached_size(&self) -> u32 {
2758 self.cached_size.get()
2759 }
2760
2761 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2762 &self.unknown_fields
2763 }
2764
2765 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2766 &mut self.unknown_fields
2767 }
2768
2769 fn as_any(&self) -> &dyn (::std::any::Any) {
2770 self as &dyn (::std::any::Any)
2771 }
2772 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2773 self as &mut dyn (::std::any::Any)
2774 }
2775 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2776 self
2777 }
2778
2779 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2780 Self::descriptor_static()
2781 }
2782
2783 fn new() -> GetBalanceRequest {
2784 GetBalanceRequest::new()
2785 }
2786
2787 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2788 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2789 lock: ::protobuf::lazy::ONCE_INIT,
2790 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2791 };
2792 unsafe {
2793 descriptor.get(|| {
2794 let mut fields = ::std::vec::Vec::new();
2795 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
2796 "query",
2797 |m: &GetBalanceRequest| { &m.query },
2798 |m: &mut GetBalanceRequest| { &mut m.query },
2799 ));
2800 ::protobuf::reflect::MessageDescriptor::new::<GetBalanceRequest>(
2801 "GetBalanceRequest",
2802 fields,
2803 file_descriptor_proto()
2804 )
2805 })
2806 }
2807 }
2808
2809 fn default_instance() -> &'static GetBalanceRequest {
2810 static mut instance: ::protobuf::lazy::Lazy<GetBalanceRequest> = ::protobuf::lazy::Lazy {
2811 lock: ::protobuf::lazy::ONCE_INIT,
2812 ptr: 0 as *const GetBalanceRequest,
2813 };
2814 unsafe {
2815 instance.get(GetBalanceRequest::new)
2816 }
2817 }
2818}
2819
2820impl ::protobuf::Clear for GetBalanceRequest {
2821 fn clear(&mut self) {
2822 self.query = false;
2823 self.unknown_fields.clear();
2824 }
2825}
2826
2827impl ::std::fmt::Debug for GetBalanceRequest {
2828 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2829 ::protobuf::text_format::fmt(self, f)
2830 }
2831}
2832
2833impl ::protobuf::reflect::ProtobufValue for GetBalanceRequest {
2834 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
2835 ::protobuf::reflect::ProtobufValueRef::Message(self)
2836 }
2837}
2838
2839#[derive(PartialEq,Clone,Default)]
2840pub struct GetBalanceResponse {
2841 pub query: ::std::string::String,
2843 pub unknown_fields: ::protobuf::UnknownFields,
2845 pub cached_size: ::protobuf::CachedSize,
2846}
2847
2848impl<'a> ::std::default::Default for &'a GetBalanceResponse {
2849 fn default() -> &'a GetBalanceResponse {
2850 <GetBalanceResponse as ::protobuf::Message>::default_instance()
2851 }
2852}
2853
2854impl GetBalanceResponse {
2855 pub fn new() -> GetBalanceResponse {
2856 ::std::default::Default::default()
2857 }
2858
2859 pub fn get_query(&self) -> &str {
2863 &self.query
2864 }
2865 pub fn clear_query(&mut self) {
2866 self.query.clear();
2867 }
2868
2869 pub fn set_query(&mut self, v: ::std::string::String) {
2871 self.query = v;
2872 }
2873
2874 pub fn mut_query(&mut self) -> &mut ::std::string::String {
2877 &mut self.query
2878 }
2879
2880 pub fn take_query(&mut self) -> ::std::string::String {
2882 ::std::mem::replace(&mut self.query, ::std::string::String::new())
2883 }
2884}
2885
2886impl ::protobuf::Message for GetBalanceResponse {
2887 fn is_initialized(&self) -> bool {
2888 true
2889 }
2890
2891 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2892 while !is.eof()? {
2893 let (field_number, wire_type) = is.read_tag_unpack()?;
2894 match field_number {
2895 1 => {
2896 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
2897 },
2898 _ => {
2899 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2900 },
2901 };
2902 }
2903 ::std::result::Result::Ok(())
2904 }
2905
2906 #[allow(unused_variables)]
2908 fn compute_size(&self) -> u32 {
2909 let mut my_size = 0;
2910 if !self.query.is_empty() {
2911 my_size += ::protobuf::rt::string_size(1, &self.query);
2912 }
2913 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2914 self.cached_size.set(my_size);
2915 my_size
2916 }
2917
2918 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2919 if !self.query.is_empty() {
2920 os.write_string(1, &self.query)?;
2921 }
2922 os.write_unknown_fields(self.get_unknown_fields())?;
2923 ::std::result::Result::Ok(())
2924 }
2925
2926 fn get_cached_size(&self) -> u32 {
2927 self.cached_size.get()
2928 }
2929
2930 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2931 &self.unknown_fields
2932 }
2933
2934 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2935 &mut self.unknown_fields
2936 }
2937
2938 fn as_any(&self) -> &dyn (::std::any::Any) {
2939 self as &dyn (::std::any::Any)
2940 }
2941 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2942 self as &mut dyn (::std::any::Any)
2943 }
2944 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2945 self
2946 }
2947
2948 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2949 Self::descriptor_static()
2950 }
2951
2952 fn new() -> GetBalanceResponse {
2953 GetBalanceResponse::new()
2954 }
2955
2956 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2957 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
2958 lock: ::protobuf::lazy::ONCE_INIT,
2959 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
2960 };
2961 unsafe {
2962 descriptor.get(|| {
2963 let mut fields = ::std::vec::Vec::new();
2964 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2965 "query",
2966 |m: &GetBalanceResponse| { &m.query },
2967 |m: &mut GetBalanceResponse| { &mut m.query },
2968 ));
2969 ::protobuf::reflect::MessageDescriptor::new::<GetBalanceResponse>(
2970 "GetBalanceResponse",
2971 fields,
2972 file_descriptor_proto()
2973 )
2974 })
2975 }
2976 }
2977
2978 fn default_instance() -> &'static GetBalanceResponse {
2979 static mut instance: ::protobuf::lazy::Lazy<GetBalanceResponse> = ::protobuf::lazy::Lazy {
2980 lock: ::protobuf::lazy::ONCE_INIT,
2981 ptr: 0 as *const GetBalanceResponse,
2982 };
2983 unsafe {
2984 instance.get(GetBalanceResponse::new)
2985 }
2986 }
2987}
2988
2989impl ::protobuf::Clear for GetBalanceResponse {
2990 fn clear(&mut self) {
2991 self.query.clear();
2992 self.unknown_fields.clear();
2993 }
2994}
2995
2996impl ::std::fmt::Debug for GetBalanceResponse {
2997 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2998 ::protobuf::text_format::fmt(self, f)
2999 }
3000}
3001
3002impl ::protobuf::reflect::ProtobufValue for GetBalanceResponse {
3003 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3004 ::protobuf::reflect::ProtobufValueRef::Message(self)
3005 }
3006}
3007
3008#[derive(PartialEq,Clone,Default)]
3009pub struct CreateRawTransactionRequest {
3010 pub query: bool,
3012 pub unknown_fields: ::protobuf::UnknownFields,
3014 pub cached_size: ::protobuf::CachedSize,
3015}
3016
3017impl<'a> ::std::default::Default for &'a CreateRawTransactionRequest {
3018 fn default() -> &'a CreateRawTransactionRequest {
3019 <CreateRawTransactionRequest as ::protobuf::Message>::default_instance()
3020 }
3021}
3022
3023impl CreateRawTransactionRequest {
3024 pub fn new() -> CreateRawTransactionRequest {
3025 ::std::default::Default::default()
3026 }
3027
3028 pub fn get_query(&self) -> bool {
3032 self.query
3033 }
3034 pub fn clear_query(&mut self) {
3035 self.query = false;
3036 }
3037
3038 pub fn set_query(&mut self, v: bool) {
3040 self.query = v;
3041 }
3042}
3043
3044impl ::protobuf::Message for CreateRawTransactionRequest {
3045 fn is_initialized(&self) -> bool {
3046 true
3047 }
3048
3049 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3050 while !is.eof()? {
3051 let (field_number, wire_type) = is.read_tag_unpack()?;
3052 match field_number {
3053 1 => {
3054 if wire_type != ::protobuf::wire_format::WireTypeVarint {
3055 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3056 }
3057 let tmp = is.read_bool()?;
3058 self.query = tmp;
3059 },
3060 _ => {
3061 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3062 },
3063 };
3064 }
3065 ::std::result::Result::Ok(())
3066 }
3067
3068 #[allow(unused_variables)]
3070 fn compute_size(&self) -> u32 {
3071 let mut my_size = 0;
3072 if self.query != false {
3073 my_size += 2;
3074 }
3075 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3076 self.cached_size.set(my_size);
3077 my_size
3078 }
3079
3080 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3081 if self.query != false {
3082 os.write_bool(1, self.query)?;
3083 }
3084 os.write_unknown_fields(self.get_unknown_fields())?;
3085 ::std::result::Result::Ok(())
3086 }
3087
3088 fn get_cached_size(&self) -> u32 {
3089 self.cached_size.get()
3090 }
3091
3092 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3093 &self.unknown_fields
3094 }
3095
3096 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3097 &mut self.unknown_fields
3098 }
3099
3100 fn as_any(&self) -> &dyn (::std::any::Any) {
3101 self as &dyn (::std::any::Any)
3102 }
3103 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3104 self as &mut dyn (::std::any::Any)
3105 }
3106 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3107 self
3108 }
3109
3110 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3111 Self::descriptor_static()
3112 }
3113
3114 fn new() -> CreateRawTransactionRequest {
3115 CreateRawTransactionRequest::new()
3116 }
3117
3118 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3119 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3120 lock: ::protobuf::lazy::ONCE_INIT,
3121 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3122 };
3123 unsafe {
3124 descriptor.get(|| {
3125 let mut fields = ::std::vec::Vec::new();
3126 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
3127 "query",
3128 |m: &CreateRawTransactionRequest| { &m.query },
3129 |m: &mut CreateRawTransactionRequest| { &mut m.query },
3130 ));
3131 ::protobuf::reflect::MessageDescriptor::new::<CreateRawTransactionRequest>(
3132 "CreateRawTransactionRequest",
3133 fields,
3134 file_descriptor_proto()
3135 )
3136 })
3137 }
3138 }
3139
3140 fn default_instance() -> &'static CreateRawTransactionRequest {
3141 static mut instance: ::protobuf::lazy::Lazy<CreateRawTransactionRequest> = ::protobuf::lazy::Lazy {
3142 lock: ::protobuf::lazy::ONCE_INIT,
3143 ptr: 0 as *const CreateRawTransactionRequest,
3144 };
3145 unsafe {
3146 instance.get(CreateRawTransactionRequest::new)
3147 }
3148 }
3149}
3150
3151impl ::protobuf::Clear for CreateRawTransactionRequest {
3152 fn clear(&mut self) {
3153 self.query = false;
3154 self.unknown_fields.clear();
3155 }
3156}
3157
3158impl ::std::fmt::Debug for CreateRawTransactionRequest {
3159 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3160 ::protobuf::text_format::fmt(self, f)
3161 }
3162}
3163
3164impl ::protobuf::reflect::ProtobufValue for CreateRawTransactionRequest {
3165 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3166 ::protobuf::reflect::ProtobufValueRef::Message(self)
3167 }
3168}
3169
3170#[derive(PartialEq,Clone,Default)]
3171pub struct CreateRawTransactionResponse {
3172 pub query: ::std::string::String,
3174 pub unknown_fields: ::protobuf::UnknownFields,
3176 pub cached_size: ::protobuf::CachedSize,
3177}
3178
3179impl<'a> ::std::default::Default for &'a CreateRawTransactionResponse {
3180 fn default() -> &'a CreateRawTransactionResponse {
3181 <CreateRawTransactionResponse as ::protobuf::Message>::default_instance()
3182 }
3183}
3184
3185impl CreateRawTransactionResponse {
3186 pub fn new() -> CreateRawTransactionResponse {
3187 ::std::default::Default::default()
3188 }
3189
3190 pub fn get_query(&self) -> &str {
3194 &self.query
3195 }
3196 pub fn clear_query(&mut self) {
3197 self.query.clear();
3198 }
3199
3200 pub fn set_query(&mut self, v: ::std::string::String) {
3202 self.query = v;
3203 }
3204
3205 pub fn mut_query(&mut self) -> &mut ::std::string::String {
3208 &mut self.query
3209 }
3210
3211 pub fn take_query(&mut self) -> ::std::string::String {
3213 ::std::mem::replace(&mut self.query, ::std::string::String::new())
3214 }
3215}
3216
3217impl ::protobuf::Message for CreateRawTransactionResponse {
3218 fn is_initialized(&self) -> bool {
3219 true
3220 }
3221
3222 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3223 while !is.eof()? {
3224 let (field_number, wire_type) = is.read_tag_unpack()?;
3225 match field_number {
3226 1 => {
3227 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
3228 },
3229 _ => {
3230 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3231 },
3232 };
3233 }
3234 ::std::result::Result::Ok(())
3235 }
3236
3237 #[allow(unused_variables)]
3239 fn compute_size(&self) -> u32 {
3240 let mut my_size = 0;
3241 if !self.query.is_empty() {
3242 my_size += ::protobuf::rt::string_size(1, &self.query);
3243 }
3244 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3245 self.cached_size.set(my_size);
3246 my_size
3247 }
3248
3249 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3250 if !self.query.is_empty() {
3251 os.write_string(1, &self.query)?;
3252 }
3253 os.write_unknown_fields(self.get_unknown_fields())?;
3254 ::std::result::Result::Ok(())
3255 }
3256
3257 fn get_cached_size(&self) -> u32 {
3258 self.cached_size.get()
3259 }
3260
3261 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3262 &self.unknown_fields
3263 }
3264
3265 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3266 &mut self.unknown_fields
3267 }
3268
3269 fn as_any(&self) -> &dyn (::std::any::Any) {
3270 self as &dyn (::std::any::Any)
3271 }
3272 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3273 self as &mut dyn (::std::any::Any)
3274 }
3275 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3276 self
3277 }
3278
3279 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3280 Self::descriptor_static()
3281 }
3282
3283 fn new() -> CreateRawTransactionResponse {
3284 CreateRawTransactionResponse::new()
3285 }
3286
3287 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3288 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3289 lock: ::protobuf::lazy::ONCE_INIT,
3290 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3291 };
3292 unsafe {
3293 descriptor.get(|| {
3294 let mut fields = ::std::vec::Vec::new();
3295 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3296 "query",
3297 |m: &CreateRawTransactionResponse| { &m.query },
3298 |m: &mut CreateRawTransactionResponse| { &mut m.query },
3299 ));
3300 ::protobuf::reflect::MessageDescriptor::new::<CreateRawTransactionResponse>(
3301 "CreateRawTransactionResponse",
3302 fields,
3303 file_descriptor_proto()
3304 )
3305 })
3306 }
3307 }
3308
3309 fn default_instance() -> &'static CreateRawTransactionResponse {
3310 static mut instance: ::protobuf::lazy::Lazy<CreateRawTransactionResponse> = ::protobuf::lazy::Lazy {
3311 lock: ::protobuf::lazy::ONCE_INIT,
3312 ptr: 0 as *const CreateRawTransactionResponse,
3313 };
3314 unsafe {
3315 instance.get(CreateRawTransactionResponse::new)
3316 }
3317 }
3318}
3319
3320impl ::protobuf::Clear for CreateRawTransactionResponse {
3321 fn clear(&mut self) {
3322 self.query.clear();
3323 self.unknown_fields.clear();
3324 }
3325}
3326
3327impl ::std::fmt::Debug for CreateRawTransactionResponse {
3328 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3329 ::protobuf::text_format::fmt(self, f)
3330 }
3331}
3332
3333impl ::protobuf::reflect::ProtobufValue for CreateRawTransactionResponse {
3334 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3335 ::protobuf::reflect::ProtobufValueRef::Message(self)
3336 }
3337}
3338
3339#[derive(PartialEq,Clone,Default)]
3340pub struct SignRawTransactionRequest {
3341 pub query: bool,
3343 pub unknown_fields: ::protobuf::UnknownFields,
3345 pub cached_size: ::protobuf::CachedSize,
3346}
3347
3348impl<'a> ::std::default::Default for &'a SignRawTransactionRequest {
3349 fn default() -> &'a SignRawTransactionRequest {
3350 <SignRawTransactionRequest as ::protobuf::Message>::default_instance()
3351 }
3352}
3353
3354impl SignRawTransactionRequest {
3355 pub fn new() -> SignRawTransactionRequest {
3356 ::std::default::Default::default()
3357 }
3358
3359 pub fn get_query(&self) -> bool {
3363 self.query
3364 }
3365 pub fn clear_query(&mut self) {
3366 self.query = false;
3367 }
3368
3369 pub fn set_query(&mut self, v: bool) {
3371 self.query = v;
3372 }
3373}
3374
3375impl ::protobuf::Message for SignRawTransactionRequest {
3376 fn is_initialized(&self) -> bool {
3377 true
3378 }
3379
3380 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3381 while !is.eof()? {
3382 let (field_number, wire_type) = is.read_tag_unpack()?;
3383 match field_number {
3384 1 => {
3385 if wire_type != ::protobuf::wire_format::WireTypeVarint {
3386 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3387 }
3388 let tmp = is.read_bool()?;
3389 self.query = tmp;
3390 },
3391 _ => {
3392 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3393 },
3394 };
3395 }
3396 ::std::result::Result::Ok(())
3397 }
3398
3399 #[allow(unused_variables)]
3401 fn compute_size(&self) -> u32 {
3402 let mut my_size = 0;
3403 if self.query != false {
3404 my_size += 2;
3405 }
3406 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3407 self.cached_size.set(my_size);
3408 my_size
3409 }
3410
3411 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3412 if self.query != false {
3413 os.write_bool(1, self.query)?;
3414 }
3415 os.write_unknown_fields(self.get_unknown_fields())?;
3416 ::std::result::Result::Ok(())
3417 }
3418
3419 fn get_cached_size(&self) -> u32 {
3420 self.cached_size.get()
3421 }
3422
3423 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3424 &self.unknown_fields
3425 }
3426
3427 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3428 &mut self.unknown_fields
3429 }
3430
3431 fn as_any(&self) -> &dyn (::std::any::Any) {
3432 self as &dyn (::std::any::Any)
3433 }
3434 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3435 self as &mut dyn (::std::any::Any)
3436 }
3437 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3438 self
3439 }
3440
3441 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3442 Self::descriptor_static()
3443 }
3444
3445 fn new() -> SignRawTransactionRequest {
3446 SignRawTransactionRequest::new()
3447 }
3448
3449 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3450 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3451 lock: ::protobuf::lazy::ONCE_INIT,
3452 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3453 };
3454 unsafe {
3455 descriptor.get(|| {
3456 let mut fields = ::std::vec::Vec::new();
3457 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
3458 "query",
3459 |m: &SignRawTransactionRequest| { &m.query },
3460 |m: &mut SignRawTransactionRequest| { &mut m.query },
3461 ));
3462 ::protobuf::reflect::MessageDescriptor::new::<SignRawTransactionRequest>(
3463 "SignRawTransactionRequest",
3464 fields,
3465 file_descriptor_proto()
3466 )
3467 })
3468 }
3469 }
3470
3471 fn default_instance() -> &'static SignRawTransactionRequest {
3472 static mut instance: ::protobuf::lazy::Lazy<SignRawTransactionRequest> = ::protobuf::lazy::Lazy {
3473 lock: ::protobuf::lazy::ONCE_INIT,
3474 ptr: 0 as *const SignRawTransactionRequest,
3475 };
3476 unsafe {
3477 instance.get(SignRawTransactionRequest::new)
3478 }
3479 }
3480}
3481
3482impl ::protobuf::Clear for SignRawTransactionRequest {
3483 fn clear(&mut self) {
3484 self.query = false;
3485 self.unknown_fields.clear();
3486 }
3487}
3488
3489impl ::std::fmt::Debug for SignRawTransactionRequest {
3490 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3491 ::protobuf::text_format::fmt(self, f)
3492 }
3493}
3494
3495impl ::protobuf::reflect::ProtobufValue for SignRawTransactionRequest {
3496 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3497 ::protobuf::reflect::ProtobufValueRef::Message(self)
3498 }
3499}
3500
3501#[derive(PartialEq,Clone,Default)]
3502pub struct SignRawTransactionResponse {
3503 pub query: ::std::string::String,
3505 pub unknown_fields: ::protobuf::UnknownFields,
3507 pub cached_size: ::protobuf::CachedSize,
3508}
3509
3510impl<'a> ::std::default::Default for &'a SignRawTransactionResponse {
3511 fn default() -> &'a SignRawTransactionResponse {
3512 <SignRawTransactionResponse as ::protobuf::Message>::default_instance()
3513 }
3514}
3515
3516impl SignRawTransactionResponse {
3517 pub fn new() -> SignRawTransactionResponse {
3518 ::std::default::Default::default()
3519 }
3520
3521 pub fn get_query(&self) -> &str {
3525 &self.query
3526 }
3527 pub fn clear_query(&mut self) {
3528 self.query.clear();
3529 }
3530
3531 pub fn set_query(&mut self, v: ::std::string::String) {
3533 self.query = v;
3534 }
3535
3536 pub fn mut_query(&mut self) -> &mut ::std::string::String {
3539 &mut self.query
3540 }
3541
3542 pub fn take_query(&mut self) -> ::std::string::String {
3544 ::std::mem::replace(&mut self.query, ::std::string::String::new())
3545 }
3546}
3547
3548impl ::protobuf::Message for SignRawTransactionResponse {
3549 fn is_initialized(&self) -> bool {
3550 true
3551 }
3552
3553 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3554 while !is.eof()? {
3555 let (field_number, wire_type) = is.read_tag_unpack()?;
3556 match field_number {
3557 1 => {
3558 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
3559 },
3560 _ => {
3561 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3562 },
3563 };
3564 }
3565 ::std::result::Result::Ok(())
3566 }
3567
3568 #[allow(unused_variables)]
3570 fn compute_size(&self) -> u32 {
3571 let mut my_size = 0;
3572 if !self.query.is_empty() {
3573 my_size += ::protobuf::rt::string_size(1, &self.query);
3574 }
3575 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3576 self.cached_size.set(my_size);
3577 my_size
3578 }
3579
3580 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3581 if !self.query.is_empty() {
3582 os.write_string(1, &self.query)?;
3583 }
3584 os.write_unknown_fields(self.get_unknown_fields())?;
3585 ::std::result::Result::Ok(())
3586 }
3587
3588 fn get_cached_size(&self) -> u32 {
3589 self.cached_size.get()
3590 }
3591
3592 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3593 &self.unknown_fields
3594 }
3595
3596 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3597 &mut self.unknown_fields
3598 }
3599
3600 fn as_any(&self) -> &dyn (::std::any::Any) {
3601 self as &dyn (::std::any::Any)
3602 }
3603 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3604 self as &mut dyn (::std::any::Any)
3605 }
3606 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3607 self
3608 }
3609
3610 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3611 Self::descriptor_static()
3612 }
3613
3614 fn new() -> SignRawTransactionResponse {
3615 SignRawTransactionResponse::new()
3616 }
3617
3618 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3619 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3620 lock: ::protobuf::lazy::ONCE_INIT,
3621 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3622 };
3623 unsafe {
3624 descriptor.get(|| {
3625 let mut fields = ::std::vec::Vec::new();
3626 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3627 "query",
3628 |m: &SignRawTransactionResponse| { &m.query },
3629 |m: &mut SignRawTransactionResponse| { &mut m.query },
3630 ));
3631 ::protobuf::reflect::MessageDescriptor::new::<SignRawTransactionResponse>(
3632 "SignRawTransactionResponse",
3633 fields,
3634 file_descriptor_proto()
3635 )
3636 })
3637 }
3638 }
3639
3640 fn default_instance() -> &'static SignRawTransactionResponse {
3641 static mut instance: ::protobuf::lazy::Lazy<SignRawTransactionResponse> = ::protobuf::lazy::Lazy {
3642 lock: ::protobuf::lazy::ONCE_INIT,
3643 ptr: 0 as *const SignRawTransactionResponse,
3644 };
3645 unsafe {
3646 instance.get(SignRawTransactionResponse::new)
3647 }
3648 }
3649}
3650
3651impl ::protobuf::Clear for SignRawTransactionResponse {
3652 fn clear(&mut self) {
3653 self.query.clear();
3654 self.unknown_fields.clear();
3655 }
3656}
3657
3658impl ::std::fmt::Debug for SignRawTransactionResponse {
3659 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3660 ::protobuf::text_format::fmt(self, f)
3661 }
3662}
3663
3664impl ::protobuf::reflect::ProtobufValue for SignRawTransactionResponse {
3665 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3666 ::protobuf::reflect::ProtobufValueRef::Message(self)
3667 }
3668}
3669
3670#[derive(PartialEq,Clone,Default)]
3671pub struct DecodeRawTransactionRequest {
3672 pub query: bool,
3674 pub unknown_fields: ::protobuf::UnknownFields,
3676 pub cached_size: ::protobuf::CachedSize,
3677}
3678
3679impl<'a> ::std::default::Default for &'a DecodeRawTransactionRequest {
3680 fn default() -> &'a DecodeRawTransactionRequest {
3681 <DecodeRawTransactionRequest as ::protobuf::Message>::default_instance()
3682 }
3683}
3684
3685impl DecodeRawTransactionRequest {
3686 pub fn new() -> DecodeRawTransactionRequest {
3687 ::std::default::Default::default()
3688 }
3689
3690 pub fn get_query(&self) -> bool {
3694 self.query
3695 }
3696 pub fn clear_query(&mut self) {
3697 self.query = false;
3698 }
3699
3700 pub fn set_query(&mut self, v: bool) {
3702 self.query = v;
3703 }
3704}
3705
3706impl ::protobuf::Message for DecodeRawTransactionRequest {
3707 fn is_initialized(&self) -> bool {
3708 true
3709 }
3710
3711 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3712 while !is.eof()? {
3713 let (field_number, wire_type) = is.read_tag_unpack()?;
3714 match field_number {
3715 1 => {
3716 if wire_type != ::protobuf::wire_format::WireTypeVarint {
3717 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
3718 }
3719 let tmp = is.read_bool()?;
3720 self.query = tmp;
3721 },
3722 _ => {
3723 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3724 },
3725 };
3726 }
3727 ::std::result::Result::Ok(())
3728 }
3729
3730 #[allow(unused_variables)]
3732 fn compute_size(&self) -> u32 {
3733 let mut my_size = 0;
3734 if self.query != false {
3735 my_size += 2;
3736 }
3737 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3738 self.cached_size.set(my_size);
3739 my_size
3740 }
3741
3742 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3743 if self.query != false {
3744 os.write_bool(1, self.query)?;
3745 }
3746 os.write_unknown_fields(self.get_unknown_fields())?;
3747 ::std::result::Result::Ok(())
3748 }
3749
3750 fn get_cached_size(&self) -> u32 {
3751 self.cached_size.get()
3752 }
3753
3754 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3755 &self.unknown_fields
3756 }
3757
3758 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3759 &mut self.unknown_fields
3760 }
3761
3762 fn as_any(&self) -> &dyn (::std::any::Any) {
3763 self as &dyn (::std::any::Any)
3764 }
3765 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3766 self as &mut dyn (::std::any::Any)
3767 }
3768 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3769 self
3770 }
3771
3772 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3773 Self::descriptor_static()
3774 }
3775
3776 fn new() -> DecodeRawTransactionRequest {
3777 DecodeRawTransactionRequest::new()
3778 }
3779
3780 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3781 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3782 lock: ::protobuf::lazy::ONCE_INIT,
3783 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3784 };
3785 unsafe {
3786 descriptor.get(|| {
3787 let mut fields = ::std::vec::Vec::new();
3788 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
3789 "query",
3790 |m: &DecodeRawTransactionRequest| { &m.query },
3791 |m: &mut DecodeRawTransactionRequest| { &mut m.query },
3792 ));
3793 ::protobuf::reflect::MessageDescriptor::new::<DecodeRawTransactionRequest>(
3794 "DecodeRawTransactionRequest",
3795 fields,
3796 file_descriptor_proto()
3797 )
3798 })
3799 }
3800 }
3801
3802 fn default_instance() -> &'static DecodeRawTransactionRequest {
3803 static mut instance: ::protobuf::lazy::Lazy<DecodeRawTransactionRequest> = ::protobuf::lazy::Lazy {
3804 lock: ::protobuf::lazy::ONCE_INIT,
3805 ptr: 0 as *const DecodeRawTransactionRequest,
3806 };
3807 unsafe {
3808 instance.get(DecodeRawTransactionRequest::new)
3809 }
3810 }
3811}
3812
3813impl ::protobuf::Clear for DecodeRawTransactionRequest {
3814 fn clear(&mut self) {
3815 self.query = false;
3816 self.unknown_fields.clear();
3817 }
3818}
3819
3820impl ::std::fmt::Debug for DecodeRawTransactionRequest {
3821 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3822 ::protobuf::text_format::fmt(self, f)
3823 }
3824}
3825
3826impl ::protobuf::reflect::ProtobufValue for DecodeRawTransactionRequest {
3827 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3828 ::protobuf::reflect::ProtobufValueRef::Message(self)
3829 }
3830}
3831
3832#[derive(PartialEq,Clone,Default)]
3833pub struct DecodeRawTransactionResponse {
3834 pub query: ::std::string::String,
3836 pub unknown_fields: ::protobuf::UnknownFields,
3838 pub cached_size: ::protobuf::CachedSize,
3839}
3840
3841impl<'a> ::std::default::Default for &'a DecodeRawTransactionResponse {
3842 fn default() -> &'a DecodeRawTransactionResponse {
3843 <DecodeRawTransactionResponse as ::protobuf::Message>::default_instance()
3844 }
3845}
3846
3847impl DecodeRawTransactionResponse {
3848 pub fn new() -> DecodeRawTransactionResponse {
3849 ::std::default::Default::default()
3850 }
3851
3852 pub fn get_query(&self) -> &str {
3856 &self.query
3857 }
3858 pub fn clear_query(&mut self) {
3859 self.query.clear();
3860 }
3861
3862 pub fn set_query(&mut self, v: ::std::string::String) {
3864 self.query = v;
3865 }
3866
3867 pub fn mut_query(&mut self) -> &mut ::std::string::String {
3870 &mut self.query
3871 }
3872
3873 pub fn take_query(&mut self) -> ::std::string::String {
3875 ::std::mem::replace(&mut self.query, ::std::string::String::new())
3876 }
3877}
3878
3879impl ::protobuf::Message for DecodeRawTransactionResponse {
3880 fn is_initialized(&self) -> bool {
3881 true
3882 }
3883
3884 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3885 while !is.eof()? {
3886 let (field_number, wire_type) = is.read_tag_unpack()?;
3887 match field_number {
3888 1 => {
3889 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
3890 },
3891 _ => {
3892 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
3893 },
3894 };
3895 }
3896 ::std::result::Result::Ok(())
3897 }
3898
3899 #[allow(unused_variables)]
3901 fn compute_size(&self) -> u32 {
3902 let mut my_size = 0;
3903 if !self.query.is_empty() {
3904 my_size += ::protobuf::rt::string_size(1, &self.query);
3905 }
3906 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
3907 self.cached_size.set(my_size);
3908 my_size
3909 }
3910
3911 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
3912 if !self.query.is_empty() {
3913 os.write_string(1, &self.query)?;
3914 }
3915 os.write_unknown_fields(self.get_unknown_fields())?;
3916 ::std::result::Result::Ok(())
3917 }
3918
3919 fn get_cached_size(&self) -> u32 {
3920 self.cached_size.get()
3921 }
3922
3923 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
3924 &self.unknown_fields
3925 }
3926
3927 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
3928 &mut self.unknown_fields
3929 }
3930
3931 fn as_any(&self) -> &dyn (::std::any::Any) {
3932 self as &dyn (::std::any::Any)
3933 }
3934 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
3935 self as &mut dyn (::std::any::Any)
3936 }
3937 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
3938 self
3939 }
3940
3941 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
3942 Self::descriptor_static()
3943 }
3944
3945 fn new() -> DecodeRawTransactionResponse {
3946 DecodeRawTransactionResponse::new()
3947 }
3948
3949 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
3950 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
3951 lock: ::protobuf::lazy::ONCE_INIT,
3952 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
3953 };
3954 unsafe {
3955 descriptor.get(|| {
3956 let mut fields = ::std::vec::Vec::new();
3957 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
3958 "query",
3959 |m: &DecodeRawTransactionResponse| { &m.query },
3960 |m: &mut DecodeRawTransactionResponse| { &mut m.query },
3961 ));
3962 ::protobuf::reflect::MessageDescriptor::new::<DecodeRawTransactionResponse>(
3963 "DecodeRawTransactionResponse",
3964 fields,
3965 file_descriptor_proto()
3966 )
3967 })
3968 }
3969 }
3970
3971 fn default_instance() -> &'static DecodeRawTransactionResponse {
3972 static mut instance: ::protobuf::lazy::Lazy<DecodeRawTransactionResponse> = ::protobuf::lazy::Lazy {
3973 lock: ::protobuf::lazy::ONCE_INIT,
3974 ptr: 0 as *const DecodeRawTransactionResponse,
3975 };
3976 unsafe {
3977 instance.get(DecodeRawTransactionResponse::new)
3978 }
3979 }
3980}
3981
3982impl ::protobuf::Clear for DecodeRawTransactionResponse {
3983 fn clear(&mut self) {
3984 self.query.clear();
3985 self.unknown_fields.clear();
3986 }
3987}
3988
3989impl ::std::fmt::Debug for DecodeRawTransactionResponse {
3990 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3991 ::protobuf::text_format::fmt(self, f)
3992 }
3993}
3994
3995impl ::protobuf::reflect::ProtobufValue for DecodeRawTransactionResponse {
3996 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
3997 ::protobuf::reflect::ProtobufValueRef::Message(self)
3998 }
3999}
4000
4001#[derive(PartialEq,Clone,Default)]
4002pub struct BroadcastRawTransactionRequest {
4003 pub transaction: ::protobuf::SingularPtrField<super::Wire::TransactionBroadcast>,
4005 pub unknown_fields: ::protobuf::UnknownFields,
4007 pub cached_size: ::protobuf::CachedSize,
4008}
4009
4010impl<'a> ::std::default::Default for &'a BroadcastRawTransactionRequest {
4011 fn default() -> &'a BroadcastRawTransactionRequest {
4012 <BroadcastRawTransactionRequest as ::protobuf::Message>::default_instance()
4013 }
4014}
4015
4016impl BroadcastRawTransactionRequest {
4017 pub fn new() -> BroadcastRawTransactionRequest {
4018 ::std::default::Default::default()
4019 }
4020
4021 pub fn get_transaction(&self) -> &super::Wire::TransactionBroadcast {
4025 self.transaction.as_ref().unwrap_or_else(|| super::Wire::TransactionBroadcast::default_instance())
4026 }
4027 pub fn clear_transaction(&mut self) {
4028 self.transaction.clear();
4029 }
4030
4031 pub fn has_transaction(&self) -> bool {
4032 self.transaction.is_some()
4033 }
4034
4035 pub fn set_transaction(&mut self, v: super::Wire::TransactionBroadcast) {
4037 self.transaction = ::protobuf::SingularPtrField::some(v);
4038 }
4039
4040 pub fn mut_transaction(&mut self) -> &mut super::Wire::TransactionBroadcast {
4043 if self.transaction.is_none() {
4044 self.transaction.set_default();
4045 }
4046 self.transaction.as_mut().unwrap()
4047 }
4048
4049 pub fn take_transaction(&mut self) -> super::Wire::TransactionBroadcast {
4051 self.transaction.take().unwrap_or_else(|| super::Wire::TransactionBroadcast::new())
4052 }
4053}
4054
4055impl ::protobuf::Message for BroadcastRawTransactionRequest {
4056 fn is_initialized(&self) -> bool {
4057 for v in &self.transaction {
4058 if !v.is_initialized() {
4059 return false;
4060 }
4061 };
4062 true
4063 }
4064
4065 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4066 while !is.eof()? {
4067 let (field_number, wire_type) = is.read_tag_unpack()?;
4068 match field_number {
4069 1 => {
4070 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?;
4071 },
4072 _ => {
4073 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4074 },
4075 };
4076 }
4077 ::std::result::Result::Ok(())
4078 }
4079
4080 #[allow(unused_variables)]
4082 fn compute_size(&self) -> u32 {
4083 let mut my_size = 0;
4084 if let Some(ref v) = self.transaction.as_ref() {
4085 let len = v.compute_size();
4086 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
4087 }
4088 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4089 self.cached_size.set(my_size);
4090 my_size
4091 }
4092
4093 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4094 if let Some(ref v) = self.transaction.as_ref() {
4095 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
4096 os.write_raw_varint32(v.get_cached_size())?;
4097 v.write_to_with_cached_sizes(os)?;
4098 }
4099 os.write_unknown_fields(self.get_unknown_fields())?;
4100 ::std::result::Result::Ok(())
4101 }
4102
4103 fn get_cached_size(&self) -> u32 {
4104 self.cached_size.get()
4105 }
4106
4107 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4108 &self.unknown_fields
4109 }
4110
4111 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4112 &mut self.unknown_fields
4113 }
4114
4115 fn as_any(&self) -> &dyn (::std::any::Any) {
4116 self as &dyn (::std::any::Any)
4117 }
4118 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4119 self as &mut dyn (::std::any::Any)
4120 }
4121 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4122 self
4123 }
4124
4125 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4126 Self::descriptor_static()
4127 }
4128
4129 fn new() -> BroadcastRawTransactionRequest {
4130 BroadcastRawTransactionRequest::new()
4131 }
4132
4133 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4134 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
4135 lock: ::protobuf::lazy::ONCE_INIT,
4136 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
4137 };
4138 unsafe {
4139 descriptor.get(|| {
4140 let mut fields = ::std::vec::Vec::new();
4141 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::Wire::TransactionBroadcast>>(
4142 "transaction",
4143 |m: &BroadcastRawTransactionRequest| { &m.transaction },
4144 |m: &mut BroadcastRawTransactionRequest| { &mut m.transaction },
4145 ));
4146 ::protobuf::reflect::MessageDescriptor::new::<BroadcastRawTransactionRequest>(
4147 "BroadcastRawTransactionRequest",
4148 fields,
4149 file_descriptor_proto()
4150 )
4151 })
4152 }
4153 }
4154
4155 fn default_instance() -> &'static BroadcastRawTransactionRequest {
4156 static mut instance: ::protobuf::lazy::Lazy<BroadcastRawTransactionRequest> = ::protobuf::lazy::Lazy {
4157 lock: ::protobuf::lazy::ONCE_INIT,
4158 ptr: 0 as *const BroadcastRawTransactionRequest,
4159 };
4160 unsafe {
4161 instance.get(BroadcastRawTransactionRequest::new)
4162 }
4163 }
4164}
4165
4166impl ::protobuf::Clear for BroadcastRawTransactionRequest {
4167 fn clear(&mut self) {
4168 self.transaction.clear();
4169 self.unknown_fields.clear();
4170 }
4171}
4172
4173impl ::std::fmt::Debug for BroadcastRawTransactionRequest {
4174 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4175 ::protobuf::text_format::fmt(self, f)
4176 }
4177}
4178
4179impl ::protobuf::reflect::ProtobufValue for BroadcastRawTransactionRequest {
4180 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
4181 ::protobuf::reflect::ProtobufValueRef::Message(self)
4182 }
4183}
4184
4185#[derive(PartialEq,Clone,Default)]
4186pub struct BroadcastRawTransactionResponse {
4187 pub response_code: ResponseCode,
4189 pub unknown_fields: ::protobuf::UnknownFields,
4191 pub cached_size: ::protobuf::CachedSize,
4192}
4193
4194impl<'a> ::std::default::Default for &'a BroadcastRawTransactionResponse {
4195 fn default() -> &'a BroadcastRawTransactionResponse {
4196 <BroadcastRawTransactionResponse as ::protobuf::Message>::default_instance()
4197 }
4198}
4199
4200impl BroadcastRawTransactionResponse {
4201 pub fn new() -> BroadcastRawTransactionResponse {
4202 ::std::default::Default::default()
4203 }
4204
4205 pub fn get_response_code(&self) -> ResponseCode {
4209 self.response_code
4210 }
4211 pub fn clear_response_code(&mut self) {
4212 self.response_code = ResponseCode::PENDING;
4213 }
4214
4215 pub fn set_response_code(&mut self, v: ResponseCode) {
4217 self.response_code = v;
4218 }
4219}
4220
4221impl ::protobuf::Message for BroadcastRawTransactionResponse {
4222 fn is_initialized(&self) -> bool {
4223 true
4224 }
4225
4226 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4227 while !is.eof()? {
4228 let (field_number, wire_type) = is.read_tag_unpack()?;
4229 match field_number {
4230 1 => {
4231 ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.response_code, 1, &mut self.unknown_fields)?
4232 },
4233 _ => {
4234 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4235 },
4236 };
4237 }
4238 ::std::result::Result::Ok(())
4239 }
4240
4241 #[allow(unused_variables)]
4243 fn compute_size(&self) -> u32 {
4244 let mut my_size = 0;
4245 if self.response_code != ResponseCode::PENDING {
4246 my_size += ::protobuf::rt::enum_size(1, self.response_code);
4247 }
4248 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4249 self.cached_size.set(my_size);
4250 my_size
4251 }
4252
4253 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4254 if self.response_code != ResponseCode::PENDING {
4255 os.write_enum(1, self.response_code.value())?;
4256 }
4257 os.write_unknown_fields(self.get_unknown_fields())?;
4258 ::std::result::Result::Ok(())
4259 }
4260
4261 fn get_cached_size(&self) -> u32 {
4262 self.cached_size.get()
4263 }
4264
4265 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4266 &self.unknown_fields
4267 }
4268
4269 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4270 &mut self.unknown_fields
4271 }
4272
4273 fn as_any(&self) -> &dyn (::std::any::Any) {
4274 self as &dyn (::std::any::Any)
4275 }
4276 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4277 self as &mut dyn (::std::any::Any)
4278 }
4279 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4280 self
4281 }
4282
4283 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4284 Self::descriptor_static()
4285 }
4286
4287 fn new() -> BroadcastRawTransactionResponse {
4288 BroadcastRawTransactionResponse::new()
4289 }
4290
4291 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4292 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
4293 lock: ::protobuf::lazy::ONCE_INIT,
4294 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
4295 };
4296 unsafe {
4297 descriptor.get(|| {
4298 let mut fields = ::std::vec::Vec::new();
4299 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ResponseCode>>(
4300 "response_code",
4301 |m: &BroadcastRawTransactionResponse| { &m.response_code },
4302 |m: &mut BroadcastRawTransactionResponse| { &mut m.response_code },
4303 ));
4304 ::protobuf::reflect::MessageDescriptor::new::<BroadcastRawTransactionResponse>(
4305 "BroadcastRawTransactionResponse",
4306 fields,
4307 file_descriptor_proto()
4308 )
4309 })
4310 }
4311 }
4312
4313 fn default_instance() -> &'static BroadcastRawTransactionResponse {
4314 static mut instance: ::protobuf::lazy::Lazy<BroadcastRawTransactionResponse> = ::protobuf::lazy::Lazy {
4315 lock: ::protobuf::lazy::ONCE_INIT,
4316 ptr: 0 as *const BroadcastRawTransactionResponse,
4317 };
4318 unsafe {
4319 instance.get(BroadcastRawTransactionResponse::new)
4320 }
4321 }
4322}
4323
4324impl ::protobuf::Clear for BroadcastRawTransactionResponse {
4325 fn clear(&mut self) {
4326 self.response_code = ResponseCode::PENDING;
4327 self.unknown_fields.clear();
4328 }
4329}
4330
4331impl ::std::fmt::Debug for BroadcastRawTransactionResponse {
4332 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4333 ::protobuf::text_format::fmt(self, f)
4334 }
4335}
4336
4337impl ::protobuf::reflect::ProtobufValue for BroadcastRawTransactionResponse {
4338 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
4339 ::protobuf::reflect::ProtobufValueRef::Message(self)
4340 }
4341}
4342
4343#[derive(PartialEq,Clone,Default)]
4344pub struct SendToRequest {
4345 pub query: bool,
4347 pub unknown_fields: ::protobuf::UnknownFields,
4349 pub cached_size: ::protobuf::CachedSize,
4350}
4351
4352impl<'a> ::std::default::Default for &'a SendToRequest {
4353 fn default() -> &'a SendToRequest {
4354 <SendToRequest as ::protobuf::Message>::default_instance()
4355 }
4356}
4357
4358impl SendToRequest {
4359 pub fn new() -> SendToRequest {
4360 ::std::default::Default::default()
4361 }
4362
4363 pub fn get_query(&self) -> bool {
4367 self.query
4368 }
4369 pub fn clear_query(&mut self) {
4370 self.query = false;
4371 }
4372
4373 pub fn set_query(&mut self, v: bool) {
4375 self.query = v;
4376 }
4377}
4378
4379impl ::protobuf::Message for SendToRequest {
4380 fn is_initialized(&self) -> bool {
4381 true
4382 }
4383
4384 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4385 while !is.eof()? {
4386 let (field_number, wire_type) = is.read_tag_unpack()?;
4387 match field_number {
4388 1 => {
4389 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4390 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4391 }
4392 let tmp = is.read_bool()?;
4393 self.query = tmp;
4394 },
4395 _ => {
4396 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4397 },
4398 };
4399 }
4400 ::std::result::Result::Ok(())
4401 }
4402
4403 #[allow(unused_variables)]
4405 fn compute_size(&self) -> u32 {
4406 let mut my_size = 0;
4407 if self.query != false {
4408 my_size += 2;
4409 }
4410 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4411 self.cached_size.set(my_size);
4412 my_size
4413 }
4414
4415 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4416 if self.query != false {
4417 os.write_bool(1, self.query)?;
4418 }
4419 os.write_unknown_fields(self.get_unknown_fields())?;
4420 ::std::result::Result::Ok(())
4421 }
4422
4423 fn get_cached_size(&self) -> u32 {
4424 self.cached_size.get()
4425 }
4426
4427 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4428 &self.unknown_fields
4429 }
4430
4431 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4432 &mut self.unknown_fields
4433 }
4434
4435 fn as_any(&self) -> &dyn (::std::any::Any) {
4436 self as &dyn (::std::any::Any)
4437 }
4438 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4439 self as &mut dyn (::std::any::Any)
4440 }
4441 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4442 self
4443 }
4444
4445 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4446 Self::descriptor_static()
4447 }
4448
4449 fn new() -> SendToRequest {
4450 SendToRequest::new()
4451 }
4452
4453 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4454 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
4455 lock: ::protobuf::lazy::ONCE_INIT,
4456 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
4457 };
4458 unsafe {
4459 descriptor.get(|| {
4460 let mut fields = ::std::vec::Vec::new();
4461 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
4462 "query",
4463 |m: &SendToRequest| { &m.query },
4464 |m: &mut SendToRequest| { &mut m.query },
4465 ));
4466 ::protobuf::reflect::MessageDescriptor::new::<SendToRequest>(
4467 "SendToRequest",
4468 fields,
4469 file_descriptor_proto()
4470 )
4471 })
4472 }
4473 }
4474
4475 fn default_instance() -> &'static SendToRequest {
4476 static mut instance: ::protobuf::lazy::Lazy<SendToRequest> = ::protobuf::lazy::Lazy {
4477 lock: ::protobuf::lazy::ONCE_INIT,
4478 ptr: 0 as *const SendToRequest,
4479 };
4480 unsafe {
4481 instance.get(SendToRequest::new)
4482 }
4483 }
4484}
4485
4486impl ::protobuf::Clear for SendToRequest {
4487 fn clear(&mut self) {
4488 self.query = false;
4489 self.unknown_fields.clear();
4490 }
4491}
4492
4493impl ::std::fmt::Debug for SendToRequest {
4494 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4495 ::protobuf::text_format::fmt(self, f)
4496 }
4497}
4498
4499impl ::protobuf::reflect::ProtobufValue for SendToRequest {
4500 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
4501 ::protobuf::reflect::ProtobufValueRef::Message(self)
4502 }
4503}
4504
4505#[derive(PartialEq,Clone,Default)]
4506pub struct SendToResponse {
4507 pub query: ::std::string::String,
4509 pub unknown_fields: ::protobuf::UnknownFields,
4511 pub cached_size: ::protobuf::CachedSize,
4512}
4513
4514impl<'a> ::std::default::Default for &'a SendToResponse {
4515 fn default() -> &'a SendToResponse {
4516 <SendToResponse as ::protobuf::Message>::default_instance()
4517 }
4518}
4519
4520impl SendToResponse {
4521 pub fn new() -> SendToResponse {
4522 ::std::default::Default::default()
4523 }
4524
4525 pub fn get_query(&self) -> &str {
4529 &self.query
4530 }
4531 pub fn clear_query(&mut self) {
4532 self.query.clear();
4533 }
4534
4535 pub fn set_query(&mut self, v: ::std::string::String) {
4537 self.query = v;
4538 }
4539
4540 pub fn mut_query(&mut self) -> &mut ::std::string::String {
4543 &mut self.query
4544 }
4545
4546 pub fn take_query(&mut self) -> ::std::string::String {
4548 ::std::mem::replace(&mut self.query, ::std::string::String::new())
4549 }
4550}
4551
4552impl ::protobuf::Message for SendToResponse {
4553 fn is_initialized(&self) -> bool {
4554 true
4555 }
4556
4557 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4558 while !is.eof()? {
4559 let (field_number, wire_type) = is.read_tag_unpack()?;
4560 match field_number {
4561 1 => {
4562 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
4563 },
4564 _ => {
4565 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4566 },
4567 };
4568 }
4569 ::std::result::Result::Ok(())
4570 }
4571
4572 #[allow(unused_variables)]
4574 fn compute_size(&self) -> u32 {
4575 let mut my_size = 0;
4576 if !self.query.is_empty() {
4577 my_size += ::protobuf::rt::string_size(1, &self.query);
4578 }
4579 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4580 self.cached_size.set(my_size);
4581 my_size
4582 }
4583
4584 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4585 if !self.query.is_empty() {
4586 os.write_string(1, &self.query)?;
4587 }
4588 os.write_unknown_fields(self.get_unknown_fields())?;
4589 ::std::result::Result::Ok(())
4590 }
4591
4592 fn get_cached_size(&self) -> u32 {
4593 self.cached_size.get()
4594 }
4595
4596 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4597 &self.unknown_fields
4598 }
4599
4600 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4601 &mut self.unknown_fields
4602 }
4603
4604 fn as_any(&self) -> &dyn (::std::any::Any) {
4605 self as &dyn (::std::any::Any)
4606 }
4607 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4608 self as &mut dyn (::std::any::Any)
4609 }
4610 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4611 self
4612 }
4613
4614 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4615 Self::descriptor_static()
4616 }
4617
4618 fn new() -> SendToResponse {
4619 SendToResponse::new()
4620 }
4621
4622 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4623 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
4624 lock: ::protobuf::lazy::ONCE_INIT,
4625 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
4626 };
4627 unsafe {
4628 descriptor.get(|| {
4629 let mut fields = ::std::vec::Vec::new();
4630 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
4631 "query",
4632 |m: &SendToResponse| { &m.query },
4633 |m: &mut SendToResponse| { &mut m.query },
4634 ));
4635 ::protobuf::reflect::MessageDescriptor::new::<SendToResponse>(
4636 "SendToResponse",
4637 fields,
4638 file_descriptor_proto()
4639 )
4640 })
4641 }
4642 }
4643
4644 fn default_instance() -> &'static SendToResponse {
4645 static mut instance: ::protobuf::lazy::Lazy<SendToResponse> = ::protobuf::lazy::Lazy {
4646 lock: ::protobuf::lazy::ONCE_INIT,
4647 ptr: 0 as *const SendToResponse,
4648 };
4649 unsafe {
4650 instance.get(SendToResponse::new)
4651 }
4652 }
4653}
4654
4655impl ::protobuf::Clear for SendToResponse {
4656 fn clear(&mut self) {
4657 self.query.clear();
4658 self.unknown_fields.clear();
4659 }
4660}
4661
4662impl ::std::fmt::Debug for SendToResponse {
4663 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4664 ::protobuf::text_format::fmt(self, f)
4665 }
4666}
4667
4668impl ::protobuf::reflect::ProtobufValue for SendToResponse {
4669 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
4670 ::protobuf::reflect::ProtobufValueRef::Message(self)
4671 }
4672}
4673
4674#[derive(PartialEq,Clone,Default)]
4675pub struct SendToFromRequest {
4676 pub query: bool,
4678 pub unknown_fields: ::protobuf::UnknownFields,
4680 pub cached_size: ::protobuf::CachedSize,
4681}
4682
4683impl<'a> ::std::default::Default for &'a SendToFromRequest {
4684 fn default() -> &'a SendToFromRequest {
4685 <SendToFromRequest as ::protobuf::Message>::default_instance()
4686 }
4687}
4688
4689impl SendToFromRequest {
4690 pub fn new() -> SendToFromRequest {
4691 ::std::default::Default::default()
4692 }
4693
4694 pub fn get_query(&self) -> bool {
4698 self.query
4699 }
4700 pub fn clear_query(&mut self) {
4701 self.query = false;
4702 }
4703
4704 pub fn set_query(&mut self, v: bool) {
4706 self.query = v;
4707 }
4708}
4709
4710impl ::protobuf::Message for SendToFromRequest {
4711 fn is_initialized(&self) -> bool {
4712 true
4713 }
4714
4715 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4716 while !is.eof()? {
4717 let (field_number, wire_type) = is.read_tag_unpack()?;
4718 match field_number {
4719 1 => {
4720 if wire_type != ::protobuf::wire_format::WireTypeVarint {
4721 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
4722 }
4723 let tmp = is.read_bool()?;
4724 self.query = tmp;
4725 },
4726 _ => {
4727 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4728 },
4729 };
4730 }
4731 ::std::result::Result::Ok(())
4732 }
4733
4734 #[allow(unused_variables)]
4736 fn compute_size(&self) -> u32 {
4737 let mut my_size = 0;
4738 if self.query != false {
4739 my_size += 2;
4740 }
4741 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4742 self.cached_size.set(my_size);
4743 my_size
4744 }
4745
4746 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4747 if self.query != false {
4748 os.write_bool(1, self.query)?;
4749 }
4750 os.write_unknown_fields(self.get_unknown_fields())?;
4751 ::std::result::Result::Ok(())
4752 }
4753
4754 fn get_cached_size(&self) -> u32 {
4755 self.cached_size.get()
4756 }
4757
4758 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4759 &self.unknown_fields
4760 }
4761
4762 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4763 &mut self.unknown_fields
4764 }
4765
4766 fn as_any(&self) -> &dyn (::std::any::Any) {
4767 self as &dyn (::std::any::Any)
4768 }
4769 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4770 self as &mut dyn (::std::any::Any)
4771 }
4772 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4773 self
4774 }
4775
4776 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4777 Self::descriptor_static()
4778 }
4779
4780 fn new() -> SendToFromRequest {
4781 SendToFromRequest::new()
4782 }
4783
4784 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4785 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
4786 lock: ::protobuf::lazy::ONCE_INIT,
4787 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
4788 };
4789 unsafe {
4790 descriptor.get(|| {
4791 let mut fields = ::std::vec::Vec::new();
4792 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
4793 "query",
4794 |m: &SendToFromRequest| { &m.query },
4795 |m: &mut SendToFromRequest| { &mut m.query },
4796 ));
4797 ::protobuf::reflect::MessageDescriptor::new::<SendToFromRequest>(
4798 "SendToFromRequest",
4799 fields,
4800 file_descriptor_proto()
4801 )
4802 })
4803 }
4804 }
4805
4806 fn default_instance() -> &'static SendToFromRequest {
4807 static mut instance: ::protobuf::lazy::Lazy<SendToFromRequest> = ::protobuf::lazy::Lazy {
4808 lock: ::protobuf::lazy::ONCE_INIT,
4809 ptr: 0 as *const SendToFromRequest,
4810 };
4811 unsafe {
4812 instance.get(SendToFromRequest::new)
4813 }
4814 }
4815}
4816
4817impl ::protobuf::Clear for SendToFromRequest {
4818 fn clear(&mut self) {
4819 self.query = false;
4820 self.unknown_fields.clear();
4821 }
4822}
4823
4824impl ::std::fmt::Debug for SendToFromRequest {
4825 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4826 ::protobuf::text_format::fmt(self, f)
4827 }
4828}
4829
4830impl ::protobuf::reflect::ProtobufValue for SendToFromRequest {
4831 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
4832 ::protobuf::reflect::ProtobufValueRef::Message(self)
4833 }
4834}
4835
4836#[derive(PartialEq,Clone,Default)]
4837pub struct SendToFromResponse {
4838 pub query: ::std::string::String,
4840 pub unknown_fields: ::protobuf::UnknownFields,
4842 pub cached_size: ::protobuf::CachedSize,
4843}
4844
4845impl<'a> ::std::default::Default for &'a SendToFromResponse {
4846 fn default() -> &'a SendToFromResponse {
4847 <SendToFromResponse as ::protobuf::Message>::default_instance()
4848 }
4849}
4850
4851impl SendToFromResponse {
4852 pub fn new() -> SendToFromResponse {
4853 ::std::default::Default::default()
4854 }
4855
4856 pub fn get_query(&self) -> &str {
4860 &self.query
4861 }
4862 pub fn clear_query(&mut self) {
4863 self.query.clear();
4864 }
4865
4866 pub fn set_query(&mut self, v: ::std::string::String) {
4868 self.query = v;
4869 }
4870
4871 pub fn mut_query(&mut self) -> &mut ::std::string::String {
4874 &mut self.query
4875 }
4876
4877 pub fn take_query(&mut self) -> ::std::string::String {
4879 ::std::mem::replace(&mut self.query, ::std::string::String::new())
4880 }
4881}
4882
4883impl ::protobuf::Message for SendToFromResponse {
4884 fn is_initialized(&self) -> bool {
4885 true
4886 }
4887
4888 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4889 while !is.eof()? {
4890 let (field_number, wire_type) = is.read_tag_unpack()?;
4891 match field_number {
4892 1 => {
4893 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
4894 },
4895 _ => {
4896 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
4897 },
4898 };
4899 }
4900 ::std::result::Result::Ok(())
4901 }
4902
4903 #[allow(unused_variables)]
4905 fn compute_size(&self) -> u32 {
4906 let mut my_size = 0;
4907 if !self.query.is_empty() {
4908 my_size += ::protobuf::rt::string_size(1, &self.query);
4909 }
4910 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
4911 self.cached_size.set(my_size);
4912 my_size
4913 }
4914
4915 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
4916 if !self.query.is_empty() {
4917 os.write_string(1, &self.query)?;
4918 }
4919 os.write_unknown_fields(self.get_unknown_fields())?;
4920 ::std::result::Result::Ok(())
4921 }
4922
4923 fn get_cached_size(&self) -> u32 {
4924 self.cached_size.get()
4925 }
4926
4927 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
4928 &self.unknown_fields
4929 }
4930
4931 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
4932 &mut self.unknown_fields
4933 }
4934
4935 fn as_any(&self) -> &dyn (::std::any::Any) {
4936 self as &dyn (::std::any::Any)
4937 }
4938 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
4939 self as &mut dyn (::std::any::Any)
4940 }
4941 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
4942 self
4943 }
4944
4945 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
4946 Self::descriptor_static()
4947 }
4948
4949 fn new() -> SendToFromResponse {
4950 SendToFromResponse::new()
4951 }
4952
4953 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
4954 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
4955 lock: ::protobuf::lazy::ONCE_INIT,
4956 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
4957 };
4958 unsafe {
4959 descriptor.get(|| {
4960 let mut fields = ::std::vec::Vec::new();
4961 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
4962 "query",
4963 |m: &SendToFromResponse| { &m.query },
4964 |m: &mut SendToFromResponse| { &mut m.query },
4965 ));
4966 ::protobuf::reflect::MessageDescriptor::new::<SendToFromResponse>(
4967 "SendToFromResponse",
4968 fields,
4969 file_descriptor_proto()
4970 )
4971 })
4972 }
4973 }
4974
4975 fn default_instance() -> &'static SendToFromResponse {
4976 static mut instance: ::protobuf::lazy::Lazy<SendToFromResponse> = ::protobuf::lazy::Lazy {
4977 lock: ::protobuf::lazy::ONCE_INIT,
4978 ptr: 0 as *const SendToFromResponse,
4979 };
4980 unsafe {
4981 instance.get(SendToFromResponse::new)
4982 }
4983 }
4984}
4985
4986impl ::protobuf::Clear for SendToFromResponse {
4987 fn clear(&mut self) {
4988 self.query.clear();
4989 self.unknown_fields.clear();
4990 }
4991}
4992
4993impl ::std::fmt::Debug for SendToFromResponse {
4994 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4995 ::protobuf::text_format::fmt(self, f)
4996 }
4997}
4998
4999impl ::protobuf::reflect::ProtobufValue for SendToFromResponse {
5000 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
5001 ::protobuf::reflect::ProtobufValueRef::Message(self)
5002 }
5003}
5004
5005#[derive(PartialEq,Clone,Default)]
5006pub struct SendManyRequest {
5007 pub query: bool,
5009 pub unknown_fields: ::protobuf::UnknownFields,
5011 pub cached_size: ::protobuf::CachedSize,
5012}
5013
5014impl<'a> ::std::default::Default for &'a SendManyRequest {
5015 fn default() -> &'a SendManyRequest {
5016 <SendManyRequest as ::protobuf::Message>::default_instance()
5017 }
5018}
5019
5020impl SendManyRequest {
5021 pub fn new() -> SendManyRequest {
5022 ::std::default::Default::default()
5023 }
5024
5025 pub fn get_query(&self) -> bool {
5029 self.query
5030 }
5031 pub fn clear_query(&mut self) {
5032 self.query = false;
5033 }
5034
5035 pub fn set_query(&mut self, v: bool) {
5037 self.query = v;
5038 }
5039}
5040
5041impl ::protobuf::Message for SendManyRequest {
5042 fn is_initialized(&self) -> bool {
5043 true
5044 }
5045
5046 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5047 while !is.eof()? {
5048 let (field_number, wire_type) = is.read_tag_unpack()?;
5049 match field_number {
5050 1 => {
5051 if wire_type != ::protobuf::wire_format::WireTypeVarint {
5052 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
5053 }
5054 let tmp = is.read_bool()?;
5055 self.query = tmp;
5056 },
5057 _ => {
5058 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5059 },
5060 };
5061 }
5062 ::std::result::Result::Ok(())
5063 }
5064
5065 #[allow(unused_variables)]
5067 fn compute_size(&self) -> u32 {
5068 let mut my_size = 0;
5069 if self.query != false {
5070 my_size += 2;
5071 }
5072 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5073 self.cached_size.set(my_size);
5074 my_size
5075 }
5076
5077 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5078 if self.query != false {
5079 os.write_bool(1, self.query)?;
5080 }
5081 os.write_unknown_fields(self.get_unknown_fields())?;
5082 ::std::result::Result::Ok(())
5083 }
5084
5085 fn get_cached_size(&self) -> u32 {
5086 self.cached_size.get()
5087 }
5088
5089 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5090 &self.unknown_fields
5091 }
5092
5093 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5094 &mut self.unknown_fields
5095 }
5096
5097 fn as_any(&self) -> &dyn (::std::any::Any) {
5098 self as &dyn (::std::any::Any)
5099 }
5100 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5101 self as &mut dyn (::std::any::Any)
5102 }
5103 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5104 self
5105 }
5106
5107 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5108 Self::descriptor_static()
5109 }
5110
5111 fn new() -> SendManyRequest {
5112 SendManyRequest::new()
5113 }
5114
5115 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5116 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
5117 lock: ::protobuf::lazy::ONCE_INIT,
5118 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
5119 };
5120 unsafe {
5121 descriptor.get(|| {
5122 let mut fields = ::std::vec::Vec::new();
5123 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
5124 "query",
5125 |m: &SendManyRequest| { &m.query },
5126 |m: &mut SendManyRequest| { &mut m.query },
5127 ));
5128 ::protobuf::reflect::MessageDescriptor::new::<SendManyRequest>(
5129 "SendManyRequest",
5130 fields,
5131 file_descriptor_proto()
5132 )
5133 })
5134 }
5135 }
5136
5137 fn default_instance() -> &'static SendManyRequest {
5138 static mut instance: ::protobuf::lazy::Lazy<SendManyRequest> = ::protobuf::lazy::Lazy {
5139 lock: ::protobuf::lazy::ONCE_INIT,
5140 ptr: 0 as *const SendManyRequest,
5141 };
5142 unsafe {
5143 instance.get(SendManyRequest::new)
5144 }
5145 }
5146}
5147
5148impl ::protobuf::Clear for SendManyRequest {
5149 fn clear(&mut self) {
5150 self.query = false;
5151 self.unknown_fields.clear();
5152 }
5153}
5154
5155impl ::std::fmt::Debug for SendManyRequest {
5156 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5157 ::protobuf::text_format::fmt(self, f)
5158 }
5159}
5160
5161impl ::protobuf::reflect::ProtobufValue for SendManyRequest {
5162 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
5163 ::protobuf::reflect::ProtobufValueRef::Message(self)
5164 }
5165}
5166
5167#[derive(PartialEq,Clone,Default)]
5168pub struct SendManyResponse {
5169 pub query: ::std::string::String,
5171 pub unknown_fields: ::protobuf::UnknownFields,
5173 pub cached_size: ::protobuf::CachedSize,
5174}
5175
5176impl<'a> ::std::default::Default for &'a SendManyResponse {
5177 fn default() -> &'a SendManyResponse {
5178 <SendManyResponse as ::protobuf::Message>::default_instance()
5179 }
5180}
5181
5182impl SendManyResponse {
5183 pub fn new() -> SendManyResponse {
5184 ::std::default::Default::default()
5185 }
5186
5187 pub fn get_query(&self) -> &str {
5191 &self.query
5192 }
5193 pub fn clear_query(&mut self) {
5194 self.query.clear();
5195 }
5196
5197 pub fn set_query(&mut self, v: ::std::string::String) {
5199 self.query = v;
5200 }
5201
5202 pub fn mut_query(&mut self) -> &mut ::std::string::String {
5205 &mut self.query
5206 }
5207
5208 pub fn take_query(&mut self) -> ::std::string::String {
5210 ::std::mem::replace(&mut self.query, ::std::string::String::new())
5211 }
5212}
5213
5214impl ::protobuf::Message for SendManyResponse {
5215 fn is_initialized(&self) -> bool {
5216 true
5217 }
5218
5219 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5220 while !is.eof()? {
5221 let (field_number, wire_type) = is.read_tag_unpack()?;
5222 match field_number {
5223 1 => {
5224 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
5225 },
5226 _ => {
5227 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5228 },
5229 };
5230 }
5231 ::std::result::Result::Ok(())
5232 }
5233
5234 #[allow(unused_variables)]
5236 fn compute_size(&self) -> u32 {
5237 let mut my_size = 0;
5238 if !self.query.is_empty() {
5239 my_size += ::protobuf::rt::string_size(1, &self.query);
5240 }
5241 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5242 self.cached_size.set(my_size);
5243 my_size
5244 }
5245
5246 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5247 if !self.query.is_empty() {
5248 os.write_string(1, &self.query)?;
5249 }
5250 os.write_unknown_fields(self.get_unknown_fields())?;
5251 ::std::result::Result::Ok(())
5252 }
5253
5254 fn get_cached_size(&self) -> u32 {
5255 self.cached_size.get()
5256 }
5257
5258 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5259 &self.unknown_fields
5260 }
5261
5262 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5263 &mut self.unknown_fields
5264 }
5265
5266 fn as_any(&self) -> &dyn (::std::any::Any) {
5267 self as &dyn (::std::any::Any)
5268 }
5269 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5270 self as &mut dyn (::std::any::Any)
5271 }
5272 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5273 self
5274 }
5275
5276 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5277 Self::descriptor_static()
5278 }
5279
5280 fn new() -> SendManyResponse {
5281 SendManyResponse::new()
5282 }
5283
5284 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5285 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
5286 lock: ::protobuf::lazy::ONCE_INIT,
5287 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
5288 };
5289 unsafe {
5290 descriptor.get(|| {
5291 let mut fields = ::std::vec::Vec::new();
5292 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
5293 "query",
5294 |m: &SendManyResponse| { &m.query },
5295 |m: &mut SendManyResponse| { &mut m.query },
5296 ));
5297 ::protobuf::reflect::MessageDescriptor::new::<SendManyResponse>(
5298 "SendManyResponse",
5299 fields,
5300 file_descriptor_proto()
5301 )
5302 })
5303 }
5304 }
5305
5306 fn default_instance() -> &'static SendManyResponse {
5307 static mut instance: ::protobuf::lazy::Lazy<SendManyResponse> = ::protobuf::lazy::Lazy {
5308 lock: ::protobuf::lazy::ONCE_INIT,
5309 ptr: 0 as *const SendManyResponse,
5310 };
5311 unsafe {
5312 instance.get(SendManyResponse::new)
5313 }
5314 }
5315}
5316
5317impl ::protobuf::Clear for SendManyResponse {
5318 fn clear(&mut self) {
5319 self.query.clear();
5320 self.unknown_fields.clear();
5321 }
5322}
5323
5324impl ::std::fmt::Debug for SendManyResponse {
5325 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5326 ::protobuf::text_format::fmt(self, f)
5327 }
5328}
5329
5330impl ::protobuf::reflect::ProtobufValue for SendManyResponse {
5331 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
5332 ::protobuf::reflect::ProtobufValueRef::Message(self)
5333 }
5334}
5335
5336#[derive(PartialEq,Clone,Default)]
5337pub struct SendFromManyRequest {
5338 pub query: bool,
5340 pub unknown_fields: ::protobuf::UnknownFields,
5342 pub cached_size: ::protobuf::CachedSize,
5343}
5344
5345impl<'a> ::std::default::Default for &'a SendFromManyRequest {
5346 fn default() -> &'a SendFromManyRequest {
5347 <SendFromManyRequest as ::protobuf::Message>::default_instance()
5348 }
5349}
5350
5351impl SendFromManyRequest {
5352 pub fn new() -> SendFromManyRequest {
5353 ::std::default::Default::default()
5354 }
5355
5356 pub fn get_query(&self) -> bool {
5360 self.query
5361 }
5362 pub fn clear_query(&mut self) {
5363 self.query = false;
5364 }
5365
5366 pub fn set_query(&mut self, v: bool) {
5368 self.query = v;
5369 }
5370}
5371
5372impl ::protobuf::Message for SendFromManyRequest {
5373 fn is_initialized(&self) -> bool {
5374 true
5375 }
5376
5377 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5378 while !is.eof()? {
5379 let (field_number, wire_type) = is.read_tag_unpack()?;
5380 match field_number {
5381 1 => {
5382 if wire_type != ::protobuf::wire_format::WireTypeVarint {
5383 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
5384 }
5385 let tmp = is.read_bool()?;
5386 self.query = tmp;
5387 },
5388 _ => {
5389 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5390 },
5391 };
5392 }
5393 ::std::result::Result::Ok(())
5394 }
5395
5396 #[allow(unused_variables)]
5398 fn compute_size(&self) -> u32 {
5399 let mut my_size = 0;
5400 if self.query != false {
5401 my_size += 2;
5402 }
5403 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5404 self.cached_size.set(my_size);
5405 my_size
5406 }
5407
5408 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5409 if self.query != false {
5410 os.write_bool(1, self.query)?;
5411 }
5412 os.write_unknown_fields(self.get_unknown_fields())?;
5413 ::std::result::Result::Ok(())
5414 }
5415
5416 fn get_cached_size(&self) -> u32 {
5417 self.cached_size.get()
5418 }
5419
5420 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5421 &self.unknown_fields
5422 }
5423
5424 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5425 &mut self.unknown_fields
5426 }
5427
5428 fn as_any(&self) -> &dyn (::std::any::Any) {
5429 self as &dyn (::std::any::Any)
5430 }
5431 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5432 self as &mut dyn (::std::any::Any)
5433 }
5434 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5435 self
5436 }
5437
5438 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5439 Self::descriptor_static()
5440 }
5441
5442 fn new() -> SendFromManyRequest {
5443 SendFromManyRequest::new()
5444 }
5445
5446 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5447 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
5448 lock: ::protobuf::lazy::ONCE_INIT,
5449 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
5450 };
5451 unsafe {
5452 descriptor.get(|| {
5453 let mut fields = ::std::vec::Vec::new();
5454 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
5455 "query",
5456 |m: &SendFromManyRequest| { &m.query },
5457 |m: &mut SendFromManyRequest| { &mut m.query },
5458 ));
5459 ::protobuf::reflect::MessageDescriptor::new::<SendFromManyRequest>(
5460 "SendFromManyRequest",
5461 fields,
5462 file_descriptor_proto()
5463 )
5464 })
5465 }
5466 }
5467
5468 fn default_instance() -> &'static SendFromManyRequest {
5469 static mut instance: ::protobuf::lazy::Lazy<SendFromManyRequest> = ::protobuf::lazy::Lazy {
5470 lock: ::protobuf::lazy::ONCE_INIT,
5471 ptr: 0 as *const SendFromManyRequest,
5472 };
5473 unsafe {
5474 instance.get(SendFromManyRequest::new)
5475 }
5476 }
5477}
5478
5479impl ::protobuf::Clear for SendFromManyRequest {
5480 fn clear(&mut self) {
5481 self.query = false;
5482 self.unknown_fields.clear();
5483 }
5484}
5485
5486impl ::std::fmt::Debug for SendFromManyRequest {
5487 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5488 ::protobuf::text_format::fmt(self, f)
5489 }
5490}
5491
5492impl ::protobuf::reflect::ProtobufValue for SendFromManyRequest {
5493 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
5494 ::protobuf::reflect::ProtobufValueRef::Message(self)
5495 }
5496}
5497
5498#[derive(PartialEq,Clone,Default)]
5499pub struct SendFromManyResponse {
5500 pub query: ::std::string::String,
5502 pub unknown_fields: ::protobuf::UnknownFields,
5504 pub cached_size: ::protobuf::CachedSize,
5505}
5506
5507impl<'a> ::std::default::Default for &'a SendFromManyResponse {
5508 fn default() -> &'a SendFromManyResponse {
5509 <SendFromManyResponse as ::protobuf::Message>::default_instance()
5510 }
5511}
5512
5513impl SendFromManyResponse {
5514 pub fn new() -> SendFromManyResponse {
5515 ::std::default::Default::default()
5516 }
5517
5518 pub fn get_query(&self) -> &str {
5522 &self.query
5523 }
5524 pub fn clear_query(&mut self) {
5525 self.query.clear();
5526 }
5527
5528 pub fn set_query(&mut self, v: ::std::string::String) {
5530 self.query = v;
5531 }
5532
5533 pub fn mut_query(&mut self) -> &mut ::std::string::String {
5536 &mut self.query
5537 }
5538
5539 pub fn take_query(&mut self) -> ::std::string::String {
5541 ::std::mem::replace(&mut self.query, ::std::string::String::new())
5542 }
5543}
5544
5545impl ::protobuf::Message for SendFromManyResponse {
5546 fn is_initialized(&self) -> bool {
5547 true
5548 }
5549
5550 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5551 while !is.eof()? {
5552 let (field_number, wire_type) = is.read_tag_unpack()?;
5553 match field_number {
5554 1 => {
5555 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
5556 },
5557 _ => {
5558 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5559 },
5560 };
5561 }
5562 ::std::result::Result::Ok(())
5563 }
5564
5565 #[allow(unused_variables)]
5567 fn compute_size(&self) -> u32 {
5568 let mut my_size = 0;
5569 if !self.query.is_empty() {
5570 my_size += ::protobuf::rt::string_size(1, &self.query);
5571 }
5572 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5573 self.cached_size.set(my_size);
5574 my_size
5575 }
5576
5577 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5578 if !self.query.is_empty() {
5579 os.write_string(1, &self.query)?;
5580 }
5581 os.write_unknown_fields(self.get_unknown_fields())?;
5582 ::std::result::Result::Ok(())
5583 }
5584
5585 fn get_cached_size(&self) -> u32 {
5586 self.cached_size.get()
5587 }
5588
5589 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5590 &self.unknown_fields
5591 }
5592
5593 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5594 &mut self.unknown_fields
5595 }
5596
5597 fn as_any(&self) -> &dyn (::std::any::Any) {
5598 self as &dyn (::std::any::Any)
5599 }
5600 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5601 self as &mut dyn (::std::any::Any)
5602 }
5603 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5604 self
5605 }
5606
5607 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5608 Self::descriptor_static()
5609 }
5610
5611 fn new() -> SendFromManyResponse {
5612 SendFromManyResponse::new()
5613 }
5614
5615 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5616 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
5617 lock: ::protobuf::lazy::ONCE_INIT,
5618 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
5619 };
5620 unsafe {
5621 descriptor.get(|| {
5622 let mut fields = ::std::vec::Vec::new();
5623 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
5624 "query",
5625 |m: &SendFromManyResponse| { &m.query },
5626 |m: &mut SendFromManyResponse| { &mut m.query },
5627 ));
5628 ::protobuf::reflect::MessageDescriptor::new::<SendFromManyResponse>(
5629 "SendFromManyResponse",
5630 fields,
5631 file_descriptor_proto()
5632 )
5633 })
5634 }
5635 }
5636
5637 fn default_instance() -> &'static SendFromManyResponse {
5638 static mut instance: ::protobuf::lazy::Lazy<SendFromManyResponse> = ::protobuf::lazy::Lazy {
5639 lock: ::protobuf::lazy::ONCE_INIT,
5640 ptr: 0 as *const SendFromManyResponse,
5641 };
5642 unsafe {
5643 instance.get(SendFromManyResponse::new)
5644 }
5645 }
5646}
5647
5648impl ::protobuf::Clear for SendFromManyResponse {
5649 fn clear(&mut self) {
5650 self.query.clear();
5651 self.unknown_fields.clear();
5652 }
5653}
5654
5655impl ::std::fmt::Debug for SendFromManyResponse {
5656 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5657 ::protobuf::text_format::fmt(self, f)
5658 }
5659}
5660
5661impl ::protobuf::reflect::ProtobufValue for SendFromManyResponse {
5662 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
5663 ::protobuf::reflect::ProtobufValueRef::Message(self)
5664 }
5665}
5666
5667#[derive(PartialEq,Clone,Default)]
5668pub struct AddNodeRequest {
5669 pub query: bool,
5671 pub unknown_fields: ::protobuf::UnknownFields,
5673 pub cached_size: ::protobuf::CachedSize,
5674}
5675
5676impl<'a> ::std::default::Default for &'a AddNodeRequest {
5677 fn default() -> &'a AddNodeRequest {
5678 <AddNodeRequest as ::protobuf::Message>::default_instance()
5679 }
5680}
5681
5682impl AddNodeRequest {
5683 pub fn new() -> AddNodeRequest {
5684 ::std::default::Default::default()
5685 }
5686
5687 pub fn get_query(&self) -> bool {
5691 self.query
5692 }
5693 pub fn clear_query(&mut self) {
5694 self.query = false;
5695 }
5696
5697 pub fn set_query(&mut self, v: bool) {
5699 self.query = v;
5700 }
5701}
5702
5703impl ::protobuf::Message for AddNodeRequest {
5704 fn is_initialized(&self) -> bool {
5705 true
5706 }
5707
5708 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5709 while !is.eof()? {
5710 let (field_number, wire_type) = is.read_tag_unpack()?;
5711 match field_number {
5712 1 => {
5713 if wire_type != ::protobuf::wire_format::WireTypeVarint {
5714 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
5715 }
5716 let tmp = is.read_bool()?;
5717 self.query = tmp;
5718 },
5719 _ => {
5720 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5721 },
5722 };
5723 }
5724 ::std::result::Result::Ok(())
5725 }
5726
5727 #[allow(unused_variables)]
5729 fn compute_size(&self) -> u32 {
5730 let mut my_size = 0;
5731 if self.query != false {
5732 my_size += 2;
5733 }
5734 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5735 self.cached_size.set(my_size);
5736 my_size
5737 }
5738
5739 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5740 if self.query != false {
5741 os.write_bool(1, self.query)?;
5742 }
5743 os.write_unknown_fields(self.get_unknown_fields())?;
5744 ::std::result::Result::Ok(())
5745 }
5746
5747 fn get_cached_size(&self) -> u32 {
5748 self.cached_size.get()
5749 }
5750
5751 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5752 &self.unknown_fields
5753 }
5754
5755 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5756 &mut self.unknown_fields
5757 }
5758
5759 fn as_any(&self) -> &dyn (::std::any::Any) {
5760 self as &dyn (::std::any::Any)
5761 }
5762 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5763 self as &mut dyn (::std::any::Any)
5764 }
5765 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5766 self
5767 }
5768
5769 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5770 Self::descriptor_static()
5771 }
5772
5773 fn new() -> AddNodeRequest {
5774 AddNodeRequest::new()
5775 }
5776
5777 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5778 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
5779 lock: ::protobuf::lazy::ONCE_INIT,
5780 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
5781 };
5782 unsafe {
5783 descriptor.get(|| {
5784 let mut fields = ::std::vec::Vec::new();
5785 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
5786 "query",
5787 |m: &AddNodeRequest| { &m.query },
5788 |m: &mut AddNodeRequest| { &mut m.query },
5789 ));
5790 ::protobuf::reflect::MessageDescriptor::new::<AddNodeRequest>(
5791 "AddNodeRequest",
5792 fields,
5793 file_descriptor_proto()
5794 )
5795 })
5796 }
5797 }
5798
5799 fn default_instance() -> &'static AddNodeRequest {
5800 static mut instance: ::protobuf::lazy::Lazy<AddNodeRequest> = ::protobuf::lazy::Lazy {
5801 lock: ::protobuf::lazy::ONCE_INIT,
5802 ptr: 0 as *const AddNodeRequest,
5803 };
5804 unsafe {
5805 instance.get(AddNodeRequest::new)
5806 }
5807 }
5808}
5809
5810impl ::protobuf::Clear for AddNodeRequest {
5811 fn clear(&mut self) {
5812 self.query = false;
5813 self.unknown_fields.clear();
5814 }
5815}
5816
5817impl ::std::fmt::Debug for AddNodeRequest {
5818 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5819 ::protobuf::text_format::fmt(self, f)
5820 }
5821}
5822
5823impl ::protobuf::reflect::ProtobufValue for AddNodeRequest {
5824 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
5825 ::protobuf::reflect::ProtobufValueRef::Message(self)
5826 }
5827}
5828
5829#[derive(PartialEq,Clone,Default)]
5830pub struct AddNodeResponse {
5831 pub query: ::std::string::String,
5833 pub unknown_fields: ::protobuf::UnknownFields,
5835 pub cached_size: ::protobuf::CachedSize,
5836}
5837
5838impl<'a> ::std::default::Default for &'a AddNodeResponse {
5839 fn default() -> &'a AddNodeResponse {
5840 <AddNodeResponse as ::protobuf::Message>::default_instance()
5841 }
5842}
5843
5844impl AddNodeResponse {
5845 pub fn new() -> AddNodeResponse {
5846 ::std::default::Default::default()
5847 }
5848
5849 pub fn get_query(&self) -> &str {
5853 &self.query
5854 }
5855 pub fn clear_query(&mut self) {
5856 self.query.clear();
5857 }
5858
5859 pub fn set_query(&mut self, v: ::std::string::String) {
5861 self.query = v;
5862 }
5863
5864 pub fn mut_query(&mut self) -> &mut ::std::string::String {
5867 &mut self.query
5868 }
5869
5870 pub fn take_query(&mut self) -> ::std::string::String {
5872 ::std::mem::replace(&mut self.query, ::std::string::String::new())
5873 }
5874}
5875
5876impl ::protobuf::Message for AddNodeResponse {
5877 fn is_initialized(&self) -> bool {
5878 true
5879 }
5880
5881 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5882 while !is.eof()? {
5883 let (field_number, wire_type) = is.read_tag_unpack()?;
5884 match field_number {
5885 1 => {
5886 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
5887 },
5888 _ => {
5889 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
5890 },
5891 };
5892 }
5893 ::std::result::Result::Ok(())
5894 }
5895
5896 #[allow(unused_variables)]
5898 fn compute_size(&self) -> u32 {
5899 let mut my_size = 0;
5900 if !self.query.is_empty() {
5901 my_size += ::protobuf::rt::string_size(1, &self.query);
5902 }
5903 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
5904 self.cached_size.set(my_size);
5905 my_size
5906 }
5907
5908 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
5909 if !self.query.is_empty() {
5910 os.write_string(1, &self.query)?;
5911 }
5912 os.write_unknown_fields(self.get_unknown_fields())?;
5913 ::std::result::Result::Ok(())
5914 }
5915
5916 fn get_cached_size(&self) -> u32 {
5917 self.cached_size.get()
5918 }
5919
5920 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
5921 &self.unknown_fields
5922 }
5923
5924 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
5925 &mut self.unknown_fields
5926 }
5927
5928 fn as_any(&self) -> &dyn (::std::any::Any) {
5929 self as &dyn (::std::any::Any)
5930 }
5931 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
5932 self as &mut dyn (::std::any::Any)
5933 }
5934 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
5935 self
5936 }
5937
5938 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
5939 Self::descriptor_static()
5940 }
5941
5942 fn new() -> AddNodeResponse {
5943 AddNodeResponse::new()
5944 }
5945
5946 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
5947 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
5948 lock: ::protobuf::lazy::ONCE_INIT,
5949 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
5950 };
5951 unsafe {
5952 descriptor.get(|| {
5953 let mut fields = ::std::vec::Vec::new();
5954 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
5955 "query",
5956 |m: &AddNodeResponse| { &m.query },
5957 |m: &mut AddNodeResponse| { &mut m.query },
5958 ));
5959 ::protobuf::reflect::MessageDescriptor::new::<AddNodeResponse>(
5960 "AddNodeResponse",
5961 fields,
5962 file_descriptor_proto()
5963 )
5964 })
5965 }
5966 }
5967
5968 fn default_instance() -> &'static AddNodeResponse {
5969 static mut instance: ::protobuf::lazy::Lazy<AddNodeResponse> = ::protobuf::lazy::Lazy {
5970 lock: ::protobuf::lazy::ONCE_INIT,
5971 ptr: 0 as *const AddNodeResponse,
5972 };
5973 unsafe {
5974 instance.get(AddNodeResponse::new)
5975 }
5976 }
5977}
5978
5979impl ::protobuf::Clear for AddNodeResponse {
5980 fn clear(&mut self) {
5981 self.query.clear();
5982 self.unknown_fields.clear();
5983 }
5984}
5985
5986impl ::std::fmt::Debug for AddNodeResponse {
5987 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5988 ::protobuf::text_format::fmt(self, f)
5989 }
5990}
5991
5992impl ::protobuf::reflect::ProtobufValue for AddNodeResponse {
5993 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
5994 ::protobuf::reflect::ProtobufValueRef::Message(self)
5995 }
5996}
5997
5998#[derive(PartialEq,Clone,Default)]
5999pub struct GetPeerListRequest {
6000 pub unknown_fields: ::protobuf::UnknownFields,
6002 pub cached_size: ::protobuf::CachedSize,
6003}
6004
6005impl<'a> ::std::default::Default for &'a GetPeerListRequest {
6006 fn default() -> &'a GetPeerListRequest {
6007 <GetPeerListRequest as ::protobuf::Message>::default_instance()
6008 }
6009}
6010
6011impl GetPeerListRequest {
6012 pub fn new() -> GetPeerListRequest {
6013 ::std::default::Default::default()
6014 }
6015}
6016
6017impl ::protobuf::Message for GetPeerListRequest {
6018 fn is_initialized(&self) -> bool {
6019 true
6020 }
6021
6022 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6023 while !is.eof()? {
6024 let (field_number, wire_type) = is.read_tag_unpack()?;
6025 match field_number {
6026 _ => {
6027 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
6028 },
6029 };
6030 }
6031 ::std::result::Result::Ok(())
6032 }
6033
6034 #[allow(unused_variables)]
6036 fn compute_size(&self) -> u32 {
6037 let mut my_size = 0;
6038 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
6039 self.cached_size.set(my_size);
6040 my_size
6041 }
6042
6043 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6044 os.write_unknown_fields(self.get_unknown_fields())?;
6045 ::std::result::Result::Ok(())
6046 }
6047
6048 fn get_cached_size(&self) -> u32 {
6049 self.cached_size.get()
6050 }
6051
6052 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
6053 &self.unknown_fields
6054 }
6055
6056 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
6057 &mut self.unknown_fields
6058 }
6059
6060 fn as_any(&self) -> &dyn (::std::any::Any) {
6061 self as &dyn (::std::any::Any)
6062 }
6063 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
6064 self as &mut dyn (::std::any::Any)
6065 }
6066 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
6067 self
6068 }
6069
6070 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
6071 Self::descriptor_static()
6072 }
6073
6074 fn new() -> GetPeerListRequest {
6075 GetPeerListRequest::new()
6076 }
6077
6078 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
6079 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
6080 lock: ::protobuf::lazy::ONCE_INIT,
6081 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
6082 };
6083 unsafe {
6084 descriptor.get(|| {
6085 let fields = ::std::vec::Vec::new();
6086 ::protobuf::reflect::MessageDescriptor::new::<GetPeerListRequest>(
6087 "GetPeerListRequest",
6088 fields,
6089 file_descriptor_proto()
6090 )
6091 })
6092 }
6093 }
6094
6095 fn default_instance() -> &'static GetPeerListRequest {
6096 static mut instance: ::protobuf::lazy::Lazy<GetPeerListRequest> = ::protobuf::lazy::Lazy {
6097 lock: ::protobuf::lazy::ONCE_INIT,
6098 ptr: 0 as *const GetPeerListRequest,
6099 };
6100 unsafe {
6101 instance.get(GetPeerListRequest::new)
6102 }
6103 }
6104}
6105
6106impl ::protobuf::Clear for GetPeerListRequest {
6107 fn clear(&mut self) {
6108 self.unknown_fields.clear();
6109 }
6110}
6111
6112impl ::std::fmt::Debug for GetPeerListRequest {
6113 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6114 ::protobuf::text_format::fmt(self, f)
6115 }
6116}
6117
6118impl ::protobuf::reflect::ProtobufValue for GetPeerListRequest {
6119 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
6120 ::protobuf::reflect::ProtobufValueRef::Message(self)
6121 }
6122}
6123
6124#[derive(PartialEq,Clone,Default)]
6125pub struct GetPeerListResponse {
6126 pub peers: ::protobuf::RepeatedField<super::Peer::PeerId>,
6128 pub unknown_fields: ::protobuf::UnknownFields,
6130 pub cached_size: ::protobuf::CachedSize,
6131}
6132
6133impl<'a> ::std::default::Default for &'a GetPeerListResponse {
6134 fn default() -> &'a GetPeerListResponse {
6135 <GetPeerListResponse as ::protobuf::Message>::default_instance()
6136 }
6137}
6138
6139impl GetPeerListResponse {
6140 pub fn new() -> GetPeerListResponse {
6141 ::std::default::Default::default()
6142 }
6143
6144 pub fn get_peers(&self) -> &[super::Peer::PeerId] {
6148 &self.peers
6149 }
6150 pub fn clear_peers(&mut self) {
6151 self.peers.clear();
6152 }
6153
6154 pub fn set_peers(&mut self, v: ::protobuf::RepeatedField<super::Peer::PeerId>) {
6156 self.peers = v;
6157 }
6158
6159 pub fn mut_peers(&mut self) -> &mut ::protobuf::RepeatedField<super::Peer::PeerId> {
6161 &mut self.peers
6162 }
6163
6164 pub fn take_peers(&mut self) -> ::protobuf::RepeatedField<super::Peer::PeerId> {
6166 ::std::mem::replace(&mut self.peers, ::protobuf::RepeatedField::new())
6167 }
6168}
6169
6170impl ::protobuf::Message for GetPeerListResponse {
6171 fn is_initialized(&self) -> bool {
6172 for v in &self.peers {
6173 if !v.is_initialized() {
6174 return false;
6175 }
6176 };
6177 true
6178 }
6179
6180 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6181 while !is.eof()? {
6182 let (field_number, wire_type) = is.read_tag_unpack()?;
6183 match field_number {
6184 1 => {
6185 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.peers)?;
6186 },
6187 _ => {
6188 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
6189 },
6190 };
6191 }
6192 ::std::result::Result::Ok(())
6193 }
6194
6195 #[allow(unused_variables)]
6197 fn compute_size(&self) -> u32 {
6198 let mut my_size = 0;
6199 for value in &self.peers {
6200 let len = value.compute_size();
6201 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
6202 };
6203 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
6204 self.cached_size.set(my_size);
6205 my_size
6206 }
6207
6208 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6209 for v in &self.peers {
6210 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
6211 os.write_raw_varint32(v.get_cached_size())?;
6212 v.write_to_with_cached_sizes(os)?;
6213 };
6214 os.write_unknown_fields(self.get_unknown_fields())?;
6215 ::std::result::Result::Ok(())
6216 }
6217
6218 fn get_cached_size(&self) -> u32 {
6219 self.cached_size.get()
6220 }
6221
6222 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
6223 &self.unknown_fields
6224 }
6225
6226 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
6227 &mut self.unknown_fields
6228 }
6229
6230 fn as_any(&self) -> &dyn (::std::any::Any) {
6231 self as &dyn (::std::any::Any)
6232 }
6233 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
6234 self as &mut dyn (::std::any::Any)
6235 }
6236 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
6237 self
6238 }
6239
6240 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
6241 Self::descriptor_static()
6242 }
6243
6244 fn new() -> GetPeerListResponse {
6245 GetPeerListResponse::new()
6246 }
6247
6248 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
6249 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
6250 lock: ::protobuf::lazy::ONCE_INIT,
6251 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
6252 };
6253 unsafe {
6254 descriptor.get(|| {
6255 let mut fields = ::std::vec::Vec::new();
6256 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::Peer::PeerId>>(
6257 "peers",
6258 |m: &GetPeerListResponse| { &m.peers },
6259 |m: &mut GetPeerListResponse| { &mut m.peers },
6260 ));
6261 ::protobuf::reflect::MessageDescriptor::new::<GetPeerListResponse>(
6262 "GetPeerListResponse",
6263 fields,
6264 file_descriptor_proto()
6265 )
6266 })
6267 }
6268 }
6269
6270 fn default_instance() -> &'static GetPeerListResponse {
6271 static mut instance: ::protobuf::lazy::Lazy<GetPeerListResponse> = ::protobuf::lazy::Lazy {
6272 lock: ::protobuf::lazy::ONCE_INIT,
6273 ptr: 0 as *const GetPeerListResponse,
6274 };
6275 unsafe {
6276 instance.get(GetPeerListResponse::new)
6277 }
6278 }
6279}
6280
6281impl ::protobuf::Clear for GetPeerListResponse {
6282 fn clear(&mut self) {
6283 self.peers.clear();
6284 self.unknown_fields.clear();
6285 }
6286}
6287
6288impl ::std::fmt::Debug for GetPeerListResponse {
6289 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6290 ::protobuf::text_format::fmt(self, f)
6291 }
6292}
6293
6294impl ::protobuf::reflect::ProtobufValue for GetPeerListResponse {
6295 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
6296 ::protobuf::reflect::ProtobufValueRef::Message(self)
6297 }
6298}
6299
6300#[derive(PartialEq,Clone,Default)]
6301pub struct GetPeerReputationRequest {
6302 pub public_key: ::std::vec::Vec<u8>,
6304 pub ip: ::std::vec::Vec<u8>,
6305 pub unknown_fields: ::protobuf::UnknownFields,
6307 pub cached_size: ::protobuf::CachedSize,
6308}
6309
6310impl<'a> ::std::default::Default for &'a GetPeerReputationRequest {
6311 fn default() -> &'a GetPeerReputationRequest {
6312 <GetPeerReputationRequest as ::protobuf::Message>::default_instance()
6313 }
6314}
6315
6316impl GetPeerReputationRequest {
6317 pub fn new() -> GetPeerReputationRequest {
6318 ::std::default::Default::default()
6319 }
6320
6321 pub fn get_public_key(&self) -> &[u8] {
6325 &self.public_key
6326 }
6327 pub fn clear_public_key(&mut self) {
6328 self.public_key.clear();
6329 }
6330
6331 pub fn set_public_key(&mut self, v: ::std::vec::Vec<u8>) {
6333 self.public_key = v;
6334 }
6335
6336 pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
6339 &mut self.public_key
6340 }
6341
6342 pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
6344 ::std::mem::replace(&mut self.public_key, ::std::vec::Vec::new())
6345 }
6346
6347 pub fn get_ip(&self) -> &[u8] {
6351 &self.ip
6352 }
6353 pub fn clear_ip(&mut self) {
6354 self.ip.clear();
6355 }
6356
6357 pub fn set_ip(&mut self, v: ::std::vec::Vec<u8>) {
6359 self.ip = v;
6360 }
6361
6362 pub fn mut_ip(&mut self) -> &mut ::std::vec::Vec<u8> {
6365 &mut self.ip
6366 }
6367
6368 pub fn take_ip(&mut self) -> ::std::vec::Vec<u8> {
6370 ::std::mem::replace(&mut self.ip, ::std::vec::Vec::new())
6371 }
6372}
6373
6374impl ::protobuf::Message for GetPeerReputationRequest {
6375 fn is_initialized(&self) -> bool {
6376 true
6377 }
6378
6379 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6380 while !is.eof()? {
6381 let (field_number, wire_type) = is.read_tag_unpack()?;
6382 match field_number {
6383 1 => {
6384 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.public_key)?;
6385 },
6386 2 => {
6387 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.ip)?;
6388 },
6389 _ => {
6390 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
6391 },
6392 };
6393 }
6394 ::std::result::Result::Ok(())
6395 }
6396
6397 #[allow(unused_variables)]
6399 fn compute_size(&self) -> u32 {
6400 let mut my_size = 0;
6401 if !self.public_key.is_empty() {
6402 my_size += ::protobuf::rt::bytes_size(1, &self.public_key);
6403 }
6404 if !self.ip.is_empty() {
6405 my_size += ::protobuf::rt::bytes_size(2, &self.ip);
6406 }
6407 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
6408 self.cached_size.set(my_size);
6409 my_size
6410 }
6411
6412 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6413 if !self.public_key.is_empty() {
6414 os.write_bytes(1, &self.public_key)?;
6415 }
6416 if !self.ip.is_empty() {
6417 os.write_bytes(2, &self.ip)?;
6418 }
6419 os.write_unknown_fields(self.get_unknown_fields())?;
6420 ::std::result::Result::Ok(())
6421 }
6422
6423 fn get_cached_size(&self) -> u32 {
6424 self.cached_size.get()
6425 }
6426
6427 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
6428 &self.unknown_fields
6429 }
6430
6431 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
6432 &mut self.unknown_fields
6433 }
6434
6435 fn as_any(&self) -> &dyn (::std::any::Any) {
6436 self as &dyn (::std::any::Any)
6437 }
6438 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
6439 self as &mut dyn (::std::any::Any)
6440 }
6441 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
6442 self
6443 }
6444
6445 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
6446 Self::descriptor_static()
6447 }
6448
6449 fn new() -> GetPeerReputationRequest {
6450 GetPeerReputationRequest::new()
6451 }
6452
6453 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
6454 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
6455 lock: ::protobuf::lazy::ONCE_INIT,
6456 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
6457 };
6458 unsafe {
6459 descriptor.get(|| {
6460 let mut fields = ::std::vec::Vec::new();
6461 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
6462 "public_key",
6463 |m: &GetPeerReputationRequest| { &m.public_key },
6464 |m: &mut GetPeerReputationRequest| { &mut m.public_key },
6465 ));
6466 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
6467 "ip",
6468 |m: &GetPeerReputationRequest| { &m.ip },
6469 |m: &mut GetPeerReputationRequest| { &mut m.ip },
6470 ));
6471 ::protobuf::reflect::MessageDescriptor::new::<GetPeerReputationRequest>(
6472 "GetPeerReputationRequest",
6473 fields,
6474 file_descriptor_proto()
6475 )
6476 })
6477 }
6478 }
6479
6480 fn default_instance() -> &'static GetPeerReputationRequest {
6481 static mut instance: ::protobuf::lazy::Lazy<GetPeerReputationRequest> = ::protobuf::lazy::Lazy {
6482 lock: ::protobuf::lazy::ONCE_INIT,
6483 ptr: 0 as *const GetPeerReputationRequest,
6484 };
6485 unsafe {
6486 instance.get(GetPeerReputationRequest::new)
6487 }
6488 }
6489}
6490
6491impl ::protobuf::Clear for GetPeerReputationRequest {
6492 fn clear(&mut self) {
6493 self.public_key.clear();
6494 self.ip.clear();
6495 self.unknown_fields.clear();
6496 }
6497}
6498
6499impl ::std::fmt::Debug for GetPeerReputationRequest {
6500 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6501 ::protobuf::text_format::fmt(self, f)
6502 }
6503}
6504
6505impl ::protobuf::reflect::ProtobufValue for GetPeerReputationRequest {
6506 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
6507 ::protobuf::reflect::ProtobufValueRef::Message(self)
6508 }
6509}
6510
6511#[derive(PartialEq,Clone,Default)]
6512pub struct GetPeerReputationResponse {
6513 pub reputation: i32,
6515 pub unknown_fields: ::protobuf::UnknownFields,
6517 pub cached_size: ::protobuf::CachedSize,
6518}
6519
6520impl<'a> ::std::default::Default for &'a GetPeerReputationResponse {
6521 fn default() -> &'a GetPeerReputationResponse {
6522 <GetPeerReputationResponse as ::protobuf::Message>::default_instance()
6523 }
6524}
6525
6526impl GetPeerReputationResponse {
6527 pub fn new() -> GetPeerReputationResponse {
6528 ::std::default::Default::default()
6529 }
6530
6531 pub fn get_reputation(&self) -> i32 {
6535 self.reputation
6536 }
6537 pub fn clear_reputation(&mut self) {
6538 self.reputation = 0;
6539 }
6540
6541 pub fn set_reputation(&mut self, v: i32) {
6543 self.reputation = v;
6544 }
6545}
6546
6547impl ::protobuf::Message for GetPeerReputationResponse {
6548 fn is_initialized(&self) -> bool {
6549 true
6550 }
6551
6552 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6553 while !is.eof()? {
6554 let (field_number, wire_type) = is.read_tag_unpack()?;
6555 match field_number {
6556 1 => {
6557 if wire_type != ::protobuf::wire_format::WireTypeVarint {
6558 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
6559 }
6560 let tmp = is.read_int32()?;
6561 self.reputation = tmp;
6562 },
6563 _ => {
6564 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
6565 },
6566 };
6567 }
6568 ::std::result::Result::Ok(())
6569 }
6570
6571 #[allow(unused_variables)]
6573 fn compute_size(&self) -> u32 {
6574 let mut my_size = 0;
6575 if self.reputation != 0 {
6576 my_size += ::protobuf::rt::value_size(1, self.reputation, ::protobuf::wire_format::WireTypeVarint);
6577 }
6578 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
6579 self.cached_size.set(my_size);
6580 my_size
6581 }
6582
6583 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6584 if self.reputation != 0 {
6585 os.write_int32(1, self.reputation)?;
6586 }
6587 os.write_unknown_fields(self.get_unknown_fields())?;
6588 ::std::result::Result::Ok(())
6589 }
6590
6591 fn get_cached_size(&self) -> u32 {
6592 self.cached_size.get()
6593 }
6594
6595 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
6596 &self.unknown_fields
6597 }
6598
6599 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
6600 &mut self.unknown_fields
6601 }
6602
6603 fn as_any(&self) -> &dyn (::std::any::Any) {
6604 self as &dyn (::std::any::Any)
6605 }
6606 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
6607 self as &mut dyn (::std::any::Any)
6608 }
6609 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
6610 self
6611 }
6612
6613 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
6614 Self::descriptor_static()
6615 }
6616
6617 fn new() -> GetPeerReputationResponse {
6618 GetPeerReputationResponse::new()
6619 }
6620
6621 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
6622 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
6623 lock: ::protobuf::lazy::ONCE_INIT,
6624 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
6625 };
6626 unsafe {
6627 descriptor.get(|| {
6628 let mut fields = ::std::vec::Vec::new();
6629 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
6630 "reputation",
6631 |m: &GetPeerReputationResponse| { &m.reputation },
6632 |m: &mut GetPeerReputationResponse| { &mut m.reputation },
6633 ));
6634 ::protobuf::reflect::MessageDescriptor::new::<GetPeerReputationResponse>(
6635 "GetPeerReputationResponse",
6636 fields,
6637 file_descriptor_proto()
6638 )
6639 })
6640 }
6641 }
6642
6643 fn default_instance() -> &'static GetPeerReputationResponse {
6644 static mut instance: ::protobuf::lazy::Lazy<GetPeerReputationResponse> = ::protobuf::lazy::Lazy {
6645 lock: ::protobuf::lazy::ONCE_INIT,
6646 ptr: 0 as *const GetPeerReputationResponse,
6647 };
6648 unsafe {
6649 instance.get(GetPeerReputationResponse::new)
6650 }
6651 }
6652}
6653
6654impl ::protobuf::Clear for GetPeerReputationResponse {
6655 fn clear(&mut self) {
6656 self.reputation = 0;
6657 self.unknown_fields.clear();
6658 }
6659}
6660
6661impl ::std::fmt::Debug for GetPeerReputationResponse {
6662 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6663 ::protobuf::text_format::fmt(self, f)
6664 }
6665}
6666
6667impl ::protobuf::reflect::ProtobufValue for GetPeerReputationResponse {
6668 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
6669 ::protobuf::reflect::ProtobufValueRef::Message(self)
6670 }
6671}
6672
6673#[derive(PartialEq,Clone,Default)]
6674pub struct SetPeerBlacklistRequest {
6675 pub public_key: ::std::vec::Vec<u8>,
6677 pub ip: ::std::vec::Vec<u8>,
6678 pub blacklist: bool,
6679 pub unknown_fields: ::protobuf::UnknownFields,
6681 pub cached_size: ::protobuf::CachedSize,
6682}
6683
6684impl<'a> ::std::default::Default for &'a SetPeerBlacklistRequest {
6685 fn default() -> &'a SetPeerBlacklistRequest {
6686 <SetPeerBlacklistRequest as ::protobuf::Message>::default_instance()
6687 }
6688}
6689
6690impl SetPeerBlacklistRequest {
6691 pub fn new() -> SetPeerBlacklistRequest {
6692 ::std::default::Default::default()
6693 }
6694
6695 pub fn get_public_key(&self) -> &[u8] {
6699 &self.public_key
6700 }
6701 pub fn clear_public_key(&mut self) {
6702 self.public_key.clear();
6703 }
6704
6705 pub fn set_public_key(&mut self, v: ::std::vec::Vec<u8>) {
6707 self.public_key = v;
6708 }
6709
6710 pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
6713 &mut self.public_key
6714 }
6715
6716 pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
6718 ::std::mem::replace(&mut self.public_key, ::std::vec::Vec::new())
6719 }
6720
6721 pub fn get_ip(&self) -> &[u8] {
6725 &self.ip
6726 }
6727 pub fn clear_ip(&mut self) {
6728 self.ip.clear();
6729 }
6730
6731 pub fn set_ip(&mut self, v: ::std::vec::Vec<u8>) {
6733 self.ip = v;
6734 }
6735
6736 pub fn mut_ip(&mut self) -> &mut ::std::vec::Vec<u8> {
6739 &mut self.ip
6740 }
6741
6742 pub fn take_ip(&mut self) -> ::std::vec::Vec<u8> {
6744 ::std::mem::replace(&mut self.ip, ::std::vec::Vec::new())
6745 }
6746
6747 pub fn get_blacklist(&self) -> bool {
6751 self.blacklist
6752 }
6753 pub fn clear_blacklist(&mut self) {
6754 self.blacklist = false;
6755 }
6756
6757 pub fn set_blacklist(&mut self, v: bool) {
6759 self.blacklist = v;
6760 }
6761}
6762
6763impl ::protobuf::Message for SetPeerBlacklistRequest {
6764 fn is_initialized(&self) -> bool {
6765 true
6766 }
6767
6768 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6769 while !is.eof()? {
6770 let (field_number, wire_type) = is.read_tag_unpack()?;
6771 match field_number {
6772 1 => {
6773 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.public_key)?;
6774 },
6775 2 => {
6776 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.ip)?;
6777 },
6778 3 => {
6779 if wire_type != ::protobuf::wire_format::WireTypeVarint {
6780 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
6781 }
6782 let tmp = is.read_bool()?;
6783 self.blacklist = tmp;
6784 },
6785 _ => {
6786 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
6787 },
6788 };
6789 }
6790 ::std::result::Result::Ok(())
6791 }
6792
6793 #[allow(unused_variables)]
6795 fn compute_size(&self) -> u32 {
6796 let mut my_size = 0;
6797 if !self.public_key.is_empty() {
6798 my_size += ::protobuf::rt::bytes_size(1, &self.public_key);
6799 }
6800 if !self.ip.is_empty() {
6801 my_size += ::protobuf::rt::bytes_size(2, &self.ip);
6802 }
6803 if self.blacklist != false {
6804 my_size += 2;
6805 }
6806 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
6807 self.cached_size.set(my_size);
6808 my_size
6809 }
6810
6811 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
6812 if !self.public_key.is_empty() {
6813 os.write_bytes(1, &self.public_key)?;
6814 }
6815 if !self.ip.is_empty() {
6816 os.write_bytes(2, &self.ip)?;
6817 }
6818 if self.blacklist != false {
6819 os.write_bool(3, self.blacklist)?;
6820 }
6821 os.write_unknown_fields(self.get_unknown_fields())?;
6822 ::std::result::Result::Ok(())
6823 }
6824
6825 fn get_cached_size(&self) -> u32 {
6826 self.cached_size.get()
6827 }
6828
6829 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
6830 &self.unknown_fields
6831 }
6832
6833 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
6834 &mut self.unknown_fields
6835 }
6836
6837 fn as_any(&self) -> &dyn (::std::any::Any) {
6838 self as &dyn (::std::any::Any)
6839 }
6840 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
6841 self as &mut dyn (::std::any::Any)
6842 }
6843 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
6844 self
6845 }
6846
6847 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
6848 Self::descriptor_static()
6849 }
6850
6851 fn new() -> SetPeerBlacklistRequest {
6852 SetPeerBlacklistRequest::new()
6853 }
6854
6855 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
6856 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
6857 lock: ::protobuf::lazy::ONCE_INIT,
6858 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
6859 };
6860 unsafe {
6861 descriptor.get(|| {
6862 let mut fields = ::std::vec::Vec::new();
6863 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
6864 "public_key",
6865 |m: &SetPeerBlacklistRequest| { &m.public_key },
6866 |m: &mut SetPeerBlacklistRequest| { &mut m.public_key },
6867 ));
6868 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
6869 "ip",
6870 |m: &SetPeerBlacklistRequest| { &m.ip },
6871 |m: &mut SetPeerBlacklistRequest| { &mut m.ip },
6872 ));
6873 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
6874 "blacklist",
6875 |m: &SetPeerBlacklistRequest| { &m.blacklist },
6876 |m: &mut SetPeerBlacklistRequest| { &mut m.blacklist },
6877 ));
6878 ::protobuf::reflect::MessageDescriptor::new::<SetPeerBlacklistRequest>(
6879 "SetPeerBlacklistRequest",
6880 fields,
6881 file_descriptor_proto()
6882 )
6883 })
6884 }
6885 }
6886
6887 fn default_instance() -> &'static SetPeerBlacklistRequest {
6888 static mut instance: ::protobuf::lazy::Lazy<SetPeerBlacklistRequest> = ::protobuf::lazy::Lazy {
6889 lock: ::protobuf::lazy::ONCE_INIT,
6890 ptr: 0 as *const SetPeerBlacklistRequest,
6891 };
6892 unsafe {
6893 instance.get(SetPeerBlacklistRequest::new)
6894 }
6895 }
6896}
6897
6898impl ::protobuf::Clear for SetPeerBlacklistRequest {
6899 fn clear(&mut self) {
6900 self.public_key.clear();
6901 self.ip.clear();
6902 self.blacklist = false;
6903 self.unknown_fields.clear();
6904 }
6905}
6906
6907impl ::std::fmt::Debug for SetPeerBlacklistRequest {
6908 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6909 ::protobuf::text_format::fmt(self, f)
6910 }
6911}
6912
6913impl ::protobuf::reflect::ProtobufValue for SetPeerBlacklistRequest {
6914 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
6915 ::protobuf::reflect::ProtobufValueRef::Message(self)
6916 }
6917}
6918
6919#[derive(PartialEq,Clone,Default)]
6920pub struct SetPeerBlacklistResponse {
6921 pub public_key: ::std::vec::Vec<u8>,
6923 pub ip: ::std::vec::Vec<u8>,
6924 pub blacklist: bool,
6925 pub unknown_fields: ::protobuf::UnknownFields,
6927 pub cached_size: ::protobuf::CachedSize,
6928}
6929
6930impl<'a> ::std::default::Default for &'a SetPeerBlacklistResponse {
6931 fn default() -> &'a SetPeerBlacklistResponse {
6932 <SetPeerBlacklistResponse as ::protobuf::Message>::default_instance()
6933 }
6934}
6935
6936impl SetPeerBlacklistResponse {
6937 pub fn new() -> SetPeerBlacklistResponse {
6938 ::std::default::Default::default()
6939 }
6940
6941 pub fn get_public_key(&self) -> &[u8] {
6945 &self.public_key
6946 }
6947 pub fn clear_public_key(&mut self) {
6948 self.public_key.clear();
6949 }
6950
6951 pub fn set_public_key(&mut self, v: ::std::vec::Vec<u8>) {
6953 self.public_key = v;
6954 }
6955
6956 pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
6959 &mut self.public_key
6960 }
6961
6962 pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
6964 ::std::mem::replace(&mut self.public_key, ::std::vec::Vec::new())
6965 }
6966
6967 pub fn get_ip(&self) -> &[u8] {
6971 &self.ip
6972 }
6973 pub fn clear_ip(&mut self) {
6974 self.ip.clear();
6975 }
6976
6977 pub fn set_ip(&mut self, v: ::std::vec::Vec<u8>) {
6979 self.ip = v;
6980 }
6981
6982 pub fn mut_ip(&mut self) -> &mut ::std::vec::Vec<u8> {
6985 &mut self.ip
6986 }
6987
6988 pub fn take_ip(&mut self) -> ::std::vec::Vec<u8> {
6990 ::std::mem::replace(&mut self.ip, ::std::vec::Vec::new())
6991 }
6992
6993 pub fn get_blacklist(&self) -> bool {
6997 self.blacklist
6998 }
6999 pub fn clear_blacklist(&mut self) {
7000 self.blacklist = false;
7001 }
7002
7003 pub fn set_blacklist(&mut self, v: bool) {
7005 self.blacklist = v;
7006 }
7007}
7008
7009impl ::protobuf::Message for SetPeerBlacklistResponse {
7010 fn is_initialized(&self) -> bool {
7011 true
7012 }
7013
7014 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7015 while !is.eof()? {
7016 let (field_number, wire_type) = is.read_tag_unpack()?;
7017 match field_number {
7018 1 => {
7019 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.public_key)?;
7020 },
7021 2 => {
7022 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.ip)?;
7023 },
7024 3 => {
7025 if wire_type != ::protobuf::wire_format::WireTypeVarint {
7026 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
7027 }
7028 let tmp = is.read_bool()?;
7029 self.blacklist = tmp;
7030 },
7031 _ => {
7032 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
7033 },
7034 };
7035 }
7036 ::std::result::Result::Ok(())
7037 }
7038
7039 #[allow(unused_variables)]
7041 fn compute_size(&self) -> u32 {
7042 let mut my_size = 0;
7043 if !self.public_key.is_empty() {
7044 my_size += ::protobuf::rt::bytes_size(1, &self.public_key);
7045 }
7046 if !self.ip.is_empty() {
7047 my_size += ::protobuf::rt::bytes_size(2, &self.ip);
7048 }
7049 if self.blacklist != false {
7050 my_size += 2;
7051 }
7052 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
7053 self.cached_size.set(my_size);
7054 my_size
7055 }
7056
7057 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7058 if !self.public_key.is_empty() {
7059 os.write_bytes(1, &self.public_key)?;
7060 }
7061 if !self.ip.is_empty() {
7062 os.write_bytes(2, &self.ip)?;
7063 }
7064 if self.blacklist != false {
7065 os.write_bool(3, self.blacklist)?;
7066 }
7067 os.write_unknown_fields(self.get_unknown_fields())?;
7068 ::std::result::Result::Ok(())
7069 }
7070
7071 fn get_cached_size(&self) -> u32 {
7072 self.cached_size.get()
7073 }
7074
7075 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
7076 &self.unknown_fields
7077 }
7078
7079 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
7080 &mut self.unknown_fields
7081 }
7082
7083 fn as_any(&self) -> &dyn (::std::any::Any) {
7084 self as &dyn (::std::any::Any)
7085 }
7086 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
7087 self as &mut dyn (::std::any::Any)
7088 }
7089 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
7090 self
7091 }
7092
7093 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
7094 Self::descriptor_static()
7095 }
7096
7097 fn new() -> SetPeerBlacklistResponse {
7098 SetPeerBlacklistResponse::new()
7099 }
7100
7101 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
7102 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
7103 lock: ::protobuf::lazy::ONCE_INIT,
7104 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
7105 };
7106 unsafe {
7107 descriptor.get(|| {
7108 let mut fields = ::std::vec::Vec::new();
7109 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
7110 "public_key",
7111 |m: &SetPeerBlacklistResponse| { &m.public_key },
7112 |m: &mut SetPeerBlacklistResponse| { &mut m.public_key },
7113 ));
7114 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
7115 "ip",
7116 |m: &SetPeerBlacklistResponse| { &m.ip },
7117 |m: &mut SetPeerBlacklistResponse| { &mut m.ip },
7118 ));
7119 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
7120 "blacklist",
7121 |m: &SetPeerBlacklistResponse| { &m.blacklist },
7122 |m: &mut SetPeerBlacklistResponse| { &mut m.blacklist },
7123 ));
7124 ::protobuf::reflect::MessageDescriptor::new::<SetPeerBlacklistResponse>(
7125 "SetPeerBlacklistResponse",
7126 fields,
7127 file_descriptor_proto()
7128 )
7129 })
7130 }
7131 }
7132
7133 fn default_instance() -> &'static SetPeerBlacklistResponse {
7134 static mut instance: ::protobuf::lazy::Lazy<SetPeerBlacklistResponse> = ::protobuf::lazy::Lazy {
7135 lock: ::protobuf::lazy::ONCE_INIT,
7136 ptr: 0 as *const SetPeerBlacklistResponse,
7137 };
7138 unsafe {
7139 instance.get(SetPeerBlacklistResponse::new)
7140 }
7141 }
7142}
7143
7144impl ::protobuf::Clear for SetPeerBlacklistResponse {
7145 fn clear(&mut self) {
7146 self.public_key.clear();
7147 self.ip.clear();
7148 self.blacklist = false;
7149 self.unknown_fields.clear();
7150 }
7151}
7152
7153impl ::std::fmt::Debug for SetPeerBlacklistResponse {
7154 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7155 ::protobuf::text_format::fmt(self, f)
7156 }
7157}
7158
7159impl ::protobuf::reflect::ProtobufValue for SetPeerBlacklistResponse {
7160 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
7161 ::protobuf::reflect::ProtobufValueRef::Message(self)
7162 }
7163}
7164
7165#[derive(PartialEq,Clone,Default)]
7166pub struct GetPeerInfoRequest {
7167 pub public_key: ::std::vec::Vec<u8>,
7169 pub ip: ::std::vec::Vec<u8>,
7170 pub unknown_fields: ::protobuf::UnknownFields,
7172 pub cached_size: ::protobuf::CachedSize,
7173}
7174
7175impl<'a> ::std::default::Default for &'a GetPeerInfoRequest {
7176 fn default() -> &'a GetPeerInfoRequest {
7177 <GetPeerInfoRequest as ::protobuf::Message>::default_instance()
7178 }
7179}
7180
7181impl GetPeerInfoRequest {
7182 pub fn new() -> GetPeerInfoRequest {
7183 ::std::default::Default::default()
7184 }
7185
7186 pub fn get_public_key(&self) -> &[u8] {
7190 &self.public_key
7191 }
7192 pub fn clear_public_key(&mut self) {
7193 self.public_key.clear();
7194 }
7195
7196 pub fn set_public_key(&mut self, v: ::std::vec::Vec<u8>) {
7198 self.public_key = v;
7199 }
7200
7201 pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
7204 &mut self.public_key
7205 }
7206
7207 pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
7209 ::std::mem::replace(&mut self.public_key, ::std::vec::Vec::new())
7210 }
7211
7212 pub fn get_ip(&self) -> &[u8] {
7216 &self.ip
7217 }
7218 pub fn clear_ip(&mut self) {
7219 self.ip.clear();
7220 }
7221
7222 pub fn set_ip(&mut self, v: ::std::vec::Vec<u8>) {
7224 self.ip = v;
7225 }
7226
7227 pub fn mut_ip(&mut self) -> &mut ::std::vec::Vec<u8> {
7230 &mut self.ip
7231 }
7232
7233 pub fn take_ip(&mut self) -> ::std::vec::Vec<u8> {
7235 ::std::mem::replace(&mut self.ip, ::std::vec::Vec::new())
7236 }
7237}
7238
7239impl ::protobuf::Message for GetPeerInfoRequest {
7240 fn is_initialized(&self) -> bool {
7241 true
7242 }
7243
7244 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7245 while !is.eof()? {
7246 let (field_number, wire_type) = is.read_tag_unpack()?;
7247 match field_number {
7248 1 => {
7249 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.public_key)?;
7250 },
7251 2 => {
7252 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.ip)?;
7253 },
7254 _ => {
7255 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
7256 },
7257 };
7258 }
7259 ::std::result::Result::Ok(())
7260 }
7261
7262 #[allow(unused_variables)]
7264 fn compute_size(&self) -> u32 {
7265 let mut my_size = 0;
7266 if !self.public_key.is_empty() {
7267 my_size += ::protobuf::rt::bytes_size(1, &self.public_key);
7268 }
7269 if !self.ip.is_empty() {
7270 my_size += ::protobuf::rt::bytes_size(2, &self.ip);
7271 }
7272 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
7273 self.cached_size.set(my_size);
7274 my_size
7275 }
7276
7277 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7278 if !self.public_key.is_empty() {
7279 os.write_bytes(1, &self.public_key)?;
7280 }
7281 if !self.ip.is_empty() {
7282 os.write_bytes(2, &self.ip)?;
7283 }
7284 os.write_unknown_fields(self.get_unknown_fields())?;
7285 ::std::result::Result::Ok(())
7286 }
7287
7288 fn get_cached_size(&self) -> u32 {
7289 self.cached_size.get()
7290 }
7291
7292 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
7293 &self.unknown_fields
7294 }
7295
7296 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
7297 &mut self.unknown_fields
7298 }
7299
7300 fn as_any(&self) -> &dyn (::std::any::Any) {
7301 self as &dyn (::std::any::Any)
7302 }
7303 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
7304 self as &mut dyn (::std::any::Any)
7305 }
7306 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
7307 self
7308 }
7309
7310 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
7311 Self::descriptor_static()
7312 }
7313
7314 fn new() -> GetPeerInfoRequest {
7315 GetPeerInfoRequest::new()
7316 }
7317
7318 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
7319 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
7320 lock: ::protobuf::lazy::ONCE_INIT,
7321 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
7322 };
7323 unsafe {
7324 descriptor.get(|| {
7325 let mut fields = ::std::vec::Vec::new();
7326 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
7327 "public_key",
7328 |m: &GetPeerInfoRequest| { &m.public_key },
7329 |m: &mut GetPeerInfoRequest| { &mut m.public_key },
7330 ));
7331 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
7332 "ip",
7333 |m: &GetPeerInfoRequest| { &m.ip },
7334 |m: &mut GetPeerInfoRequest| { &mut m.ip },
7335 ));
7336 ::protobuf::reflect::MessageDescriptor::new::<GetPeerInfoRequest>(
7337 "GetPeerInfoRequest",
7338 fields,
7339 file_descriptor_proto()
7340 )
7341 })
7342 }
7343 }
7344
7345 fn default_instance() -> &'static GetPeerInfoRequest {
7346 static mut instance: ::protobuf::lazy::Lazy<GetPeerInfoRequest> = ::protobuf::lazy::Lazy {
7347 lock: ::protobuf::lazy::ONCE_INIT,
7348 ptr: 0 as *const GetPeerInfoRequest,
7349 };
7350 unsafe {
7351 instance.get(GetPeerInfoRequest::new)
7352 }
7353 }
7354}
7355
7356impl ::protobuf::Clear for GetPeerInfoRequest {
7357 fn clear(&mut self) {
7358 self.public_key.clear();
7359 self.ip.clear();
7360 self.unknown_fields.clear();
7361 }
7362}
7363
7364impl ::std::fmt::Debug for GetPeerInfoRequest {
7365 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7366 ::protobuf::text_format::fmt(self, f)
7367 }
7368}
7369
7370impl ::protobuf::reflect::ProtobufValue for GetPeerInfoRequest {
7371 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
7372 ::protobuf::reflect::ProtobufValueRef::Message(self)
7373 }
7374}
7375
7376#[derive(PartialEq,Clone,Default)]
7377pub struct GetPeerInfoResponse {
7378 pub peer_info: ::protobuf::RepeatedField<super::Peer::PeerInfo>,
7380 pub unknown_fields: ::protobuf::UnknownFields,
7382 pub cached_size: ::protobuf::CachedSize,
7383}
7384
7385impl<'a> ::std::default::Default for &'a GetPeerInfoResponse {
7386 fn default() -> &'a GetPeerInfoResponse {
7387 <GetPeerInfoResponse as ::protobuf::Message>::default_instance()
7388 }
7389}
7390
7391impl GetPeerInfoResponse {
7392 pub fn new() -> GetPeerInfoResponse {
7393 ::std::default::Default::default()
7394 }
7395
7396 pub fn get_peer_info(&self) -> &[super::Peer::PeerInfo] {
7400 &self.peer_info
7401 }
7402 pub fn clear_peer_info(&mut self) {
7403 self.peer_info.clear();
7404 }
7405
7406 pub fn set_peer_info(&mut self, v: ::protobuf::RepeatedField<super::Peer::PeerInfo>) {
7408 self.peer_info = v;
7409 }
7410
7411 pub fn mut_peer_info(&mut self) -> &mut ::protobuf::RepeatedField<super::Peer::PeerInfo> {
7413 &mut self.peer_info
7414 }
7415
7416 pub fn take_peer_info(&mut self) -> ::protobuf::RepeatedField<super::Peer::PeerInfo> {
7418 ::std::mem::replace(&mut self.peer_info, ::protobuf::RepeatedField::new())
7419 }
7420}
7421
7422impl ::protobuf::Message for GetPeerInfoResponse {
7423 fn is_initialized(&self) -> bool {
7424 for v in &self.peer_info {
7425 if !v.is_initialized() {
7426 return false;
7427 }
7428 };
7429 true
7430 }
7431
7432 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7433 while !is.eof()? {
7434 let (field_number, wire_type) = is.read_tag_unpack()?;
7435 match field_number {
7436 1 => {
7437 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.peer_info)?;
7438 },
7439 _ => {
7440 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
7441 },
7442 };
7443 }
7444 ::std::result::Result::Ok(())
7445 }
7446
7447 #[allow(unused_variables)]
7449 fn compute_size(&self) -> u32 {
7450 let mut my_size = 0;
7451 for value in &self.peer_info {
7452 let len = value.compute_size();
7453 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
7454 };
7455 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
7456 self.cached_size.set(my_size);
7457 my_size
7458 }
7459
7460 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7461 for v in &self.peer_info {
7462 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
7463 os.write_raw_varint32(v.get_cached_size())?;
7464 v.write_to_with_cached_sizes(os)?;
7465 };
7466 os.write_unknown_fields(self.get_unknown_fields())?;
7467 ::std::result::Result::Ok(())
7468 }
7469
7470 fn get_cached_size(&self) -> u32 {
7471 self.cached_size.get()
7472 }
7473
7474 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
7475 &self.unknown_fields
7476 }
7477
7478 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
7479 &mut self.unknown_fields
7480 }
7481
7482 fn as_any(&self) -> &dyn (::std::any::Any) {
7483 self as &dyn (::std::any::Any)
7484 }
7485 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
7486 self as &mut dyn (::std::any::Any)
7487 }
7488 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
7489 self
7490 }
7491
7492 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
7493 Self::descriptor_static()
7494 }
7495
7496 fn new() -> GetPeerInfoResponse {
7497 GetPeerInfoResponse::new()
7498 }
7499
7500 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
7501 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
7502 lock: ::protobuf::lazy::ONCE_INIT,
7503 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
7504 };
7505 unsafe {
7506 descriptor.get(|| {
7507 let mut fields = ::std::vec::Vec::new();
7508 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::Peer::PeerInfo>>(
7509 "peer_info",
7510 |m: &GetPeerInfoResponse| { &m.peer_info },
7511 |m: &mut GetPeerInfoResponse| { &mut m.peer_info },
7512 ));
7513 ::protobuf::reflect::MessageDescriptor::new::<GetPeerInfoResponse>(
7514 "GetPeerInfoResponse",
7515 fields,
7516 file_descriptor_proto()
7517 )
7518 })
7519 }
7520 }
7521
7522 fn default_instance() -> &'static GetPeerInfoResponse {
7523 static mut instance: ::protobuf::lazy::Lazy<GetPeerInfoResponse> = ::protobuf::lazy::Lazy {
7524 lock: ::protobuf::lazy::ONCE_INIT,
7525 ptr: 0 as *const GetPeerInfoResponse,
7526 };
7527 unsafe {
7528 instance.get(GetPeerInfoResponse::new)
7529 }
7530 }
7531}
7532
7533impl ::protobuf::Clear for GetPeerInfoResponse {
7534 fn clear(&mut self) {
7535 self.peer_info.clear();
7536 self.unknown_fields.clear();
7537 }
7538}
7539
7540impl ::std::fmt::Debug for GetPeerInfoResponse {
7541 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7542 ::protobuf::text_format::fmt(self, f)
7543 }
7544}
7545
7546impl ::protobuf::reflect::ProtobufValue for GetPeerInfoResponse {
7547 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
7548 ::protobuf::reflect::ProtobufValueRef::Message(self)
7549 }
7550}
7551
7552#[derive(PartialEq,Clone,Default)]
7553pub struct GetConnectionCountRequest {
7554 pub query: bool,
7556 pub unknown_fields: ::protobuf::UnknownFields,
7558 pub cached_size: ::protobuf::CachedSize,
7559}
7560
7561impl<'a> ::std::default::Default for &'a GetConnectionCountRequest {
7562 fn default() -> &'a GetConnectionCountRequest {
7563 <GetConnectionCountRequest as ::protobuf::Message>::default_instance()
7564 }
7565}
7566
7567impl GetConnectionCountRequest {
7568 pub fn new() -> GetConnectionCountRequest {
7569 ::std::default::Default::default()
7570 }
7571
7572 pub fn get_query(&self) -> bool {
7576 self.query
7577 }
7578 pub fn clear_query(&mut self) {
7579 self.query = false;
7580 }
7581
7582 pub fn set_query(&mut self, v: bool) {
7584 self.query = v;
7585 }
7586}
7587
7588impl ::protobuf::Message for GetConnectionCountRequest {
7589 fn is_initialized(&self) -> bool {
7590 true
7591 }
7592
7593 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7594 while !is.eof()? {
7595 let (field_number, wire_type) = is.read_tag_unpack()?;
7596 match field_number {
7597 1 => {
7598 if wire_type != ::protobuf::wire_format::WireTypeVarint {
7599 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
7600 }
7601 let tmp = is.read_bool()?;
7602 self.query = tmp;
7603 },
7604 _ => {
7605 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
7606 },
7607 };
7608 }
7609 ::std::result::Result::Ok(())
7610 }
7611
7612 #[allow(unused_variables)]
7614 fn compute_size(&self) -> u32 {
7615 let mut my_size = 0;
7616 if self.query != false {
7617 my_size += 2;
7618 }
7619 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
7620 self.cached_size.set(my_size);
7621 my_size
7622 }
7623
7624 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7625 if self.query != false {
7626 os.write_bool(1, self.query)?;
7627 }
7628 os.write_unknown_fields(self.get_unknown_fields())?;
7629 ::std::result::Result::Ok(())
7630 }
7631
7632 fn get_cached_size(&self) -> u32 {
7633 self.cached_size.get()
7634 }
7635
7636 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
7637 &self.unknown_fields
7638 }
7639
7640 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
7641 &mut self.unknown_fields
7642 }
7643
7644 fn as_any(&self) -> &dyn (::std::any::Any) {
7645 self as &dyn (::std::any::Any)
7646 }
7647 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
7648 self as &mut dyn (::std::any::Any)
7649 }
7650 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
7651 self
7652 }
7653
7654 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
7655 Self::descriptor_static()
7656 }
7657
7658 fn new() -> GetConnectionCountRequest {
7659 GetConnectionCountRequest::new()
7660 }
7661
7662 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
7663 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
7664 lock: ::protobuf::lazy::ONCE_INIT,
7665 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
7666 };
7667 unsafe {
7668 descriptor.get(|| {
7669 let mut fields = ::std::vec::Vec::new();
7670 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
7671 "query",
7672 |m: &GetConnectionCountRequest| { &m.query },
7673 |m: &mut GetConnectionCountRequest| { &mut m.query },
7674 ));
7675 ::protobuf::reflect::MessageDescriptor::new::<GetConnectionCountRequest>(
7676 "GetConnectionCountRequest",
7677 fields,
7678 file_descriptor_proto()
7679 )
7680 })
7681 }
7682 }
7683
7684 fn default_instance() -> &'static GetConnectionCountRequest {
7685 static mut instance: ::protobuf::lazy::Lazy<GetConnectionCountRequest> = ::protobuf::lazy::Lazy {
7686 lock: ::protobuf::lazy::ONCE_INIT,
7687 ptr: 0 as *const GetConnectionCountRequest,
7688 };
7689 unsafe {
7690 instance.get(GetConnectionCountRequest::new)
7691 }
7692 }
7693}
7694
7695impl ::protobuf::Clear for GetConnectionCountRequest {
7696 fn clear(&mut self) {
7697 self.query = false;
7698 self.unknown_fields.clear();
7699 }
7700}
7701
7702impl ::std::fmt::Debug for GetConnectionCountRequest {
7703 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7704 ::protobuf::text_format::fmt(self, f)
7705 }
7706}
7707
7708impl ::protobuf::reflect::ProtobufValue for GetConnectionCountRequest {
7709 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
7710 ::protobuf::reflect::ProtobufValueRef::Message(self)
7711 }
7712}
7713
7714#[derive(PartialEq,Clone,Default)]
7715pub struct GetConnectionCountResponse {
7716 pub query: ::std::string::String,
7718 pub unknown_fields: ::protobuf::UnknownFields,
7720 pub cached_size: ::protobuf::CachedSize,
7721}
7722
7723impl<'a> ::std::default::Default for &'a GetConnectionCountResponse {
7724 fn default() -> &'a GetConnectionCountResponse {
7725 <GetConnectionCountResponse as ::protobuf::Message>::default_instance()
7726 }
7727}
7728
7729impl GetConnectionCountResponse {
7730 pub fn new() -> GetConnectionCountResponse {
7731 ::std::default::Default::default()
7732 }
7733
7734 pub fn get_query(&self) -> &str {
7738 &self.query
7739 }
7740 pub fn clear_query(&mut self) {
7741 self.query.clear();
7742 }
7743
7744 pub fn set_query(&mut self, v: ::std::string::String) {
7746 self.query = v;
7747 }
7748
7749 pub fn mut_query(&mut self) -> &mut ::std::string::String {
7752 &mut self.query
7753 }
7754
7755 pub fn take_query(&mut self) -> ::std::string::String {
7757 ::std::mem::replace(&mut self.query, ::std::string::String::new())
7758 }
7759}
7760
7761impl ::protobuf::Message for GetConnectionCountResponse {
7762 fn is_initialized(&self) -> bool {
7763 true
7764 }
7765
7766 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7767 while !is.eof()? {
7768 let (field_number, wire_type) = is.read_tag_unpack()?;
7769 match field_number {
7770 1 => {
7771 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
7772 },
7773 _ => {
7774 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
7775 },
7776 };
7777 }
7778 ::std::result::Result::Ok(())
7779 }
7780
7781 #[allow(unused_variables)]
7783 fn compute_size(&self) -> u32 {
7784 let mut my_size = 0;
7785 if !self.query.is_empty() {
7786 my_size += ::protobuf::rt::string_size(1, &self.query);
7787 }
7788 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
7789 self.cached_size.set(my_size);
7790 my_size
7791 }
7792
7793 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7794 if !self.query.is_empty() {
7795 os.write_string(1, &self.query)?;
7796 }
7797 os.write_unknown_fields(self.get_unknown_fields())?;
7798 ::std::result::Result::Ok(())
7799 }
7800
7801 fn get_cached_size(&self) -> u32 {
7802 self.cached_size.get()
7803 }
7804
7805 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
7806 &self.unknown_fields
7807 }
7808
7809 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
7810 &mut self.unknown_fields
7811 }
7812
7813 fn as_any(&self) -> &dyn (::std::any::Any) {
7814 self as &dyn (::std::any::Any)
7815 }
7816 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
7817 self as &mut dyn (::std::any::Any)
7818 }
7819 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
7820 self
7821 }
7822
7823 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
7824 Self::descriptor_static()
7825 }
7826
7827 fn new() -> GetConnectionCountResponse {
7828 GetConnectionCountResponse::new()
7829 }
7830
7831 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
7832 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
7833 lock: ::protobuf::lazy::ONCE_INIT,
7834 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
7835 };
7836 unsafe {
7837 descriptor.get(|| {
7838 let mut fields = ::std::vec::Vec::new();
7839 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
7840 "query",
7841 |m: &GetConnectionCountResponse| { &m.query },
7842 |m: &mut GetConnectionCountResponse| { &mut m.query },
7843 ));
7844 ::protobuf::reflect::MessageDescriptor::new::<GetConnectionCountResponse>(
7845 "GetConnectionCountResponse",
7846 fields,
7847 file_descriptor_proto()
7848 )
7849 })
7850 }
7851 }
7852
7853 fn default_instance() -> &'static GetConnectionCountResponse {
7854 static mut instance: ::protobuf::lazy::Lazy<GetConnectionCountResponse> = ::protobuf::lazy::Lazy {
7855 lock: ::protobuf::lazy::ONCE_INIT,
7856 ptr: 0 as *const GetConnectionCountResponse,
7857 };
7858 unsafe {
7859 instance.get(GetConnectionCountResponse::new)
7860 }
7861 }
7862}
7863
7864impl ::protobuf::Clear for GetConnectionCountResponse {
7865 fn clear(&mut self) {
7866 self.query.clear();
7867 self.unknown_fields.clear();
7868 }
7869}
7870
7871impl ::std::fmt::Debug for GetConnectionCountResponse {
7872 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7873 ::protobuf::text_format::fmt(self, f)
7874 }
7875}
7876
7877impl ::protobuf::reflect::ProtobufValue for GetConnectionCountResponse {
7878 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
7879 ::protobuf::reflect::ProtobufValueRef::Message(self)
7880 }
7881}
7882
7883#[derive(PartialEq,Clone,Default)]
7884pub struct GetDeltaRequest {
7885 pub delta_dfs_hash: ::std::vec::Vec<u8>,
7887 pub unknown_fields: ::protobuf::UnknownFields,
7889 pub cached_size: ::protobuf::CachedSize,
7890}
7891
7892impl<'a> ::std::default::Default for &'a GetDeltaRequest {
7893 fn default() -> &'a GetDeltaRequest {
7894 <GetDeltaRequest as ::protobuf::Message>::default_instance()
7895 }
7896}
7897
7898impl GetDeltaRequest {
7899 pub fn new() -> GetDeltaRequest {
7900 ::std::default::Default::default()
7901 }
7902
7903 pub fn get_delta_dfs_hash(&self) -> &[u8] {
7907 &self.delta_dfs_hash
7908 }
7909 pub fn clear_delta_dfs_hash(&mut self) {
7910 self.delta_dfs_hash.clear();
7911 }
7912
7913 pub fn set_delta_dfs_hash(&mut self, v: ::std::vec::Vec<u8>) {
7915 self.delta_dfs_hash = v;
7916 }
7917
7918 pub fn mut_delta_dfs_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
7921 &mut self.delta_dfs_hash
7922 }
7923
7924 pub fn take_delta_dfs_hash(&mut self) -> ::std::vec::Vec<u8> {
7926 ::std::mem::replace(&mut self.delta_dfs_hash, ::std::vec::Vec::new())
7927 }
7928}
7929
7930impl ::protobuf::Message for GetDeltaRequest {
7931 fn is_initialized(&self) -> bool {
7932 true
7933 }
7934
7935 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7936 while !is.eof()? {
7937 let (field_number, wire_type) = is.read_tag_unpack()?;
7938 match field_number {
7939 1 => {
7940 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.delta_dfs_hash)?;
7941 },
7942 _ => {
7943 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
7944 },
7945 };
7946 }
7947 ::std::result::Result::Ok(())
7948 }
7949
7950 #[allow(unused_variables)]
7952 fn compute_size(&self) -> u32 {
7953 let mut my_size = 0;
7954 if !self.delta_dfs_hash.is_empty() {
7955 my_size += ::protobuf::rt::bytes_size(1, &self.delta_dfs_hash);
7956 }
7957 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
7958 self.cached_size.set(my_size);
7959 my_size
7960 }
7961
7962 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
7963 if !self.delta_dfs_hash.is_empty() {
7964 os.write_bytes(1, &self.delta_dfs_hash)?;
7965 }
7966 os.write_unknown_fields(self.get_unknown_fields())?;
7967 ::std::result::Result::Ok(())
7968 }
7969
7970 fn get_cached_size(&self) -> u32 {
7971 self.cached_size.get()
7972 }
7973
7974 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
7975 &self.unknown_fields
7976 }
7977
7978 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
7979 &mut self.unknown_fields
7980 }
7981
7982 fn as_any(&self) -> &dyn (::std::any::Any) {
7983 self as &dyn (::std::any::Any)
7984 }
7985 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
7986 self as &mut dyn (::std::any::Any)
7987 }
7988 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
7989 self
7990 }
7991
7992 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
7993 Self::descriptor_static()
7994 }
7995
7996 fn new() -> GetDeltaRequest {
7997 GetDeltaRequest::new()
7998 }
7999
8000 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
8001 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
8002 lock: ::protobuf::lazy::ONCE_INIT,
8003 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
8004 };
8005 unsafe {
8006 descriptor.get(|| {
8007 let mut fields = ::std::vec::Vec::new();
8008 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
8009 "delta_dfs_hash",
8010 |m: &GetDeltaRequest| { &m.delta_dfs_hash },
8011 |m: &mut GetDeltaRequest| { &mut m.delta_dfs_hash },
8012 ));
8013 ::protobuf::reflect::MessageDescriptor::new::<GetDeltaRequest>(
8014 "GetDeltaRequest",
8015 fields,
8016 file_descriptor_proto()
8017 )
8018 })
8019 }
8020 }
8021
8022 fn default_instance() -> &'static GetDeltaRequest {
8023 static mut instance: ::protobuf::lazy::Lazy<GetDeltaRequest> = ::protobuf::lazy::Lazy {
8024 lock: ::protobuf::lazy::ONCE_INIT,
8025 ptr: 0 as *const GetDeltaRequest,
8026 };
8027 unsafe {
8028 instance.get(GetDeltaRequest::new)
8029 }
8030 }
8031}
8032
8033impl ::protobuf::Clear for GetDeltaRequest {
8034 fn clear(&mut self) {
8035 self.delta_dfs_hash.clear();
8036 self.unknown_fields.clear();
8037 }
8038}
8039
8040impl ::std::fmt::Debug for GetDeltaRequest {
8041 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8042 ::protobuf::text_format::fmt(self, f)
8043 }
8044}
8045
8046impl ::protobuf::reflect::ProtobufValue for GetDeltaRequest {
8047 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
8048 ::protobuf::reflect::ProtobufValueRef::Message(self)
8049 }
8050}
8051
8052#[derive(PartialEq,Clone,Default)]
8053pub struct GetDeltaResponse {
8054 pub delta: ::protobuf::SingularPtrField<super::Deltas::Delta>,
8056 pub unknown_fields: ::protobuf::UnknownFields,
8058 pub cached_size: ::protobuf::CachedSize,
8059}
8060
8061impl<'a> ::std::default::Default for &'a GetDeltaResponse {
8062 fn default() -> &'a GetDeltaResponse {
8063 <GetDeltaResponse as ::protobuf::Message>::default_instance()
8064 }
8065}
8066
8067impl GetDeltaResponse {
8068 pub fn new() -> GetDeltaResponse {
8069 ::std::default::Default::default()
8070 }
8071
8072 pub fn get_delta(&self) -> &super::Deltas::Delta {
8076 self.delta.as_ref().unwrap_or_else(|| super::Deltas::Delta::default_instance())
8077 }
8078 pub fn clear_delta(&mut self) {
8079 self.delta.clear();
8080 }
8081
8082 pub fn has_delta(&self) -> bool {
8083 self.delta.is_some()
8084 }
8085
8086 pub fn set_delta(&mut self, v: super::Deltas::Delta) {
8088 self.delta = ::protobuf::SingularPtrField::some(v);
8089 }
8090
8091 pub fn mut_delta(&mut self) -> &mut super::Deltas::Delta {
8094 if self.delta.is_none() {
8095 self.delta.set_default();
8096 }
8097 self.delta.as_mut().unwrap()
8098 }
8099
8100 pub fn take_delta(&mut self) -> super::Deltas::Delta {
8102 self.delta.take().unwrap_or_else(|| super::Deltas::Delta::new())
8103 }
8104}
8105
8106impl ::protobuf::Message for GetDeltaResponse {
8107 fn is_initialized(&self) -> bool {
8108 for v in &self.delta {
8109 if !v.is_initialized() {
8110 return false;
8111 }
8112 };
8113 true
8114 }
8115
8116 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8117 while !is.eof()? {
8118 let (field_number, wire_type) = is.read_tag_unpack()?;
8119 match field_number {
8120 1 => {
8121 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.delta)?;
8122 },
8123 _ => {
8124 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
8125 },
8126 };
8127 }
8128 ::std::result::Result::Ok(())
8129 }
8130
8131 #[allow(unused_variables)]
8133 fn compute_size(&self) -> u32 {
8134 let mut my_size = 0;
8135 if let Some(ref v) = self.delta.as_ref() {
8136 let len = v.compute_size();
8137 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
8138 }
8139 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
8140 self.cached_size.set(my_size);
8141 my_size
8142 }
8143
8144 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8145 if let Some(ref v) = self.delta.as_ref() {
8146 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
8147 os.write_raw_varint32(v.get_cached_size())?;
8148 v.write_to_with_cached_sizes(os)?;
8149 }
8150 os.write_unknown_fields(self.get_unknown_fields())?;
8151 ::std::result::Result::Ok(())
8152 }
8153
8154 fn get_cached_size(&self) -> u32 {
8155 self.cached_size.get()
8156 }
8157
8158 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
8159 &self.unknown_fields
8160 }
8161
8162 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
8163 &mut self.unknown_fields
8164 }
8165
8166 fn as_any(&self) -> &dyn (::std::any::Any) {
8167 self as &dyn (::std::any::Any)
8168 }
8169 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
8170 self as &mut dyn (::std::any::Any)
8171 }
8172 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
8173 self
8174 }
8175
8176 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
8177 Self::descriptor_static()
8178 }
8179
8180 fn new() -> GetDeltaResponse {
8181 GetDeltaResponse::new()
8182 }
8183
8184 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
8185 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
8186 lock: ::protobuf::lazy::ONCE_INIT,
8187 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
8188 };
8189 unsafe {
8190 descriptor.get(|| {
8191 let mut fields = ::std::vec::Vec::new();
8192 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::Deltas::Delta>>(
8193 "delta",
8194 |m: &GetDeltaResponse| { &m.delta },
8195 |m: &mut GetDeltaResponse| { &mut m.delta },
8196 ));
8197 ::protobuf::reflect::MessageDescriptor::new::<GetDeltaResponse>(
8198 "GetDeltaResponse",
8199 fields,
8200 file_descriptor_proto()
8201 )
8202 })
8203 }
8204 }
8205
8206 fn default_instance() -> &'static GetDeltaResponse {
8207 static mut instance: ::protobuf::lazy::Lazy<GetDeltaResponse> = ::protobuf::lazy::Lazy {
8208 lock: ::protobuf::lazy::ONCE_INIT,
8209 ptr: 0 as *const GetDeltaResponse,
8210 };
8211 unsafe {
8212 instance.get(GetDeltaResponse::new)
8213 }
8214 }
8215}
8216
8217impl ::protobuf::Clear for GetDeltaResponse {
8218 fn clear(&mut self) {
8219 self.delta.clear();
8220 self.unknown_fields.clear();
8221 }
8222}
8223
8224impl ::std::fmt::Debug for GetDeltaResponse {
8225 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8226 ::protobuf::text_format::fmt(self, f)
8227 }
8228}
8229
8230impl ::protobuf::reflect::ProtobufValue for GetDeltaResponse {
8231 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
8232 ::protobuf::reflect::ProtobufValueRef::Message(self)
8233 }
8234}
8235
8236#[derive(PartialEq,Clone,Default)]
8237pub struct GetMempoolRequest {
8238 pub query: bool,
8240 pub unknown_fields: ::protobuf::UnknownFields,
8242 pub cached_size: ::protobuf::CachedSize,
8243}
8244
8245impl<'a> ::std::default::Default for &'a GetMempoolRequest {
8246 fn default() -> &'a GetMempoolRequest {
8247 <GetMempoolRequest as ::protobuf::Message>::default_instance()
8248 }
8249}
8250
8251impl GetMempoolRequest {
8252 pub fn new() -> GetMempoolRequest {
8253 ::std::default::Default::default()
8254 }
8255
8256 pub fn get_query(&self) -> bool {
8260 self.query
8261 }
8262 pub fn clear_query(&mut self) {
8263 self.query = false;
8264 }
8265
8266 pub fn set_query(&mut self, v: bool) {
8268 self.query = v;
8269 }
8270}
8271
8272impl ::protobuf::Message for GetMempoolRequest {
8273 fn is_initialized(&self) -> bool {
8274 true
8275 }
8276
8277 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8278 while !is.eof()? {
8279 let (field_number, wire_type) = is.read_tag_unpack()?;
8280 match field_number {
8281 1 => {
8282 if wire_type != ::protobuf::wire_format::WireTypeVarint {
8283 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
8284 }
8285 let tmp = is.read_bool()?;
8286 self.query = tmp;
8287 },
8288 _ => {
8289 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
8290 },
8291 };
8292 }
8293 ::std::result::Result::Ok(())
8294 }
8295
8296 #[allow(unused_variables)]
8298 fn compute_size(&self) -> u32 {
8299 let mut my_size = 0;
8300 if self.query != false {
8301 my_size += 2;
8302 }
8303 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
8304 self.cached_size.set(my_size);
8305 my_size
8306 }
8307
8308 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8309 if self.query != false {
8310 os.write_bool(1, self.query)?;
8311 }
8312 os.write_unknown_fields(self.get_unknown_fields())?;
8313 ::std::result::Result::Ok(())
8314 }
8315
8316 fn get_cached_size(&self) -> u32 {
8317 self.cached_size.get()
8318 }
8319
8320 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
8321 &self.unknown_fields
8322 }
8323
8324 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
8325 &mut self.unknown_fields
8326 }
8327
8328 fn as_any(&self) -> &dyn (::std::any::Any) {
8329 self as &dyn (::std::any::Any)
8330 }
8331 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
8332 self as &mut dyn (::std::any::Any)
8333 }
8334 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
8335 self
8336 }
8337
8338 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
8339 Self::descriptor_static()
8340 }
8341
8342 fn new() -> GetMempoolRequest {
8343 GetMempoolRequest::new()
8344 }
8345
8346 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
8347 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
8348 lock: ::protobuf::lazy::ONCE_INIT,
8349 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
8350 };
8351 unsafe {
8352 descriptor.get(|| {
8353 let mut fields = ::std::vec::Vec::new();
8354 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
8355 "query",
8356 |m: &GetMempoolRequest| { &m.query },
8357 |m: &mut GetMempoolRequest| { &mut m.query },
8358 ));
8359 ::protobuf::reflect::MessageDescriptor::new::<GetMempoolRequest>(
8360 "GetMempoolRequest",
8361 fields,
8362 file_descriptor_proto()
8363 )
8364 })
8365 }
8366 }
8367
8368 fn default_instance() -> &'static GetMempoolRequest {
8369 static mut instance: ::protobuf::lazy::Lazy<GetMempoolRequest> = ::protobuf::lazy::Lazy {
8370 lock: ::protobuf::lazy::ONCE_INIT,
8371 ptr: 0 as *const GetMempoolRequest,
8372 };
8373 unsafe {
8374 instance.get(GetMempoolRequest::new)
8375 }
8376 }
8377}
8378
8379impl ::protobuf::Clear for GetMempoolRequest {
8380 fn clear(&mut self) {
8381 self.query = false;
8382 self.unknown_fields.clear();
8383 }
8384}
8385
8386impl ::std::fmt::Debug for GetMempoolRequest {
8387 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8388 ::protobuf::text_format::fmt(self, f)
8389 }
8390}
8391
8392impl ::protobuf::reflect::ProtobufValue for GetMempoolRequest {
8393 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
8394 ::protobuf::reflect::ProtobufValueRef::Message(self)
8395 }
8396}
8397
8398#[derive(PartialEq,Clone,Default)]
8399pub struct GetMempoolResponse {
8400 pub transactions: ::protobuf::RepeatedField<super::Transaction::PublicEntry>,
8402 pub unknown_fields: ::protobuf::UnknownFields,
8404 pub cached_size: ::protobuf::CachedSize,
8405}
8406
8407impl<'a> ::std::default::Default for &'a GetMempoolResponse {
8408 fn default() -> &'a GetMempoolResponse {
8409 <GetMempoolResponse as ::protobuf::Message>::default_instance()
8410 }
8411}
8412
8413impl GetMempoolResponse {
8414 pub fn new() -> GetMempoolResponse {
8415 ::std::default::Default::default()
8416 }
8417
8418 pub fn get_transactions(&self) -> &[super::Transaction::PublicEntry] {
8422 &self.transactions
8423 }
8424 pub fn clear_transactions(&mut self) {
8425 self.transactions.clear();
8426 }
8427
8428 pub fn set_transactions(&mut self, v: ::protobuf::RepeatedField<super::Transaction::PublicEntry>) {
8430 self.transactions = v;
8431 }
8432
8433 pub fn mut_transactions(&mut self) -> &mut ::protobuf::RepeatedField<super::Transaction::PublicEntry> {
8435 &mut self.transactions
8436 }
8437
8438 pub fn take_transactions(&mut self) -> ::protobuf::RepeatedField<super::Transaction::PublicEntry> {
8440 ::std::mem::replace(&mut self.transactions, ::protobuf::RepeatedField::new())
8441 }
8442}
8443
8444impl ::protobuf::Message for GetMempoolResponse {
8445 fn is_initialized(&self) -> bool {
8446 for v in &self.transactions {
8447 if !v.is_initialized() {
8448 return false;
8449 }
8450 };
8451 true
8452 }
8453
8454 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8455 while !is.eof()? {
8456 let (field_number, wire_type) = is.read_tag_unpack()?;
8457 match field_number {
8458 1 => {
8459 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.transactions)?;
8460 },
8461 _ => {
8462 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
8463 },
8464 };
8465 }
8466 ::std::result::Result::Ok(())
8467 }
8468
8469 #[allow(unused_variables)]
8471 fn compute_size(&self) -> u32 {
8472 let mut my_size = 0;
8473 for value in &self.transactions {
8474 let len = value.compute_size();
8475 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
8476 };
8477 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
8478 self.cached_size.set(my_size);
8479 my_size
8480 }
8481
8482 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8483 for v in &self.transactions {
8484 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
8485 os.write_raw_varint32(v.get_cached_size())?;
8486 v.write_to_with_cached_sizes(os)?;
8487 };
8488 os.write_unknown_fields(self.get_unknown_fields())?;
8489 ::std::result::Result::Ok(())
8490 }
8491
8492 fn get_cached_size(&self) -> u32 {
8493 self.cached_size.get()
8494 }
8495
8496 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
8497 &self.unknown_fields
8498 }
8499
8500 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
8501 &mut self.unknown_fields
8502 }
8503
8504 fn as_any(&self) -> &dyn (::std::any::Any) {
8505 self as &dyn (::std::any::Any)
8506 }
8507 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
8508 self as &mut dyn (::std::any::Any)
8509 }
8510 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
8511 self
8512 }
8513
8514 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
8515 Self::descriptor_static()
8516 }
8517
8518 fn new() -> GetMempoolResponse {
8519 GetMempoolResponse::new()
8520 }
8521
8522 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
8523 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
8524 lock: ::protobuf::lazy::ONCE_INIT,
8525 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
8526 };
8527 unsafe {
8528 descriptor.get(|| {
8529 let mut fields = ::std::vec::Vec::new();
8530 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::Transaction::PublicEntry>>(
8531 "transactions",
8532 |m: &GetMempoolResponse| { &m.transactions },
8533 |m: &mut GetMempoolResponse| { &mut m.transactions },
8534 ));
8535 ::protobuf::reflect::MessageDescriptor::new::<GetMempoolResponse>(
8536 "GetMempoolResponse",
8537 fields,
8538 file_descriptor_proto()
8539 )
8540 })
8541 }
8542 }
8543
8544 fn default_instance() -> &'static GetMempoolResponse {
8545 static mut instance: ::protobuf::lazy::Lazy<GetMempoolResponse> = ::protobuf::lazy::Lazy {
8546 lock: ::protobuf::lazy::ONCE_INIT,
8547 ptr: 0 as *const GetMempoolResponse,
8548 };
8549 unsafe {
8550 instance.get(GetMempoolResponse::new)
8551 }
8552 }
8553}
8554
8555impl ::protobuf::Clear for GetMempoolResponse {
8556 fn clear(&mut self) {
8557 self.transactions.clear();
8558 self.unknown_fields.clear();
8559 }
8560}
8561
8562impl ::std::fmt::Debug for GetMempoolResponse {
8563 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8564 ::protobuf::text_format::fmt(self, f)
8565 }
8566}
8567
8568impl ::protobuf::reflect::ProtobufValue for GetMempoolResponse {
8569 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
8570 ::protobuf::reflect::ProtobufValueRef::Message(self)
8571 }
8572}
8573
8574#[derive(PartialEq,Clone,Default)]
8575pub struct SignMessageRequest {
8576 pub message: ::std::vec::Vec<u8>,
8578 pub key_id: ::std::string::String,
8579 pub signing_context: ::protobuf::SingularPtrField<super::Cryptography::SigningContext>,
8580 pub unknown_fields: ::protobuf::UnknownFields,
8582 pub cached_size: ::protobuf::CachedSize,
8583}
8584
8585impl<'a> ::std::default::Default for &'a SignMessageRequest {
8586 fn default() -> &'a SignMessageRequest {
8587 <SignMessageRequest as ::protobuf::Message>::default_instance()
8588 }
8589}
8590
8591impl SignMessageRequest {
8592 pub fn new() -> SignMessageRequest {
8593 ::std::default::Default::default()
8594 }
8595
8596 pub fn get_message(&self) -> &[u8] {
8600 &self.message
8601 }
8602 pub fn clear_message(&mut self) {
8603 self.message.clear();
8604 }
8605
8606 pub fn set_message(&mut self, v: ::std::vec::Vec<u8>) {
8608 self.message = v;
8609 }
8610
8611 pub fn mut_message(&mut self) -> &mut ::std::vec::Vec<u8> {
8614 &mut self.message
8615 }
8616
8617 pub fn take_message(&mut self) -> ::std::vec::Vec<u8> {
8619 ::std::mem::replace(&mut self.message, ::std::vec::Vec::new())
8620 }
8621
8622 pub fn get_key_id(&self) -> &str {
8626 &self.key_id
8627 }
8628 pub fn clear_key_id(&mut self) {
8629 self.key_id.clear();
8630 }
8631
8632 pub fn set_key_id(&mut self, v: ::std::string::String) {
8634 self.key_id = v;
8635 }
8636
8637 pub fn mut_key_id(&mut self) -> &mut ::std::string::String {
8640 &mut self.key_id
8641 }
8642
8643 pub fn take_key_id(&mut self) -> ::std::string::String {
8645 ::std::mem::replace(&mut self.key_id, ::std::string::String::new())
8646 }
8647
8648 pub fn get_signing_context(&self) -> &super::Cryptography::SigningContext {
8652 self.signing_context.as_ref().unwrap_or_else(|| super::Cryptography::SigningContext::default_instance())
8653 }
8654 pub fn clear_signing_context(&mut self) {
8655 self.signing_context.clear();
8656 }
8657
8658 pub fn has_signing_context(&self) -> bool {
8659 self.signing_context.is_some()
8660 }
8661
8662 pub fn set_signing_context(&mut self, v: super::Cryptography::SigningContext) {
8664 self.signing_context = ::protobuf::SingularPtrField::some(v);
8665 }
8666
8667 pub fn mut_signing_context(&mut self) -> &mut super::Cryptography::SigningContext {
8670 if self.signing_context.is_none() {
8671 self.signing_context.set_default();
8672 }
8673 self.signing_context.as_mut().unwrap()
8674 }
8675
8676 pub fn take_signing_context(&mut self) -> super::Cryptography::SigningContext {
8678 self.signing_context.take().unwrap_or_else(|| super::Cryptography::SigningContext::new())
8679 }
8680}
8681
8682impl ::protobuf::Message for SignMessageRequest {
8683 fn is_initialized(&self) -> bool {
8684 for v in &self.signing_context {
8685 if !v.is_initialized() {
8686 return false;
8687 }
8688 };
8689 true
8690 }
8691
8692 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8693 while !is.eof()? {
8694 let (field_number, wire_type) = is.read_tag_unpack()?;
8695 match field_number {
8696 1 => {
8697 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.message)?;
8698 },
8699 2 => {
8700 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.key_id)?;
8701 },
8702 3 => {
8703 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.signing_context)?;
8704 },
8705 _ => {
8706 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
8707 },
8708 };
8709 }
8710 ::std::result::Result::Ok(())
8711 }
8712
8713 #[allow(unused_variables)]
8715 fn compute_size(&self) -> u32 {
8716 let mut my_size = 0;
8717 if !self.message.is_empty() {
8718 my_size += ::protobuf::rt::bytes_size(1, &self.message);
8719 }
8720 if !self.key_id.is_empty() {
8721 my_size += ::protobuf::rt::string_size(2, &self.key_id);
8722 }
8723 if let Some(ref v) = self.signing_context.as_ref() {
8724 let len = v.compute_size();
8725 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
8726 }
8727 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
8728 self.cached_size.set(my_size);
8729 my_size
8730 }
8731
8732 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8733 if !self.message.is_empty() {
8734 os.write_bytes(1, &self.message)?;
8735 }
8736 if !self.key_id.is_empty() {
8737 os.write_string(2, &self.key_id)?;
8738 }
8739 if let Some(ref v) = self.signing_context.as_ref() {
8740 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
8741 os.write_raw_varint32(v.get_cached_size())?;
8742 v.write_to_with_cached_sizes(os)?;
8743 }
8744 os.write_unknown_fields(self.get_unknown_fields())?;
8745 ::std::result::Result::Ok(())
8746 }
8747
8748 fn get_cached_size(&self) -> u32 {
8749 self.cached_size.get()
8750 }
8751
8752 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
8753 &self.unknown_fields
8754 }
8755
8756 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
8757 &mut self.unknown_fields
8758 }
8759
8760 fn as_any(&self) -> &dyn (::std::any::Any) {
8761 self as &dyn (::std::any::Any)
8762 }
8763 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
8764 self as &mut dyn (::std::any::Any)
8765 }
8766 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
8767 self
8768 }
8769
8770 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
8771 Self::descriptor_static()
8772 }
8773
8774 fn new() -> SignMessageRequest {
8775 SignMessageRequest::new()
8776 }
8777
8778 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
8779 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
8780 lock: ::protobuf::lazy::ONCE_INIT,
8781 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
8782 };
8783 unsafe {
8784 descriptor.get(|| {
8785 let mut fields = ::std::vec::Vec::new();
8786 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
8787 "message",
8788 |m: &SignMessageRequest| { &m.message },
8789 |m: &mut SignMessageRequest| { &mut m.message },
8790 ));
8791 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
8792 "key_id",
8793 |m: &SignMessageRequest| { &m.key_id },
8794 |m: &mut SignMessageRequest| { &mut m.key_id },
8795 ));
8796 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::Cryptography::SigningContext>>(
8797 "signing_context",
8798 |m: &SignMessageRequest| { &m.signing_context },
8799 |m: &mut SignMessageRequest| { &mut m.signing_context },
8800 ));
8801 ::protobuf::reflect::MessageDescriptor::new::<SignMessageRequest>(
8802 "SignMessageRequest",
8803 fields,
8804 file_descriptor_proto()
8805 )
8806 })
8807 }
8808 }
8809
8810 fn default_instance() -> &'static SignMessageRequest {
8811 static mut instance: ::protobuf::lazy::Lazy<SignMessageRequest> = ::protobuf::lazy::Lazy {
8812 lock: ::protobuf::lazy::ONCE_INIT,
8813 ptr: 0 as *const SignMessageRequest,
8814 };
8815 unsafe {
8816 instance.get(SignMessageRequest::new)
8817 }
8818 }
8819}
8820
8821impl ::protobuf::Clear for SignMessageRequest {
8822 fn clear(&mut self) {
8823 self.message.clear();
8824 self.key_id.clear();
8825 self.signing_context.clear();
8826 self.unknown_fields.clear();
8827 }
8828}
8829
8830impl ::std::fmt::Debug for SignMessageRequest {
8831 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8832 ::protobuf::text_format::fmt(self, f)
8833 }
8834}
8835
8836impl ::protobuf::reflect::ProtobufValue for SignMessageRequest {
8837 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
8838 ::protobuf::reflect::ProtobufValueRef::Message(self)
8839 }
8840}
8841
8842#[derive(PartialEq,Clone,Default)]
8843pub struct SignMessageResponse {
8844 pub signature: ::std::vec::Vec<u8>,
8846 pub public_key: ::std::vec::Vec<u8>,
8847 pub original_message: ::std::vec::Vec<u8>,
8848 pub unknown_fields: ::protobuf::UnknownFields,
8850 pub cached_size: ::protobuf::CachedSize,
8851}
8852
8853impl<'a> ::std::default::Default for &'a SignMessageResponse {
8854 fn default() -> &'a SignMessageResponse {
8855 <SignMessageResponse as ::protobuf::Message>::default_instance()
8856 }
8857}
8858
8859impl SignMessageResponse {
8860 pub fn new() -> SignMessageResponse {
8861 ::std::default::Default::default()
8862 }
8863
8864 pub fn get_signature(&self) -> &[u8] {
8868 &self.signature
8869 }
8870 pub fn clear_signature(&mut self) {
8871 self.signature.clear();
8872 }
8873
8874 pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
8876 self.signature = v;
8877 }
8878
8879 pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
8882 &mut self.signature
8883 }
8884
8885 pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
8887 ::std::mem::replace(&mut self.signature, ::std::vec::Vec::new())
8888 }
8889
8890 pub fn get_public_key(&self) -> &[u8] {
8894 &self.public_key
8895 }
8896 pub fn clear_public_key(&mut self) {
8897 self.public_key.clear();
8898 }
8899
8900 pub fn set_public_key(&mut self, v: ::std::vec::Vec<u8>) {
8902 self.public_key = v;
8903 }
8904
8905 pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
8908 &mut self.public_key
8909 }
8910
8911 pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
8913 ::std::mem::replace(&mut self.public_key, ::std::vec::Vec::new())
8914 }
8915
8916 pub fn get_original_message(&self) -> &[u8] {
8920 &self.original_message
8921 }
8922 pub fn clear_original_message(&mut self) {
8923 self.original_message.clear();
8924 }
8925
8926 pub fn set_original_message(&mut self, v: ::std::vec::Vec<u8>) {
8928 self.original_message = v;
8929 }
8930
8931 pub fn mut_original_message(&mut self) -> &mut ::std::vec::Vec<u8> {
8934 &mut self.original_message
8935 }
8936
8937 pub fn take_original_message(&mut self) -> ::std::vec::Vec<u8> {
8939 ::std::mem::replace(&mut self.original_message, ::std::vec::Vec::new())
8940 }
8941}
8942
8943impl ::protobuf::Message for SignMessageResponse {
8944 fn is_initialized(&self) -> bool {
8945 true
8946 }
8947
8948 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8949 while !is.eof()? {
8950 let (field_number, wire_type) = is.read_tag_unpack()?;
8951 match field_number {
8952 1 => {
8953 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.signature)?;
8954 },
8955 2 => {
8956 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.public_key)?;
8957 },
8958 3 => {
8959 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.original_message)?;
8960 },
8961 _ => {
8962 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
8963 },
8964 };
8965 }
8966 ::std::result::Result::Ok(())
8967 }
8968
8969 #[allow(unused_variables)]
8971 fn compute_size(&self) -> u32 {
8972 let mut my_size = 0;
8973 if !self.signature.is_empty() {
8974 my_size += ::protobuf::rt::bytes_size(1, &self.signature);
8975 }
8976 if !self.public_key.is_empty() {
8977 my_size += ::protobuf::rt::bytes_size(2, &self.public_key);
8978 }
8979 if !self.original_message.is_empty() {
8980 my_size += ::protobuf::rt::bytes_size(3, &self.original_message);
8981 }
8982 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
8983 self.cached_size.set(my_size);
8984 my_size
8985 }
8986
8987 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
8988 if !self.signature.is_empty() {
8989 os.write_bytes(1, &self.signature)?;
8990 }
8991 if !self.public_key.is_empty() {
8992 os.write_bytes(2, &self.public_key)?;
8993 }
8994 if !self.original_message.is_empty() {
8995 os.write_bytes(3, &self.original_message)?;
8996 }
8997 os.write_unknown_fields(self.get_unknown_fields())?;
8998 ::std::result::Result::Ok(())
8999 }
9000
9001 fn get_cached_size(&self) -> u32 {
9002 self.cached_size.get()
9003 }
9004
9005 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
9006 &self.unknown_fields
9007 }
9008
9009 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
9010 &mut self.unknown_fields
9011 }
9012
9013 fn as_any(&self) -> &dyn (::std::any::Any) {
9014 self as &dyn (::std::any::Any)
9015 }
9016 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
9017 self as &mut dyn (::std::any::Any)
9018 }
9019 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
9020 self
9021 }
9022
9023 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
9024 Self::descriptor_static()
9025 }
9026
9027 fn new() -> SignMessageResponse {
9028 SignMessageResponse::new()
9029 }
9030
9031 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
9032 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
9033 lock: ::protobuf::lazy::ONCE_INIT,
9034 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
9035 };
9036 unsafe {
9037 descriptor.get(|| {
9038 let mut fields = ::std::vec::Vec::new();
9039 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
9040 "signature",
9041 |m: &SignMessageResponse| { &m.signature },
9042 |m: &mut SignMessageResponse| { &mut m.signature },
9043 ));
9044 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
9045 "public_key",
9046 |m: &SignMessageResponse| { &m.public_key },
9047 |m: &mut SignMessageResponse| { &mut m.public_key },
9048 ));
9049 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
9050 "original_message",
9051 |m: &SignMessageResponse| { &m.original_message },
9052 |m: &mut SignMessageResponse| { &mut m.original_message },
9053 ));
9054 ::protobuf::reflect::MessageDescriptor::new::<SignMessageResponse>(
9055 "SignMessageResponse",
9056 fields,
9057 file_descriptor_proto()
9058 )
9059 })
9060 }
9061 }
9062
9063 fn default_instance() -> &'static SignMessageResponse {
9064 static mut instance: ::protobuf::lazy::Lazy<SignMessageResponse> = ::protobuf::lazy::Lazy {
9065 lock: ::protobuf::lazy::ONCE_INIT,
9066 ptr: 0 as *const SignMessageResponse,
9067 };
9068 unsafe {
9069 instance.get(SignMessageResponse::new)
9070 }
9071 }
9072}
9073
9074impl ::protobuf::Clear for SignMessageResponse {
9075 fn clear(&mut self) {
9076 self.signature.clear();
9077 self.public_key.clear();
9078 self.original_message.clear();
9079 self.unknown_fields.clear();
9080 }
9081}
9082
9083impl ::std::fmt::Debug for SignMessageResponse {
9084 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9085 ::protobuf::text_format::fmt(self, f)
9086 }
9087}
9088
9089impl ::protobuf::reflect::ProtobufValue for SignMessageResponse {
9090 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
9091 ::protobuf::reflect::ProtobufValueRef::Message(self)
9092 }
9093}
9094
9095#[derive(PartialEq,Clone,Default)]
9096pub struct VerifyMessageRequest {
9097 pub signature: ::std::vec::Vec<u8>,
9099 pub public_key: ::std::vec::Vec<u8>,
9100 pub message: ::std::vec::Vec<u8>,
9101 pub signing_context: ::protobuf::SingularPtrField<super::Cryptography::SigningContext>,
9102 pub unknown_fields: ::protobuf::UnknownFields,
9104 pub cached_size: ::protobuf::CachedSize,
9105}
9106
9107impl<'a> ::std::default::Default for &'a VerifyMessageRequest {
9108 fn default() -> &'a VerifyMessageRequest {
9109 <VerifyMessageRequest as ::protobuf::Message>::default_instance()
9110 }
9111}
9112
9113impl VerifyMessageRequest {
9114 pub fn new() -> VerifyMessageRequest {
9115 ::std::default::Default::default()
9116 }
9117
9118 pub fn get_signature(&self) -> &[u8] {
9122 &self.signature
9123 }
9124 pub fn clear_signature(&mut self) {
9125 self.signature.clear();
9126 }
9127
9128 pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
9130 self.signature = v;
9131 }
9132
9133 pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
9136 &mut self.signature
9137 }
9138
9139 pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
9141 ::std::mem::replace(&mut self.signature, ::std::vec::Vec::new())
9142 }
9143
9144 pub fn get_public_key(&self) -> &[u8] {
9148 &self.public_key
9149 }
9150 pub fn clear_public_key(&mut self) {
9151 self.public_key.clear();
9152 }
9153
9154 pub fn set_public_key(&mut self, v: ::std::vec::Vec<u8>) {
9156 self.public_key = v;
9157 }
9158
9159 pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
9162 &mut self.public_key
9163 }
9164
9165 pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
9167 ::std::mem::replace(&mut self.public_key, ::std::vec::Vec::new())
9168 }
9169
9170 pub fn get_message(&self) -> &[u8] {
9174 &self.message
9175 }
9176 pub fn clear_message(&mut self) {
9177 self.message.clear();
9178 }
9179
9180 pub fn set_message(&mut self, v: ::std::vec::Vec<u8>) {
9182 self.message = v;
9183 }
9184
9185 pub fn mut_message(&mut self) -> &mut ::std::vec::Vec<u8> {
9188 &mut self.message
9189 }
9190
9191 pub fn take_message(&mut self) -> ::std::vec::Vec<u8> {
9193 ::std::mem::replace(&mut self.message, ::std::vec::Vec::new())
9194 }
9195
9196 pub fn get_signing_context(&self) -> &super::Cryptography::SigningContext {
9200 self.signing_context.as_ref().unwrap_or_else(|| super::Cryptography::SigningContext::default_instance())
9201 }
9202 pub fn clear_signing_context(&mut self) {
9203 self.signing_context.clear();
9204 }
9205
9206 pub fn has_signing_context(&self) -> bool {
9207 self.signing_context.is_some()
9208 }
9209
9210 pub fn set_signing_context(&mut self, v: super::Cryptography::SigningContext) {
9212 self.signing_context = ::protobuf::SingularPtrField::some(v);
9213 }
9214
9215 pub fn mut_signing_context(&mut self) -> &mut super::Cryptography::SigningContext {
9218 if self.signing_context.is_none() {
9219 self.signing_context.set_default();
9220 }
9221 self.signing_context.as_mut().unwrap()
9222 }
9223
9224 pub fn take_signing_context(&mut self) -> super::Cryptography::SigningContext {
9226 self.signing_context.take().unwrap_or_else(|| super::Cryptography::SigningContext::new())
9227 }
9228}
9229
9230impl ::protobuf::Message for VerifyMessageRequest {
9231 fn is_initialized(&self) -> bool {
9232 for v in &self.signing_context {
9233 if !v.is_initialized() {
9234 return false;
9235 }
9236 };
9237 true
9238 }
9239
9240 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9241 while !is.eof()? {
9242 let (field_number, wire_type) = is.read_tag_unpack()?;
9243 match field_number {
9244 1 => {
9245 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.signature)?;
9246 },
9247 2 => {
9248 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.public_key)?;
9249 },
9250 3 => {
9251 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.message)?;
9252 },
9253 4 => {
9254 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.signing_context)?;
9255 },
9256 _ => {
9257 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
9258 },
9259 };
9260 }
9261 ::std::result::Result::Ok(())
9262 }
9263
9264 #[allow(unused_variables)]
9266 fn compute_size(&self) -> u32 {
9267 let mut my_size = 0;
9268 if !self.signature.is_empty() {
9269 my_size += ::protobuf::rt::bytes_size(1, &self.signature);
9270 }
9271 if !self.public_key.is_empty() {
9272 my_size += ::protobuf::rt::bytes_size(2, &self.public_key);
9273 }
9274 if !self.message.is_empty() {
9275 my_size += ::protobuf::rt::bytes_size(3, &self.message);
9276 }
9277 if let Some(ref v) = self.signing_context.as_ref() {
9278 let len = v.compute_size();
9279 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
9280 }
9281 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
9282 self.cached_size.set(my_size);
9283 my_size
9284 }
9285
9286 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9287 if !self.signature.is_empty() {
9288 os.write_bytes(1, &self.signature)?;
9289 }
9290 if !self.public_key.is_empty() {
9291 os.write_bytes(2, &self.public_key)?;
9292 }
9293 if !self.message.is_empty() {
9294 os.write_bytes(3, &self.message)?;
9295 }
9296 if let Some(ref v) = self.signing_context.as_ref() {
9297 os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
9298 os.write_raw_varint32(v.get_cached_size())?;
9299 v.write_to_with_cached_sizes(os)?;
9300 }
9301 os.write_unknown_fields(self.get_unknown_fields())?;
9302 ::std::result::Result::Ok(())
9303 }
9304
9305 fn get_cached_size(&self) -> u32 {
9306 self.cached_size.get()
9307 }
9308
9309 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
9310 &self.unknown_fields
9311 }
9312
9313 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
9314 &mut self.unknown_fields
9315 }
9316
9317 fn as_any(&self) -> &dyn (::std::any::Any) {
9318 self as &dyn (::std::any::Any)
9319 }
9320 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
9321 self as &mut dyn (::std::any::Any)
9322 }
9323 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
9324 self
9325 }
9326
9327 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
9328 Self::descriptor_static()
9329 }
9330
9331 fn new() -> VerifyMessageRequest {
9332 VerifyMessageRequest::new()
9333 }
9334
9335 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
9336 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
9337 lock: ::protobuf::lazy::ONCE_INIT,
9338 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
9339 };
9340 unsafe {
9341 descriptor.get(|| {
9342 let mut fields = ::std::vec::Vec::new();
9343 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
9344 "signature",
9345 |m: &VerifyMessageRequest| { &m.signature },
9346 |m: &mut VerifyMessageRequest| { &mut m.signature },
9347 ));
9348 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
9349 "public_key",
9350 |m: &VerifyMessageRequest| { &m.public_key },
9351 |m: &mut VerifyMessageRequest| { &mut m.public_key },
9352 ));
9353 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
9354 "message",
9355 |m: &VerifyMessageRequest| { &m.message },
9356 |m: &mut VerifyMessageRequest| { &mut m.message },
9357 ));
9358 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::Cryptography::SigningContext>>(
9359 "signing_context",
9360 |m: &VerifyMessageRequest| { &m.signing_context },
9361 |m: &mut VerifyMessageRequest| { &mut m.signing_context },
9362 ));
9363 ::protobuf::reflect::MessageDescriptor::new::<VerifyMessageRequest>(
9364 "VerifyMessageRequest",
9365 fields,
9366 file_descriptor_proto()
9367 )
9368 })
9369 }
9370 }
9371
9372 fn default_instance() -> &'static VerifyMessageRequest {
9373 static mut instance: ::protobuf::lazy::Lazy<VerifyMessageRequest> = ::protobuf::lazy::Lazy {
9374 lock: ::protobuf::lazy::ONCE_INIT,
9375 ptr: 0 as *const VerifyMessageRequest,
9376 };
9377 unsafe {
9378 instance.get(VerifyMessageRequest::new)
9379 }
9380 }
9381}
9382
9383impl ::protobuf::Clear for VerifyMessageRequest {
9384 fn clear(&mut self) {
9385 self.signature.clear();
9386 self.public_key.clear();
9387 self.message.clear();
9388 self.signing_context.clear();
9389 self.unknown_fields.clear();
9390 }
9391}
9392
9393impl ::std::fmt::Debug for VerifyMessageRequest {
9394 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9395 ::protobuf::text_format::fmt(self, f)
9396 }
9397}
9398
9399impl ::protobuf::reflect::ProtobufValue for VerifyMessageRequest {
9400 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
9401 ::protobuf::reflect::ProtobufValueRef::Message(self)
9402 }
9403}
9404
9405#[derive(PartialEq,Clone,Default)]
9406pub struct VerifyMessageResponse {
9407 pub is_signed_by_key: bool,
9409 pub unknown_fields: ::protobuf::UnknownFields,
9411 pub cached_size: ::protobuf::CachedSize,
9412}
9413
9414impl<'a> ::std::default::Default for &'a VerifyMessageResponse {
9415 fn default() -> &'a VerifyMessageResponse {
9416 <VerifyMessageResponse as ::protobuf::Message>::default_instance()
9417 }
9418}
9419
9420impl VerifyMessageResponse {
9421 pub fn new() -> VerifyMessageResponse {
9422 ::std::default::Default::default()
9423 }
9424
9425 pub fn get_is_signed_by_key(&self) -> bool {
9429 self.is_signed_by_key
9430 }
9431 pub fn clear_is_signed_by_key(&mut self) {
9432 self.is_signed_by_key = false;
9433 }
9434
9435 pub fn set_is_signed_by_key(&mut self, v: bool) {
9437 self.is_signed_by_key = v;
9438 }
9439}
9440
9441impl ::protobuf::Message for VerifyMessageResponse {
9442 fn is_initialized(&self) -> bool {
9443 true
9444 }
9445
9446 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9447 while !is.eof()? {
9448 let (field_number, wire_type) = is.read_tag_unpack()?;
9449 match field_number {
9450 1 => {
9451 if wire_type != ::protobuf::wire_format::WireTypeVarint {
9452 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
9453 }
9454 let tmp = is.read_bool()?;
9455 self.is_signed_by_key = tmp;
9456 },
9457 _ => {
9458 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
9459 },
9460 };
9461 }
9462 ::std::result::Result::Ok(())
9463 }
9464
9465 #[allow(unused_variables)]
9467 fn compute_size(&self) -> u32 {
9468 let mut my_size = 0;
9469 if self.is_signed_by_key != false {
9470 my_size += 2;
9471 }
9472 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
9473 self.cached_size.set(my_size);
9474 my_size
9475 }
9476
9477 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9478 if self.is_signed_by_key != false {
9479 os.write_bool(1, self.is_signed_by_key)?;
9480 }
9481 os.write_unknown_fields(self.get_unknown_fields())?;
9482 ::std::result::Result::Ok(())
9483 }
9484
9485 fn get_cached_size(&self) -> u32 {
9486 self.cached_size.get()
9487 }
9488
9489 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
9490 &self.unknown_fields
9491 }
9492
9493 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
9494 &mut self.unknown_fields
9495 }
9496
9497 fn as_any(&self) -> &dyn (::std::any::Any) {
9498 self as &dyn (::std::any::Any)
9499 }
9500 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
9501 self as &mut dyn (::std::any::Any)
9502 }
9503 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
9504 self
9505 }
9506
9507 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
9508 Self::descriptor_static()
9509 }
9510
9511 fn new() -> VerifyMessageResponse {
9512 VerifyMessageResponse::new()
9513 }
9514
9515 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
9516 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
9517 lock: ::protobuf::lazy::ONCE_INIT,
9518 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
9519 };
9520 unsafe {
9521 descriptor.get(|| {
9522 let mut fields = ::std::vec::Vec::new();
9523 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
9524 "is_signed_by_key",
9525 |m: &VerifyMessageResponse| { &m.is_signed_by_key },
9526 |m: &mut VerifyMessageResponse| { &mut m.is_signed_by_key },
9527 ));
9528 ::protobuf::reflect::MessageDescriptor::new::<VerifyMessageResponse>(
9529 "VerifyMessageResponse",
9530 fields,
9531 file_descriptor_proto()
9532 )
9533 })
9534 }
9535 }
9536
9537 fn default_instance() -> &'static VerifyMessageResponse {
9538 static mut instance: ::protobuf::lazy::Lazy<VerifyMessageResponse> = ::protobuf::lazy::Lazy {
9539 lock: ::protobuf::lazy::ONCE_INIT,
9540 ptr: 0 as *const VerifyMessageResponse,
9541 };
9542 unsafe {
9543 instance.get(VerifyMessageResponse::new)
9544 }
9545 }
9546}
9547
9548impl ::protobuf::Clear for VerifyMessageResponse {
9549 fn clear(&mut self) {
9550 self.is_signed_by_key = false;
9551 self.unknown_fields.clear();
9552 }
9553}
9554
9555impl ::std::fmt::Debug for VerifyMessageResponse {
9556 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9557 ::protobuf::text_format::fmt(self, f)
9558 }
9559}
9560
9561impl ::protobuf::reflect::ProtobufValue for VerifyMessageResponse {
9562 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
9563 ::protobuf::reflect::ProtobufValueRef::Message(self)
9564 }
9565}
9566
9567#[derive(PartialEq,Clone,Default)]
9568pub struct ServiceStatusRequest {
9569 pub query: bool,
9571 pub unknown_fields: ::protobuf::UnknownFields,
9573 pub cached_size: ::protobuf::CachedSize,
9574}
9575
9576impl<'a> ::std::default::Default for &'a ServiceStatusRequest {
9577 fn default() -> &'a ServiceStatusRequest {
9578 <ServiceStatusRequest as ::protobuf::Message>::default_instance()
9579 }
9580}
9581
9582impl ServiceStatusRequest {
9583 pub fn new() -> ServiceStatusRequest {
9584 ::std::default::Default::default()
9585 }
9586
9587 pub fn get_query(&self) -> bool {
9591 self.query
9592 }
9593 pub fn clear_query(&mut self) {
9594 self.query = false;
9595 }
9596
9597 pub fn set_query(&mut self, v: bool) {
9599 self.query = v;
9600 }
9601}
9602
9603impl ::protobuf::Message for ServiceStatusRequest {
9604 fn is_initialized(&self) -> bool {
9605 true
9606 }
9607
9608 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9609 while !is.eof()? {
9610 let (field_number, wire_type) = is.read_tag_unpack()?;
9611 match field_number {
9612 1 => {
9613 if wire_type != ::protobuf::wire_format::WireTypeVarint {
9614 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
9615 }
9616 let tmp = is.read_bool()?;
9617 self.query = tmp;
9618 },
9619 _ => {
9620 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
9621 },
9622 };
9623 }
9624 ::std::result::Result::Ok(())
9625 }
9626
9627 #[allow(unused_variables)]
9629 fn compute_size(&self) -> u32 {
9630 let mut my_size = 0;
9631 if self.query != false {
9632 my_size += 2;
9633 }
9634 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
9635 self.cached_size.set(my_size);
9636 my_size
9637 }
9638
9639 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9640 if self.query != false {
9641 os.write_bool(1, self.query)?;
9642 }
9643 os.write_unknown_fields(self.get_unknown_fields())?;
9644 ::std::result::Result::Ok(())
9645 }
9646
9647 fn get_cached_size(&self) -> u32 {
9648 self.cached_size.get()
9649 }
9650
9651 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
9652 &self.unknown_fields
9653 }
9654
9655 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
9656 &mut self.unknown_fields
9657 }
9658
9659 fn as_any(&self) -> &dyn (::std::any::Any) {
9660 self as &dyn (::std::any::Any)
9661 }
9662 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
9663 self as &mut dyn (::std::any::Any)
9664 }
9665 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
9666 self
9667 }
9668
9669 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
9670 Self::descriptor_static()
9671 }
9672
9673 fn new() -> ServiceStatusRequest {
9674 ServiceStatusRequest::new()
9675 }
9676
9677 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
9678 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
9679 lock: ::protobuf::lazy::ONCE_INIT,
9680 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
9681 };
9682 unsafe {
9683 descriptor.get(|| {
9684 let mut fields = ::std::vec::Vec::new();
9685 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
9686 "query",
9687 |m: &ServiceStatusRequest| { &m.query },
9688 |m: &mut ServiceStatusRequest| { &mut m.query },
9689 ));
9690 ::protobuf::reflect::MessageDescriptor::new::<ServiceStatusRequest>(
9691 "ServiceStatusRequest",
9692 fields,
9693 file_descriptor_proto()
9694 )
9695 })
9696 }
9697 }
9698
9699 fn default_instance() -> &'static ServiceStatusRequest {
9700 static mut instance: ::protobuf::lazy::Lazy<ServiceStatusRequest> = ::protobuf::lazy::Lazy {
9701 lock: ::protobuf::lazy::ONCE_INIT,
9702 ptr: 0 as *const ServiceStatusRequest,
9703 };
9704 unsafe {
9705 instance.get(ServiceStatusRequest::new)
9706 }
9707 }
9708}
9709
9710impl ::protobuf::Clear for ServiceStatusRequest {
9711 fn clear(&mut self) {
9712 self.query = false;
9713 self.unknown_fields.clear();
9714 }
9715}
9716
9717impl ::std::fmt::Debug for ServiceStatusRequest {
9718 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9719 ::protobuf::text_format::fmt(self, f)
9720 }
9721}
9722
9723impl ::protobuf::reflect::ProtobufValue for ServiceStatusRequest {
9724 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
9725 ::protobuf::reflect::ProtobufValueRef::Message(self)
9726 }
9727}
9728
9729#[derive(PartialEq,Clone,Default)]
9730pub struct ServiceStatusResponse {
9731 pub query: ::std::string::String,
9733 pub unknown_fields: ::protobuf::UnknownFields,
9735 pub cached_size: ::protobuf::CachedSize,
9736}
9737
9738impl<'a> ::std::default::Default for &'a ServiceStatusResponse {
9739 fn default() -> &'a ServiceStatusResponse {
9740 <ServiceStatusResponse as ::protobuf::Message>::default_instance()
9741 }
9742}
9743
9744impl ServiceStatusResponse {
9745 pub fn new() -> ServiceStatusResponse {
9746 ::std::default::Default::default()
9747 }
9748
9749 pub fn get_query(&self) -> &str {
9753 &self.query
9754 }
9755 pub fn clear_query(&mut self) {
9756 self.query.clear();
9757 }
9758
9759 pub fn set_query(&mut self, v: ::std::string::String) {
9761 self.query = v;
9762 }
9763
9764 pub fn mut_query(&mut self) -> &mut ::std::string::String {
9767 &mut self.query
9768 }
9769
9770 pub fn take_query(&mut self) -> ::std::string::String {
9772 ::std::mem::replace(&mut self.query, ::std::string::String::new())
9773 }
9774}
9775
9776impl ::protobuf::Message for ServiceStatusResponse {
9777 fn is_initialized(&self) -> bool {
9778 true
9779 }
9780
9781 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9782 while !is.eof()? {
9783 let (field_number, wire_type) = is.read_tag_unpack()?;
9784 match field_number {
9785 1 => {
9786 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
9787 },
9788 _ => {
9789 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
9790 },
9791 };
9792 }
9793 ::std::result::Result::Ok(())
9794 }
9795
9796 #[allow(unused_variables)]
9798 fn compute_size(&self) -> u32 {
9799 let mut my_size = 0;
9800 if !self.query.is_empty() {
9801 my_size += ::protobuf::rt::string_size(1, &self.query);
9802 }
9803 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
9804 self.cached_size.set(my_size);
9805 my_size
9806 }
9807
9808 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9809 if !self.query.is_empty() {
9810 os.write_string(1, &self.query)?;
9811 }
9812 os.write_unknown_fields(self.get_unknown_fields())?;
9813 ::std::result::Result::Ok(())
9814 }
9815
9816 fn get_cached_size(&self) -> u32 {
9817 self.cached_size.get()
9818 }
9819
9820 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
9821 &self.unknown_fields
9822 }
9823
9824 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
9825 &mut self.unknown_fields
9826 }
9827
9828 fn as_any(&self) -> &dyn (::std::any::Any) {
9829 self as &dyn (::std::any::Any)
9830 }
9831 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
9832 self as &mut dyn (::std::any::Any)
9833 }
9834 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
9835 self
9836 }
9837
9838 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
9839 Self::descriptor_static()
9840 }
9841
9842 fn new() -> ServiceStatusResponse {
9843 ServiceStatusResponse::new()
9844 }
9845
9846 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
9847 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
9848 lock: ::protobuf::lazy::ONCE_INIT,
9849 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
9850 };
9851 unsafe {
9852 descriptor.get(|| {
9853 let mut fields = ::std::vec::Vec::new();
9854 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
9855 "query",
9856 |m: &ServiceStatusResponse| { &m.query },
9857 |m: &mut ServiceStatusResponse| { &mut m.query },
9858 ));
9859 ::protobuf::reflect::MessageDescriptor::new::<ServiceStatusResponse>(
9860 "ServiceStatusResponse",
9861 fields,
9862 file_descriptor_proto()
9863 )
9864 })
9865 }
9866 }
9867
9868 fn default_instance() -> &'static ServiceStatusResponse {
9869 static mut instance: ::protobuf::lazy::Lazy<ServiceStatusResponse> = ::protobuf::lazy::Lazy {
9870 lock: ::protobuf::lazy::ONCE_INIT,
9871 ptr: 0 as *const ServiceStatusResponse,
9872 };
9873 unsafe {
9874 instance.get(ServiceStatusResponse::new)
9875 }
9876 }
9877}
9878
9879impl ::protobuf::Clear for ServiceStatusResponse {
9880 fn clear(&mut self) {
9881 self.query.clear();
9882 self.unknown_fields.clear();
9883 }
9884}
9885
9886impl ::std::fmt::Debug for ServiceStatusResponse {
9887 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9888 ::protobuf::text_format::fmt(self, f)
9889 }
9890}
9891
9892impl ::protobuf::reflect::ProtobufValue for ServiceStatusResponse {
9893 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
9894 ::protobuf::reflect::ProtobufValueRef::Message(self)
9895 }
9896}
9897
9898#[derive(PartialEq,Clone,Default)]
9899pub struct AddFileToDfsRequest {
9900 pub file_size: u64,
9902 pub file_name: ::std::string::String,
9903 pub node: ::std::string::String,
9904 pub unknown_fields: ::protobuf::UnknownFields,
9906 pub cached_size: ::protobuf::CachedSize,
9907}
9908
9909impl<'a> ::std::default::Default for &'a AddFileToDfsRequest {
9910 fn default() -> &'a AddFileToDfsRequest {
9911 <AddFileToDfsRequest as ::protobuf::Message>::default_instance()
9912 }
9913}
9914
9915impl AddFileToDfsRequest {
9916 pub fn new() -> AddFileToDfsRequest {
9917 ::std::default::Default::default()
9918 }
9919
9920 pub fn get_file_size(&self) -> u64 {
9924 self.file_size
9925 }
9926 pub fn clear_file_size(&mut self) {
9927 self.file_size = 0;
9928 }
9929
9930 pub fn set_file_size(&mut self, v: u64) {
9932 self.file_size = v;
9933 }
9934
9935 pub fn get_file_name(&self) -> &str {
9939 &self.file_name
9940 }
9941 pub fn clear_file_name(&mut self) {
9942 self.file_name.clear();
9943 }
9944
9945 pub fn set_file_name(&mut self, v: ::std::string::String) {
9947 self.file_name = v;
9948 }
9949
9950 pub fn mut_file_name(&mut self) -> &mut ::std::string::String {
9953 &mut self.file_name
9954 }
9955
9956 pub fn take_file_name(&mut self) -> ::std::string::String {
9958 ::std::mem::replace(&mut self.file_name, ::std::string::String::new())
9959 }
9960
9961 pub fn get_node(&self) -> &str {
9965 &self.node
9966 }
9967 pub fn clear_node(&mut self) {
9968 self.node.clear();
9969 }
9970
9971 pub fn set_node(&mut self, v: ::std::string::String) {
9973 self.node = v;
9974 }
9975
9976 pub fn mut_node(&mut self) -> &mut ::std::string::String {
9979 &mut self.node
9980 }
9981
9982 pub fn take_node(&mut self) -> ::std::string::String {
9984 ::std::mem::replace(&mut self.node, ::std::string::String::new())
9985 }
9986}
9987
9988impl ::protobuf::Message for AddFileToDfsRequest {
9989 fn is_initialized(&self) -> bool {
9990 true
9991 }
9992
9993 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
9994 while !is.eof()? {
9995 let (field_number, wire_type) = is.read_tag_unpack()?;
9996 match field_number {
9997 1 => {
9998 if wire_type != ::protobuf::wire_format::WireTypeVarint {
9999 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
10000 }
10001 let tmp = is.read_uint64()?;
10002 self.file_size = tmp;
10003 },
10004 2 => {
10005 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.file_name)?;
10006 },
10007 3 => {
10008 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.node)?;
10009 },
10010 _ => {
10011 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
10012 },
10013 };
10014 }
10015 ::std::result::Result::Ok(())
10016 }
10017
10018 #[allow(unused_variables)]
10020 fn compute_size(&self) -> u32 {
10021 let mut my_size = 0;
10022 if self.file_size != 0 {
10023 my_size += ::protobuf::rt::value_size(1, self.file_size, ::protobuf::wire_format::WireTypeVarint);
10024 }
10025 if !self.file_name.is_empty() {
10026 my_size += ::protobuf::rt::string_size(2, &self.file_name);
10027 }
10028 if !self.node.is_empty() {
10029 my_size += ::protobuf::rt::string_size(3, &self.node);
10030 }
10031 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
10032 self.cached_size.set(my_size);
10033 my_size
10034 }
10035
10036 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10037 if self.file_size != 0 {
10038 os.write_uint64(1, self.file_size)?;
10039 }
10040 if !self.file_name.is_empty() {
10041 os.write_string(2, &self.file_name)?;
10042 }
10043 if !self.node.is_empty() {
10044 os.write_string(3, &self.node)?;
10045 }
10046 os.write_unknown_fields(self.get_unknown_fields())?;
10047 ::std::result::Result::Ok(())
10048 }
10049
10050 fn get_cached_size(&self) -> u32 {
10051 self.cached_size.get()
10052 }
10053
10054 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
10055 &self.unknown_fields
10056 }
10057
10058 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
10059 &mut self.unknown_fields
10060 }
10061
10062 fn as_any(&self) -> &dyn (::std::any::Any) {
10063 self as &dyn (::std::any::Any)
10064 }
10065 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
10066 self as &mut dyn (::std::any::Any)
10067 }
10068 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
10069 self
10070 }
10071
10072 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
10073 Self::descriptor_static()
10074 }
10075
10076 fn new() -> AddFileToDfsRequest {
10077 AddFileToDfsRequest::new()
10078 }
10079
10080 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
10081 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
10082 lock: ::protobuf::lazy::ONCE_INIT,
10083 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
10084 };
10085 unsafe {
10086 descriptor.get(|| {
10087 let mut fields = ::std::vec::Vec::new();
10088 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
10089 "file_size",
10090 |m: &AddFileToDfsRequest| { &m.file_size },
10091 |m: &mut AddFileToDfsRequest| { &mut m.file_size },
10092 ));
10093 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
10094 "file_name",
10095 |m: &AddFileToDfsRequest| { &m.file_name },
10096 |m: &mut AddFileToDfsRequest| { &mut m.file_name },
10097 ));
10098 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
10099 "node",
10100 |m: &AddFileToDfsRequest| { &m.node },
10101 |m: &mut AddFileToDfsRequest| { &mut m.node },
10102 ));
10103 ::protobuf::reflect::MessageDescriptor::new::<AddFileToDfsRequest>(
10104 "AddFileToDfsRequest",
10105 fields,
10106 file_descriptor_proto()
10107 )
10108 })
10109 }
10110 }
10111
10112 fn default_instance() -> &'static AddFileToDfsRequest {
10113 static mut instance: ::protobuf::lazy::Lazy<AddFileToDfsRequest> = ::protobuf::lazy::Lazy {
10114 lock: ::protobuf::lazy::ONCE_INIT,
10115 ptr: 0 as *const AddFileToDfsRequest,
10116 };
10117 unsafe {
10118 instance.get(AddFileToDfsRequest::new)
10119 }
10120 }
10121}
10122
10123impl ::protobuf::Clear for AddFileToDfsRequest {
10124 fn clear(&mut self) {
10125 self.file_size = 0;
10126 self.file_name.clear();
10127 self.node.clear();
10128 self.unknown_fields.clear();
10129 }
10130}
10131
10132impl ::std::fmt::Debug for AddFileToDfsRequest {
10133 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10134 ::protobuf::text_format::fmt(self, f)
10135 }
10136}
10137
10138impl ::protobuf::reflect::ProtobufValue for AddFileToDfsRequest {
10139 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
10140 ::protobuf::reflect::ProtobufValueRef::Message(self)
10141 }
10142}
10143
10144#[derive(PartialEq,Clone,Default)]
10145pub struct AddFileToDfsResponse {
10146 pub response_code: ::std::vec::Vec<u8>,
10148 pub dfs_hash: ::std::string::String,
10149 pub unknown_fields: ::protobuf::UnknownFields,
10151 pub cached_size: ::protobuf::CachedSize,
10152}
10153
10154impl<'a> ::std::default::Default for &'a AddFileToDfsResponse {
10155 fn default() -> &'a AddFileToDfsResponse {
10156 <AddFileToDfsResponse as ::protobuf::Message>::default_instance()
10157 }
10158}
10159
10160impl AddFileToDfsResponse {
10161 pub fn new() -> AddFileToDfsResponse {
10162 ::std::default::Default::default()
10163 }
10164
10165 pub fn get_response_code(&self) -> &[u8] {
10169 &self.response_code
10170 }
10171 pub fn clear_response_code(&mut self) {
10172 self.response_code.clear();
10173 }
10174
10175 pub fn set_response_code(&mut self, v: ::std::vec::Vec<u8>) {
10177 self.response_code = v;
10178 }
10179
10180 pub fn mut_response_code(&mut self) -> &mut ::std::vec::Vec<u8> {
10183 &mut self.response_code
10184 }
10185
10186 pub fn take_response_code(&mut self) -> ::std::vec::Vec<u8> {
10188 ::std::mem::replace(&mut self.response_code, ::std::vec::Vec::new())
10189 }
10190
10191 pub fn get_dfs_hash(&self) -> &str {
10195 &self.dfs_hash
10196 }
10197 pub fn clear_dfs_hash(&mut self) {
10198 self.dfs_hash.clear();
10199 }
10200
10201 pub fn set_dfs_hash(&mut self, v: ::std::string::String) {
10203 self.dfs_hash = v;
10204 }
10205
10206 pub fn mut_dfs_hash(&mut self) -> &mut ::std::string::String {
10209 &mut self.dfs_hash
10210 }
10211
10212 pub fn take_dfs_hash(&mut self) -> ::std::string::String {
10214 ::std::mem::replace(&mut self.dfs_hash, ::std::string::String::new())
10215 }
10216}
10217
10218impl ::protobuf::Message for AddFileToDfsResponse {
10219 fn is_initialized(&self) -> bool {
10220 true
10221 }
10222
10223 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10224 while !is.eof()? {
10225 let (field_number, wire_type) = is.read_tag_unpack()?;
10226 match field_number {
10227 1 => {
10228 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.response_code)?;
10229 },
10230 2 => {
10231 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.dfs_hash)?;
10232 },
10233 _ => {
10234 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
10235 },
10236 };
10237 }
10238 ::std::result::Result::Ok(())
10239 }
10240
10241 #[allow(unused_variables)]
10243 fn compute_size(&self) -> u32 {
10244 let mut my_size = 0;
10245 if !self.response_code.is_empty() {
10246 my_size += ::protobuf::rt::bytes_size(1, &self.response_code);
10247 }
10248 if !self.dfs_hash.is_empty() {
10249 my_size += ::protobuf::rt::string_size(2, &self.dfs_hash);
10250 }
10251 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
10252 self.cached_size.set(my_size);
10253 my_size
10254 }
10255
10256 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10257 if !self.response_code.is_empty() {
10258 os.write_bytes(1, &self.response_code)?;
10259 }
10260 if !self.dfs_hash.is_empty() {
10261 os.write_string(2, &self.dfs_hash)?;
10262 }
10263 os.write_unknown_fields(self.get_unknown_fields())?;
10264 ::std::result::Result::Ok(())
10265 }
10266
10267 fn get_cached_size(&self) -> u32 {
10268 self.cached_size.get()
10269 }
10270
10271 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
10272 &self.unknown_fields
10273 }
10274
10275 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
10276 &mut self.unknown_fields
10277 }
10278
10279 fn as_any(&self) -> &dyn (::std::any::Any) {
10280 self as &dyn (::std::any::Any)
10281 }
10282 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
10283 self as &mut dyn (::std::any::Any)
10284 }
10285 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
10286 self
10287 }
10288
10289 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
10290 Self::descriptor_static()
10291 }
10292
10293 fn new() -> AddFileToDfsResponse {
10294 AddFileToDfsResponse::new()
10295 }
10296
10297 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
10298 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
10299 lock: ::protobuf::lazy::ONCE_INIT,
10300 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
10301 };
10302 unsafe {
10303 descriptor.get(|| {
10304 let mut fields = ::std::vec::Vec::new();
10305 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
10306 "response_code",
10307 |m: &AddFileToDfsResponse| { &m.response_code },
10308 |m: &mut AddFileToDfsResponse| { &mut m.response_code },
10309 ));
10310 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
10311 "dfs_hash",
10312 |m: &AddFileToDfsResponse| { &m.dfs_hash },
10313 |m: &mut AddFileToDfsResponse| { &mut m.dfs_hash },
10314 ));
10315 ::protobuf::reflect::MessageDescriptor::new::<AddFileToDfsResponse>(
10316 "AddFileToDfsResponse",
10317 fields,
10318 file_descriptor_proto()
10319 )
10320 })
10321 }
10322 }
10323
10324 fn default_instance() -> &'static AddFileToDfsResponse {
10325 static mut instance: ::protobuf::lazy::Lazy<AddFileToDfsResponse> = ::protobuf::lazy::Lazy {
10326 lock: ::protobuf::lazy::ONCE_INIT,
10327 ptr: 0 as *const AddFileToDfsResponse,
10328 };
10329 unsafe {
10330 instance.get(AddFileToDfsResponse::new)
10331 }
10332 }
10333}
10334
10335impl ::protobuf::Clear for AddFileToDfsResponse {
10336 fn clear(&mut self) {
10337 self.response_code.clear();
10338 self.dfs_hash.clear();
10339 self.unknown_fields.clear();
10340 }
10341}
10342
10343impl ::std::fmt::Debug for AddFileToDfsResponse {
10344 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10345 ::protobuf::text_format::fmt(self, f)
10346 }
10347}
10348
10349impl ::protobuf::reflect::ProtobufValue for AddFileToDfsResponse {
10350 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
10351 ::protobuf::reflect::ProtobufValueRef::Message(self)
10352 }
10353}
10354
10355#[derive(PartialEq,Clone,Default)]
10356pub struct TransferFileBytesRequest {
10357 pub chunk_id: u32,
10359 pub chunk_bytes: ::std::vec::Vec<u8>,
10360 pub correlation_file_name: ::std::vec::Vec<u8>,
10361 pub unknown_fields: ::protobuf::UnknownFields,
10363 pub cached_size: ::protobuf::CachedSize,
10364}
10365
10366impl<'a> ::std::default::Default for &'a TransferFileBytesRequest {
10367 fn default() -> &'a TransferFileBytesRequest {
10368 <TransferFileBytesRequest as ::protobuf::Message>::default_instance()
10369 }
10370}
10371
10372impl TransferFileBytesRequest {
10373 pub fn new() -> TransferFileBytesRequest {
10374 ::std::default::Default::default()
10375 }
10376
10377 pub fn get_chunk_id(&self) -> u32 {
10381 self.chunk_id
10382 }
10383 pub fn clear_chunk_id(&mut self) {
10384 self.chunk_id = 0;
10385 }
10386
10387 pub fn set_chunk_id(&mut self, v: u32) {
10389 self.chunk_id = v;
10390 }
10391
10392 pub fn get_chunk_bytes(&self) -> &[u8] {
10396 &self.chunk_bytes
10397 }
10398 pub fn clear_chunk_bytes(&mut self) {
10399 self.chunk_bytes.clear();
10400 }
10401
10402 pub fn set_chunk_bytes(&mut self, v: ::std::vec::Vec<u8>) {
10404 self.chunk_bytes = v;
10405 }
10406
10407 pub fn mut_chunk_bytes(&mut self) -> &mut ::std::vec::Vec<u8> {
10410 &mut self.chunk_bytes
10411 }
10412
10413 pub fn take_chunk_bytes(&mut self) -> ::std::vec::Vec<u8> {
10415 ::std::mem::replace(&mut self.chunk_bytes, ::std::vec::Vec::new())
10416 }
10417
10418 pub fn get_correlation_file_name(&self) -> &[u8] {
10422 &self.correlation_file_name
10423 }
10424 pub fn clear_correlation_file_name(&mut self) {
10425 self.correlation_file_name.clear();
10426 }
10427
10428 pub fn set_correlation_file_name(&mut self, v: ::std::vec::Vec<u8>) {
10430 self.correlation_file_name = v;
10431 }
10432
10433 pub fn mut_correlation_file_name(&mut self) -> &mut ::std::vec::Vec<u8> {
10436 &mut self.correlation_file_name
10437 }
10438
10439 pub fn take_correlation_file_name(&mut self) -> ::std::vec::Vec<u8> {
10441 ::std::mem::replace(&mut self.correlation_file_name, ::std::vec::Vec::new())
10442 }
10443}
10444
10445impl ::protobuf::Message for TransferFileBytesRequest {
10446 fn is_initialized(&self) -> bool {
10447 true
10448 }
10449
10450 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10451 while !is.eof()? {
10452 let (field_number, wire_type) = is.read_tag_unpack()?;
10453 match field_number {
10454 1 => {
10455 if wire_type != ::protobuf::wire_format::WireTypeVarint {
10456 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
10457 }
10458 let tmp = is.read_uint32()?;
10459 self.chunk_id = tmp;
10460 },
10461 2 => {
10462 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.chunk_bytes)?;
10463 },
10464 3 => {
10465 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.correlation_file_name)?;
10466 },
10467 _ => {
10468 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
10469 },
10470 };
10471 }
10472 ::std::result::Result::Ok(())
10473 }
10474
10475 #[allow(unused_variables)]
10477 fn compute_size(&self) -> u32 {
10478 let mut my_size = 0;
10479 if self.chunk_id != 0 {
10480 my_size += ::protobuf::rt::value_size(1, self.chunk_id, ::protobuf::wire_format::WireTypeVarint);
10481 }
10482 if !self.chunk_bytes.is_empty() {
10483 my_size += ::protobuf::rt::bytes_size(2, &self.chunk_bytes);
10484 }
10485 if !self.correlation_file_name.is_empty() {
10486 my_size += ::protobuf::rt::bytes_size(3, &self.correlation_file_name);
10487 }
10488 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
10489 self.cached_size.set(my_size);
10490 my_size
10491 }
10492
10493 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10494 if self.chunk_id != 0 {
10495 os.write_uint32(1, self.chunk_id)?;
10496 }
10497 if !self.chunk_bytes.is_empty() {
10498 os.write_bytes(2, &self.chunk_bytes)?;
10499 }
10500 if !self.correlation_file_name.is_empty() {
10501 os.write_bytes(3, &self.correlation_file_name)?;
10502 }
10503 os.write_unknown_fields(self.get_unknown_fields())?;
10504 ::std::result::Result::Ok(())
10505 }
10506
10507 fn get_cached_size(&self) -> u32 {
10508 self.cached_size.get()
10509 }
10510
10511 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
10512 &self.unknown_fields
10513 }
10514
10515 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
10516 &mut self.unknown_fields
10517 }
10518
10519 fn as_any(&self) -> &dyn (::std::any::Any) {
10520 self as &dyn (::std::any::Any)
10521 }
10522 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
10523 self as &mut dyn (::std::any::Any)
10524 }
10525 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
10526 self
10527 }
10528
10529 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
10530 Self::descriptor_static()
10531 }
10532
10533 fn new() -> TransferFileBytesRequest {
10534 TransferFileBytesRequest::new()
10535 }
10536
10537 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
10538 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
10539 lock: ::protobuf::lazy::ONCE_INIT,
10540 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
10541 };
10542 unsafe {
10543 descriptor.get(|| {
10544 let mut fields = ::std::vec::Vec::new();
10545 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
10546 "chunk_id",
10547 |m: &TransferFileBytesRequest| { &m.chunk_id },
10548 |m: &mut TransferFileBytesRequest| { &mut m.chunk_id },
10549 ));
10550 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
10551 "chunk_bytes",
10552 |m: &TransferFileBytesRequest| { &m.chunk_bytes },
10553 |m: &mut TransferFileBytesRequest| { &mut m.chunk_bytes },
10554 ));
10555 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
10556 "correlation_file_name",
10557 |m: &TransferFileBytesRequest| { &m.correlation_file_name },
10558 |m: &mut TransferFileBytesRequest| { &mut m.correlation_file_name },
10559 ));
10560 ::protobuf::reflect::MessageDescriptor::new::<TransferFileBytesRequest>(
10561 "TransferFileBytesRequest",
10562 fields,
10563 file_descriptor_proto()
10564 )
10565 })
10566 }
10567 }
10568
10569 fn default_instance() -> &'static TransferFileBytesRequest {
10570 static mut instance: ::protobuf::lazy::Lazy<TransferFileBytesRequest> = ::protobuf::lazy::Lazy {
10571 lock: ::protobuf::lazy::ONCE_INIT,
10572 ptr: 0 as *const TransferFileBytesRequest,
10573 };
10574 unsafe {
10575 instance.get(TransferFileBytesRequest::new)
10576 }
10577 }
10578}
10579
10580impl ::protobuf::Clear for TransferFileBytesRequest {
10581 fn clear(&mut self) {
10582 self.chunk_id = 0;
10583 self.chunk_bytes.clear();
10584 self.correlation_file_name.clear();
10585 self.unknown_fields.clear();
10586 }
10587}
10588
10589impl ::std::fmt::Debug for TransferFileBytesRequest {
10590 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10591 ::protobuf::text_format::fmt(self, f)
10592 }
10593}
10594
10595impl ::protobuf::reflect::ProtobufValue for TransferFileBytesRequest {
10596 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
10597 ::protobuf::reflect::ProtobufValueRef::Message(self)
10598 }
10599}
10600
10601#[derive(PartialEq,Clone,Default)]
10602pub struct TransferFileBytesResponse {
10603 pub response_code: ::std::vec::Vec<u8>,
10605 pub unknown_fields: ::protobuf::UnknownFields,
10607 pub cached_size: ::protobuf::CachedSize,
10608}
10609
10610impl<'a> ::std::default::Default for &'a TransferFileBytesResponse {
10611 fn default() -> &'a TransferFileBytesResponse {
10612 <TransferFileBytesResponse as ::protobuf::Message>::default_instance()
10613 }
10614}
10615
10616impl TransferFileBytesResponse {
10617 pub fn new() -> TransferFileBytesResponse {
10618 ::std::default::Default::default()
10619 }
10620
10621 pub fn get_response_code(&self) -> &[u8] {
10625 &self.response_code
10626 }
10627 pub fn clear_response_code(&mut self) {
10628 self.response_code.clear();
10629 }
10630
10631 pub fn set_response_code(&mut self, v: ::std::vec::Vec<u8>) {
10633 self.response_code = v;
10634 }
10635
10636 pub fn mut_response_code(&mut self) -> &mut ::std::vec::Vec<u8> {
10639 &mut self.response_code
10640 }
10641
10642 pub fn take_response_code(&mut self) -> ::std::vec::Vec<u8> {
10644 ::std::mem::replace(&mut self.response_code, ::std::vec::Vec::new())
10645 }
10646}
10647
10648impl ::protobuf::Message for TransferFileBytesResponse {
10649 fn is_initialized(&self) -> bool {
10650 true
10651 }
10652
10653 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10654 while !is.eof()? {
10655 let (field_number, wire_type) = is.read_tag_unpack()?;
10656 match field_number {
10657 1 => {
10658 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.response_code)?;
10659 },
10660 _ => {
10661 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
10662 },
10663 };
10664 }
10665 ::std::result::Result::Ok(())
10666 }
10667
10668 #[allow(unused_variables)]
10670 fn compute_size(&self) -> u32 {
10671 let mut my_size = 0;
10672 if !self.response_code.is_empty() {
10673 my_size += ::protobuf::rt::bytes_size(1, &self.response_code);
10674 }
10675 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
10676 self.cached_size.set(my_size);
10677 my_size
10678 }
10679
10680 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10681 if !self.response_code.is_empty() {
10682 os.write_bytes(1, &self.response_code)?;
10683 }
10684 os.write_unknown_fields(self.get_unknown_fields())?;
10685 ::std::result::Result::Ok(())
10686 }
10687
10688 fn get_cached_size(&self) -> u32 {
10689 self.cached_size.get()
10690 }
10691
10692 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
10693 &self.unknown_fields
10694 }
10695
10696 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
10697 &mut self.unknown_fields
10698 }
10699
10700 fn as_any(&self) -> &dyn (::std::any::Any) {
10701 self as &dyn (::std::any::Any)
10702 }
10703 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
10704 self as &mut dyn (::std::any::Any)
10705 }
10706 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
10707 self
10708 }
10709
10710 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
10711 Self::descriptor_static()
10712 }
10713
10714 fn new() -> TransferFileBytesResponse {
10715 TransferFileBytesResponse::new()
10716 }
10717
10718 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
10719 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
10720 lock: ::protobuf::lazy::ONCE_INIT,
10721 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
10722 };
10723 unsafe {
10724 descriptor.get(|| {
10725 let mut fields = ::std::vec::Vec::new();
10726 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
10727 "response_code",
10728 |m: &TransferFileBytesResponse| { &m.response_code },
10729 |m: &mut TransferFileBytesResponse| { &mut m.response_code },
10730 ));
10731 ::protobuf::reflect::MessageDescriptor::new::<TransferFileBytesResponse>(
10732 "TransferFileBytesResponse",
10733 fields,
10734 file_descriptor_proto()
10735 )
10736 })
10737 }
10738 }
10739
10740 fn default_instance() -> &'static TransferFileBytesResponse {
10741 static mut instance: ::protobuf::lazy::Lazy<TransferFileBytesResponse> = ::protobuf::lazy::Lazy {
10742 lock: ::protobuf::lazy::ONCE_INIT,
10743 ptr: 0 as *const TransferFileBytesResponse,
10744 };
10745 unsafe {
10746 instance.get(TransferFileBytesResponse::new)
10747 }
10748 }
10749}
10750
10751impl ::protobuf::Clear for TransferFileBytesResponse {
10752 fn clear(&mut self) {
10753 self.response_code.clear();
10754 self.unknown_fields.clear();
10755 }
10756}
10757
10758impl ::std::fmt::Debug for TransferFileBytesResponse {
10759 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10760 ::protobuf::text_format::fmt(self, f)
10761 }
10762}
10763
10764impl ::protobuf::reflect::ProtobufValue for TransferFileBytesResponse {
10765 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
10766 ::protobuf::reflect::ProtobufValueRef::Message(self)
10767 }
10768}
10769
10770#[derive(PartialEq,Clone,Default)]
10771pub struct RemovePeerRequest {
10772 pub peer_ip: ::std::vec::Vec<u8>,
10774 pub public_key: ::std::vec::Vec<u8>,
10775 pub unknown_fields: ::protobuf::UnknownFields,
10777 pub cached_size: ::protobuf::CachedSize,
10778}
10779
10780impl<'a> ::std::default::Default for &'a RemovePeerRequest {
10781 fn default() -> &'a RemovePeerRequest {
10782 <RemovePeerRequest as ::protobuf::Message>::default_instance()
10783 }
10784}
10785
10786impl RemovePeerRequest {
10787 pub fn new() -> RemovePeerRequest {
10788 ::std::default::Default::default()
10789 }
10790
10791 pub fn get_peer_ip(&self) -> &[u8] {
10795 &self.peer_ip
10796 }
10797 pub fn clear_peer_ip(&mut self) {
10798 self.peer_ip.clear();
10799 }
10800
10801 pub fn set_peer_ip(&mut self, v: ::std::vec::Vec<u8>) {
10803 self.peer_ip = v;
10804 }
10805
10806 pub fn mut_peer_ip(&mut self) -> &mut ::std::vec::Vec<u8> {
10809 &mut self.peer_ip
10810 }
10811
10812 pub fn take_peer_ip(&mut self) -> ::std::vec::Vec<u8> {
10814 ::std::mem::replace(&mut self.peer_ip, ::std::vec::Vec::new())
10815 }
10816
10817 pub fn get_public_key(&self) -> &[u8] {
10821 &self.public_key
10822 }
10823 pub fn clear_public_key(&mut self) {
10824 self.public_key.clear();
10825 }
10826
10827 pub fn set_public_key(&mut self, v: ::std::vec::Vec<u8>) {
10829 self.public_key = v;
10830 }
10831
10832 pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
10835 &mut self.public_key
10836 }
10837
10838 pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
10840 ::std::mem::replace(&mut self.public_key, ::std::vec::Vec::new())
10841 }
10842}
10843
10844impl ::protobuf::Message for RemovePeerRequest {
10845 fn is_initialized(&self) -> bool {
10846 true
10847 }
10848
10849 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10850 while !is.eof()? {
10851 let (field_number, wire_type) = is.read_tag_unpack()?;
10852 match field_number {
10853 1 => {
10854 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.peer_ip)?;
10855 },
10856 2 => {
10857 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.public_key)?;
10858 },
10859 _ => {
10860 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
10861 },
10862 };
10863 }
10864 ::std::result::Result::Ok(())
10865 }
10866
10867 #[allow(unused_variables)]
10869 fn compute_size(&self) -> u32 {
10870 let mut my_size = 0;
10871 if !self.peer_ip.is_empty() {
10872 my_size += ::protobuf::rt::bytes_size(1, &self.peer_ip);
10873 }
10874 if !self.public_key.is_empty() {
10875 my_size += ::protobuf::rt::bytes_size(2, &self.public_key);
10876 }
10877 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
10878 self.cached_size.set(my_size);
10879 my_size
10880 }
10881
10882 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
10883 if !self.peer_ip.is_empty() {
10884 os.write_bytes(1, &self.peer_ip)?;
10885 }
10886 if !self.public_key.is_empty() {
10887 os.write_bytes(2, &self.public_key)?;
10888 }
10889 os.write_unknown_fields(self.get_unknown_fields())?;
10890 ::std::result::Result::Ok(())
10891 }
10892
10893 fn get_cached_size(&self) -> u32 {
10894 self.cached_size.get()
10895 }
10896
10897 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
10898 &self.unknown_fields
10899 }
10900
10901 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
10902 &mut self.unknown_fields
10903 }
10904
10905 fn as_any(&self) -> &dyn (::std::any::Any) {
10906 self as &dyn (::std::any::Any)
10907 }
10908 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
10909 self as &mut dyn (::std::any::Any)
10910 }
10911 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
10912 self
10913 }
10914
10915 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
10916 Self::descriptor_static()
10917 }
10918
10919 fn new() -> RemovePeerRequest {
10920 RemovePeerRequest::new()
10921 }
10922
10923 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
10924 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
10925 lock: ::protobuf::lazy::ONCE_INIT,
10926 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
10927 };
10928 unsafe {
10929 descriptor.get(|| {
10930 let mut fields = ::std::vec::Vec::new();
10931 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
10932 "peer_ip",
10933 |m: &RemovePeerRequest| { &m.peer_ip },
10934 |m: &mut RemovePeerRequest| { &mut m.peer_ip },
10935 ));
10936 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
10937 "public_key",
10938 |m: &RemovePeerRequest| { &m.public_key },
10939 |m: &mut RemovePeerRequest| { &mut m.public_key },
10940 ));
10941 ::protobuf::reflect::MessageDescriptor::new::<RemovePeerRequest>(
10942 "RemovePeerRequest",
10943 fields,
10944 file_descriptor_proto()
10945 )
10946 })
10947 }
10948 }
10949
10950 fn default_instance() -> &'static RemovePeerRequest {
10951 static mut instance: ::protobuf::lazy::Lazy<RemovePeerRequest> = ::protobuf::lazy::Lazy {
10952 lock: ::protobuf::lazy::ONCE_INIT,
10953 ptr: 0 as *const RemovePeerRequest,
10954 };
10955 unsafe {
10956 instance.get(RemovePeerRequest::new)
10957 }
10958 }
10959}
10960
10961impl ::protobuf::Clear for RemovePeerRequest {
10962 fn clear(&mut self) {
10963 self.peer_ip.clear();
10964 self.public_key.clear();
10965 self.unknown_fields.clear();
10966 }
10967}
10968
10969impl ::std::fmt::Debug for RemovePeerRequest {
10970 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10971 ::protobuf::text_format::fmt(self, f)
10972 }
10973}
10974
10975impl ::protobuf::reflect::ProtobufValue for RemovePeerRequest {
10976 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
10977 ::protobuf::reflect::ProtobufValueRef::Message(self)
10978 }
10979}
10980
10981#[derive(PartialEq,Clone,Default)]
10982pub struct RemovePeerResponse {
10983 pub deleted_count: u32,
10985 pub unknown_fields: ::protobuf::UnknownFields,
10987 pub cached_size: ::protobuf::CachedSize,
10988}
10989
10990impl<'a> ::std::default::Default for &'a RemovePeerResponse {
10991 fn default() -> &'a RemovePeerResponse {
10992 <RemovePeerResponse as ::protobuf::Message>::default_instance()
10993 }
10994}
10995
10996impl RemovePeerResponse {
10997 pub fn new() -> RemovePeerResponse {
10998 ::std::default::Default::default()
10999 }
11000
11001 pub fn get_deleted_count(&self) -> u32 {
11005 self.deleted_count
11006 }
11007 pub fn clear_deleted_count(&mut self) {
11008 self.deleted_count = 0;
11009 }
11010
11011 pub fn set_deleted_count(&mut self, v: u32) {
11013 self.deleted_count = v;
11014 }
11015}
11016
11017impl ::protobuf::Message for RemovePeerResponse {
11018 fn is_initialized(&self) -> bool {
11019 true
11020 }
11021
11022 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11023 while !is.eof()? {
11024 let (field_number, wire_type) = is.read_tag_unpack()?;
11025 match field_number {
11026 1 => {
11027 if wire_type != ::protobuf::wire_format::WireTypeVarint {
11028 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
11029 }
11030 let tmp = is.read_uint32()?;
11031 self.deleted_count = tmp;
11032 },
11033 _ => {
11034 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
11035 },
11036 };
11037 }
11038 ::std::result::Result::Ok(())
11039 }
11040
11041 #[allow(unused_variables)]
11043 fn compute_size(&self) -> u32 {
11044 let mut my_size = 0;
11045 if self.deleted_count != 0 {
11046 my_size += ::protobuf::rt::value_size(1, self.deleted_count, ::protobuf::wire_format::WireTypeVarint);
11047 }
11048 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
11049 self.cached_size.set(my_size);
11050 my_size
11051 }
11052
11053 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11054 if self.deleted_count != 0 {
11055 os.write_uint32(1, self.deleted_count)?;
11056 }
11057 os.write_unknown_fields(self.get_unknown_fields())?;
11058 ::std::result::Result::Ok(())
11059 }
11060
11061 fn get_cached_size(&self) -> u32 {
11062 self.cached_size.get()
11063 }
11064
11065 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
11066 &self.unknown_fields
11067 }
11068
11069 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
11070 &mut self.unknown_fields
11071 }
11072
11073 fn as_any(&self) -> &dyn (::std::any::Any) {
11074 self as &dyn (::std::any::Any)
11075 }
11076 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
11077 self as &mut dyn (::std::any::Any)
11078 }
11079 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
11080 self
11081 }
11082
11083 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
11084 Self::descriptor_static()
11085 }
11086
11087 fn new() -> RemovePeerResponse {
11088 RemovePeerResponse::new()
11089 }
11090
11091 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
11092 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
11093 lock: ::protobuf::lazy::ONCE_INIT,
11094 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
11095 };
11096 unsafe {
11097 descriptor.get(|| {
11098 let mut fields = ::std::vec::Vec::new();
11099 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
11100 "deleted_count",
11101 |m: &RemovePeerResponse| { &m.deleted_count },
11102 |m: &mut RemovePeerResponse| { &mut m.deleted_count },
11103 ));
11104 ::protobuf::reflect::MessageDescriptor::new::<RemovePeerResponse>(
11105 "RemovePeerResponse",
11106 fields,
11107 file_descriptor_proto()
11108 )
11109 })
11110 }
11111 }
11112
11113 fn default_instance() -> &'static RemovePeerResponse {
11114 static mut instance: ::protobuf::lazy::Lazy<RemovePeerResponse> = ::protobuf::lazy::Lazy {
11115 lock: ::protobuf::lazy::ONCE_INIT,
11116 ptr: 0 as *const RemovePeerResponse,
11117 };
11118 unsafe {
11119 instance.get(RemovePeerResponse::new)
11120 }
11121 }
11122}
11123
11124impl ::protobuf::Clear for RemovePeerResponse {
11125 fn clear(&mut self) {
11126 self.deleted_count = 0;
11127 self.unknown_fields.clear();
11128 }
11129}
11130
11131impl ::std::fmt::Debug for RemovePeerResponse {
11132 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11133 ::protobuf::text_format::fmt(self, f)
11134 }
11135}
11136
11137impl ::protobuf::reflect::ProtobufValue for RemovePeerResponse {
11138 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
11139 ::protobuf::reflect::ProtobufValueRef::Message(self)
11140 }
11141}
11142
11143#[derive(PartialEq,Clone,Default)]
11144pub struct GetPeerCountRequest {
11145 pub unknown_fields: ::protobuf::UnknownFields,
11147 pub cached_size: ::protobuf::CachedSize,
11148}
11149
11150impl<'a> ::std::default::Default for &'a GetPeerCountRequest {
11151 fn default() -> &'a GetPeerCountRequest {
11152 <GetPeerCountRequest as ::protobuf::Message>::default_instance()
11153 }
11154}
11155
11156impl GetPeerCountRequest {
11157 pub fn new() -> GetPeerCountRequest {
11158 ::std::default::Default::default()
11159 }
11160}
11161
11162impl ::protobuf::Message for GetPeerCountRequest {
11163 fn is_initialized(&self) -> bool {
11164 true
11165 }
11166
11167 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11168 while !is.eof()? {
11169 let (field_number, wire_type) = is.read_tag_unpack()?;
11170 match field_number {
11171 _ => {
11172 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
11173 },
11174 };
11175 }
11176 ::std::result::Result::Ok(())
11177 }
11178
11179 #[allow(unused_variables)]
11181 fn compute_size(&self) -> u32 {
11182 let mut my_size = 0;
11183 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
11184 self.cached_size.set(my_size);
11185 my_size
11186 }
11187
11188 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11189 os.write_unknown_fields(self.get_unknown_fields())?;
11190 ::std::result::Result::Ok(())
11191 }
11192
11193 fn get_cached_size(&self) -> u32 {
11194 self.cached_size.get()
11195 }
11196
11197 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
11198 &self.unknown_fields
11199 }
11200
11201 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
11202 &mut self.unknown_fields
11203 }
11204
11205 fn as_any(&self) -> &dyn (::std::any::Any) {
11206 self as &dyn (::std::any::Any)
11207 }
11208 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
11209 self as &mut dyn (::std::any::Any)
11210 }
11211 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
11212 self
11213 }
11214
11215 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
11216 Self::descriptor_static()
11217 }
11218
11219 fn new() -> GetPeerCountRequest {
11220 GetPeerCountRequest::new()
11221 }
11222
11223 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
11224 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
11225 lock: ::protobuf::lazy::ONCE_INIT,
11226 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
11227 };
11228 unsafe {
11229 descriptor.get(|| {
11230 let fields = ::std::vec::Vec::new();
11231 ::protobuf::reflect::MessageDescriptor::new::<GetPeerCountRequest>(
11232 "GetPeerCountRequest",
11233 fields,
11234 file_descriptor_proto()
11235 )
11236 })
11237 }
11238 }
11239
11240 fn default_instance() -> &'static GetPeerCountRequest {
11241 static mut instance: ::protobuf::lazy::Lazy<GetPeerCountRequest> = ::protobuf::lazy::Lazy {
11242 lock: ::protobuf::lazy::ONCE_INIT,
11243 ptr: 0 as *const GetPeerCountRequest,
11244 };
11245 unsafe {
11246 instance.get(GetPeerCountRequest::new)
11247 }
11248 }
11249}
11250
11251impl ::protobuf::Clear for GetPeerCountRequest {
11252 fn clear(&mut self) {
11253 self.unknown_fields.clear();
11254 }
11255}
11256
11257impl ::std::fmt::Debug for GetPeerCountRequest {
11258 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11259 ::protobuf::text_format::fmt(self, f)
11260 }
11261}
11262
11263impl ::protobuf::reflect::ProtobufValue for GetPeerCountRequest {
11264 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
11265 ::protobuf::reflect::ProtobufValueRef::Message(self)
11266 }
11267}
11268
11269#[derive(PartialEq,Clone,Default)]
11270pub struct GetPeerCountResponse {
11271 pub peer_count: i32,
11273 pub unknown_fields: ::protobuf::UnknownFields,
11275 pub cached_size: ::protobuf::CachedSize,
11276}
11277
11278impl<'a> ::std::default::Default for &'a GetPeerCountResponse {
11279 fn default() -> &'a GetPeerCountResponse {
11280 <GetPeerCountResponse as ::protobuf::Message>::default_instance()
11281 }
11282}
11283
11284impl GetPeerCountResponse {
11285 pub fn new() -> GetPeerCountResponse {
11286 ::std::default::Default::default()
11287 }
11288
11289 pub fn get_peer_count(&self) -> i32 {
11293 self.peer_count
11294 }
11295 pub fn clear_peer_count(&mut self) {
11296 self.peer_count = 0;
11297 }
11298
11299 pub fn set_peer_count(&mut self, v: i32) {
11301 self.peer_count = v;
11302 }
11303}
11304
11305impl ::protobuf::Message for GetPeerCountResponse {
11306 fn is_initialized(&self) -> bool {
11307 true
11308 }
11309
11310 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11311 while !is.eof()? {
11312 let (field_number, wire_type) = is.read_tag_unpack()?;
11313 match field_number {
11314 1 => {
11315 if wire_type != ::protobuf::wire_format::WireTypeVarint {
11316 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
11317 }
11318 let tmp = is.read_int32()?;
11319 self.peer_count = tmp;
11320 },
11321 _ => {
11322 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
11323 },
11324 };
11325 }
11326 ::std::result::Result::Ok(())
11327 }
11328
11329 #[allow(unused_variables)]
11331 fn compute_size(&self) -> u32 {
11332 let mut my_size = 0;
11333 if self.peer_count != 0 {
11334 my_size += ::protobuf::rt::value_size(1, self.peer_count, ::protobuf::wire_format::WireTypeVarint);
11335 }
11336 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
11337 self.cached_size.set(my_size);
11338 my_size
11339 }
11340
11341 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11342 if self.peer_count != 0 {
11343 os.write_int32(1, self.peer_count)?;
11344 }
11345 os.write_unknown_fields(self.get_unknown_fields())?;
11346 ::std::result::Result::Ok(())
11347 }
11348
11349 fn get_cached_size(&self) -> u32 {
11350 self.cached_size.get()
11351 }
11352
11353 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
11354 &self.unknown_fields
11355 }
11356
11357 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
11358 &mut self.unknown_fields
11359 }
11360
11361 fn as_any(&self) -> &dyn (::std::any::Any) {
11362 self as &dyn (::std::any::Any)
11363 }
11364 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
11365 self as &mut dyn (::std::any::Any)
11366 }
11367 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
11368 self
11369 }
11370
11371 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
11372 Self::descriptor_static()
11373 }
11374
11375 fn new() -> GetPeerCountResponse {
11376 GetPeerCountResponse::new()
11377 }
11378
11379 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
11380 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
11381 lock: ::protobuf::lazy::ONCE_INIT,
11382 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
11383 };
11384 unsafe {
11385 descriptor.get(|| {
11386 let mut fields = ::std::vec::Vec::new();
11387 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
11388 "peer_count",
11389 |m: &GetPeerCountResponse| { &m.peer_count },
11390 |m: &mut GetPeerCountResponse| { &mut m.peer_count },
11391 ));
11392 ::protobuf::reflect::MessageDescriptor::new::<GetPeerCountResponse>(
11393 "GetPeerCountResponse",
11394 fields,
11395 file_descriptor_proto()
11396 )
11397 })
11398 }
11399 }
11400
11401 fn default_instance() -> &'static GetPeerCountResponse {
11402 static mut instance: ::protobuf::lazy::Lazy<GetPeerCountResponse> = ::protobuf::lazy::Lazy {
11403 lock: ::protobuf::lazy::ONCE_INIT,
11404 ptr: 0 as *const GetPeerCountResponse,
11405 };
11406 unsafe {
11407 instance.get(GetPeerCountResponse::new)
11408 }
11409 }
11410}
11411
11412impl ::protobuf::Clear for GetPeerCountResponse {
11413 fn clear(&mut self) {
11414 self.peer_count = 0;
11415 self.unknown_fields.clear();
11416 }
11417}
11418
11419impl ::std::fmt::Debug for GetPeerCountResponse {
11420 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11421 ::protobuf::text_format::fmt(self, f)
11422 }
11423}
11424
11425impl ::protobuf::reflect::ProtobufValue for GetPeerCountResponse {
11426 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
11427 ::protobuf::reflect::ProtobufValueRef::Message(self)
11428 }
11429}
11430
11431#[derive(PartialEq,Clone,Default)]
11432pub struct GetFileFromDfsRequest {
11433 pub dfs_hash: ::std::string::String,
11435 pub unknown_fields: ::protobuf::UnknownFields,
11437 pub cached_size: ::protobuf::CachedSize,
11438}
11439
11440impl<'a> ::std::default::Default for &'a GetFileFromDfsRequest {
11441 fn default() -> &'a GetFileFromDfsRequest {
11442 <GetFileFromDfsRequest as ::protobuf::Message>::default_instance()
11443 }
11444}
11445
11446impl GetFileFromDfsRequest {
11447 pub fn new() -> GetFileFromDfsRequest {
11448 ::std::default::Default::default()
11449 }
11450
11451 pub fn get_dfs_hash(&self) -> &str {
11455 &self.dfs_hash
11456 }
11457 pub fn clear_dfs_hash(&mut self) {
11458 self.dfs_hash.clear();
11459 }
11460
11461 pub fn set_dfs_hash(&mut self, v: ::std::string::String) {
11463 self.dfs_hash = v;
11464 }
11465
11466 pub fn mut_dfs_hash(&mut self) -> &mut ::std::string::String {
11469 &mut self.dfs_hash
11470 }
11471
11472 pub fn take_dfs_hash(&mut self) -> ::std::string::String {
11474 ::std::mem::replace(&mut self.dfs_hash, ::std::string::String::new())
11475 }
11476}
11477
11478impl ::protobuf::Message for GetFileFromDfsRequest {
11479 fn is_initialized(&self) -> bool {
11480 true
11481 }
11482
11483 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11484 while !is.eof()? {
11485 let (field_number, wire_type) = is.read_tag_unpack()?;
11486 match field_number {
11487 1 => {
11488 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.dfs_hash)?;
11489 },
11490 _ => {
11491 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
11492 },
11493 };
11494 }
11495 ::std::result::Result::Ok(())
11496 }
11497
11498 #[allow(unused_variables)]
11500 fn compute_size(&self) -> u32 {
11501 let mut my_size = 0;
11502 if !self.dfs_hash.is_empty() {
11503 my_size += ::protobuf::rt::string_size(1, &self.dfs_hash);
11504 }
11505 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
11506 self.cached_size.set(my_size);
11507 my_size
11508 }
11509
11510 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11511 if !self.dfs_hash.is_empty() {
11512 os.write_string(1, &self.dfs_hash)?;
11513 }
11514 os.write_unknown_fields(self.get_unknown_fields())?;
11515 ::std::result::Result::Ok(())
11516 }
11517
11518 fn get_cached_size(&self) -> u32 {
11519 self.cached_size.get()
11520 }
11521
11522 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
11523 &self.unknown_fields
11524 }
11525
11526 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
11527 &mut self.unknown_fields
11528 }
11529
11530 fn as_any(&self) -> &dyn (::std::any::Any) {
11531 self as &dyn (::std::any::Any)
11532 }
11533 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
11534 self as &mut dyn (::std::any::Any)
11535 }
11536 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
11537 self
11538 }
11539
11540 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
11541 Self::descriptor_static()
11542 }
11543
11544 fn new() -> GetFileFromDfsRequest {
11545 GetFileFromDfsRequest::new()
11546 }
11547
11548 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
11549 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
11550 lock: ::protobuf::lazy::ONCE_INIT,
11551 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
11552 };
11553 unsafe {
11554 descriptor.get(|| {
11555 let mut fields = ::std::vec::Vec::new();
11556 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
11557 "dfs_hash",
11558 |m: &GetFileFromDfsRequest| { &m.dfs_hash },
11559 |m: &mut GetFileFromDfsRequest| { &mut m.dfs_hash },
11560 ));
11561 ::protobuf::reflect::MessageDescriptor::new::<GetFileFromDfsRequest>(
11562 "GetFileFromDfsRequest",
11563 fields,
11564 file_descriptor_proto()
11565 )
11566 })
11567 }
11568 }
11569
11570 fn default_instance() -> &'static GetFileFromDfsRequest {
11571 static mut instance: ::protobuf::lazy::Lazy<GetFileFromDfsRequest> = ::protobuf::lazy::Lazy {
11572 lock: ::protobuf::lazy::ONCE_INIT,
11573 ptr: 0 as *const GetFileFromDfsRequest,
11574 };
11575 unsafe {
11576 instance.get(GetFileFromDfsRequest::new)
11577 }
11578 }
11579}
11580
11581impl ::protobuf::Clear for GetFileFromDfsRequest {
11582 fn clear(&mut self) {
11583 self.dfs_hash.clear();
11584 self.unknown_fields.clear();
11585 }
11586}
11587
11588impl ::std::fmt::Debug for GetFileFromDfsRequest {
11589 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11590 ::protobuf::text_format::fmt(self, f)
11591 }
11592}
11593
11594impl ::protobuf::reflect::ProtobufValue for GetFileFromDfsRequest {
11595 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
11596 ::protobuf::reflect::ProtobufValueRef::Message(self)
11597 }
11598}
11599
11600#[derive(PartialEq,Clone,Default)]
11601pub struct GetFileFromDfsResponse {
11602 pub file_size: u64,
11604 pub response_code: ::std::vec::Vec<u8>,
11605 pub unknown_fields: ::protobuf::UnknownFields,
11607 pub cached_size: ::protobuf::CachedSize,
11608}
11609
11610impl<'a> ::std::default::Default for &'a GetFileFromDfsResponse {
11611 fn default() -> &'a GetFileFromDfsResponse {
11612 <GetFileFromDfsResponse as ::protobuf::Message>::default_instance()
11613 }
11614}
11615
11616impl GetFileFromDfsResponse {
11617 pub fn new() -> GetFileFromDfsResponse {
11618 ::std::default::Default::default()
11619 }
11620
11621 pub fn get_file_size(&self) -> u64 {
11625 self.file_size
11626 }
11627 pub fn clear_file_size(&mut self) {
11628 self.file_size = 0;
11629 }
11630
11631 pub fn set_file_size(&mut self, v: u64) {
11633 self.file_size = v;
11634 }
11635
11636 pub fn get_response_code(&self) -> &[u8] {
11640 &self.response_code
11641 }
11642 pub fn clear_response_code(&mut self) {
11643 self.response_code.clear();
11644 }
11645
11646 pub fn set_response_code(&mut self, v: ::std::vec::Vec<u8>) {
11648 self.response_code = v;
11649 }
11650
11651 pub fn mut_response_code(&mut self) -> &mut ::std::vec::Vec<u8> {
11654 &mut self.response_code
11655 }
11656
11657 pub fn take_response_code(&mut self) -> ::std::vec::Vec<u8> {
11659 ::std::mem::replace(&mut self.response_code, ::std::vec::Vec::new())
11660 }
11661}
11662
11663impl ::protobuf::Message for GetFileFromDfsResponse {
11664 fn is_initialized(&self) -> bool {
11665 true
11666 }
11667
11668 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11669 while !is.eof()? {
11670 let (field_number, wire_type) = is.read_tag_unpack()?;
11671 match field_number {
11672 1 => {
11673 if wire_type != ::protobuf::wire_format::WireTypeVarint {
11674 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
11675 }
11676 let tmp = is.read_uint64()?;
11677 self.file_size = tmp;
11678 },
11679 2 => {
11680 ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.response_code)?;
11681 },
11682 _ => {
11683 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
11684 },
11685 };
11686 }
11687 ::std::result::Result::Ok(())
11688 }
11689
11690 #[allow(unused_variables)]
11692 fn compute_size(&self) -> u32 {
11693 let mut my_size = 0;
11694 if self.file_size != 0 {
11695 my_size += ::protobuf::rt::value_size(1, self.file_size, ::protobuf::wire_format::WireTypeVarint);
11696 }
11697 if !self.response_code.is_empty() {
11698 my_size += ::protobuf::rt::bytes_size(2, &self.response_code);
11699 }
11700 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
11701 self.cached_size.set(my_size);
11702 my_size
11703 }
11704
11705 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11706 if self.file_size != 0 {
11707 os.write_uint64(1, self.file_size)?;
11708 }
11709 if !self.response_code.is_empty() {
11710 os.write_bytes(2, &self.response_code)?;
11711 }
11712 os.write_unknown_fields(self.get_unknown_fields())?;
11713 ::std::result::Result::Ok(())
11714 }
11715
11716 fn get_cached_size(&self) -> u32 {
11717 self.cached_size.get()
11718 }
11719
11720 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
11721 &self.unknown_fields
11722 }
11723
11724 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
11725 &mut self.unknown_fields
11726 }
11727
11728 fn as_any(&self) -> &dyn (::std::any::Any) {
11729 self as &dyn (::std::any::Any)
11730 }
11731 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
11732 self as &mut dyn (::std::any::Any)
11733 }
11734 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
11735 self
11736 }
11737
11738 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
11739 Self::descriptor_static()
11740 }
11741
11742 fn new() -> GetFileFromDfsResponse {
11743 GetFileFromDfsResponse::new()
11744 }
11745
11746 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
11747 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
11748 lock: ::protobuf::lazy::ONCE_INIT,
11749 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
11750 };
11751 unsafe {
11752 descriptor.get(|| {
11753 let mut fields = ::std::vec::Vec::new();
11754 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
11755 "file_size",
11756 |m: &GetFileFromDfsResponse| { &m.file_size },
11757 |m: &mut GetFileFromDfsResponse| { &mut m.file_size },
11758 ));
11759 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
11760 "response_code",
11761 |m: &GetFileFromDfsResponse| { &m.response_code },
11762 |m: &mut GetFileFromDfsResponse| { &mut m.response_code },
11763 ));
11764 ::protobuf::reflect::MessageDescriptor::new::<GetFileFromDfsResponse>(
11765 "GetFileFromDfsResponse",
11766 fields,
11767 file_descriptor_proto()
11768 )
11769 })
11770 }
11771 }
11772
11773 fn default_instance() -> &'static GetFileFromDfsResponse {
11774 static mut instance: ::protobuf::lazy::Lazy<GetFileFromDfsResponse> = ::protobuf::lazy::Lazy {
11775 lock: ::protobuf::lazy::ONCE_INIT,
11776 ptr: 0 as *const GetFileFromDfsResponse,
11777 };
11778 unsafe {
11779 instance.get(GetFileFromDfsResponse::new)
11780 }
11781 }
11782}
11783
11784impl ::protobuf::Clear for GetFileFromDfsResponse {
11785 fn clear(&mut self) {
11786 self.file_size = 0;
11787 self.response_code.clear();
11788 self.unknown_fields.clear();
11789 }
11790}
11791
11792impl ::std::fmt::Debug for GetFileFromDfsResponse {
11793 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11794 ::protobuf::text_format::fmt(self, f)
11795 }
11796}
11797
11798impl ::protobuf::reflect::ProtobufValue for GetFileFromDfsResponse {
11799 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
11800 ::protobuf::reflect::ProtobufValueRef::Message(self)
11801 }
11802}
11803
11804#[derive(PartialEq,Clone,Default)]
11805pub struct SetPeerDataFolderRequest {
11806 pub data_folder: ::std::string::String,
11808 pub unknown_fields: ::protobuf::UnknownFields,
11810 pub cached_size: ::protobuf::CachedSize,
11811}
11812
11813impl<'a> ::std::default::Default for &'a SetPeerDataFolderRequest {
11814 fn default() -> &'a SetPeerDataFolderRequest {
11815 <SetPeerDataFolderRequest as ::protobuf::Message>::default_instance()
11816 }
11817}
11818
11819impl SetPeerDataFolderRequest {
11820 pub fn new() -> SetPeerDataFolderRequest {
11821 ::std::default::Default::default()
11822 }
11823
11824 pub fn get_data_folder(&self) -> &str {
11828 &self.data_folder
11829 }
11830 pub fn clear_data_folder(&mut self) {
11831 self.data_folder.clear();
11832 }
11833
11834 pub fn set_data_folder(&mut self, v: ::std::string::String) {
11836 self.data_folder = v;
11837 }
11838
11839 pub fn mut_data_folder(&mut self) -> &mut ::std::string::String {
11842 &mut self.data_folder
11843 }
11844
11845 pub fn take_data_folder(&mut self) -> ::std::string::String {
11847 ::std::mem::replace(&mut self.data_folder, ::std::string::String::new())
11848 }
11849}
11850
11851impl ::protobuf::Message for SetPeerDataFolderRequest {
11852 fn is_initialized(&self) -> bool {
11853 true
11854 }
11855
11856 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11857 while !is.eof()? {
11858 let (field_number, wire_type) = is.read_tag_unpack()?;
11859 match field_number {
11860 1 => {
11861 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.data_folder)?;
11862 },
11863 _ => {
11864 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
11865 },
11866 };
11867 }
11868 ::std::result::Result::Ok(())
11869 }
11870
11871 #[allow(unused_variables)]
11873 fn compute_size(&self) -> u32 {
11874 let mut my_size = 0;
11875 if !self.data_folder.is_empty() {
11876 my_size += ::protobuf::rt::string_size(1, &self.data_folder);
11877 }
11878 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
11879 self.cached_size.set(my_size);
11880 my_size
11881 }
11882
11883 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
11884 if !self.data_folder.is_empty() {
11885 os.write_string(1, &self.data_folder)?;
11886 }
11887 os.write_unknown_fields(self.get_unknown_fields())?;
11888 ::std::result::Result::Ok(())
11889 }
11890
11891 fn get_cached_size(&self) -> u32 {
11892 self.cached_size.get()
11893 }
11894
11895 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
11896 &self.unknown_fields
11897 }
11898
11899 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
11900 &mut self.unknown_fields
11901 }
11902
11903 fn as_any(&self) -> &dyn (::std::any::Any) {
11904 self as &dyn (::std::any::Any)
11905 }
11906 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
11907 self as &mut dyn (::std::any::Any)
11908 }
11909 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
11910 self
11911 }
11912
11913 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
11914 Self::descriptor_static()
11915 }
11916
11917 fn new() -> SetPeerDataFolderRequest {
11918 SetPeerDataFolderRequest::new()
11919 }
11920
11921 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
11922 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
11923 lock: ::protobuf::lazy::ONCE_INIT,
11924 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
11925 };
11926 unsafe {
11927 descriptor.get(|| {
11928 let mut fields = ::std::vec::Vec::new();
11929 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
11930 "data_folder",
11931 |m: &SetPeerDataFolderRequest| { &m.data_folder },
11932 |m: &mut SetPeerDataFolderRequest| { &mut m.data_folder },
11933 ));
11934 ::protobuf::reflect::MessageDescriptor::new::<SetPeerDataFolderRequest>(
11935 "SetPeerDataFolderRequest",
11936 fields,
11937 file_descriptor_proto()
11938 )
11939 })
11940 }
11941 }
11942
11943 fn default_instance() -> &'static SetPeerDataFolderRequest {
11944 static mut instance: ::protobuf::lazy::Lazy<SetPeerDataFolderRequest> = ::protobuf::lazy::Lazy {
11945 lock: ::protobuf::lazy::ONCE_INIT,
11946 ptr: 0 as *const SetPeerDataFolderRequest,
11947 };
11948 unsafe {
11949 instance.get(SetPeerDataFolderRequest::new)
11950 }
11951 }
11952}
11953
11954impl ::protobuf::Clear for SetPeerDataFolderRequest {
11955 fn clear(&mut self) {
11956 self.data_folder.clear();
11957 self.unknown_fields.clear();
11958 }
11959}
11960
11961impl ::std::fmt::Debug for SetPeerDataFolderRequest {
11962 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11963 ::protobuf::text_format::fmt(self, f)
11964 }
11965}
11966
11967impl ::protobuf::reflect::ProtobufValue for SetPeerDataFolderRequest {
11968 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
11969 ::protobuf::reflect::ProtobufValueRef::Message(self)
11970 }
11971}
11972
11973#[derive(PartialEq,Clone,Default)]
11974pub struct SetPeerDataFolderResponse {
11975 pub query: bool,
11977 pub unknown_fields: ::protobuf::UnknownFields,
11979 pub cached_size: ::protobuf::CachedSize,
11980}
11981
11982impl<'a> ::std::default::Default for &'a SetPeerDataFolderResponse {
11983 fn default() -> &'a SetPeerDataFolderResponse {
11984 <SetPeerDataFolderResponse as ::protobuf::Message>::default_instance()
11985 }
11986}
11987
11988impl SetPeerDataFolderResponse {
11989 pub fn new() -> SetPeerDataFolderResponse {
11990 ::std::default::Default::default()
11991 }
11992
11993 pub fn get_query(&self) -> bool {
11997 self.query
11998 }
11999 pub fn clear_query(&mut self) {
12000 self.query = false;
12001 }
12002
12003 pub fn set_query(&mut self, v: bool) {
12005 self.query = v;
12006 }
12007}
12008
12009impl ::protobuf::Message for SetPeerDataFolderResponse {
12010 fn is_initialized(&self) -> bool {
12011 true
12012 }
12013
12014 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
12015 while !is.eof()? {
12016 let (field_number, wire_type) = is.read_tag_unpack()?;
12017 match field_number {
12018 1 => {
12019 if wire_type != ::protobuf::wire_format::WireTypeVarint {
12020 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
12021 }
12022 let tmp = is.read_bool()?;
12023 self.query = tmp;
12024 },
12025 _ => {
12026 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
12027 },
12028 };
12029 }
12030 ::std::result::Result::Ok(())
12031 }
12032
12033 #[allow(unused_variables)]
12035 fn compute_size(&self) -> u32 {
12036 let mut my_size = 0;
12037 if self.query != false {
12038 my_size += 2;
12039 }
12040 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
12041 self.cached_size.set(my_size);
12042 my_size
12043 }
12044
12045 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
12046 if self.query != false {
12047 os.write_bool(1, self.query)?;
12048 }
12049 os.write_unknown_fields(self.get_unknown_fields())?;
12050 ::std::result::Result::Ok(())
12051 }
12052
12053 fn get_cached_size(&self) -> u32 {
12054 self.cached_size.get()
12055 }
12056
12057 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
12058 &self.unknown_fields
12059 }
12060
12061 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
12062 &mut self.unknown_fields
12063 }
12064
12065 fn as_any(&self) -> &dyn (::std::any::Any) {
12066 self as &dyn (::std::any::Any)
12067 }
12068 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
12069 self as &mut dyn (::std::any::Any)
12070 }
12071 fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
12072 self
12073 }
12074
12075 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
12076 Self::descriptor_static()
12077 }
12078
12079 fn new() -> SetPeerDataFolderResponse {
12080 SetPeerDataFolderResponse::new()
12081 }
12082
12083 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
12084 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
12085 lock: ::protobuf::lazy::ONCE_INIT,
12086 ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
12087 };
12088 unsafe {
12089 descriptor.get(|| {
12090 let mut fields = ::std::vec::Vec::new();
12091 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
12092 "query",
12093 |m: &SetPeerDataFolderResponse| { &m.query },
12094 |m: &mut SetPeerDataFolderResponse| { &mut m.query },
12095 ));
12096 ::protobuf::reflect::MessageDescriptor::new::<SetPeerDataFolderResponse>(
12097 "SetPeerDataFolderResponse",
12098 fields,
12099 file_descriptor_proto()
12100 )
12101 })
12102 }
12103 }
12104
12105 fn default_instance() -> &'static SetPeerDataFolderResponse {
12106 static mut instance: ::protobuf::lazy::Lazy<SetPeerDataFolderResponse> = ::protobuf::lazy::Lazy {
12107 lock: ::protobuf::lazy::ONCE_INIT,
12108 ptr: 0 as *const SetPeerDataFolderResponse,
12109 };
12110 unsafe {
12111 instance.get(SetPeerDataFolderResponse::new)
12112 }
12113 }
12114}
12115
12116impl ::protobuf::Clear for SetPeerDataFolderResponse {
12117 fn clear(&mut self) {
12118 self.query = false;
12119 self.unknown_fields.clear();
12120 }
12121}
12122
12123impl ::std::fmt::Debug for SetPeerDataFolderResponse {
12124 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12125 ::protobuf::text_format::fmt(self, f)
12126 }
12127}
12128
12129impl ::protobuf::reflect::ProtobufValue for SetPeerDataFolderResponse {
12130 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
12131 ::protobuf::reflect::ProtobufValueRef::Message(self)
12132 }
12133}
12134
12135#[derive(Clone,PartialEq,Eq,Debug,Hash)]
12136pub enum ResponseCode {
12137 PENDING = 0,
12138 SUCCESSFUL = 1,
12139 ERROR = 2,
12140 FINISHED = 3,
12141 EXPIRED = 4,
12142 FAILED = 5,
12143 EXISTS = 6,
12144}
12145
12146impl ::protobuf::ProtobufEnum for ResponseCode {
12147 fn value(&self) -> i32 {
12148 *self as i32
12149 }
12150
12151 fn from_i32(value: i32) -> ::std::option::Option<ResponseCode> {
12152 match value {
12153 0 => ::std::option::Option::Some(ResponseCode::PENDING),
12154 1 => ::std::option::Option::Some(ResponseCode::SUCCESSFUL),
12155 2 => ::std::option::Option::Some(ResponseCode::ERROR),
12156 3 => ::std::option::Option::Some(ResponseCode::FINISHED),
12157 4 => ::std::option::Option::Some(ResponseCode::EXPIRED),
12158 5 => ::std::option::Option::Some(ResponseCode::FAILED),
12159 6 => ::std::option::Option::Some(ResponseCode::EXISTS),
12160 _ => ::std::option::Option::None
12161 }
12162 }
12163
12164 fn values() -> &'static [Self] {
12165 static values: &'static [ResponseCode] = &[
12166 ResponseCode::PENDING,
12167 ResponseCode::SUCCESSFUL,
12168 ResponseCode::ERROR,
12169 ResponseCode::FINISHED,
12170 ResponseCode::EXPIRED,
12171 ResponseCode::FAILED,
12172 ResponseCode::EXISTS,
12173 ];
12174 values
12175 }
12176
12177 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
12178 static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
12179 lock: ::protobuf::lazy::ONCE_INIT,
12180 ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
12181 };
12182 unsafe {
12183 descriptor.get(|| {
12184 ::protobuf::reflect::EnumDescriptor::new("ResponseCode", file_descriptor_proto())
12185 })
12186 }
12187 }
12188}
12189
12190impl ::std::marker::Copy for ResponseCode {
12191}
12192
12193impl ::std::default::Default for ResponseCode {
12194 fn default() -> Self {
12195 ResponseCode::PENDING
12196 }
12197}
12198
12199impl ::protobuf::reflect::ProtobufValue for ResponseCode {
12200 fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
12201 ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
12202 }
12203}
12204
12205static file_descriptor_proto_data: &'static [u8] = b"\
12206 \n\tRpc.proto\x12\x1aCatalyst.Protocol.Rpc.Node\x1a\nPeer.proto\x1a\x12C\
12207 ryptography.proto\x1a\x0cDeltas.proto\x1a\nWire.proto\x1a\x11Transaction\
12208 .proto\"&\n\x0eVersionRequest\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\
12209 \x05query\"+\n\x0fVersionResponse\x12\x18\n\x07version\x18\x01\x20\x01(\
12210 \tR\x07version\"&\n\x0eGetInfoRequest\x12\x14\n\x05query\x18\x01\x20\x01\
12211 (\x08R\x05query\"'\n\x0fGetInfoResponse\x12\x14\n\x05query\x18\x01\x20\
12212 \x01(\tR\x05query\"+\n\x13CreateWalletRequest\x12\x14\n\x05query\x18\x01\
12213 \x20\x01(\x08R\x05query\",\n\x14CreateWalletResponse\x12\x14\n\x05query\
12214 \x18\x01\x20\x01(\tR\x05query\")\n\x11ListWalletRequest\x12\x14\n\x05que\
12215 ry\x18\x01\x20\x01(\x08R\x05query\"*\n\x12ListWalletResponse\x12\x14\n\
12216 \x05query\x18\x01\x20\x01(\tR\x05query\",\n\x14CreateAddressRequest\x12\
12217 \x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"-\n\x15CreateAddressResp\
12218 onse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\")\n\x11GetAddressR\
12219 equest\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"*\n\x12GetAddr\
12220 essResponse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\"*\n\x12List\
12221 AddressRequest\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"+\n\
12222 \x13ListAddressResponse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\
12223 \".\n\x16ValidateAddressRequest\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\
12224 \x05query\"/\n\x17ValidateAddressResponse\x12\x14\n\x05query\x18\x01\x20\
12225 \x01(\tR\x05query\")\n\x11GetBalanceRequest\x12\x14\n\x05query\x18\x01\
12226 \x20\x01(\x08R\x05query\"*\n\x12GetBalanceResponse\x12\x14\n\x05query\
12227 \x18\x01\x20\x01(\tR\x05query\"3\n\x1bCreateRawTransactionRequest\x12\
12228 \x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"4\n\x1cCreateRawTransact\
12229 ionResponse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\"1\n\x19Sign\
12230 RawTransactionRequest\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\
12231 \"2\n\x1aSignRawTransactionResponse\x12\x14\n\x05query\x18\x01\x20\x01(\
12232 \tR\x05query\"3\n\x1bDecodeRawTransactionRequest\x12\x14\n\x05query\x18\
12233 \x01\x20\x01(\x08R\x05query\"4\n\x1cDecodeRawTransactionResponse\x12\x14\
12234 \n\x05query\x18\x01\x20\x01(\tR\x05query\"p\n\x1eBroadcastRawTransaction\
12235 Request\x12N\n\x0btransaction\x18\x01\x20\x01(\x0b2,.Catalyst.Protocol.W\
12236 ire.TransactionBroadcastR\x0btransaction\"p\n\x1fBroadcastRawTransaction\
12237 Response\x12M\n\rresponse_code\x18\x01\x20\x01(\x0e2(.Catalyst.Protocol.\
12238 Rpc.Node.ResponseCodeR\x0cresponseCode\"%\n\rSendToRequest\x12\x14\n\x05\
12239 query\x18\x01\x20\x01(\x08R\x05query\"&\n\x0eSendToResponse\x12\x14\n\
12240 \x05query\x18\x01\x20\x01(\tR\x05query\")\n\x11SendToFromRequest\x12\x14\
12241 \n\x05query\x18\x01\x20\x01(\x08R\x05query\"*\n\x12SendToFromResponse\
12242 \x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\"'\n\x0fSendManyRequest\
12243 \x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"(\n\x10SendManyRespo\
12244 nse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\"+\n\x13SendFromMany\
12245 Request\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\",\n\x14SendFr\
12246 omManyResponse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\"&\n\x0eA\
12247 ddNodeRequest\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"'\n\x0f\
12248 AddNodeResponse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\"\x14\n\
12249 \x12GetPeerListRequest\"K\n\x13GetPeerListResponse\x124\n\x05peers\x18\
12250 \x01\x20\x03(\x0b2\x1e.Catalyst.Protocol.Peer.PeerIdR\x05peers\"I\n\x18G\
12251 etPeerReputationRequest\x12\x1d\n\npublic_key\x18\x01\x20\x01(\x0cR\tpub\
12252 licKey\x12\x0e\n\x02ip\x18\x02\x20\x01(\x0cR\x02ip\";\n\x19GetPeerReputa\
12253 tionResponse\x12\x1e\n\nreputation\x18\x01\x20\x01(\x05R\nreputation\"f\
12254 \n\x17SetPeerBlacklistRequest\x12\x1d\n\npublic_key\x18\x01\x20\x01(\x0c\
12255 R\tpublicKey\x12\x0e\n\x02ip\x18\x02\x20\x01(\x0cR\x02ip\x12\x1c\n\tblac\
12256 klist\x18\x03\x20\x01(\x08R\tblacklist\"g\n\x18SetPeerBlacklistResponse\
12257 \x12\x1d\n\npublic_key\x18\x01\x20\x01(\x0cR\tpublicKey\x12\x0e\n\x02ip\
12258 \x18\x02\x20\x01(\x0cR\x02ip\x12\x1c\n\tblacklist\x18\x03\x20\x01(\x08R\
12259 \tblacklist\"C\n\x12GetPeerInfoRequest\x12\x1d\n\npublic_key\x18\x01\x20\
12260 \x01(\x0cR\tpublicKey\x12\x0e\n\x02ip\x18\x02\x20\x01(\x0cR\x02ip\"T\n\
12261 \x13GetPeerInfoResponse\x12=\n\tpeer_info\x18\x01\x20\x03(\x0b2\x20.Cata\
12262 lyst.Protocol.Peer.PeerInfoR\x08peerInfo\"1\n\x19GetConnectionCountReque\
12263 st\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"2\n\x1aGetConnecti\
12264 onCountResponse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\"7\n\x0f\
12265 GetDeltaRequest\x12$\n\x0edelta_dfs_hash\x18\x01\x20\x01(\x0cR\x0cdeltaD\
12266 fsHash\"I\n\x10GetDeltaResponse\x125\n\x05delta\x18\x01\x20\x01(\x0b2\
12267 \x1f.Catalyst.Protocol.Deltas.DeltaR\x05delta\")\n\x11GetMempoolRequest\
12268 \x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"d\n\x12GetMempoolRes\
12269 ponse\x12N\n\x0ctransactions\x18\x01\x20\x03(\x0b2*.Catalyst.Protocol.Tr\
12270 ansaction.PublicEntryR\x0ctransactions\"\x9e\x01\n\x12SignMessageRequest\
12271 \x12\x18\n\x07message\x18\x01\x20\x01(\x0cR\x07message\x12\x15\n\x06key_\
12272 id\x18\x02\x20\x01(\tR\x05keyId\x12W\n\x0fsigning_context\x18\x03\x20\
12273 \x01(\x0b2..Catalyst.Protocol.Cryptography.SigningContextR\x0esigningCon\
12274 text\"}\n\x13SignMessageResponse\x12\x1c\n\tsignature\x18\x01\x20\x01(\
12275 \x0cR\tsignature\x12\x1d\n\npublic_key\x18\x02\x20\x01(\x0cR\tpublicKey\
12276 \x12)\n\x10original_message\x18\x03\x20\x01(\x0cR\x0foriginalMessage\"\
12277 \xc6\x01\n\x14VerifyMessageRequest\x12\x1c\n\tsignature\x18\x01\x20\x01(\
12278 \x0cR\tsignature\x12\x1d\n\npublic_key\x18\x02\x20\x01(\x0cR\tpublicKey\
12279 \x12\x18\n\x07message\x18\x03\x20\x01(\x0cR\x07message\x12W\n\x0fsigning\
12280 _context\x18\x04\x20\x01(\x0b2..Catalyst.Protocol.Cryptography.SigningCo\
12281 ntextR\x0esigningContext\"@\n\x15VerifyMessageResponse\x12'\n\x10is_sign\
12282 ed_by_key\x18\x01\x20\x01(\x08R\risSignedByKey\",\n\x14ServiceStatusRequ\
12283 est\x12\x14\n\x05query\x18\x01\x20\x01(\x08R\x05query\"-\n\x15ServiceSta\
12284 tusResponse\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\"c\n\x13AddF\
12285 ileToDfsRequest\x12\x1b\n\tfile_size\x18\x01\x20\x01(\x04R\x08fileSize\
12286 \x12\x1b\n\tfile_name\x18\x02\x20\x01(\tR\x08fileName\x12\x12\n\x04node\
12287 \x18\x03\x20\x01(\tR\x04node\"V\n\x14AddFileToDfsResponse\x12#\n\rrespon\
12288 se_code\x18\x01\x20\x01(\x0cR\x0cresponseCode\x12\x19\n\x08dfs_hash\x18\
12289 \x02\x20\x01(\tR\x07dfsHash\"\x8a\x01\n\x18TransferFileBytesRequest\x12\
12290 \x19\n\x08chunk_id\x18\x01\x20\x01(\rR\x07chunkId\x12\x1f\n\x0bchunk_byt\
12291 es\x18\x02\x20\x01(\x0cR\nchunkBytes\x122\n\x15correlation_file_name\x18\
12292 \x03\x20\x01(\x0cR\x13correlationFileName\"@\n\x19TransferFileBytesRespo\
12293 nse\x12#\n\rresponse_code\x18\x01\x20\x01(\x0cR\x0cresponseCode\"K\n\x11\
12294 RemovePeerRequest\x12\x17\n\x07peer_ip\x18\x01\x20\x01(\x0cR\x06peerIp\
12295 \x12\x1d\n\npublic_key\x18\x02\x20\x01(\x0cR\tpublicKey\"9\n\x12RemovePe\
12296 erResponse\x12#\n\rdeleted_count\x18\x01\x20\x01(\rR\x0cdeletedCount\"\
12297 \x15\n\x13GetPeerCountRequest\"5\n\x14GetPeerCountResponse\x12\x1d\n\npe\
12298 er_count\x18\x01\x20\x01(\x05R\tpeerCount\"2\n\x15GetFileFromDfsRequest\
12299 \x12\x19\n\x08dfs_hash\x18\x01\x20\x01(\tR\x07dfsHash\"Z\n\x16GetFileFro\
12300 mDfsResponse\x12\x1b\n\tfile_size\x18\x01\x20\x01(\x04R\x08fileSize\x12#\
12301 \n\rresponse_code\x18\x02\x20\x01(\x0cR\x0cresponseCode\";\n\x18SetPeerD\
12302 ataFolderRequest\x12\x1f\n\x0bdata_folder\x18\x01\x20\x01(\tR\ndataFolde\
12303 r\"1\n\x19SetPeerDataFolderResponse\x12\x14\n\x05query\x18\x01\x20\x01(\
12304 \x08R\x05query*i\n\x0cResponseCode\x12\x0b\n\x07PENDING\x10\0\x12\x0e\n\
12305 \nSUCCESSFUL\x10\x01\x12\t\n\x05ERROR\x10\x02\x12\x0c\n\x08FINISHED\x10\
12306 \x03\x12\x0b\n\x07EXPIRED\x10\x04\x12\n\n\x06FAILED\x10\x05\x12\n\n\x06E\
12307 XISTS\x10\x06B\x02P\x01J\x99J\n\x07\x12\x05\x13\0\xc7\x02\x01\n\xdf\x06\
12308 \n\x01\x0c\x12\x03\x13\0\x122\xd4\x06*\n\x20Copyright\x20(c)\x202019\x20\
12309 Catalyst\x20Network\n\n\x20This\x20file\x20is\x20part\x20of\x20Catalyst.\
12310 Network.Protocol.Protobuffs\x20<https://github.com/catalyst-network/prot\
12311 ocol-protobuffs>\n\n\x20Catalyst.Network.Protocol.Protobuffs\x20is\x20fr\
12312 ee\x20software:\x20you\x20can\x20redistribute\x20it\x20and/or\x20modify\
12313 \n\x20it\x20under\x20the\x20terms\x20of\x20the\x20GNU\x20General\x20Publ\
12314 ic\x20License\x20as\x20published\x20by\n\x20the\x20Free\x20Software\x20F\
12315 oundation,\x20either\x20version\x202\x20of\x20the\x20License,\x20or\n\
12316 \x20(at\x20your\x20option)\x20any\x20later\x20version.\n\x20\n\x20Cataly\
12317 st.Network.Protocol.Protobuffs\x20is\x20distributed\x20in\x20the\x20hope\
12318 \x20that\x20it\x20will\x20be\x20useful,\n\x20but\x20WITHOUT\x20ANY\x20WA\
12319 RRANTY;\x20without\x20even\x20the\x20implied\x20warranty\x20of\n\x20MERC\
12320 HANTABILITY\x20or\x20FITNESS\x20FOR\x20A\x20PARTICULAR\x20PURPOSE.\x20Se\
12321 e\x20the\n\x20GNU\x20General\x20Public\x20License\x20for\x20more\x20deta\
12322 ils.\n\x20\n\x20You\x20should\x20have\x20received\x20a\x20copy\x20of\x20\
12323 the\x20GNU\x20General\x20Public\x20License\n\x20along\x20with\x20Catalys\
12324 t.Network.Protocol.Protobuffs\x20If\x20not,\x20see\x20<https://www.gnu.o\
12325 rg/licenses/>.\n\n\x08\n\x01\x08\x12\x03\x15\0\"\n\x0b\n\x04\x08\xe7\x07\
12326 \0\x12\x03\x15\0\"\n\x0c\n\x05\x08\xe7\x07\0\x02\x12\x03\x15\x07\x1a\n\r\
12327 \n\x06\x08\xe7\x07\0\x02\0\x12\x03\x15\x07\x1a\n\x0e\n\x07\x08\xe7\x07\0\
12328 \x02\0\x01\x12\x03\x15\x07\x1a\n\x0c\n\x05\x08\xe7\x07\0\x03\x12\x03\x15\
12329 \x1d!\n\x08\n\x01\x02\x12\x03\x17\x08\"\n\t\n\x02\x03\0\x12\x03\x19\x07\
12330 \x13\n\t\n\x02\x03\x01\x12\x03\x1a\x07\x1b\n\t\n\x02\x03\x02\x12\x03\x1b\
12331 \x07\x15\n\t\n\x02\x03\x03\x12\x03\x1c\x07\x13\n\t\n\x02\x03\x04\x12\x03\
12332 \x1d\x07\x1a\n\n\n\x02\x05\0\x12\x04\x1f\0'\x01\n\n\n\x03\x05\0\x01\x12\
12333 \x03\x1f\x05\x11\n\x0b\n\x04\x05\0\x02\0\x12\x03\x20\x08\x14\n\x0c\n\x05\
12334 \x05\0\x02\0\x01\x12\x03\x20\x08\x0f\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03\
12335 \x20\x12\x13\n\x0b\n\x04\x05\0\x02\x01\x12\x03!\x08\x17\n\x0c\n\x05\x05\
12336 \0\x02\x01\x01\x12\x03!\x08\x12\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03!\
12337 \x15\x16\n\x0b\n\x04\x05\0\x02\x02\x12\x03\"\x08\x12\n\x0c\n\x05\x05\0\
12338 \x02\x02\x01\x12\x03\"\x08\r\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03\"\x10\
12339 \x11\n\x0b\n\x04\x05\0\x02\x03\x12\x03#\x08\x15\n\x0c\n\x05\x05\0\x02\
12340 \x03\x01\x12\x03#\x08\x10\n\x0c\n\x05\x05\0\x02\x03\x02\x12\x03#\x13\x14\
12341 \n\x0b\n\x04\x05\0\x02\x04\x12\x03$\x08\x14\n\x0c\n\x05\x05\0\x02\x04\
12342 \x01\x12\x03$\x08\x0f\n\x0c\n\x05\x05\0\x02\x04\x02\x12\x03$\x12\x13\n\
12343 \x0b\n\x04\x05\0\x02\x05\x12\x03%\x08\x13\n\x0c\n\x05\x05\0\x02\x05\x01\
12344 \x12\x03%\x08\x0e\n\x0c\n\x05\x05\0\x02\x05\x02\x12\x03%\x11\x12\n\x0b\n\
12345 \x04\x05\0\x02\x06\x12\x03&\x08\x13\n\x0c\n\x05\x05\0\x02\x06\x01\x12\
12346 \x03&\x08\x0e\n\x0c\n\x05\x05\0\x02\x06\x02\x12\x03&\x11\x12\n\n\n\x02\
12347 \x04\0\x12\x04)\0+\x01\n\n\n\x03\x04\0\x01\x12\x03)\x08\x16\n\x0b\n\x04\
12348 \x04\0\x02\0\x12\x03*\x04\x13\n\r\n\x05\x04\0\x02\0\x04\x12\x04*\x04)\
12349 \x18\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03*\x04\x08\n\x0c\n\x05\x04\0\x02\
12350 \0\x01\x12\x03*\t\x0e\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03*\x11\x12\n\n\n\
12351 \x02\x04\x01\x12\x04-\0/\x01\n\n\n\x03\x04\x01\x01\x12\x03-\x08\x17\n\
12352 \x0b\n\x04\x04\x01\x02\0\x12\x03.\x04\x17\n\r\n\x05\x04\x01\x02\0\x04\
12353 \x12\x04.\x04-\x19\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03.\x04\n\n\x0c\n\
12354 \x05\x04\x01\x02\0\x01\x12\x03.\x0b\x12\n\x0c\n\x05\x04\x01\x02\0\x03\
12355 \x12\x03.\x15\x16\n\n\n\x02\x04\x02\x12\x041\03\x01\n\n\n\x03\x04\x02\
12356 \x01\x12\x031\x08\x16\n\x0b\n\x04\x04\x02\x02\0\x12\x032\x04\x13\n\r\n\
12357 \x05\x04\x02\x02\0\x04\x12\x042\x041\x18\n\x0c\n\x05\x04\x02\x02\0\x05\
12358 \x12\x032\x04\x08\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x032\t\x0e\n\x0c\n\
12359 \x05\x04\x02\x02\0\x03\x12\x032\x11\x12\n\n\n\x02\x04\x03\x12\x045\07\
12360 \x01\n\n\n\x03\x04\x03\x01\x12\x035\x08\x17\n\x0b\n\x04\x04\x03\x02\0\
12361 \x12\x036\x04\x15\n\r\n\x05\x04\x03\x02\0\x04\x12\x046\x045\x19\n\x0c\n\
12362 \x05\x04\x03\x02\0\x05\x12\x036\x04\n\n\x0c\n\x05\x04\x03\x02\0\x01\x12\
12363 \x036\x0b\x10\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x036\x13\x14\n\n\n\x02\
12364 \x04\x04\x12\x049\0;\x01\n\n\n\x03\x04\x04\x01\x12\x039\x08\x1b\n\x0b\n\
12365 \x04\x04\x04\x02\0\x12\x03:\x04\x13\n\r\n\x05\x04\x04\x02\0\x04\x12\x04:\
12366 \x049\x1d\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03:\x04\x08\n\x0c\n\x05\x04\
12367 \x04\x02\0\x01\x12\x03:\t\x0e\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03:\x11\
12368 \x12\n\n\n\x02\x04\x05\x12\x04=\0?\x01\n\n\n\x03\x04\x05\x01\x12\x03=\
12369 \x08\x1c\n\x0b\n\x04\x04\x05\x02\0\x12\x03>\x04\x15\n\r\n\x05\x04\x05\
12370 \x02\0\x04\x12\x04>\x04=\x1e\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03>\x04\
12371 \n\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03>\x0b\x10\n\x0c\n\x05\x04\x05\
12372 \x02\0\x03\x12\x03>\x13\x14\n\n\n\x02\x04\x06\x12\x04A\0C\x01\n\n\n\x03\
12373 \x04\x06\x01\x12\x03A\x08\x19\n\x0b\n\x04\x04\x06\x02\0\x12\x03B\x04\x13\
12374 \n\r\n\x05\x04\x06\x02\0\x04\x12\x04B\x04A\x1b\n\x0c\n\x05\x04\x06\x02\0\
12375 \x05\x12\x03B\x04\x08\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03B\t\x0e\n\x0c\
12376 \n\x05\x04\x06\x02\0\x03\x12\x03B\x11\x12\n\n\n\x02\x04\x07\x12\x04E\0G\
12377 \x01\n\n\n\x03\x04\x07\x01\x12\x03E\x08\x1a\n\x0b\n\x04\x04\x07\x02\0\
12378 \x12\x03F\x04\x15\n\r\n\x05\x04\x07\x02\0\x04\x12\x04F\x04E\x1c\n\x0c\n\
12379 \x05\x04\x07\x02\0\x05\x12\x03F\x04\n\n\x0c\n\x05\x04\x07\x02\0\x01\x12\
12380 \x03F\x0b\x10\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03F\x13\x14\n\n\n\x02\
12381 \x04\x08\x12\x04I\0K\x01\n\n\n\x03\x04\x08\x01\x12\x03I\x08\x1c\n\x0b\n\
12382 \x04\x04\x08\x02\0\x12\x03J\x04\x13\n\r\n\x05\x04\x08\x02\0\x04\x12\x04J\
12383 \x04I\x1e\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03J\x04\x08\n\x0c\n\x05\x04\
12384 \x08\x02\0\x01\x12\x03J\t\x0e\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x03J\x11\
12385 \x12\n\n\n\x02\x04\t\x12\x04M\0O\x01\n\n\n\x03\x04\t\x01\x12\x03M\x08\
12386 \x1d\n\x0b\n\x04\x04\t\x02\0\x12\x03N\x04\x15\n\r\n\x05\x04\t\x02\0\x04\
12387 \x12\x04N\x04M\x1f\n\x0c\n\x05\x04\t\x02\0\x05\x12\x03N\x04\n\n\x0c\n\
12388 \x05\x04\t\x02\0\x01\x12\x03N\x0b\x10\n\x0c\n\x05\x04\t\x02\0\x03\x12\
12389 \x03N\x13\x14\n\n\n\x02\x04\n\x12\x04Q\0S\x01\n\n\n\x03\x04\n\x01\x12\
12390 \x03Q\x08\x19\n\x0b\n\x04\x04\n\x02\0\x12\x03R\x04\x13\n\r\n\x05\x04\n\
12391 \x02\0\x04\x12\x04R\x04Q\x1b\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03R\x04\
12392 \x08\n\x0c\n\x05\x04\n\x02\0\x01\x12\x03R\t\x0e\n\x0c\n\x05\x04\n\x02\0\
12393 \x03\x12\x03R\x11\x12\n\n\n\x02\x04\x0b\x12\x04U\0W\x01\n\n\n\x03\x04\
12394 \x0b\x01\x12\x03U\x08\x1a\n\x0b\n\x04\x04\x0b\x02\0\x12\x03V\x04\x15\n\r\
12395 \n\x05\x04\x0b\x02\0\x04\x12\x04V\x04U\x1c\n\x0c\n\x05\x04\x0b\x02\0\x05\
12396 \x12\x03V\x04\n\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\x03V\x0b\x10\n\x0c\n\
12397 \x05\x04\x0b\x02\0\x03\x12\x03V\x13\x14\n\n\n\x02\x04\x0c\x12\x04Y\0[\
12398 \x01\n\n\n\x03\x04\x0c\x01\x12\x03Y\x08\x1a\n\x0b\n\x04\x04\x0c\x02\0\
12399 \x12\x03Z\x04\x13\n\r\n\x05\x04\x0c\x02\0\x04\x12\x04Z\x04Y\x1c\n\x0c\n\
12400 \x05\x04\x0c\x02\0\x05\x12\x03Z\x04\x08\n\x0c\n\x05\x04\x0c\x02\0\x01\
12401 \x12\x03Z\t\x0e\n\x0c\n\x05\x04\x0c\x02\0\x03\x12\x03Z\x11\x12\n\n\n\x02\
12402 \x04\r\x12\x04]\0_\x01\n\n\n\x03\x04\r\x01\x12\x03]\x08\x1b\n\x0b\n\x04\
12403 \x04\r\x02\0\x12\x03^\x04\x15\n\r\n\x05\x04\r\x02\0\x04\x12\x04^\x04]\
12404 \x1d\n\x0c\n\x05\x04\r\x02\0\x05\x12\x03^\x04\n\n\x0c\n\x05\x04\r\x02\0\
12405 \x01\x12\x03^\x0b\x10\n\x0c\n\x05\x04\r\x02\0\x03\x12\x03^\x13\x14\n\n\n\
12406 \x02\x04\x0e\x12\x04a\0c\x01\n\n\n\x03\x04\x0e\x01\x12\x03a\x08\x1e\n\
12407 \x0b\n\x04\x04\x0e\x02\0\x12\x03b\x04\x13\n\r\n\x05\x04\x0e\x02\0\x04\
12408 \x12\x04b\x04a\x20\n\x0c\n\x05\x04\x0e\x02\0\x05\x12\x03b\x04\x08\n\x0c\
12409 \n\x05\x04\x0e\x02\0\x01\x12\x03b\t\x0e\n\x0c\n\x05\x04\x0e\x02\0\x03\
12410 \x12\x03b\x11\x12\n\n\n\x02\x04\x0f\x12\x04e\0g\x01\n\n\n\x03\x04\x0f\
12411 \x01\x12\x03e\x08\x1f\n\x0b\n\x04\x04\x0f\x02\0\x12\x03f\x04\x15\n\r\n\
12412 \x05\x04\x0f\x02\0\x04\x12\x04f\x04e!\n\x0c\n\x05\x04\x0f\x02\0\x05\x12\
12413 \x03f\x04\n\n\x0c\n\x05\x04\x0f\x02\0\x01\x12\x03f\x0b\x10\n\x0c\n\x05\
12414 \x04\x0f\x02\0\x03\x12\x03f\x13\x14\n\n\n\x02\x04\x10\x12\x04i\0k\x01\n\
12415 \n\n\x03\x04\x10\x01\x12\x03i\x08\x19\n\x0b\n\x04\x04\x10\x02\0\x12\x03j\
12416 \x04\x13\n\r\n\x05\x04\x10\x02\0\x04\x12\x04j\x04i\x1b\n\x0c\n\x05\x04\
12417 \x10\x02\0\x05\x12\x03j\x04\x08\n\x0c\n\x05\x04\x10\x02\0\x01\x12\x03j\t\
12418 \x0e\n\x0c\n\x05\x04\x10\x02\0\x03\x12\x03j\x11\x12\n\n\n\x02\x04\x11\
12419 \x12\x04m\0o\x01\n\n\n\x03\x04\x11\x01\x12\x03m\x08\x1a\n\x0b\n\x04\x04\
12420 \x11\x02\0\x12\x03n\x04\x15\n\r\n\x05\x04\x11\x02\0\x04\x12\x04n\x04m\
12421 \x1c\n\x0c\n\x05\x04\x11\x02\0\x05\x12\x03n\x04\n\n\x0c\n\x05\x04\x11\
12422 \x02\0\x01\x12\x03n\x0b\x10\n\x0c\n\x05\x04\x11\x02\0\x03\x12\x03n\x13\
12423 \x14\n\n\n\x02\x04\x12\x12\x04q\0s\x01\n\n\n\x03\x04\x12\x01\x12\x03q\
12424 \x08#\n\x0b\n\x04\x04\x12\x02\0\x12\x03r\x04\x13\n\r\n\x05\x04\x12\x02\0\
12425 \x04\x12\x04r\x04q%\n\x0c\n\x05\x04\x12\x02\0\x05\x12\x03r\x04\x08\n\x0c\
12426 \n\x05\x04\x12\x02\0\x01\x12\x03r\t\x0e\n\x0c\n\x05\x04\x12\x02\0\x03\
12427 \x12\x03r\x11\x12\n\n\n\x02\x04\x13\x12\x04u\0w\x01\n\n\n\x03\x04\x13\
12428 \x01\x12\x03u\x08$\n\x0b\n\x04\x04\x13\x02\0\x12\x03v\x04\x15\n\r\n\x05\
12429 \x04\x13\x02\0\x04\x12\x04v\x04u&\n\x0c\n\x05\x04\x13\x02\0\x05\x12\x03v\
12430 \x04\n\n\x0c\n\x05\x04\x13\x02\0\x01\x12\x03v\x0b\x10\n\x0c\n\x05\x04\
12431 \x13\x02\0\x03\x12\x03v\x13\x14\n\n\n\x02\x04\x14\x12\x04y\0{\x01\n\n\n\
12432 \x03\x04\x14\x01\x12\x03y\x08!\n\x0b\n\x04\x04\x14\x02\0\x12\x03z\x04\
12433 \x13\n\r\n\x05\x04\x14\x02\0\x04\x12\x04z\x04y#\n\x0c\n\x05\x04\x14\x02\
12434 \0\x05\x12\x03z\x04\x08\n\x0c\n\x05\x04\x14\x02\0\x01\x12\x03z\t\x0e\n\
12435 \x0c\n\x05\x04\x14\x02\0\x03\x12\x03z\x11\x12\n\n\n\x02\x04\x15\x12\x04}\
12436 \0\x7f\x01\n\n\n\x03\x04\x15\x01\x12\x03}\x08\"\n\x0b\n\x04\x04\x15\x02\
12437 \0\x12\x03~\x04\x15\n\r\n\x05\x04\x15\x02\0\x04\x12\x04~\x04}$\n\x0c\n\
12438 \x05\x04\x15\x02\0\x05\x12\x03~\x04\n\n\x0c\n\x05\x04\x15\x02\0\x01\x12\
12439 \x03~\x0b\x10\n\x0c\n\x05\x04\x15\x02\0\x03\x12\x03~\x13\x14\n\x0c\n\x02\
12440 \x04\x16\x12\x06\x81\x01\0\x83\x01\x01\n\x0b\n\x03\x04\x16\x01\x12\x04\
12441 \x81\x01\x08#\n\x0c\n\x04\x04\x16\x02\0\x12\x04\x82\x01\x04\x13\n\x0f\n\
12442 \x05\x04\x16\x02\0\x04\x12\x06\x82\x01\x04\x81\x01%\n\r\n\x05\x04\x16\
12443 \x02\0\x05\x12\x04\x82\x01\x04\x08\n\r\n\x05\x04\x16\x02\0\x01\x12\x04\
12444 \x82\x01\t\x0e\n\r\n\x05\x04\x16\x02\0\x03\x12\x04\x82\x01\x11\x12\n\x0c\
12445 \n\x02\x04\x17\x12\x06\x85\x01\0\x87\x01\x01\n\x0b\n\x03\x04\x17\x01\x12\
12446 \x04\x85\x01\x08$\n\x0c\n\x04\x04\x17\x02\0\x12\x04\x86\x01\x04\x15\n\
12447 \x0f\n\x05\x04\x17\x02\0\x04\x12\x06\x86\x01\x04\x85\x01&\n\r\n\x05\x04\
12448 \x17\x02\0\x05\x12\x04\x86\x01\x04\n\n\r\n\x05\x04\x17\x02\0\x01\x12\x04\
12449 \x86\x01\x0b\x10\n\r\n\x05\x04\x17\x02\0\x03\x12\x04\x86\x01\x13\x14\n\
12450 \x0c\n\x02\x04\x18\x12\x06\x89\x01\0\x8b\x01\x01\n\x0b\n\x03\x04\x18\x01\
12451 \x12\x04\x89\x01\x08&\n\x0c\n\x04\x04\x18\x02\0\x12\x04\x8a\x01\x082\n\
12452 \x0f\n\x05\x04\x18\x02\0\x04\x12\x06\x8a\x01\x08\x89\x01(\n\r\n\x05\x04\
12453 \x18\x02\0\x06\x12\x04\x8a\x01\x08!\n\r\n\x05\x04\x18\x02\0\x01\x12\x04\
12454 \x8a\x01\"-\n\r\n\x05\x04\x18\x02\0\x03\x12\x04\x8a\x0101\n\x0c\n\x02\
12455 \x04\x19\x12\x06\x8d\x01\0\x8f\x01\x01\n\x0b\n\x03\x04\x19\x01\x12\x04\
12456 \x8d\x01\x08'\n\x0c\n\x04\x04\x19\x02\0\x12\x04\x8e\x01\x04#\n\x0f\n\x05\
12457 \x04\x19\x02\0\x04\x12\x06\x8e\x01\x04\x8d\x01)\n\r\n\x05\x04\x19\x02\0\
12458 \x06\x12\x04\x8e\x01\x04\x10\n\r\n\x05\x04\x19\x02\0\x01\x12\x04\x8e\x01\
12459 \x11\x1e\n\r\n\x05\x04\x19\x02\0\x03\x12\x04\x8e\x01!\"\n\x0c\n\x02\x04\
12460 \x1a\x12\x06\x91\x01\0\x93\x01\x01\n\x0b\n\x03\x04\x1a\x01\x12\x04\x91\
12461 \x01\x08\x15\n\x0c\n\x04\x04\x1a\x02\0\x12\x04\x92\x01\x04\x13\n\x0f\n\
12462 \x05\x04\x1a\x02\0\x04\x12\x06\x92\x01\x04\x91\x01\x17\n\r\n\x05\x04\x1a\
12463 \x02\0\x05\x12\x04\x92\x01\x04\x08\n\r\n\x05\x04\x1a\x02\0\x01\x12\x04\
12464 \x92\x01\t\x0e\n\r\n\x05\x04\x1a\x02\0\x03\x12\x04\x92\x01\x11\x12\n\x0c\
12465 \n\x02\x04\x1b\x12\x06\x95\x01\0\x97\x01\x01\n\x0b\n\x03\x04\x1b\x01\x12\
12466 \x04\x95\x01\x08\x16\n\x0c\n\x04\x04\x1b\x02\0\x12\x04\x96\x01\x04\x15\n\
12467 \x0f\n\x05\x04\x1b\x02\0\x04\x12\x06\x96\x01\x04\x95\x01\x18\n\r\n\x05\
12468 \x04\x1b\x02\0\x05\x12\x04\x96\x01\x04\n\n\r\n\x05\x04\x1b\x02\0\x01\x12\
12469 \x04\x96\x01\x0b\x10\n\r\n\x05\x04\x1b\x02\0\x03\x12\x04\x96\x01\x13\x14\
12470 \n\x0c\n\x02\x04\x1c\x12\x06\x99\x01\0\x9b\x01\x01\n\x0b\n\x03\x04\x1c\
12471 \x01\x12\x04\x99\x01\x08\x19\n\x0c\n\x04\x04\x1c\x02\0\x12\x04\x9a\x01\
12472 \x04\x13\n\x0f\n\x05\x04\x1c\x02\0\x04\x12\x06\x9a\x01\x04\x99\x01\x1b\n\
12473 \r\n\x05\x04\x1c\x02\0\x05\x12\x04\x9a\x01\x04\x08\n\r\n\x05\x04\x1c\x02\
12474 \0\x01\x12\x04\x9a\x01\t\x0e\n\r\n\x05\x04\x1c\x02\0\x03\x12\x04\x9a\x01\
12475 \x11\x12\n\x0c\n\x02\x04\x1d\x12\x06\x9d\x01\0\x9f\x01\x01\n\x0b\n\x03\
12476 \x04\x1d\x01\x12\x04\x9d\x01\x08\x1a\n\x0c\n\x04\x04\x1d\x02\0\x12\x04\
12477 \x9e\x01\x04\x15\n\x0f\n\x05\x04\x1d\x02\0\x04\x12\x06\x9e\x01\x04\x9d\
12478 \x01\x1c\n\r\n\x05\x04\x1d\x02\0\x05\x12\x04\x9e\x01\x04\n\n\r\n\x05\x04\
12479 \x1d\x02\0\x01\x12\x04\x9e\x01\x0b\x10\n\r\n\x05\x04\x1d\x02\0\x03\x12\
12480 \x04\x9e\x01\x13\x14\n\x0c\n\x02\x04\x1e\x12\x06\xa1\x01\0\xa3\x01\x01\n\
12481 \x0b\n\x03\x04\x1e\x01\x12\x04\xa1\x01\x08\x17\n\x0c\n\x04\x04\x1e\x02\0\
12482 \x12\x04\xa2\x01\x04\x13\n\x0f\n\x05\x04\x1e\x02\0\x04\x12\x06\xa2\x01\
12483 \x04\xa1\x01\x19\n\r\n\x05\x04\x1e\x02\0\x05\x12\x04\xa2\x01\x04\x08\n\r\
12484 \n\x05\x04\x1e\x02\0\x01\x12\x04\xa2\x01\t\x0e\n\r\n\x05\x04\x1e\x02\0\
12485 \x03\x12\x04\xa2\x01\x11\x12\n\x0c\n\x02\x04\x1f\x12\x06\xa5\x01\0\xa7\
12486 \x01\x01\n\x0b\n\x03\x04\x1f\x01\x12\x04\xa5\x01\x08\x18\n\x0c\n\x04\x04\
12487 \x1f\x02\0\x12\x04\xa6\x01\x04\x15\n\x0f\n\x05\x04\x1f\x02\0\x04\x12\x06\
12488 \xa6\x01\x04\xa5\x01\x1a\n\r\n\x05\x04\x1f\x02\0\x05\x12\x04\xa6\x01\x04\
12489 \n\n\r\n\x05\x04\x1f\x02\0\x01\x12\x04\xa6\x01\x0b\x10\n\r\n\x05\x04\x1f\
12490 \x02\0\x03\x12\x04\xa6\x01\x13\x14\n\x0c\n\x02\x04\x20\x12\x06\xa9\x01\0\
12491 \xab\x01\x01\n\x0b\n\x03\x04\x20\x01\x12\x04\xa9\x01\x08\x1b\n\x0c\n\x04\
12492 \x04\x20\x02\0\x12\x04\xaa\x01\x04\x13\n\x0f\n\x05\x04\x20\x02\0\x04\x12\
12493 \x06\xaa\x01\x04\xa9\x01\x1d\n\r\n\x05\x04\x20\x02\0\x05\x12\x04\xaa\x01\
12494 \x04\x08\n\r\n\x05\x04\x20\x02\0\x01\x12\x04\xaa\x01\t\x0e\n\r\n\x05\x04\
12495 \x20\x02\0\x03\x12\x04\xaa\x01\x11\x12\n\x0c\n\x02\x04!\x12\x06\xad\x01\
12496 \0\xaf\x01\x01\n\x0b\n\x03\x04!\x01\x12\x04\xad\x01\x08\x1c\n\x0c\n\x04\
12497 \x04!\x02\0\x12\x04\xae\x01\x04\x15\n\x0f\n\x05\x04!\x02\0\x04\x12\x06\
12498 \xae\x01\x04\xad\x01\x1e\n\r\n\x05\x04!\x02\0\x05\x12\x04\xae\x01\x04\n\
12499 \n\r\n\x05\x04!\x02\0\x01\x12\x04\xae\x01\x0b\x10\n\r\n\x05\x04!\x02\0\
12500 \x03\x12\x04\xae\x01\x13\x14\n\x0c\n\x02\x04\"\x12\x06\xb1\x01\0\xb3\x01\
12501 \x01\n\x0b\n\x03\x04\"\x01\x12\x04\xb1\x01\x08\x16\n\x0c\n\x04\x04\"\x02\
12502 \0\x12\x04\xb2\x01\x04\x13\n\x0f\n\x05\x04\"\x02\0\x04\x12\x06\xb2\x01\
12503 \x04\xb1\x01\x18\n\r\n\x05\x04\"\x02\0\x05\x12\x04\xb2\x01\x04\x08\n\r\n\
12504 \x05\x04\"\x02\0\x01\x12\x04\xb2\x01\t\x0e\n\r\n\x05\x04\"\x02\0\x03\x12\
12505 \x04\xb2\x01\x11\x12\n\x0c\n\x02\x04#\x12\x06\xb5\x01\0\xb7\x01\x01\n\
12506 \x0b\n\x03\x04#\x01\x12\x04\xb5\x01\x08\x17\n\x0c\n\x04\x04#\x02\0\x12\
12507 \x04\xb6\x01\x04\x15\n\x0f\n\x05\x04#\x02\0\x04\x12\x06\xb6\x01\x04\xb5\
12508 \x01\x19\n\r\n\x05\x04#\x02\0\x05\x12\x04\xb6\x01\x04\n\n\r\n\x05\x04#\
12509 \x02\0\x01\x12\x04\xb6\x01\x0b\x10\n\r\n\x05\x04#\x02\0\x03\x12\x04\xb6\
12510 \x01\x13\x14\n\n\n\x02\x04$\x12\x04\xb9\x01\0\x1e\n\x0b\n\x03\x04$\x01\
12511 \x12\x04\xb9\x01\x08\x1a\n\x0c\n\x02\x04%\x12\x06\xbb\x01\0\xbd\x01\x01\
12512 \n\x0b\n\x03\x04%\x01\x12\x04\xbb\x01\x08\x1b\n\x0c\n\x04\x04%\x02\0\x12\
12513 \x04\xbc\x01\x04#\n\r\n\x05\x04%\x02\0\x04\x12\x04\xbc\x01\x04\x0c\n\r\n\
12514 \x05\x04%\x02\0\x06\x12\x04\xbc\x01\r\x18\n\r\n\x05\x04%\x02\0\x01\x12\
12515 \x04\xbc\x01\x19\x1e\n\r\n\x05\x04%\x02\0\x03\x12\x04\xbc\x01!\"\n\x0c\n\
12516 \x02\x04&\x12\x06\xbf\x01\0\xc2\x01\x01\n\x0b\n\x03\x04&\x01\x12\x04\xbf\
12517 \x01\x08\x20\n\x0c\n\x04\x04&\x02\0\x12\x04\xc0\x01\x04\x19\n\x0f\n\x05\
12518 \x04&\x02\0\x04\x12\x06\xc0\x01\x04\xbf\x01\"\n\r\n\x05\x04&\x02\0\x05\
12519 \x12\x04\xc0\x01\x04\t\n\r\n\x05\x04&\x02\0\x01\x12\x04\xc0\x01\n\x14\n\
12520 \r\n\x05\x04&\x02\0\x03\x12\x04\xc0\x01\x17\x18\n\x0c\n\x04\x04&\x02\x01\
12521 \x12\x04\xc1\x01\x04\x11\n\x0f\n\x05\x04&\x02\x01\x04\x12\x06\xc1\x01\
12522 \x04\xc0\x01\x19\n\r\n\x05\x04&\x02\x01\x05\x12\x04\xc1\x01\x04\t\n\r\n\
12523 \x05\x04&\x02\x01\x01\x12\x04\xc1\x01\n\x0c\n\r\n\x05\x04&\x02\x01\x03\
12524 \x12\x04\xc1\x01\x0f\x10\n\x0c\n\x02\x04'\x12\x06\xc4\x01\0\xc6\x01\x01\
12525 \n\x0b\n\x03\x04'\x01\x12\x04\xc4\x01\x08!\n\x0c\n\x04\x04'\x02\0\x12\
12526 \x04\xc5\x01\x03\x18\n\x0f\n\x05\x04'\x02\0\x04\x12\x06\xc5\x01\x03\xc4\
12527 \x01#\n\r\n\x05\x04'\x02\0\x05\x12\x04\xc5\x01\x03\x08\n\r\n\x05\x04'\
12528 \x02\0\x01\x12\x04\xc5\x01\t\x13\n\r\n\x05\x04'\x02\0\x03\x12\x04\xc5\
12529 \x01\x16\x17\n\x0c\n\x02\x04(\x12\x06\xc8\x01\0\xcc\x01\x01\n\x0b\n\x03\
12530 \x04(\x01\x12\x04\xc8\x01\x08\x1f\n\x0c\n\x04\x04(\x02\0\x12\x04\xc9\x01\
12531 \x04\x19\n\x0f\n\x05\x04(\x02\0\x04\x12\x06\xc9\x01\x04\xc8\x01!\n\r\n\
12532 \x05\x04(\x02\0\x05\x12\x04\xc9\x01\x04\t\n\r\n\x05\x04(\x02\0\x01\x12\
12533 \x04\xc9\x01\n\x14\n\r\n\x05\x04(\x02\0\x03\x12\x04\xc9\x01\x17\x18\n\
12534 \x0c\n\x04\x04(\x02\x01\x12\x04\xca\x01\x04\x11\n\x0f\n\x05\x04(\x02\x01\
12535 \x04\x12\x06\xca\x01\x04\xc9\x01\x19\n\r\n\x05\x04(\x02\x01\x05\x12\x04\
12536 \xca\x01\x04\t\n\r\n\x05\x04(\x02\x01\x01\x12\x04\xca\x01\n\x0c\n\r\n\
12537 \x05\x04(\x02\x01\x03\x12\x04\xca\x01\x0f\x10\n\x0c\n\x04\x04(\x02\x02\
12538 \x12\x04\xcb\x01\x04\x17\n\x0f\n\x05\x04(\x02\x02\x04\x12\x06\xcb\x01\
12539 \x04\xca\x01\x11\n\r\n\x05\x04(\x02\x02\x05\x12\x04\xcb\x01\x04\x08\n\r\
12540 \n\x05\x04(\x02\x02\x01\x12\x04\xcb\x01\t\x12\n\r\n\x05\x04(\x02\x02\x03\
12541 \x12\x04\xcb\x01\x15\x16\n\x0c\n\x02\x04)\x12\x06\xce\x01\0\xd2\x01\x01\
12542 \n\x0b\n\x03\x04)\x01\x12\x04\xce\x01\x08\x20\n\x0c\n\x04\x04)\x02\0\x12\
12543 \x04\xcf\x01\x04\x19\n\x0f\n\x05\x04)\x02\0\x04\x12\x06\xcf\x01\x04\xce\
12544 \x01!\n\r\n\x05\x04)\x02\0\x05\x12\x04\xcf\x01\x04\t\n\r\n\x05\x04)\x02\
12545 \0\x01\x12\x04\xcf\x01\n\x14\n\r\n\x05\x04)\x02\0\x03\x12\x04\xcf\x01\
12546 \x17\x18\n\x0c\n\x04\x04)\x02\x01\x12\x04\xd0\x01\x04\x11\n\x0f\n\x05\
12547 \x04)\x02\x01\x04\x12\x06\xd0\x01\x04\xcf\x01\x19\n\r\n\x05\x04)\x02\x01\
12548 \x05\x12\x04\xd0\x01\x04\t\n\r\n\x05\x04)\x02\x01\x01\x12\x04\xd0\x01\n\
12549 \x0c\n\r\n\x05\x04)\x02\x01\x03\x12\x04\xd0\x01\x0f\x10\n\x0c\n\x04\x04)\
12550 \x02\x02\x12\x04\xd1\x01\x04\x17\n\x0f\n\x05\x04)\x02\x02\x04\x12\x06\
12551 \xd1\x01\x04\xd0\x01\x11\n\r\n\x05\x04)\x02\x02\x05\x12\x04\xd1\x01\x04\
12552 \x08\n\r\n\x05\x04)\x02\x02\x01\x12\x04\xd1\x01\t\x12\n\r\n\x05\x04)\x02\
12553 \x02\x03\x12\x04\xd1\x01\x15\x16\n\x0c\n\x02\x04*\x12\x06\xd4\x01\0\xd7\
12554 \x01\x01\n\x0b\n\x03\x04*\x01\x12\x04\xd4\x01\x08\x1a\n\x0c\n\x04\x04*\
12555 \x02\0\x12\x04\xd5\x01\x04\x19\n\x0f\n\x05\x04*\x02\0\x04\x12\x06\xd5\
12556 \x01\x04\xd4\x01\x1c\n\r\n\x05\x04*\x02\0\x05\x12\x04\xd5\x01\x04\t\n\r\
12557 \n\x05\x04*\x02\0\x01\x12\x04\xd5\x01\n\x14\n\r\n\x05\x04*\x02\0\x03\x12\
12558 \x04\xd5\x01\x17\x18\n\x0c\n\x04\x04*\x02\x01\x12\x04\xd6\x01\x04\x11\n\
12559 \x0f\n\x05\x04*\x02\x01\x04\x12\x06\xd6\x01\x04\xd5\x01\x19\n\r\n\x05\
12560 \x04*\x02\x01\x05\x12\x04\xd6\x01\x04\t\n\r\n\x05\x04*\x02\x01\x01\x12\
12561 \x04\xd6\x01\n\x0c\n\r\n\x05\x04*\x02\x01\x03\x12\x04\xd6\x01\x0f\x10\n\
12562 \x0c\n\x02\x04+\x12\x06\xd9\x01\0\xdb\x01\x01\n\x0b\n\x03\x04+\x01\x12\
12563 \x04\xd9\x01\x08\x1b\n\x0c\n\x04\x04+\x02\0\x12\x04\xda\x01\x04)\n\r\n\
12564 \x05\x04+\x02\0\x04\x12\x04\xda\x01\x04\x0c\n\r\n\x05\x04+\x02\0\x06\x12\
12565 \x04\xda\x01\r\x1a\n\r\n\x05\x04+\x02\0\x01\x12\x04\xda\x01\x1b$\n\r\n\
12566 \x05\x04+\x02\0\x03\x12\x04\xda\x01'(\n\x0c\n\x02\x04,\x12\x06\xdd\x01\0\
12567 \xdf\x01\x01\n\x0b\n\x03\x04,\x01\x12\x04\xdd\x01\x08!\n\x0c\n\x04\x04,\
12568 \x02\0\x12\x04\xde\x01\x04\x13\n\x0f\n\x05\x04,\x02\0\x04\x12\x06\xde\
12569 \x01\x04\xdd\x01#\n\r\n\x05\x04,\x02\0\x05\x12\x04\xde\x01\x04\x08\n\r\n\
12570 \x05\x04,\x02\0\x01\x12\x04\xde\x01\t\x0e\n\r\n\x05\x04,\x02\0\x03\x12\
12571 \x04\xde\x01\x11\x12\n\x0c\n\x02\x04-\x12\x06\xe1\x01\0\xe3\x01\x01\n\
12572 \x0b\n\x03\x04-\x01\x12\x04\xe1\x01\x08\"\n\x0c\n\x04\x04-\x02\0\x12\x04\
12573 \xe2\x01\x04\x15\n\x0f\n\x05\x04-\x02\0\x04\x12\x06\xe2\x01\x04\xe1\x01$\
12574 \n\r\n\x05\x04-\x02\0\x05\x12\x04\xe2\x01\x04\n\n\r\n\x05\x04-\x02\0\x01\
12575 \x12\x04\xe2\x01\x0b\x10\n\r\n\x05\x04-\x02\0\x03\x12\x04\xe2\x01\x13\
12576 \x14\n\x0c\n\x02\x04.\x12\x06\xe5\x01\0\xe7\x01\x01\n\x0b\n\x03\x04.\x01\
12577 \x12\x04\xe5\x01\x08\x17\n\x0c\n\x04\x04.\x02\0\x12\x04\xe6\x01\x04\x1d\
12578 \n\x0f\n\x05\x04.\x02\0\x04\x12\x06\xe6\x01\x04\xe5\x01\x19\n\r\n\x05\
12579 \x04.\x02\0\x05\x12\x04\xe6\x01\x04\t\n\r\n\x05\x04.\x02\0\x01\x12\x04\
12580 \xe6\x01\n\x18\n\r\n\x05\x04.\x02\0\x03\x12\x04\xe6\x01\x1b\x1c\n\x0c\n\
12581 \x02\x04/\x12\x06\xe9\x01\0\xeb\x01\x01\n\x0b\n\x03\x04/\x01\x12\x04\xe9\
12582 \x01\x08\x18\n\x0c\n\x04\x04/\x02\0\x12\x04\xea\x01\x04\x1b\n\x0f\n\x05\
12583 \x04/\x02\0\x04\x12\x06\xea\x01\x04\xe9\x01\x1a\n\r\n\x05\x04/\x02\0\x06\
12584 \x12\x04\xea\x01\x04\x10\n\r\n\x05\x04/\x02\0\x01\x12\x04\xea\x01\x11\
12585 \x16\n\r\n\x05\x04/\x02\0\x03\x12\x04\xea\x01\x19\x1a\n\x0c\n\x02\x040\
12586 \x12\x06\xed\x01\0\xef\x01\x01\n\x0b\n\x03\x040\x01\x12\x04\xed\x01\x08\
12587 \x19\n\x0c\n\x04\x040\x02\0\x12\x04\xee\x01\x04\x13\n\x0f\n\x05\x040\x02\
12588 \0\x04\x12\x06\xee\x01\x04\xed\x01\x1b\n\r\n\x05\x040\x02\0\x05\x12\x04\
12589 \xee\x01\x04\x08\n\r\n\x05\x040\x02\0\x01\x12\x04\xee\x01\t\x0e\n\r\n\
12590 \x05\x040\x02\0\x03\x12\x04\xee\x01\x11\x12\n\x0c\n\x02\x041\x12\x06\xf1\
12591 \x01\0\xf3\x01\x01\n\x0b\n\x03\x041\x01\x12\x04\xf1\x01\x08\x1a\n\x0c\n\
12592 \x04\x041\x02\0\x12\x04\xf2\x01\x046\n\r\n\x05\x041\x02\0\x04\x12\x04\
12593 \xf2\x01\x04\x0c\n\r\n\x05\x041\x02\0\x06\x12\x04\xf2\x01\r$\n\r\n\x05\
12594 \x041\x02\0\x01\x12\x04\xf2\x01%1\n\r\n\x05\x041\x02\0\x03\x12\x04\xf2\
12595 \x0145\n\x0c\n\x02\x042\x12\x06\xf5\x01\0\xf9\x01\x01\n\x0b\n\x03\x042\
12596 \x01\x12\x04\xf5\x01\x08\x1a\n\x0c\n\x04\x042\x02\0\x12\x04\xf6\x01\x04\
12597 \x16\n\x0f\n\x05\x042\x02\0\x04\x12\x06\xf6\x01\x04\xf5\x01\x1c\n\r\n\
12598 \x05\x042\x02\0\x05\x12\x04\xf6\x01\x04\t\n\r\n\x05\x042\x02\0\x01\x12\
12599 \x04\xf6\x01\n\x11\n\r\n\x05\x042\x02\0\x03\x12\x04\xf6\x01\x14\x15\n\
12600 \x0c\n\x04\x042\x02\x01\x12\x04\xf7\x01\x04\x16\n\x0f\n\x05\x042\x02\x01\
12601 \x04\x12\x06\xf7\x01\x04\xf6\x01\x16\n\r\n\x05\x042\x02\x01\x05\x12\x04\
12602 \xf7\x01\x04\n\n\r\n\x05\x042\x02\x01\x01\x12\x04\xf7\x01\x0b\x11\n\r\n\
12603 \x05\x042\x02\x01\x03\x12\x04\xf7\x01\x14\x15\n\x0c\n\x04\x042\x02\x02\
12604 \x12\x04\xf8\x01\x044\n\x0f\n\x05\x042\x02\x02\x04\x12\x06\xf8\x01\x04\
12605 \xf7\x01\x16\n\r\n\x05\x042\x02\x02\x06\x12\x04\xf8\x01\x04\x1f\n\r\n\
12606 \x05\x042\x02\x02\x01\x12\x04\xf8\x01\x20/\n\r\n\x05\x042\x02\x02\x03\
12607 \x12\x04\xf8\x0123\n\x0c\n\x02\x043\x12\x06\xfb\x01\0\xff\x01\x01\n\x0b\
12608 \n\x03\x043\x01\x12\x04\xfb\x01\x08\x1b\n\x0c\n\x04\x043\x02\0\x12\x04\
12609 \xfc\x01\x04\x18\n\x0f\n\x05\x043\x02\0\x04\x12\x06\xfc\x01\x04\xfb\x01\
12610 \x1d\n\r\n\x05\x043\x02\0\x05\x12\x04\xfc\x01\x04\t\n\r\n\x05\x043\x02\0\
12611 \x01\x12\x04\xfc\x01\n\x13\n\r\n\x05\x043\x02\0\x03\x12\x04\xfc\x01\x16\
12612 \x17\n\x0c\n\x04\x043\x02\x01\x12\x04\xfd\x01\x04\x19\n\x0f\n\x05\x043\
12613 \x02\x01\x04\x12\x06\xfd\x01\x04\xfc\x01\x18\n\r\n\x05\x043\x02\x01\x05\
12614 \x12\x04\xfd\x01\x04\t\n\r\n\x05\x043\x02\x01\x01\x12\x04\xfd\x01\n\x14\
12615 \n\r\n\x05\x043\x02\x01\x03\x12\x04\xfd\x01\x17\x18\n\x0c\n\x04\x043\x02\
12616 \x02\x12\x04\xfe\x01\x04\x1f\n\x0f\n\x05\x043\x02\x02\x04\x12\x06\xfe\
12617 \x01\x04\xfd\x01\x19\n\r\n\x05\x043\x02\x02\x05\x12\x04\xfe\x01\x04\t\n\
12618 \r\n\x05\x043\x02\x02\x01\x12\x04\xfe\x01\n\x1a\n\r\n\x05\x043\x02\x02\
12619 \x03\x12\x04\xfe\x01\x1d\x1e\n\x0c\n\x02\x044\x12\x06\x81\x02\0\x86\x02\
12620 \x01\n\x0b\n\x03\x044\x01\x12\x04\x81\x02\x08\x1c\n\x0c\n\x04\x044\x02\0\
12621 \x12\x04\x82\x02\x04\x18\n\x0f\n\x05\x044\x02\0\x04\x12\x06\x82\x02\x04\
12622 \x81\x02\x1e\n\r\n\x05\x044\x02\0\x05\x12\x04\x82\x02\x04\t\n\r\n\x05\
12623 \x044\x02\0\x01\x12\x04\x82\x02\n\x13\n\r\n\x05\x044\x02\0\x03\x12\x04\
12624 \x82\x02\x16\x17\n\x0c\n\x04\x044\x02\x01\x12\x04\x83\x02\x04\x19\n\x0f\
12625 \n\x05\x044\x02\x01\x04\x12\x06\x83\x02\x04\x82\x02\x18\n\r\n\x05\x044\
12626 \x02\x01\x05\x12\x04\x83\x02\x04\t\n\r\n\x05\x044\x02\x01\x01\x12\x04\
12627 \x83\x02\n\x14\n\r\n\x05\x044\x02\x01\x03\x12\x04\x83\x02\x17\x18\n\x0c\
12628 \n\x04\x044\x02\x02\x12\x04\x84\x02\x04\x16\n\x0f\n\x05\x044\x02\x02\x04\
12629 \x12\x06\x84\x02\x04\x83\x02\x19\n\r\n\x05\x044\x02\x02\x05\x12\x04\x84\
12630 \x02\x04\t\n\r\n\x05\x044\x02\x02\x01\x12\x04\x84\x02\n\x11\n\r\n\x05\
12631 \x044\x02\x02\x03\x12\x04\x84\x02\x14\x15\n\x0c\n\x04\x044\x02\x03\x12\
12632 \x04\x85\x02\x044\n\x0f\n\x05\x044\x02\x03\x04\x12\x06\x85\x02\x04\x84\
12633 \x02\x16\n\r\n\x05\x044\x02\x03\x06\x12\x04\x85\x02\x04\x1f\n\r\n\x05\
12634 \x044\x02\x03\x01\x12\x04\x85\x02\x20/\n\r\n\x05\x044\x02\x03\x03\x12\
12635 \x04\x85\x0223\n\x0c\n\x02\x045\x12\x06\x88\x02\0\x8a\x02\x01\n\x0b\n\
12636 \x03\x045\x01\x12\x04\x88\x02\x08\x1d\n\x0c\n\x04\x045\x02\0\x12\x04\x89\
12637 \x02\x04\x1e\n\x0f\n\x05\x045\x02\0\x04\x12\x06\x89\x02\x04\x88\x02\x1f\
12638 \n\r\n\x05\x045\x02\0\x05\x12\x04\x89\x02\x04\x08\n\r\n\x05\x045\x02\0\
12639 \x01\x12\x04\x89\x02\t\x19\n\r\n\x05\x045\x02\0\x03\x12\x04\x89\x02\x1c\
12640 \x1d\n\x0c\n\x02\x046\x12\x06\x8c\x02\0\x8e\x02\x01\n\x0b\n\x03\x046\x01\
12641 \x12\x04\x8c\x02\x08\x1c\n\x0c\n\x04\x046\x02\0\x12\x04\x8d\x02\x04\x13\
12642 \n\x0f\n\x05\x046\x02\0\x04\x12\x06\x8d\x02\x04\x8c\x02\x1e\n\r\n\x05\
12643 \x046\x02\0\x05\x12\x04\x8d\x02\x04\x08\n\r\n\x05\x046\x02\0\x01\x12\x04\
12644 \x8d\x02\t\x0e\n\r\n\x05\x046\x02\0\x03\x12\x04\x8d\x02\x11\x12\n\x0c\n\
12645 \x02\x047\x12\x06\x90\x02\0\x92\x02\x01\n\x0b\n\x03\x047\x01\x12\x04\x90\
12646 \x02\x08\x1d\n\x0c\n\x04\x047\x02\0\x12\x04\x91\x02\x04\x15\n\x0f\n\x05\
12647 \x047\x02\0\x04\x12\x06\x91\x02\x04\x90\x02\x1f\n\r\n\x05\x047\x02\0\x05\
12648 \x12\x04\x91\x02\x04\n\n\r\n\x05\x047\x02\0\x01\x12\x04\x91\x02\x0b\x10\
12649 \n\r\n\x05\x047\x02\0\x03\x12\x04\x91\x02\x13\x14\n\x0c\n\x02\x048\x12\
12650 \x06\x94\x02\0\x98\x02\x01\n\x0b\n\x03\x048\x01\x12\x04\x94\x02\x08\x1b\
12651 \n\x0c\n\x04\x048\x02\0\x12\x04\x95\x02\x08\x1d\n\x0f\n\x05\x048\x02\0\
12652 \x04\x12\x06\x95\x02\x08\x94\x02\x1d\n\r\n\x05\x048\x02\0\x05\x12\x04\
12653 \x95\x02\x08\x0e\n\r\n\x05\x048\x02\0\x01\x12\x04\x95\x02\x0f\x18\n\r\n\
12654 \x05\x048\x02\0\x03\x12\x04\x95\x02\x1b\x1c\n\x0c\n\x04\x048\x02\x01\x12\
12655 \x04\x96\x02\x08\x1d\n\x0f\n\x05\x048\x02\x01\x04\x12\x06\x96\x02\x08\
12656 \x95\x02\x1d\n\r\n\x05\x048\x02\x01\x05\x12\x04\x96\x02\x08\x0e\n\r\n\
12657 \x05\x048\x02\x01\x01\x12\x04\x96\x02\x0f\x18\n\r\n\x05\x048\x02\x01\x03\
12658 \x12\x04\x96\x02\x1b\x1c\n\x0c\n\x04\x048\x02\x02\x12\x04\x97\x02\x08\
12659 \x18\n\x0f\n\x05\x048\x02\x02\x04\x12\x06\x97\x02\x08\x96\x02\x1d\n\r\n\
12660 \x05\x048\x02\x02\x05\x12\x04\x97\x02\x08\x0e\n\r\n\x05\x048\x02\x02\x01\
12661 \x12\x04\x97\x02\x0f\x13\n\r\n\x05\x048\x02\x02\x03\x12\x04\x97\x02\x16\
12662 \x17\n\x0c\n\x02\x049\x12\x06\x9a\x02\0\x9d\x02\x01\n\x0b\n\x03\x049\x01\
12663 \x12\x04\x9a\x02\x08\x1c\n\x0c\n\x04\x049\x02\0\x12\x04\x9b\x02\x08\x20\
12664 \n\x0f\n\x05\x049\x02\0\x04\x12\x06\x9b\x02\x08\x9a\x02\x1e\n\r\n\x05\
12665 \x049\x02\0\x05\x12\x04\x9b\x02\x08\r\n\r\n\x05\x049\x02\0\x01\x12\x04\
12666 \x9b\x02\x0e\x1b\n\r\n\x05\x049\x02\0\x03\x12\x04\x9b\x02\x1e\x1f\n\x0c\
12667 \n\x04\x049\x02\x01\x12\x04\x9c\x02\x08\x1c\n\x0f\n\x05\x049\x02\x01\x04\
12668 \x12\x06\x9c\x02\x08\x9b\x02\x20\n\r\n\x05\x049\x02\x01\x05\x12\x04\x9c\
12669 \x02\x08\x0e\n\r\n\x05\x049\x02\x01\x01\x12\x04\x9c\x02\x0f\x17\n\r\n\
12670 \x05\x049\x02\x01\x03\x12\x04\x9c\x02\x1a\x1b\n\x0c\n\x02\x04:\x12\x06\
12671 \x9f\x02\0\xa3\x02\x01\n\x0b\n\x03\x04:\x01\x12\x04\x9f\x02\x08\x20\n\
12672 \x0c\n\x04\x04:\x02\0\x12\x04\xa0\x02\x08\x1c\n\x0f\n\x05\x04:\x02\0\x04\
12673 \x12\x06\xa0\x02\x08\x9f\x02\"\n\r\n\x05\x04:\x02\0\x05\x12\x04\xa0\x02\
12674 \x08\x0e\n\r\n\x05\x04:\x02\0\x01\x12\x04\xa0\x02\x0f\x17\n\r\n\x05\x04:\
12675 \x02\0\x03\x12\x04\xa0\x02\x1a\x1b\n\x0c\n\x04\x04:\x02\x01\x12\x04\xa1\
12676 \x02\x08\x1e\n\x0f\n\x05\x04:\x02\x01\x04\x12\x06\xa1\x02\x08\xa0\x02\
12677 \x1c\n\r\n\x05\x04:\x02\x01\x05\x12\x04\xa1\x02\x08\r\n\r\n\x05\x04:\x02\
12678 \x01\x01\x12\x04\xa1\x02\x0e\x19\n\r\n\x05\x04:\x02\x01\x03\x12\x04\xa1\
12679 \x02\x1c\x1d\n\x0c\n\x04\x04:\x02\x02\x12\x04\xa2\x02\x08(\n\x0f\n\x05\
12680 \x04:\x02\x02\x04\x12\x06\xa2\x02\x08\xa1\x02\x1e\n\r\n\x05\x04:\x02\x02\
12681 \x05\x12\x04\xa2\x02\x08\r\n\r\n\x05\x04:\x02\x02\x01\x12\x04\xa2\x02\
12682 \x0e#\n\r\n\x05\x04:\x02\x02\x03\x12\x04\xa2\x02&'\n\x0c\n\x02\x04;\x12\
12683 \x06\xa5\x02\0\xa7\x02\x01\n\x0b\n\x03\x04;\x01\x12\x04\xa5\x02\x08!\n\
12684 \x0c\n\x04\x04;\x02\0\x12\x04\xa6\x02\x08\x20\n\x0f\n\x05\x04;\x02\0\x04\
12685 \x12\x06\xa6\x02\x08\xa5\x02#\n\r\n\x05\x04;\x02\0\x05\x12\x04\xa6\x02\
12686 \x08\r\n\r\n\x05\x04;\x02\0\x01\x12\x04\xa6\x02\x0e\x1b\n\r\n\x05\x04;\
12687 \x02\0\x03\x12\x04\xa6\x02\x1e\x1f\n\x0c\n\x02\x04<\x12\x06\xa9\x02\0\
12688 \xac\x02\x01\n\x0b\n\x03\x04<\x01\x12\x04\xa9\x02\x08\x19\n\x0c\n\x04\
12689 \x04<\x02\0\x12\x04\xaa\x02\x08\x1a\n\x0f\n\x05\x04<\x02\0\x04\x12\x06\
12690 \xaa\x02\x08\xa9\x02\x1b\n\r\n\x05\x04<\x02\0\x05\x12\x04\xaa\x02\x08\r\
12691 \n\r\n\x05\x04<\x02\0\x01\x12\x04\xaa\x02\x0e\x15\n\r\n\x05\x04<\x02\0\
12692 \x03\x12\x04\xaa\x02\x18\x19\n\x0c\n\x04\x04<\x02\x01\x12\x04\xab\x02\
12693 \x08\x1d\n\x0f\n\x05\x04<\x02\x01\x04\x12\x06\xab\x02\x08\xaa\x02\x1a\n\
12694 \r\n\x05\x04<\x02\x01\x05\x12\x04\xab\x02\x08\r\n\r\n\x05\x04<\x02\x01\
12695 \x01\x12\x04\xab\x02\x0e\x18\n\r\n\x05\x04<\x02\x01\x03\x12\x04\xab\x02\
12696 \x1b\x1c\n\x0c\n\x02\x04=\x12\x06\xae\x02\0\xb0\x02\x01\n\x0b\n\x03\x04=\
12697 \x01\x12\x04\xae\x02\x08\x1a\n\x0c\n\x04\x04=\x02\0\x12\x04\xaf\x02\x08!\
12698 \n\x0f\n\x05\x04=\x02\0\x04\x12\x06\xaf\x02\x08\xae\x02\x1c\n\r\n\x05\
12699 \x04=\x02\0\x05\x12\x04\xaf\x02\x08\x0e\n\r\n\x05\x04=\x02\0\x01\x12\x04\
12700 \xaf\x02\x0f\x1c\n\r\n\x05\x04=\x02\0\x03\x12\x04\xaf\x02\x1f\x20\n\n\n\
12701 \x02\x04>\x12\x04\xb2\x02\0\x1f\n\x0b\n\x03\x04>\x01\x12\x04\xb2\x02\x08\
12702 \x1b\n\x0c\n\x02\x04?\x12\x06\xb4\x02\0\xb6\x02\x01\n\x0b\n\x03\x04?\x01\
12703 \x12\x04\xb4\x02\x08\x1c\n\x0c\n\x04\x04?\x02\0\x12\x04\xb5\x02\x08\x1d\
12704 \n\x0f\n\x05\x04?\x02\0\x04\x12\x06\xb5\x02\x08\xb4\x02\x1e\n\r\n\x05\
12705 \x04?\x02\0\x05\x12\x04\xb5\x02\x08\r\n\r\n\x05\x04?\x02\0\x01\x12\x04\
12706 \xb5\x02\x0e\x18\n\r\n\x05\x04?\x02\0\x03\x12\x04\xb5\x02\x1b\x1c\n\x0c\
12707 \n\x02\x04@\x12\x06\xb8\x02\0\xba\x02\x01\n\x0b\n\x03\x04@\x01\x12\x04\
12708 \xb8\x02\x08\x1d\n\x0c\n\x04\x04@\x02\0\x12\x04\xb9\x02\x08\x1c\n\x0f\n\
12709 \x05\x04@\x02\0\x04\x12\x06\xb9\x02\x08\xb8\x02\x1f\n\r\n\x05\x04@\x02\0\
12710 \x05\x12\x04\xb9\x02\x08\x0e\n\r\n\x05\x04@\x02\0\x01\x12\x04\xb9\x02\
12711 \x0f\x17\n\r\n\x05\x04@\x02\0\x03\x12\x04\xb9\x02\x1a\x1b\n\x0c\n\x02\
12712 \x04A\x12\x06\xbc\x02\0\xbf\x02\x01\n\x0b\n\x03\x04A\x01\x12\x04\xbc\x02\
12713 \x08\x1e\n\x0c\n\x04\x04A\x02\0\x12\x04\xbd\x02\x08\x1d\n\x0f\n\x05\x04A\
12714 \x02\0\x04\x12\x06\xbd\x02\x08\xbc\x02\x20\n\r\n\x05\x04A\x02\0\x05\x12\
12715 \x04\xbd\x02\x08\x0e\n\r\n\x05\x04A\x02\0\x01\x12\x04\xbd\x02\x0f\x18\n\
12716 \r\n\x05\x04A\x02\0\x03\x12\x04\xbd\x02\x1b\x1c\n\x0c\n\x04\x04A\x02\x01\
12717 \x12\x04\xbe\x02\x08\x20\n\x0f\n\x05\x04A\x02\x01\x04\x12\x06\xbe\x02\
12718 \x08\xbd\x02\x1d\n\r\n\x05\x04A\x02\x01\x05\x12\x04\xbe\x02\x08\r\n\r\n\
12719 \x05\x04A\x02\x01\x01\x12\x04\xbe\x02\x0e\x1b\n\r\n\x05\x04A\x02\x01\x03\
12720 \x12\x04\xbe\x02\x1e\x1f\n\x0c\n\x02\x04B\x12\x06\xc1\x02\0\xc3\x02\x01\
12721 \n\x0b\n\x03\x04B\x01\x12\x04\xc1\x02\x08\x20\n\x0c\n\x04\x04B\x02\0\x12\
12722 \x04\xc2\x02\x04\x1b\n\x0f\n\x05\x04B\x02\0\x04\x12\x06\xc2\x02\x04\xc1\
12723 \x02\"\n\r\n\x05\x04B\x02\0\x05\x12\x04\xc2\x02\x04\n\n\r\n\x05\x04B\x02\
12724 \0\x01\x12\x04\xc2\x02\x0b\x16\n\r\n\x05\x04B\x02\0\x03\x12\x04\xc2\x02\
12725 \x19\x1a\n\x0c\n\x02\x04C\x12\x06\xc5\x02\0\xc7\x02\x01\n\x0b\n\x03\x04C\
12726 \x01\x12\x04\xc5\x02\x08!\n\x0c\n\x04\x04C\x02\0\x12\x04\xc6\x02\x04\x13\
12727 \n\x0f\n\x05\x04C\x02\0\x04\x12\x06\xc6\x02\x04\xc5\x02#\n\r\n\x05\x04C\
12728 \x02\0\x05\x12\x04\xc6\x02\x04\x08\n\r\n\x05\x04C\x02\0\x01\x12\x04\xc6\
12729 \x02\t\x0e\n\r\n\x05\x04C\x02\0\x03\x12\x04\xc6\x02\x11\x12b\x06proto3\
12730";
12731
12732static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
12733 lock: ::protobuf::lazy::ONCE_INIT,
12734 ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
12735};
12736
12737fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
12738 ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
12739}
12740
12741pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
12742 unsafe {
12743 file_descriptor_proto_lazy.get(|| {
12744 parse_descriptor_proto()
12745 })
12746 }
12747}