1#![allow(unknown_lints)]
7#![allow(clippy::all)]
8
9#![allow(unused_attributes)]
10#![cfg_attr(rustfmt, rustfmt::skip)]
11
12#![allow(dead_code)]
13#![allow(missing_docs)]
14#![allow(non_camel_case_types)]
15#![allow(non_snake_case)]
16#![allow(non_upper_case_globals)]
17#![allow(trivial_casts)]
18#![allow(unused_results)]
19#![allow(unused_mut)]
20
21const _PROTOBUF_VERSION_CHECK: () = ::steam_vent_proto_common::protobuf::VERSION_3_5_1;
27
28#[derive(PartialEq,Clone,Default,Debug)]
30pub struct SiteServerUI_Login_Request {
31 pub username: ::std::option::Option<::std::string::String>,
34 pub password: ::std::option::Option<::std::string::String>,
36 pub steamguardcode: ::std::option::Option<::std::string::String>,
38 pub remember_password: ::std::option::Option<bool>,
40 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
43}
44
45impl<'a> ::std::default::Default for &'a SiteServerUI_Login_Request {
46 fn default() -> &'a SiteServerUI_Login_Request {
47 <SiteServerUI_Login_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
48 }
49}
50
51impl SiteServerUI_Login_Request {
52 pub fn new() -> SiteServerUI_Login_Request {
53 ::std::default::Default::default()
54 }
55
56 pub fn username(&self) -> &str {
59 match self.username.as_ref() {
60 Some(v) => v,
61 None => "",
62 }
63 }
64
65 pub fn clear_username(&mut self) {
66 self.username = ::std::option::Option::None;
67 }
68
69 pub fn has_username(&self) -> bool {
70 self.username.is_some()
71 }
72
73 pub fn set_username(&mut self, v: ::std::string::String) {
75 self.username = ::std::option::Option::Some(v);
76 }
77
78 pub fn mut_username(&mut self) -> &mut ::std::string::String {
81 if self.username.is_none() {
82 self.username = ::std::option::Option::Some(::std::string::String::new());
83 }
84 self.username.as_mut().unwrap()
85 }
86
87 pub fn take_username(&mut self) -> ::std::string::String {
89 self.username.take().unwrap_or_else(|| ::std::string::String::new())
90 }
91
92 pub fn password(&self) -> &str {
95 match self.password.as_ref() {
96 Some(v) => v,
97 None => "",
98 }
99 }
100
101 pub fn clear_password(&mut self) {
102 self.password = ::std::option::Option::None;
103 }
104
105 pub fn has_password(&self) -> bool {
106 self.password.is_some()
107 }
108
109 pub fn set_password(&mut self, v: ::std::string::String) {
111 self.password = ::std::option::Option::Some(v);
112 }
113
114 pub fn mut_password(&mut self) -> &mut ::std::string::String {
117 if self.password.is_none() {
118 self.password = ::std::option::Option::Some(::std::string::String::new());
119 }
120 self.password.as_mut().unwrap()
121 }
122
123 pub fn take_password(&mut self) -> ::std::string::String {
125 self.password.take().unwrap_or_else(|| ::std::string::String::new())
126 }
127
128 pub fn steamguardcode(&self) -> &str {
131 match self.steamguardcode.as_ref() {
132 Some(v) => v,
133 None => "",
134 }
135 }
136
137 pub fn clear_steamguardcode(&mut self) {
138 self.steamguardcode = ::std::option::Option::None;
139 }
140
141 pub fn has_steamguardcode(&self) -> bool {
142 self.steamguardcode.is_some()
143 }
144
145 pub fn set_steamguardcode(&mut self, v: ::std::string::String) {
147 self.steamguardcode = ::std::option::Option::Some(v);
148 }
149
150 pub fn mut_steamguardcode(&mut self) -> &mut ::std::string::String {
153 if self.steamguardcode.is_none() {
154 self.steamguardcode = ::std::option::Option::Some(::std::string::String::new());
155 }
156 self.steamguardcode.as_mut().unwrap()
157 }
158
159 pub fn take_steamguardcode(&mut self) -> ::std::string::String {
161 self.steamguardcode.take().unwrap_or_else(|| ::std::string::String::new())
162 }
163
164 pub fn remember_password(&self) -> bool {
167 self.remember_password.unwrap_or(false)
168 }
169
170 pub fn clear_remember_password(&mut self) {
171 self.remember_password = ::std::option::Option::None;
172 }
173
174 pub fn has_remember_password(&self) -> bool {
175 self.remember_password.is_some()
176 }
177
178 pub fn set_remember_password(&mut self, v: bool) {
180 self.remember_password = ::std::option::Option::Some(v);
181 }
182}
183
184impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Login_Request {
185 const NAME: &'static str = "SiteServerUI_Login_Request";
186
187 fn is_initialized(&self) -> bool {
188 true
189 }
190
191 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
192 while let Some(tag) = is.read_raw_tag_or_eof()? {
193 match tag {
194 10 => {
195 self.username = ::std::option::Option::Some(is.read_string()?);
196 },
197 18 => {
198 self.password = ::std::option::Option::Some(is.read_string()?);
199 },
200 26 => {
201 self.steamguardcode = ::std::option::Option::Some(is.read_string()?);
202 },
203 32 => {
204 self.remember_password = ::std::option::Option::Some(is.read_bool()?);
205 },
206 tag => {
207 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
208 },
209 };
210 }
211 ::std::result::Result::Ok(())
212 }
213
214 #[allow(unused_variables)]
216 fn compute_size(&self) -> u64 {
217 let mut my_size = 0;
218 if let Some(v) = self.username.as_ref() {
219 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
220 }
221 if let Some(v) = self.password.as_ref() {
222 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
223 }
224 if let Some(v) = self.steamguardcode.as_ref() {
225 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
226 }
227 if let Some(v) = self.remember_password {
228 my_size += 1 + 1;
229 }
230 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
231 self.special_fields.cached_size().set(my_size as u32);
232 my_size
233 }
234
235 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
236 if let Some(v) = self.username.as_ref() {
237 os.write_string(1, v)?;
238 }
239 if let Some(v) = self.password.as_ref() {
240 os.write_string(2, v)?;
241 }
242 if let Some(v) = self.steamguardcode.as_ref() {
243 os.write_string(3, v)?;
244 }
245 if let Some(v) = self.remember_password {
246 os.write_bool(4, v)?;
247 }
248 os.write_unknown_fields(self.special_fields.unknown_fields())?;
249 ::std::result::Result::Ok(())
250 }
251
252 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
253 &self.special_fields
254 }
255
256 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
257 &mut self.special_fields
258 }
259
260 fn new() -> SiteServerUI_Login_Request {
261 SiteServerUI_Login_Request::new()
262 }
263
264 fn clear(&mut self) {
265 self.username = ::std::option::Option::None;
266 self.password = ::std::option::Option::None;
267 self.steamguardcode = ::std::option::Option::None;
268 self.remember_password = ::std::option::Option::None;
269 self.special_fields.clear();
270 }
271
272 fn default_instance() -> &'static SiteServerUI_Login_Request {
273 static instance: SiteServerUI_Login_Request = SiteServerUI_Login_Request {
274 username: ::std::option::Option::None,
275 password: ::std::option::Option::None,
276 steamguardcode: ::std::option::Option::None,
277 remember_password: ::std::option::Option::None,
278 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
279 };
280 &instance
281 }
282}
283
284#[derive(PartialEq,Clone,Default,Debug)]
286pub struct SiteServerUI_Login_Response {
287 pub logon_state: ::std::option::Option<i32>,
290 pub logon_eresult: ::std::option::Option<i32>,
292 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
295}
296
297impl<'a> ::std::default::Default for &'a SiteServerUI_Login_Response {
298 fn default() -> &'a SiteServerUI_Login_Response {
299 <SiteServerUI_Login_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
300 }
301}
302
303impl SiteServerUI_Login_Response {
304 pub fn new() -> SiteServerUI_Login_Response {
305 ::std::default::Default::default()
306 }
307
308 pub fn logon_state(&self) -> i32 {
311 self.logon_state.unwrap_or(0)
312 }
313
314 pub fn clear_logon_state(&mut self) {
315 self.logon_state = ::std::option::Option::None;
316 }
317
318 pub fn has_logon_state(&self) -> bool {
319 self.logon_state.is_some()
320 }
321
322 pub fn set_logon_state(&mut self, v: i32) {
324 self.logon_state = ::std::option::Option::Some(v);
325 }
326
327 pub fn logon_eresult(&self) -> i32 {
330 self.logon_eresult.unwrap_or(0)
331 }
332
333 pub fn clear_logon_eresult(&mut self) {
334 self.logon_eresult = ::std::option::Option::None;
335 }
336
337 pub fn has_logon_eresult(&self) -> bool {
338 self.logon_eresult.is_some()
339 }
340
341 pub fn set_logon_eresult(&mut self, v: i32) {
343 self.logon_eresult = ::std::option::Option::Some(v);
344 }
345}
346
347impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Login_Response {
348 const NAME: &'static str = "SiteServerUI_Login_Response";
349
350 fn is_initialized(&self) -> bool {
351 true
352 }
353
354 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
355 while let Some(tag) = is.read_raw_tag_or_eof()? {
356 match tag {
357 8 => {
358 self.logon_state = ::std::option::Option::Some(is.read_int32()?);
359 },
360 16 => {
361 self.logon_eresult = ::std::option::Option::Some(is.read_int32()?);
362 },
363 tag => {
364 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
365 },
366 };
367 }
368 ::std::result::Result::Ok(())
369 }
370
371 #[allow(unused_variables)]
373 fn compute_size(&self) -> u64 {
374 let mut my_size = 0;
375 if let Some(v) = self.logon_state {
376 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
377 }
378 if let Some(v) = self.logon_eresult {
379 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
380 }
381 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
382 self.special_fields.cached_size().set(my_size as u32);
383 my_size
384 }
385
386 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
387 if let Some(v) = self.logon_state {
388 os.write_int32(1, v)?;
389 }
390 if let Some(v) = self.logon_eresult {
391 os.write_int32(2, v)?;
392 }
393 os.write_unknown_fields(self.special_fields.unknown_fields())?;
394 ::std::result::Result::Ok(())
395 }
396
397 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
398 &self.special_fields
399 }
400
401 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
402 &mut self.special_fields
403 }
404
405 fn new() -> SiteServerUI_Login_Response {
406 SiteServerUI_Login_Response::new()
407 }
408
409 fn clear(&mut self) {
410 self.logon_state = ::std::option::Option::None;
411 self.logon_eresult = ::std::option::Option::None;
412 self.special_fields.clear();
413 }
414
415 fn default_instance() -> &'static SiteServerUI_Login_Response {
416 static instance: SiteServerUI_Login_Response = SiteServerUI_Login_Response {
417 logon_state: ::std::option::Option::None,
418 logon_eresult: ::std::option::Option::None,
419 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
420 };
421 &instance
422 }
423}
424
425#[derive(PartialEq,Clone,Default,Debug)]
427pub struct SiteServerUI_LoginStatus_Request {
428 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
431}
432
433impl<'a> ::std::default::Default for &'a SiteServerUI_LoginStatus_Request {
434 fn default() -> &'a SiteServerUI_LoginStatus_Request {
435 <SiteServerUI_LoginStatus_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
436 }
437}
438
439impl SiteServerUI_LoginStatus_Request {
440 pub fn new() -> SiteServerUI_LoginStatus_Request {
441 ::std::default::Default::default()
442 }
443}
444
445impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_LoginStatus_Request {
446 const NAME: &'static str = "SiteServerUI_LoginStatus_Request";
447
448 fn is_initialized(&self) -> bool {
449 true
450 }
451
452 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
453 while let Some(tag) = is.read_raw_tag_or_eof()? {
454 match tag {
455 tag => {
456 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
457 },
458 };
459 }
460 ::std::result::Result::Ok(())
461 }
462
463 #[allow(unused_variables)]
465 fn compute_size(&self) -> u64 {
466 let mut my_size = 0;
467 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
468 self.special_fields.cached_size().set(my_size as u32);
469 my_size
470 }
471
472 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
473 os.write_unknown_fields(self.special_fields.unknown_fields())?;
474 ::std::result::Result::Ok(())
475 }
476
477 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
478 &self.special_fields
479 }
480
481 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
482 &mut self.special_fields
483 }
484
485 fn new() -> SiteServerUI_LoginStatus_Request {
486 SiteServerUI_LoginStatus_Request::new()
487 }
488
489 fn clear(&mut self) {
490 self.special_fields.clear();
491 }
492
493 fn default_instance() -> &'static SiteServerUI_LoginStatus_Request {
494 static instance: SiteServerUI_LoginStatus_Request = SiteServerUI_LoginStatus_Request {
495 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
496 };
497 &instance
498 }
499}
500
501#[derive(PartialEq,Clone,Default,Debug)]
503pub struct SiteServerUI_LoginStatus_Response {
504 pub username: ::std::option::Option<::std::string::String>,
507 pub cached_credentials: ::std::option::Option<bool>,
509 pub logon_state: ::std::option::Option<i32>,
511 pub logon_eresult: ::std::option::Option<i32>,
513 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
516}
517
518impl<'a> ::std::default::Default for &'a SiteServerUI_LoginStatus_Response {
519 fn default() -> &'a SiteServerUI_LoginStatus_Response {
520 <SiteServerUI_LoginStatus_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
521 }
522}
523
524impl SiteServerUI_LoginStatus_Response {
525 pub fn new() -> SiteServerUI_LoginStatus_Response {
526 ::std::default::Default::default()
527 }
528
529 pub fn username(&self) -> &str {
532 match self.username.as_ref() {
533 Some(v) => v,
534 None => "",
535 }
536 }
537
538 pub fn clear_username(&mut self) {
539 self.username = ::std::option::Option::None;
540 }
541
542 pub fn has_username(&self) -> bool {
543 self.username.is_some()
544 }
545
546 pub fn set_username(&mut self, v: ::std::string::String) {
548 self.username = ::std::option::Option::Some(v);
549 }
550
551 pub fn mut_username(&mut self) -> &mut ::std::string::String {
554 if self.username.is_none() {
555 self.username = ::std::option::Option::Some(::std::string::String::new());
556 }
557 self.username.as_mut().unwrap()
558 }
559
560 pub fn take_username(&mut self) -> ::std::string::String {
562 self.username.take().unwrap_or_else(|| ::std::string::String::new())
563 }
564
565 pub fn cached_credentials(&self) -> bool {
568 self.cached_credentials.unwrap_or(false)
569 }
570
571 pub fn clear_cached_credentials(&mut self) {
572 self.cached_credentials = ::std::option::Option::None;
573 }
574
575 pub fn has_cached_credentials(&self) -> bool {
576 self.cached_credentials.is_some()
577 }
578
579 pub fn set_cached_credentials(&mut self, v: bool) {
581 self.cached_credentials = ::std::option::Option::Some(v);
582 }
583
584 pub fn logon_state(&self) -> i32 {
587 self.logon_state.unwrap_or(0)
588 }
589
590 pub fn clear_logon_state(&mut self) {
591 self.logon_state = ::std::option::Option::None;
592 }
593
594 pub fn has_logon_state(&self) -> bool {
595 self.logon_state.is_some()
596 }
597
598 pub fn set_logon_state(&mut self, v: i32) {
600 self.logon_state = ::std::option::Option::Some(v);
601 }
602
603 pub fn logon_eresult(&self) -> i32 {
606 self.logon_eresult.unwrap_or(0)
607 }
608
609 pub fn clear_logon_eresult(&mut self) {
610 self.logon_eresult = ::std::option::Option::None;
611 }
612
613 pub fn has_logon_eresult(&self) -> bool {
614 self.logon_eresult.is_some()
615 }
616
617 pub fn set_logon_eresult(&mut self, v: i32) {
619 self.logon_eresult = ::std::option::Option::Some(v);
620 }
621}
622
623impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_LoginStatus_Response {
624 const NAME: &'static str = "SiteServerUI_LoginStatus_Response";
625
626 fn is_initialized(&self) -> bool {
627 true
628 }
629
630 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
631 while let Some(tag) = is.read_raw_tag_or_eof()? {
632 match tag {
633 10 => {
634 self.username = ::std::option::Option::Some(is.read_string()?);
635 },
636 16 => {
637 self.cached_credentials = ::std::option::Option::Some(is.read_bool()?);
638 },
639 24 => {
640 self.logon_state = ::std::option::Option::Some(is.read_int32()?);
641 },
642 32 => {
643 self.logon_eresult = ::std::option::Option::Some(is.read_int32()?);
644 },
645 tag => {
646 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
647 },
648 };
649 }
650 ::std::result::Result::Ok(())
651 }
652
653 #[allow(unused_variables)]
655 fn compute_size(&self) -> u64 {
656 let mut my_size = 0;
657 if let Some(v) = self.username.as_ref() {
658 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
659 }
660 if let Some(v) = self.cached_credentials {
661 my_size += 1 + 1;
662 }
663 if let Some(v) = self.logon_state {
664 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
665 }
666 if let Some(v) = self.logon_eresult {
667 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
668 }
669 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
670 self.special_fields.cached_size().set(my_size as u32);
671 my_size
672 }
673
674 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
675 if let Some(v) = self.username.as_ref() {
676 os.write_string(1, v)?;
677 }
678 if let Some(v) = self.cached_credentials {
679 os.write_bool(2, v)?;
680 }
681 if let Some(v) = self.logon_state {
682 os.write_int32(3, v)?;
683 }
684 if let Some(v) = self.logon_eresult {
685 os.write_int32(4, v)?;
686 }
687 os.write_unknown_fields(self.special_fields.unknown_fields())?;
688 ::std::result::Result::Ok(())
689 }
690
691 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
692 &self.special_fields
693 }
694
695 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
696 &mut self.special_fields
697 }
698
699 fn new() -> SiteServerUI_LoginStatus_Response {
700 SiteServerUI_LoginStatus_Response::new()
701 }
702
703 fn clear(&mut self) {
704 self.username = ::std::option::Option::None;
705 self.cached_credentials = ::std::option::Option::None;
706 self.logon_state = ::std::option::Option::None;
707 self.logon_eresult = ::std::option::Option::None;
708 self.special_fields.clear();
709 }
710
711 fn default_instance() -> &'static SiteServerUI_LoginStatus_Response {
712 static instance: SiteServerUI_LoginStatus_Response = SiteServerUI_LoginStatus_Response {
713 username: ::std::option::Option::None,
714 cached_credentials: ::std::option::Option::None,
715 logon_state: ::std::option::Option::None,
716 logon_eresult: ::std::option::Option::None,
717 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
718 };
719 &instance
720 }
721}
722
723#[derive(PartialEq,Clone,Default,Debug)]
725pub struct SiteServerUI_CancelLogin_Request {
726 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
729}
730
731impl<'a> ::std::default::Default for &'a SiteServerUI_CancelLogin_Request {
732 fn default() -> &'a SiteServerUI_CancelLogin_Request {
733 <SiteServerUI_CancelLogin_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
734 }
735}
736
737impl SiteServerUI_CancelLogin_Request {
738 pub fn new() -> SiteServerUI_CancelLogin_Request {
739 ::std::default::Default::default()
740 }
741}
742
743impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_CancelLogin_Request {
744 const NAME: &'static str = "SiteServerUI_CancelLogin_Request";
745
746 fn is_initialized(&self) -> bool {
747 true
748 }
749
750 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
751 while let Some(tag) = is.read_raw_tag_or_eof()? {
752 match tag {
753 tag => {
754 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
755 },
756 };
757 }
758 ::std::result::Result::Ok(())
759 }
760
761 #[allow(unused_variables)]
763 fn compute_size(&self) -> u64 {
764 let mut my_size = 0;
765 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
766 self.special_fields.cached_size().set(my_size as u32);
767 my_size
768 }
769
770 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
771 os.write_unknown_fields(self.special_fields.unknown_fields())?;
772 ::std::result::Result::Ok(())
773 }
774
775 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
776 &self.special_fields
777 }
778
779 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
780 &mut self.special_fields
781 }
782
783 fn new() -> SiteServerUI_CancelLogin_Request {
784 SiteServerUI_CancelLogin_Request::new()
785 }
786
787 fn clear(&mut self) {
788 self.special_fields.clear();
789 }
790
791 fn default_instance() -> &'static SiteServerUI_CancelLogin_Request {
792 static instance: SiteServerUI_CancelLogin_Request = SiteServerUI_CancelLogin_Request {
793 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
794 };
795 &instance
796 }
797}
798
799#[derive(PartialEq,Clone,Default,Debug)]
801pub struct SiteServerUI_CancelLogin_Response {
802 pub logon_state: ::std::option::Option<i32>,
805 pub logon_eresult: ::std::option::Option<i32>,
807 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
810}
811
812impl<'a> ::std::default::Default for &'a SiteServerUI_CancelLogin_Response {
813 fn default() -> &'a SiteServerUI_CancelLogin_Response {
814 <SiteServerUI_CancelLogin_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
815 }
816}
817
818impl SiteServerUI_CancelLogin_Response {
819 pub fn new() -> SiteServerUI_CancelLogin_Response {
820 ::std::default::Default::default()
821 }
822
823 pub fn logon_state(&self) -> i32 {
826 self.logon_state.unwrap_or(0)
827 }
828
829 pub fn clear_logon_state(&mut self) {
830 self.logon_state = ::std::option::Option::None;
831 }
832
833 pub fn has_logon_state(&self) -> bool {
834 self.logon_state.is_some()
835 }
836
837 pub fn set_logon_state(&mut self, v: i32) {
839 self.logon_state = ::std::option::Option::Some(v);
840 }
841
842 pub fn logon_eresult(&self) -> i32 {
845 self.logon_eresult.unwrap_or(0)
846 }
847
848 pub fn clear_logon_eresult(&mut self) {
849 self.logon_eresult = ::std::option::Option::None;
850 }
851
852 pub fn has_logon_eresult(&self) -> bool {
853 self.logon_eresult.is_some()
854 }
855
856 pub fn set_logon_eresult(&mut self, v: i32) {
858 self.logon_eresult = ::std::option::Option::Some(v);
859 }
860}
861
862impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_CancelLogin_Response {
863 const NAME: &'static str = "SiteServerUI_CancelLogin_Response";
864
865 fn is_initialized(&self) -> bool {
866 true
867 }
868
869 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
870 while let Some(tag) = is.read_raw_tag_or_eof()? {
871 match tag {
872 8 => {
873 self.logon_state = ::std::option::Option::Some(is.read_int32()?);
874 },
875 16 => {
876 self.logon_eresult = ::std::option::Option::Some(is.read_int32()?);
877 },
878 tag => {
879 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
880 },
881 };
882 }
883 ::std::result::Result::Ok(())
884 }
885
886 #[allow(unused_variables)]
888 fn compute_size(&self) -> u64 {
889 let mut my_size = 0;
890 if let Some(v) = self.logon_state {
891 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
892 }
893 if let Some(v) = self.logon_eresult {
894 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
895 }
896 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
897 self.special_fields.cached_size().set(my_size as u32);
898 my_size
899 }
900
901 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
902 if let Some(v) = self.logon_state {
903 os.write_int32(1, v)?;
904 }
905 if let Some(v) = self.logon_eresult {
906 os.write_int32(2, v)?;
907 }
908 os.write_unknown_fields(self.special_fields.unknown_fields())?;
909 ::std::result::Result::Ok(())
910 }
911
912 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
913 &self.special_fields
914 }
915
916 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
917 &mut self.special_fields
918 }
919
920 fn new() -> SiteServerUI_CancelLogin_Response {
921 SiteServerUI_CancelLogin_Response::new()
922 }
923
924 fn clear(&mut self) {
925 self.logon_state = ::std::option::Option::None;
926 self.logon_eresult = ::std::option::Option::None;
927 self.special_fields.clear();
928 }
929
930 fn default_instance() -> &'static SiteServerUI_CancelLogin_Response {
931 static instance: SiteServerUI_CancelLogin_Response = SiteServerUI_CancelLogin_Response {
932 logon_state: ::std::option::Option::None,
933 logon_eresult: ::std::option::Option::None,
934 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
935 };
936 &instance
937 }
938}
939
940#[derive(PartialEq,Clone,Default,Debug)]
942pub struct SiteServerUI_Logout_Request {
943 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
946}
947
948impl<'a> ::std::default::Default for &'a SiteServerUI_Logout_Request {
949 fn default() -> &'a SiteServerUI_Logout_Request {
950 <SiteServerUI_Logout_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
951 }
952}
953
954impl SiteServerUI_Logout_Request {
955 pub fn new() -> SiteServerUI_Logout_Request {
956 ::std::default::Default::default()
957 }
958}
959
960impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Logout_Request {
961 const NAME: &'static str = "SiteServerUI_Logout_Request";
962
963 fn is_initialized(&self) -> bool {
964 true
965 }
966
967 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
968 while let Some(tag) = is.read_raw_tag_or_eof()? {
969 match tag {
970 tag => {
971 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
972 },
973 };
974 }
975 ::std::result::Result::Ok(())
976 }
977
978 #[allow(unused_variables)]
980 fn compute_size(&self) -> u64 {
981 let mut my_size = 0;
982 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
983 self.special_fields.cached_size().set(my_size as u32);
984 my_size
985 }
986
987 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
988 os.write_unknown_fields(self.special_fields.unknown_fields())?;
989 ::std::result::Result::Ok(())
990 }
991
992 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
993 &self.special_fields
994 }
995
996 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
997 &mut self.special_fields
998 }
999
1000 fn new() -> SiteServerUI_Logout_Request {
1001 SiteServerUI_Logout_Request::new()
1002 }
1003
1004 fn clear(&mut self) {
1005 self.special_fields.clear();
1006 }
1007
1008 fn default_instance() -> &'static SiteServerUI_Logout_Request {
1009 static instance: SiteServerUI_Logout_Request = SiteServerUI_Logout_Request {
1010 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1011 };
1012 &instance
1013 }
1014}
1015
1016#[derive(PartialEq,Clone,Default,Debug)]
1018pub struct SiteServerUI_Logout_Response {
1019 pub logon_state: ::std::option::Option<i32>,
1022 pub logout_eresult: ::std::option::Option<i32>,
1024 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1027}
1028
1029impl<'a> ::std::default::Default for &'a SiteServerUI_Logout_Response {
1030 fn default() -> &'a SiteServerUI_Logout_Response {
1031 <SiteServerUI_Logout_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1032 }
1033}
1034
1035impl SiteServerUI_Logout_Response {
1036 pub fn new() -> SiteServerUI_Logout_Response {
1037 ::std::default::Default::default()
1038 }
1039
1040 pub fn logon_state(&self) -> i32 {
1043 self.logon_state.unwrap_or(0)
1044 }
1045
1046 pub fn clear_logon_state(&mut self) {
1047 self.logon_state = ::std::option::Option::None;
1048 }
1049
1050 pub fn has_logon_state(&self) -> bool {
1051 self.logon_state.is_some()
1052 }
1053
1054 pub fn set_logon_state(&mut self, v: i32) {
1056 self.logon_state = ::std::option::Option::Some(v);
1057 }
1058
1059 pub fn logout_eresult(&self) -> i32 {
1062 self.logout_eresult.unwrap_or(0)
1063 }
1064
1065 pub fn clear_logout_eresult(&mut self) {
1066 self.logout_eresult = ::std::option::Option::None;
1067 }
1068
1069 pub fn has_logout_eresult(&self) -> bool {
1070 self.logout_eresult.is_some()
1071 }
1072
1073 pub fn set_logout_eresult(&mut self, v: i32) {
1075 self.logout_eresult = ::std::option::Option::Some(v);
1076 }
1077}
1078
1079impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Logout_Response {
1080 const NAME: &'static str = "SiteServerUI_Logout_Response";
1081
1082 fn is_initialized(&self) -> bool {
1083 true
1084 }
1085
1086 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1087 while let Some(tag) = is.read_raw_tag_or_eof()? {
1088 match tag {
1089 8 => {
1090 self.logon_state = ::std::option::Option::Some(is.read_int32()?);
1091 },
1092 16 => {
1093 self.logout_eresult = ::std::option::Option::Some(is.read_int32()?);
1094 },
1095 tag => {
1096 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1097 },
1098 };
1099 }
1100 ::std::result::Result::Ok(())
1101 }
1102
1103 #[allow(unused_variables)]
1105 fn compute_size(&self) -> u64 {
1106 let mut my_size = 0;
1107 if let Some(v) = self.logon_state {
1108 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
1109 }
1110 if let Some(v) = self.logout_eresult {
1111 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
1112 }
1113 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1114 self.special_fields.cached_size().set(my_size as u32);
1115 my_size
1116 }
1117
1118 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1119 if let Some(v) = self.logon_state {
1120 os.write_int32(1, v)?;
1121 }
1122 if let Some(v) = self.logout_eresult {
1123 os.write_int32(2, v)?;
1124 }
1125 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1126 ::std::result::Result::Ok(())
1127 }
1128
1129 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1130 &self.special_fields
1131 }
1132
1133 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1134 &mut self.special_fields
1135 }
1136
1137 fn new() -> SiteServerUI_Logout_Response {
1138 SiteServerUI_Logout_Response::new()
1139 }
1140
1141 fn clear(&mut self) {
1142 self.logon_state = ::std::option::Option::None;
1143 self.logout_eresult = ::std::option::Option::None;
1144 self.special_fields.clear();
1145 }
1146
1147 fn default_instance() -> &'static SiteServerUI_Logout_Response {
1148 static instance: SiteServerUI_Logout_Response = SiteServerUI_Logout_Response {
1149 logon_state: ::std::option::Option::None,
1150 logout_eresult: ::std::option::Option::None,
1151 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1152 };
1153 &instance
1154 }
1155}
1156
1157#[derive(PartialEq,Clone,Default,Debug)]
1159pub struct SiteServerUI_Quit_Request {
1160 pub restart: ::std::option::Option<bool>,
1163 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1166}
1167
1168impl<'a> ::std::default::Default for &'a SiteServerUI_Quit_Request {
1169 fn default() -> &'a SiteServerUI_Quit_Request {
1170 <SiteServerUI_Quit_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1171 }
1172}
1173
1174impl SiteServerUI_Quit_Request {
1175 pub fn new() -> SiteServerUI_Quit_Request {
1176 ::std::default::Default::default()
1177 }
1178
1179 pub fn restart(&self) -> bool {
1182 self.restart.unwrap_or(false)
1183 }
1184
1185 pub fn clear_restart(&mut self) {
1186 self.restart = ::std::option::Option::None;
1187 }
1188
1189 pub fn has_restart(&self) -> bool {
1190 self.restart.is_some()
1191 }
1192
1193 pub fn set_restart(&mut self, v: bool) {
1195 self.restart = ::std::option::Option::Some(v);
1196 }
1197}
1198
1199impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Quit_Request {
1200 const NAME: &'static str = "SiteServerUI_Quit_Request";
1201
1202 fn is_initialized(&self) -> bool {
1203 true
1204 }
1205
1206 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1207 while let Some(tag) = is.read_raw_tag_or_eof()? {
1208 match tag {
1209 8 => {
1210 self.restart = ::std::option::Option::Some(is.read_bool()?);
1211 },
1212 tag => {
1213 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1214 },
1215 };
1216 }
1217 ::std::result::Result::Ok(())
1218 }
1219
1220 #[allow(unused_variables)]
1222 fn compute_size(&self) -> u64 {
1223 let mut my_size = 0;
1224 if let Some(v) = self.restart {
1225 my_size += 1 + 1;
1226 }
1227 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1228 self.special_fields.cached_size().set(my_size as u32);
1229 my_size
1230 }
1231
1232 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1233 if let Some(v) = self.restart {
1234 os.write_bool(1, v)?;
1235 }
1236 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1237 ::std::result::Result::Ok(())
1238 }
1239
1240 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1241 &self.special_fields
1242 }
1243
1244 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1245 &mut self.special_fields
1246 }
1247
1248 fn new() -> SiteServerUI_Quit_Request {
1249 SiteServerUI_Quit_Request::new()
1250 }
1251
1252 fn clear(&mut self) {
1253 self.restart = ::std::option::Option::None;
1254 self.special_fields.clear();
1255 }
1256
1257 fn default_instance() -> &'static SiteServerUI_Quit_Request {
1258 static instance: SiteServerUI_Quit_Request = SiteServerUI_Quit_Request {
1259 restart: ::std::option::Option::None,
1260 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1261 };
1262 &instance
1263 }
1264}
1265
1266#[derive(PartialEq,Clone,Default,Debug)]
1268pub struct SiteServerUI_Quit_Response {
1269 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1272}
1273
1274impl<'a> ::std::default::Default for &'a SiteServerUI_Quit_Response {
1275 fn default() -> &'a SiteServerUI_Quit_Response {
1276 <SiteServerUI_Quit_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1277 }
1278}
1279
1280impl SiteServerUI_Quit_Response {
1281 pub fn new() -> SiteServerUI_Quit_Response {
1282 ::std::default::Default::default()
1283 }
1284}
1285
1286impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Quit_Response {
1287 const NAME: &'static str = "SiteServerUI_Quit_Response";
1288
1289 fn is_initialized(&self) -> bool {
1290 true
1291 }
1292
1293 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1294 while let Some(tag) = is.read_raw_tag_or_eof()? {
1295 match tag {
1296 tag => {
1297 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1298 },
1299 };
1300 }
1301 ::std::result::Result::Ok(())
1302 }
1303
1304 #[allow(unused_variables)]
1306 fn compute_size(&self) -> u64 {
1307 let mut my_size = 0;
1308 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1309 self.special_fields.cached_size().set(my_size as u32);
1310 my_size
1311 }
1312
1313 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1314 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1315 ::std::result::Result::Ok(())
1316 }
1317
1318 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1319 &self.special_fields
1320 }
1321
1322 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1323 &mut self.special_fields
1324 }
1325
1326 fn new() -> SiteServerUI_Quit_Response {
1327 SiteServerUI_Quit_Response::new()
1328 }
1329
1330 fn clear(&mut self) {
1331 self.special_fields.clear();
1332 }
1333
1334 fn default_instance() -> &'static SiteServerUI_Quit_Response {
1335 static instance: SiteServerUI_Quit_Response = SiteServerUI_Quit_Response {
1336 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1337 };
1338 &instance
1339 }
1340}
1341
1342#[derive(PartialEq,Clone,Default,Debug)]
1344pub struct SiteServerUI_Status_Request {
1345 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1348}
1349
1350impl<'a> ::std::default::Default for &'a SiteServerUI_Status_Request {
1351 fn default() -> &'a SiteServerUI_Status_Request {
1352 <SiteServerUI_Status_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1353 }
1354}
1355
1356impl SiteServerUI_Status_Request {
1357 pub fn new() -> SiteServerUI_Status_Request {
1358 ::std::default::Default::default()
1359 }
1360}
1361
1362impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Status_Request {
1363 const NAME: &'static str = "SiteServerUI_Status_Request";
1364
1365 fn is_initialized(&self) -> bool {
1366 true
1367 }
1368
1369 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1370 while let Some(tag) = is.read_raw_tag_or_eof()? {
1371 match tag {
1372 tag => {
1373 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1374 },
1375 };
1376 }
1377 ::std::result::Result::Ok(())
1378 }
1379
1380 #[allow(unused_variables)]
1382 fn compute_size(&self) -> u64 {
1383 let mut my_size = 0;
1384 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1385 self.special_fields.cached_size().set(my_size as u32);
1386 my_size
1387 }
1388
1389 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1390 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1391 ::std::result::Result::Ok(())
1392 }
1393
1394 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1395 &self.special_fields
1396 }
1397
1398 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1399 &mut self.special_fields
1400 }
1401
1402 fn new() -> SiteServerUI_Status_Request {
1403 SiteServerUI_Status_Request::new()
1404 }
1405
1406 fn clear(&mut self) {
1407 self.special_fields.clear();
1408 }
1409
1410 fn default_instance() -> &'static SiteServerUI_Status_Request {
1411 static instance: SiteServerUI_Status_Request = SiteServerUI_Status_Request {
1412 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1413 };
1414 &instance
1415 }
1416}
1417
1418#[derive(PartialEq,Clone,Default,Debug)]
1420pub struct SiteServerUI_Status_Response {
1421 pub logon_state: ::std::option::Option<i32>,
1424 pub logon_eresult: ::std::option::Option<i32>,
1426 pub connected: ::std::option::Option<bool>,
1428 pub cache_enabled: ::std::option::Option<bool>,
1430 pub acct_status: ::std::option::Option<i32>,
1432 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1435}
1436
1437impl<'a> ::std::default::Default for &'a SiteServerUI_Status_Response {
1438 fn default() -> &'a SiteServerUI_Status_Response {
1439 <SiteServerUI_Status_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1440 }
1441}
1442
1443impl SiteServerUI_Status_Response {
1444 pub fn new() -> SiteServerUI_Status_Response {
1445 ::std::default::Default::default()
1446 }
1447
1448 pub fn logon_state(&self) -> i32 {
1451 self.logon_state.unwrap_or(0)
1452 }
1453
1454 pub fn clear_logon_state(&mut self) {
1455 self.logon_state = ::std::option::Option::None;
1456 }
1457
1458 pub fn has_logon_state(&self) -> bool {
1459 self.logon_state.is_some()
1460 }
1461
1462 pub fn set_logon_state(&mut self, v: i32) {
1464 self.logon_state = ::std::option::Option::Some(v);
1465 }
1466
1467 pub fn logon_eresult(&self) -> i32 {
1470 self.logon_eresult.unwrap_or(0)
1471 }
1472
1473 pub fn clear_logon_eresult(&mut self) {
1474 self.logon_eresult = ::std::option::Option::None;
1475 }
1476
1477 pub fn has_logon_eresult(&self) -> bool {
1478 self.logon_eresult.is_some()
1479 }
1480
1481 pub fn set_logon_eresult(&mut self, v: i32) {
1483 self.logon_eresult = ::std::option::Option::Some(v);
1484 }
1485
1486 pub fn connected(&self) -> bool {
1489 self.connected.unwrap_or(false)
1490 }
1491
1492 pub fn clear_connected(&mut self) {
1493 self.connected = ::std::option::Option::None;
1494 }
1495
1496 pub fn has_connected(&self) -> bool {
1497 self.connected.is_some()
1498 }
1499
1500 pub fn set_connected(&mut self, v: bool) {
1502 self.connected = ::std::option::Option::Some(v);
1503 }
1504
1505 pub fn cache_enabled(&self) -> bool {
1508 self.cache_enabled.unwrap_or(false)
1509 }
1510
1511 pub fn clear_cache_enabled(&mut self) {
1512 self.cache_enabled = ::std::option::Option::None;
1513 }
1514
1515 pub fn has_cache_enabled(&self) -> bool {
1516 self.cache_enabled.is_some()
1517 }
1518
1519 pub fn set_cache_enabled(&mut self, v: bool) {
1521 self.cache_enabled = ::std::option::Option::Some(v);
1522 }
1523
1524 pub fn acct_status(&self) -> i32 {
1527 self.acct_status.unwrap_or(0)
1528 }
1529
1530 pub fn clear_acct_status(&mut self) {
1531 self.acct_status = ::std::option::Option::None;
1532 }
1533
1534 pub fn has_acct_status(&self) -> bool {
1535 self.acct_status.is_some()
1536 }
1537
1538 pub fn set_acct_status(&mut self, v: i32) {
1540 self.acct_status = ::std::option::Option::Some(v);
1541 }
1542}
1543
1544impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_Status_Response {
1545 const NAME: &'static str = "SiteServerUI_Status_Response";
1546
1547 fn is_initialized(&self) -> bool {
1548 true
1549 }
1550
1551 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1552 while let Some(tag) = is.read_raw_tag_or_eof()? {
1553 match tag {
1554 8 => {
1555 self.logon_state = ::std::option::Option::Some(is.read_int32()?);
1556 },
1557 16 => {
1558 self.logon_eresult = ::std::option::Option::Some(is.read_int32()?);
1559 },
1560 24 => {
1561 self.connected = ::std::option::Option::Some(is.read_bool()?);
1562 },
1563 32 => {
1564 self.cache_enabled = ::std::option::Option::Some(is.read_bool()?);
1565 },
1566 40 => {
1567 self.acct_status = ::std::option::Option::Some(is.read_int32()?);
1568 },
1569 tag => {
1570 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1571 },
1572 };
1573 }
1574 ::std::result::Result::Ok(())
1575 }
1576
1577 #[allow(unused_variables)]
1579 fn compute_size(&self) -> u64 {
1580 let mut my_size = 0;
1581 if let Some(v) = self.logon_state {
1582 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
1583 }
1584 if let Some(v) = self.logon_eresult {
1585 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
1586 }
1587 if let Some(v) = self.connected {
1588 my_size += 1 + 1;
1589 }
1590 if let Some(v) = self.cache_enabled {
1591 my_size += 1 + 1;
1592 }
1593 if let Some(v) = self.acct_status {
1594 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
1595 }
1596 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1597 self.special_fields.cached_size().set(my_size as u32);
1598 my_size
1599 }
1600
1601 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1602 if let Some(v) = self.logon_state {
1603 os.write_int32(1, v)?;
1604 }
1605 if let Some(v) = self.logon_eresult {
1606 os.write_int32(2, v)?;
1607 }
1608 if let Some(v) = self.connected {
1609 os.write_bool(3, v)?;
1610 }
1611 if let Some(v) = self.cache_enabled {
1612 os.write_bool(4, v)?;
1613 }
1614 if let Some(v) = self.acct_status {
1615 os.write_int32(5, v)?;
1616 }
1617 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1618 ::std::result::Result::Ok(())
1619 }
1620
1621 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1622 &self.special_fields
1623 }
1624
1625 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1626 &mut self.special_fields
1627 }
1628
1629 fn new() -> SiteServerUI_Status_Response {
1630 SiteServerUI_Status_Response::new()
1631 }
1632
1633 fn clear(&mut self) {
1634 self.logon_state = ::std::option::Option::None;
1635 self.logon_eresult = ::std::option::Option::None;
1636 self.connected = ::std::option::Option::None;
1637 self.cache_enabled = ::std::option::Option::None;
1638 self.acct_status = ::std::option::Option::None;
1639 self.special_fields.clear();
1640 }
1641
1642 fn default_instance() -> &'static SiteServerUI_Status_Response {
1643 static instance: SiteServerUI_Status_Response = SiteServerUI_Status_Response {
1644 logon_state: ::std::option::Option::None,
1645 logon_eresult: ::std::option::Option::None,
1646 connected: ::std::option::Option::None,
1647 cache_enabled: ::std::option::Option::None,
1648 acct_status: ::std::option::Option::None,
1649 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1650 };
1651 &instance
1652 }
1653}
1654
1655#[derive(PartialEq,Clone,Default,Debug)]
1657pub struct SiteServerUI_GetLanguage_Request {
1658 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1661}
1662
1663impl<'a> ::std::default::Default for &'a SiteServerUI_GetLanguage_Request {
1664 fn default() -> &'a SiteServerUI_GetLanguage_Request {
1665 <SiteServerUI_GetLanguage_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1666 }
1667}
1668
1669impl SiteServerUI_GetLanguage_Request {
1670 pub fn new() -> SiteServerUI_GetLanguage_Request {
1671 ::std::default::Default::default()
1672 }
1673}
1674
1675impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_GetLanguage_Request {
1676 const NAME: &'static str = "SiteServerUI_GetLanguage_Request";
1677
1678 fn is_initialized(&self) -> bool {
1679 true
1680 }
1681
1682 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1683 while let Some(tag) = is.read_raw_tag_or_eof()? {
1684 match tag {
1685 tag => {
1686 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1687 },
1688 };
1689 }
1690 ::std::result::Result::Ok(())
1691 }
1692
1693 #[allow(unused_variables)]
1695 fn compute_size(&self) -> u64 {
1696 let mut my_size = 0;
1697 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1698 self.special_fields.cached_size().set(my_size as u32);
1699 my_size
1700 }
1701
1702 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1703 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1704 ::std::result::Result::Ok(())
1705 }
1706
1707 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1708 &self.special_fields
1709 }
1710
1711 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1712 &mut self.special_fields
1713 }
1714
1715 fn new() -> SiteServerUI_GetLanguage_Request {
1716 SiteServerUI_GetLanguage_Request::new()
1717 }
1718
1719 fn clear(&mut self) {
1720 self.special_fields.clear();
1721 }
1722
1723 fn default_instance() -> &'static SiteServerUI_GetLanguage_Request {
1724 static instance: SiteServerUI_GetLanguage_Request = SiteServerUI_GetLanguage_Request {
1725 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1726 };
1727 &instance
1728 }
1729}
1730
1731#[derive(PartialEq,Clone,Default,Debug)]
1733pub struct SiteServerUI_GetLanguage_Response {
1734 pub language: ::std::option::Option<::std::string::String>,
1737 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1740}
1741
1742impl<'a> ::std::default::Default for &'a SiteServerUI_GetLanguage_Response {
1743 fn default() -> &'a SiteServerUI_GetLanguage_Response {
1744 <SiteServerUI_GetLanguage_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1745 }
1746}
1747
1748impl SiteServerUI_GetLanguage_Response {
1749 pub fn new() -> SiteServerUI_GetLanguage_Response {
1750 ::std::default::Default::default()
1751 }
1752
1753 pub fn language(&self) -> &str {
1756 match self.language.as_ref() {
1757 Some(v) => v,
1758 None => "",
1759 }
1760 }
1761
1762 pub fn clear_language(&mut self) {
1763 self.language = ::std::option::Option::None;
1764 }
1765
1766 pub fn has_language(&self) -> bool {
1767 self.language.is_some()
1768 }
1769
1770 pub fn set_language(&mut self, v: ::std::string::String) {
1772 self.language = ::std::option::Option::Some(v);
1773 }
1774
1775 pub fn mut_language(&mut self) -> &mut ::std::string::String {
1778 if self.language.is_none() {
1779 self.language = ::std::option::Option::Some(::std::string::String::new());
1780 }
1781 self.language.as_mut().unwrap()
1782 }
1783
1784 pub fn take_language(&mut self) -> ::std::string::String {
1786 self.language.take().unwrap_or_else(|| ::std::string::String::new())
1787 }
1788}
1789
1790impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_GetLanguage_Response {
1791 const NAME: &'static str = "SiteServerUI_GetLanguage_Response";
1792
1793 fn is_initialized(&self) -> bool {
1794 true
1795 }
1796
1797 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1798 while let Some(tag) = is.read_raw_tag_or_eof()? {
1799 match tag {
1800 10 => {
1801 self.language = ::std::option::Option::Some(is.read_string()?);
1802 },
1803 tag => {
1804 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1805 },
1806 };
1807 }
1808 ::std::result::Result::Ok(())
1809 }
1810
1811 #[allow(unused_variables)]
1813 fn compute_size(&self) -> u64 {
1814 let mut my_size = 0;
1815 if let Some(v) = self.language.as_ref() {
1816 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
1817 }
1818 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1819 self.special_fields.cached_size().set(my_size as u32);
1820 my_size
1821 }
1822
1823 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1824 if let Some(v) = self.language.as_ref() {
1825 os.write_string(1, v)?;
1826 }
1827 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1828 ::std::result::Result::Ok(())
1829 }
1830
1831 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1832 &self.special_fields
1833 }
1834
1835 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1836 &mut self.special_fields
1837 }
1838
1839 fn new() -> SiteServerUI_GetLanguage_Response {
1840 SiteServerUI_GetLanguage_Response::new()
1841 }
1842
1843 fn clear(&mut self) {
1844 self.language = ::std::option::Option::None;
1845 self.special_fields.clear();
1846 }
1847
1848 fn default_instance() -> &'static SiteServerUI_GetLanguage_Response {
1849 static instance: SiteServerUI_GetLanguage_Response = SiteServerUI_GetLanguage_Response {
1850 language: ::std::option::Option::None,
1851 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1852 };
1853 &instance
1854 }
1855}
1856
1857#[derive(PartialEq,Clone,Default,Debug)]
1859pub struct SiteServerUI_SetLanguage_Request {
1860 pub language: ::std::option::Option<::std::string::String>,
1863 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1866}
1867
1868impl<'a> ::std::default::Default for &'a SiteServerUI_SetLanguage_Request {
1869 fn default() -> &'a SiteServerUI_SetLanguage_Request {
1870 <SiteServerUI_SetLanguage_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1871 }
1872}
1873
1874impl SiteServerUI_SetLanguage_Request {
1875 pub fn new() -> SiteServerUI_SetLanguage_Request {
1876 ::std::default::Default::default()
1877 }
1878
1879 pub fn language(&self) -> &str {
1882 match self.language.as_ref() {
1883 Some(v) => v,
1884 None => "",
1885 }
1886 }
1887
1888 pub fn clear_language(&mut self) {
1889 self.language = ::std::option::Option::None;
1890 }
1891
1892 pub fn has_language(&self) -> bool {
1893 self.language.is_some()
1894 }
1895
1896 pub fn set_language(&mut self, v: ::std::string::String) {
1898 self.language = ::std::option::Option::Some(v);
1899 }
1900
1901 pub fn mut_language(&mut self) -> &mut ::std::string::String {
1904 if self.language.is_none() {
1905 self.language = ::std::option::Option::Some(::std::string::String::new());
1906 }
1907 self.language.as_mut().unwrap()
1908 }
1909
1910 pub fn take_language(&mut self) -> ::std::string::String {
1912 self.language.take().unwrap_or_else(|| ::std::string::String::new())
1913 }
1914}
1915
1916impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_SetLanguage_Request {
1917 const NAME: &'static str = "SiteServerUI_SetLanguage_Request";
1918
1919 fn is_initialized(&self) -> bool {
1920 true
1921 }
1922
1923 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1924 while let Some(tag) = is.read_raw_tag_or_eof()? {
1925 match tag {
1926 10 => {
1927 self.language = ::std::option::Option::Some(is.read_string()?);
1928 },
1929 tag => {
1930 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1931 },
1932 };
1933 }
1934 ::std::result::Result::Ok(())
1935 }
1936
1937 #[allow(unused_variables)]
1939 fn compute_size(&self) -> u64 {
1940 let mut my_size = 0;
1941 if let Some(v) = self.language.as_ref() {
1942 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
1943 }
1944 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1945 self.special_fields.cached_size().set(my_size as u32);
1946 my_size
1947 }
1948
1949 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1950 if let Some(v) = self.language.as_ref() {
1951 os.write_string(1, v)?;
1952 }
1953 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1954 ::std::result::Result::Ok(())
1955 }
1956
1957 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1958 &self.special_fields
1959 }
1960
1961 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1962 &mut self.special_fields
1963 }
1964
1965 fn new() -> SiteServerUI_SetLanguage_Request {
1966 SiteServerUI_SetLanguage_Request::new()
1967 }
1968
1969 fn clear(&mut self) {
1970 self.language = ::std::option::Option::None;
1971 self.special_fields.clear();
1972 }
1973
1974 fn default_instance() -> &'static SiteServerUI_SetLanguage_Request {
1975 static instance: SiteServerUI_SetLanguage_Request = SiteServerUI_SetLanguage_Request {
1976 language: ::std::option::Option::None,
1977 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1978 };
1979 &instance
1980 }
1981}
1982
1983#[derive(PartialEq,Clone,Default,Debug)]
1985pub struct SiteServerUI_SetLanguage_Response {
1986 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1989}
1990
1991impl<'a> ::std::default::Default for &'a SiteServerUI_SetLanguage_Response {
1992 fn default() -> &'a SiteServerUI_SetLanguage_Response {
1993 <SiteServerUI_SetLanguage_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1994 }
1995}
1996
1997impl SiteServerUI_SetLanguage_Response {
1998 pub fn new() -> SiteServerUI_SetLanguage_Response {
1999 ::std::default::Default::default()
2000 }
2001}
2002
2003impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_SetLanguage_Response {
2004 const NAME: &'static str = "SiteServerUI_SetLanguage_Response";
2005
2006 fn is_initialized(&self) -> bool {
2007 true
2008 }
2009
2010 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2011 while let Some(tag) = is.read_raw_tag_or_eof()? {
2012 match tag {
2013 tag => {
2014 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2015 },
2016 };
2017 }
2018 ::std::result::Result::Ok(())
2019 }
2020
2021 #[allow(unused_variables)]
2023 fn compute_size(&self) -> u64 {
2024 let mut my_size = 0;
2025 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2026 self.special_fields.cached_size().set(my_size as u32);
2027 my_size
2028 }
2029
2030 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2031 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2032 ::std::result::Result::Ok(())
2033 }
2034
2035 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2036 &self.special_fields
2037 }
2038
2039 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2040 &mut self.special_fields
2041 }
2042
2043 fn new() -> SiteServerUI_SetLanguage_Response {
2044 SiteServerUI_SetLanguage_Response::new()
2045 }
2046
2047 fn clear(&mut self) {
2048 self.special_fields.clear();
2049 }
2050
2051 fn default_instance() -> &'static SiteServerUI_SetLanguage_Response {
2052 static instance: SiteServerUI_SetLanguage_Response = SiteServerUI_SetLanguage_Response {
2053 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2054 };
2055 &instance
2056 }
2057}
2058
2059#[derive(PartialEq,Clone,Default,Debug)]
2061pub struct SiteServerUI_ClientStatus_Request {
2062 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2065}
2066
2067impl<'a> ::std::default::Default for &'a SiteServerUI_ClientStatus_Request {
2068 fn default() -> &'a SiteServerUI_ClientStatus_Request {
2069 <SiteServerUI_ClientStatus_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2070 }
2071}
2072
2073impl SiteServerUI_ClientStatus_Request {
2074 pub fn new() -> SiteServerUI_ClientStatus_Request {
2075 ::std::default::Default::default()
2076 }
2077}
2078
2079impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ClientStatus_Request {
2080 const NAME: &'static str = "SiteServerUI_ClientStatus_Request";
2081
2082 fn is_initialized(&self) -> bool {
2083 true
2084 }
2085
2086 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2087 while let Some(tag) = is.read_raw_tag_or_eof()? {
2088 match tag {
2089 tag => {
2090 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2091 },
2092 };
2093 }
2094 ::std::result::Result::Ok(())
2095 }
2096
2097 #[allow(unused_variables)]
2099 fn compute_size(&self) -> u64 {
2100 let mut my_size = 0;
2101 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2102 self.special_fields.cached_size().set(my_size as u32);
2103 my_size
2104 }
2105
2106 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2107 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2108 ::std::result::Result::Ok(())
2109 }
2110
2111 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2112 &self.special_fields
2113 }
2114
2115 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2116 &mut self.special_fields
2117 }
2118
2119 fn new() -> SiteServerUI_ClientStatus_Request {
2120 SiteServerUI_ClientStatus_Request::new()
2121 }
2122
2123 fn clear(&mut self) {
2124 self.special_fields.clear();
2125 }
2126
2127 fn default_instance() -> &'static SiteServerUI_ClientStatus_Request {
2128 static instance: SiteServerUI_ClientStatus_Request = SiteServerUI_ClientStatus_Request {
2129 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2130 };
2131 &instance
2132 }
2133}
2134
2135#[derive(PartialEq,Clone,Default,Debug)]
2137pub struct SiteServerUI_ClientStatus_Response {
2138 pub clients: ::std::vec::Vec<site_server_ui_client_status_response::ClientInfo>,
2141 pub payments: ::std::vec::Vec<site_server_ui_client_status_response::Payment>,
2143 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2146}
2147
2148impl<'a> ::std::default::Default for &'a SiteServerUI_ClientStatus_Response {
2149 fn default() -> &'a SiteServerUI_ClientStatus_Response {
2150 <SiteServerUI_ClientStatus_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2151 }
2152}
2153
2154impl SiteServerUI_ClientStatus_Response {
2155 pub fn new() -> SiteServerUI_ClientStatus_Response {
2156 ::std::default::Default::default()
2157 }
2158}
2159
2160impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ClientStatus_Response {
2161 const NAME: &'static str = "SiteServerUI_ClientStatus_Response";
2162
2163 fn is_initialized(&self) -> bool {
2164 true
2165 }
2166
2167 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2168 while let Some(tag) = is.read_raw_tag_or_eof()? {
2169 match tag {
2170 34 => {
2171 self.clients.push(is.read_message()?);
2172 },
2173 42 => {
2174 self.payments.push(is.read_message()?);
2175 },
2176 tag => {
2177 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2178 },
2179 };
2180 }
2181 ::std::result::Result::Ok(())
2182 }
2183
2184 #[allow(unused_variables)]
2186 fn compute_size(&self) -> u64 {
2187 let mut my_size = 0;
2188 for value in &self.clients {
2189 let len = value.compute_size();
2190 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
2191 };
2192 for value in &self.payments {
2193 let len = value.compute_size();
2194 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
2195 };
2196 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2197 self.special_fields.cached_size().set(my_size as u32);
2198 my_size
2199 }
2200
2201 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2202 for v in &self.clients {
2203 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
2204 };
2205 for v in &self.payments {
2206 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
2207 };
2208 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2209 ::std::result::Result::Ok(())
2210 }
2211
2212 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2213 &self.special_fields
2214 }
2215
2216 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2217 &mut self.special_fields
2218 }
2219
2220 fn new() -> SiteServerUI_ClientStatus_Response {
2221 SiteServerUI_ClientStatus_Response::new()
2222 }
2223
2224 fn clear(&mut self) {
2225 self.clients.clear();
2226 self.payments.clear();
2227 self.special_fields.clear();
2228 }
2229
2230 fn default_instance() -> &'static SiteServerUI_ClientStatus_Response {
2231 static instance: SiteServerUI_ClientStatus_Response = SiteServerUI_ClientStatus_Response {
2232 clients: ::std::vec::Vec::new(),
2233 payments: ::std::vec::Vec::new(),
2234 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2235 };
2236 &instance
2237 }
2238}
2239
2240pub mod site_server_ui_client_status_response {
2242 #[derive(PartialEq,Clone,Default,Debug)]
2244 pub struct ClientInfo {
2245 pub ip: ::std::option::Option<u32>,
2248 pub hostname: ::std::option::Option<::std::string::String>,
2250 pub connected: ::std::option::Option<bool>,
2252 pub instance_id: ::std::option::Option<u64>,
2254 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2257 }
2258
2259 impl<'a> ::std::default::Default for &'a ClientInfo {
2260 fn default() -> &'a ClientInfo {
2261 <ClientInfo as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2262 }
2263 }
2264
2265 impl ClientInfo {
2266 pub fn new() -> ClientInfo {
2267 ::std::default::Default::default()
2268 }
2269
2270 pub fn ip(&self) -> u32 {
2273 self.ip.unwrap_or(0)
2274 }
2275
2276 pub fn clear_ip(&mut self) {
2277 self.ip = ::std::option::Option::None;
2278 }
2279
2280 pub fn has_ip(&self) -> bool {
2281 self.ip.is_some()
2282 }
2283
2284 pub fn set_ip(&mut self, v: u32) {
2286 self.ip = ::std::option::Option::Some(v);
2287 }
2288
2289 pub fn hostname(&self) -> &str {
2292 match self.hostname.as_ref() {
2293 Some(v) => v,
2294 None => "",
2295 }
2296 }
2297
2298 pub fn clear_hostname(&mut self) {
2299 self.hostname = ::std::option::Option::None;
2300 }
2301
2302 pub fn has_hostname(&self) -> bool {
2303 self.hostname.is_some()
2304 }
2305
2306 pub fn set_hostname(&mut self, v: ::std::string::String) {
2308 self.hostname = ::std::option::Option::Some(v);
2309 }
2310
2311 pub fn mut_hostname(&mut self) -> &mut ::std::string::String {
2314 if self.hostname.is_none() {
2315 self.hostname = ::std::option::Option::Some(::std::string::String::new());
2316 }
2317 self.hostname.as_mut().unwrap()
2318 }
2319
2320 pub fn take_hostname(&mut self) -> ::std::string::String {
2322 self.hostname.take().unwrap_or_else(|| ::std::string::String::new())
2323 }
2324
2325 pub fn connected(&self) -> bool {
2328 self.connected.unwrap_or(false)
2329 }
2330
2331 pub fn clear_connected(&mut self) {
2332 self.connected = ::std::option::Option::None;
2333 }
2334
2335 pub fn has_connected(&self) -> bool {
2336 self.connected.is_some()
2337 }
2338
2339 pub fn set_connected(&mut self, v: bool) {
2341 self.connected = ::std::option::Option::Some(v);
2342 }
2343
2344 pub fn instance_id(&self) -> u64 {
2347 self.instance_id.unwrap_or(0)
2348 }
2349
2350 pub fn clear_instance_id(&mut self) {
2351 self.instance_id = ::std::option::Option::None;
2352 }
2353
2354 pub fn has_instance_id(&self) -> bool {
2355 self.instance_id.is_some()
2356 }
2357
2358 pub fn set_instance_id(&mut self, v: u64) {
2360 self.instance_id = ::std::option::Option::Some(v);
2361 }
2362 }
2363
2364 impl ::steam_vent_proto_common::protobuf::Message for ClientInfo {
2365 const NAME: &'static str = "ClientInfo";
2366
2367 fn is_initialized(&self) -> bool {
2368 true
2369 }
2370
2371 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2372 while let Some(tag) = is.read_raw_tag_or_eof()? {
2373 match tag {
2374 8 => {
2375 self.ip = ::std::option::Option::Some(is.read_uint32()?);
2376 },
2377 18 => {
2378 self.hostname = ::std::option::Option::Some(is.read_string()?);
2379 },
2380 24 => {
2381 self.connected = ::std::option::Option::Some(is.read_bool()?);
2382 },
2383 32 => {
2384 self.instance_id = ::std::option::Option::Some(is.read_uint64()?);
2385 },
2386 tag => {
2387 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2388 },
2389 };
2390 }
2391 ::std::result::Result::Ok(())
2392 }
2393
2394 #[allow(unused_variables)]
2396 fn compute_size(&self) -> u64 {
2397 let mut my_size = 0;
2398 if let Some(v) = self.ip {
2399 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
2400 }
2401 if let Some(v) = self.hostname.as_ref() {
2402 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
2403 }
2404 if let Some(v) = self.connected {
2405 my_size += 1 + 1;
2406 }
2407 if let Some(v) = self.instance_id {
2408 my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
2409 }
2410 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2411 self.special_fields.cached_size().set(my_size as u32);
2412 my_size
2413 }
2414
2415 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2416 if let Some(v) = self.ip {
2417 os.write_uint32(1, v)?;
2418 }
2419 if let Some(v) = self.hostname.as_ref() {
2420 os.write_string(2, v)?;
2421 }
2422 if let Some(v) = self.connected {
2423 os.write_bool(3, v)?;
2424 }
2425 if let Some(v) = self.instance_id {
2426 os.write_uint64(4, v)?;
2427 }
2428 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2429 ::std::result::Result::Ok(())
2430 }
2431
2432 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2433 &self.special_fields
2434 }
2435
2436 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2437 &mut self.special_fields
2438 }
2439
2440 fn new() -> ClientInfo {
2441 ClientInfo::new()
2442 }
2443
2444 fn clear(&mut self) {
2445 self.ip = ::std::option::Option::None;
2446 self.hostname = ::std::option::Option::None;
2447 self.connected = ::std::option::Option::None;
2448 self.instance_id = ::std::option::Option::None;
2449 self.special_fields.clear();
2450 }
2451
2452 fn default_instance() -> &'static ClientInfo {
2453 static instance: ClientInfo = ClientInfo {
2454 ip: ::std::option::Option::None,
2455 hostname: ::std::option::Option::None,
2456 connected: ::std::option::Option::None,
2457 instance_id: ::std::option::Option::None,
2458 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2459 };
2460 &instance
2461 }
2462 }
2463
2464 #[derive(PartialEq,Clone,Default,Debug)]
2466 pub struct Payment {
2467 pub transid: ::std::option::Option<u64>,
2470 pub steamid: ::std::option::Option<u64>,
2472 pub amount: ::std::option::Option<::std::string::String>,
2474 pub time_created: ::std::option::Option<i32>,
2476 pub purchase_status: ::std::option::Option<i32>,
2478 pub hostname: ::std::option::Option<::std::string::String>,
2480 pub persona_name: ::std::option::Option<::std::string::String>,
2482 pub profile_url: ::std::option::Option<::std::string::String>,
2484 pub avatar_url: ::std::option::Option<::std::string::String>,
2486 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2489 }
2490
2491 impl<'a> ::std::default::Default for &'a Payment {
2492 fn default() -> &'a Payment {
2493 <Payment as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2494 }
2495 }
2496
2497 impl Payment {
2498 pub fn new() -> Payment {
2499 ::std::default::Default::default()
2500 }
2501
2502 pub fn transid(&self) -> u64 {
2505 self.transid.unwrap_or(0)
2506 }
2507
2508 pub fn clear_transid(&mut self) {
2509 self.transid = ::std::option::Option::None;
2510 }
2511
2512 pub fn has_transid(&self) -> bool {
2513 self.transid.is_some()
2514 }
2515
2516 pub fn set_transid(&mut self, v: u64) {
2518 self.transid = ::std::option::Option::Some(v);
2519 }
2520
2521 pub fn steamid(&self) -> u64 {
2524 self.steamid.unwrap_or(0)
2525 }
2526
2527 pub fn clear_steamid(&mut self) {
2528 self.steamid = ::std::option::Option::None;
2529 }
2530
2531 pub fn has_steamid(&self) -> bool {
2532 self.steamid.is_some()
2533 }
2534
2535 pub fn set_steamid(&mut self, v: u64) {
2537 self.steamid = ::std::option::Option::Some(v);
2538 }
2539
2540 pub fn amount(&self) -> &str {
2543 match self.amount.as_ref() {
2544 Some(v) => v,
2545 None => "",
2546 }
2547 }
2548
2549 pub fn clear_amount(&mut self) {
2550 self.amount = ::std::option::Option::None;
2551 }
2552
2553 pub fn has_amount(&self) -> bool {
2554 self.amount.is_some()
2555 }
2556
2557 pub fn set_amount(&mut self, v: ::std::string::String) {
2559 self.amount = ::std::option::Option::Some(v);
2560 }
2561
2562 pub fn mut_amount(&mut self) -> &mut ::std::string::String {
2565 if self.amount.is_none() {
2566 self.amount = ::std::option::Option::Some(::std::string::String::new());
2567 }
2568 self.amount.as_mut().unwrap()
2569 }
2570
2571 pub fn take_amount(&mut self) -> ::std::string::String {
2573 self.amount.take().unwrap_or_else(|| ::std::string::String::new())
2574 }
2575
2576 pub fn time_created(&self) -> i32 {
2579 self.time_created.unwrap_or(0)
2580 }
2581
2582 pub fn clear_time_created(&mut self) {
2583 self.time_created = ::std::option::Option::None;
2584 }
2585
2586 pub fn has_time_created(&self) -> bool {
2587 self.time_created.is_some()
2588 }
2589
2590 pub fn set_time_created(&mut self, v: i32) {
2592 self.time_created = ::std::option::Option::Some(v);
2593 }
2594
2595 pub fn purchase_status(&self) -> i32 {
2598 self.purchase_status.unwrap_or(0)
2599 }
2600
2601 pub fn clear_purchase_status(&mut self) {
2602 self.purchase_status = ::std::option::Option::None;
2603 }
2604
2605 pub fn has_purchase_status(&self) -> bool {
2606 self.purchase_status.is_some()
2607 }
2608
2609 pub fn set_purchase_status(&mut self, v: i32) {
2611 self.purchase_status = ::std::option::Option::Some(v);
2612 }
2613
2614 pub fn hostname(&self) -> &str {
2617 match self.hostname.as_ref() {
2618 Some(v) => v,
2619 None => "",
2620 }
2621 }
2622
2623 pub fn clear_hostname(&mut self) {
2624 self.hostname = ::std::option::Option::None;
2625 }
2626
2627 pub fn has_hostname(&self) -> bool {
2628 self.hostname.is_some()
2629 }
2630
2631 pub fn set_hostname(&mut self, v: ::std::string::String) {
2633 self.hostname = ::std::option::Option::Some(v);
2634 }
2635
2636 pub fn mut_hostname(&mut self) -> &mut ::std::string::String {
2639 if self.hostname.is_none() {
2640 self.hostname = ::std::option::Option::Some(::std::string::String::new());
2641 }
2642 self.hostname.as_mut().unwrap()
2643 }
2644
2645 pub fn take_hostname(&mut self) -> ::std::string::String {
2647 self.hostname.take().unwrap_or_else(|| ::std::string::String::new())
2648 }
2649
2650 pub fn persona_name(&self) -> &str {
2653 match self.persona_name.as_ref() {
2654 Some(v) => v,
2655 None => "",
2656 }
2657 }
2658
2659 pub fn clear_persona_name(&mut self) {
2660 self.persona_name = ::std::option::Option::None;
2661 }
2662
2663 pub fn has_persona_name(&self) -> bool {
2664 self.persona_name.is_some()
2665 }
2666
2667 pub fn set_persona_name(&mut self, v: ::std::string::String) {
2669 self.persona_name = ::std::option::Option::Some(v);
2670 }
2671
2672 pub fn mut_persona_name(&mut self) -> &mut ::std::string::String {
2675 if self.persona_name.is_none() {
2676 self.persona_name = ::std::option::Option::Some(::std::string::String::new());
2677 }
2678 self.persona_name.as_mut().unwrap()
2679 }
2680
2681 pub fn take_persona_name(&mut self) -> ::std::string::String {
2683 self.persona_name.take().unwrap_or_else(|| ::std::string::String::new())
2684 }
2685
2686 pub fn profile_url(&self) -> &str {
2689 match self.profile_url.as_ref() {
2690 Some(v) => v,
2691 None => "",
2692 }
2693 }
2694
2695 pub fn clear_profile_url(&mut self) {
2696 self.profile_url = ::std::option::Option::None;
2697 }
2698
2699 pub fn has_profile_url(&self) -> bool {
2700 self.profile_url.is_some()
2701 }
2702
2703 pub fn set_profile_url(&mut self, v: ::std::string::String) {
2705 self.profile_url = ::std::option::Option::Some(v);
2706 }
2707
2708 pub fn mut_profile_url(&mut self) -> &mut ::std::string::String {
2711 if self.profile_url.is_none() {
2712 self.profile_url = ::std::option::Option::Some(::std::string::String::new());
2713 }
2714 self.profile_url.as_mut().unwrap()
2715 }
2716
2717 pub fn take_profile_url(&mut self) -> ::std::string::String {
2719 self.profile_url.take().unwrap_or_else(|| ::std::string::String::new())
2720 }
2721
2722 pub fn avatar_url(&self) -> &str {
2725 match self.avatar_url.as_ref() {
2726 Some(v) => v,
2727 None => "",
2728 }
2729 }
2730
2731 pub fn clear_avatar_url(&mut self) {
2732 self.avatar_url = ::std::option::Option::None;
2733 }
2734
2735 pub fn has_avatar_url(&self) -> bool {
2736 self.avatar_url.is_some()
2737 }
2738
2739 pub fn set_avatar_url(&mut self, v: ::std::string::String) {
2741 self.avatar_url = ::std::option::Option::Some(v);
2742 }
2743
2744 pub fn mut_avatar_url(&mut self) -> &mut ::std::string::String {
2747 if self.avatar_url.is_none() {
2748 self.avatar_url = ::std::option::Option::Some(::std::string::String::new());
2749 }
2750 self.avatar_url.as_mut().unwrap()
2751 }
2752
2753 pub fn take_avatar_url(&mut self) -> ::std::string::String {
2755 self.avatar_url.take().unwrap_or_else(|| ::std::string::String::new())
2756 }
2757 }
2758
2759 impl ::steam_vent_proto_common::protobuf::Message for Payment {
2760 const NAME: &'static str = "Payment";
2761
2762 fn is_initialized(&self) -> bool {
2763 true
2764 }
2765
2766 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2767 while let Some(tag) = is.read_raw_tag_or_eof()? {
2768 match tag {
2769 8 => {
2770 self.transid = ::std::option::Option::Some(is.read_uint64()?);
2771 },
2772 16 => {
2773 self.steamid = ::std::option::Option::Some(is.read_uint64()?);
2774 },
2775 26 => {
2776 self.amount = ::std::option::Option::Some(is.read_string()?);
2777 },
2778 32 => {
2779 self.time_created = ::std::option::Option::Some(is.read_int32()?);
2780 },
2781 40 => {
2782 self.purchase_status = ::std::option::Option::Some(is.read_int32()?);
2783 },
2784 50 => {
2785 self.hostname = ::std::option::Option::Some(is.read_string()?);
2786 },
2787 58 => {
2788 self.persona_name = ::std::option::Option::Some(is.read_string()?);
2789 },
2790 66 => {
2791 self.profile_url = ::std::option::Option::Some(is.read_string()?);
2792 },
2793 74 => {
2794 self.avatar_url = ::std::option::Option::Some(is.read_string()?);
2795 },
2796 tag => {
2797 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2798 },
2799 };
2800 }
2801 ::std::result::Result::Ok(())
2802 }
2803
2804 #[allow(unused_variables)]
2806 fn compute_size(&self) -> u64 {
2807 let mut my_size = 0;
2808 if let Some(v) = self.transid {
2809 my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(1, v);
2810 }
2811 if let Some(v) = self.steamid {
2812 my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(2, v);
2813 }
2814 if let Some(v) = self.amount.as_ref() {
2815 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
2816 }
2817 if let Some(v) = self.time_created {
2818 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
2819 }
2820 if let Some(v) = self.purchase_status {
2821 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(5, v);
2822 }
2823 if let Some(v) = self.hostname.as_ref() {
2824 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
2825 }
2826 if let Some(v) = self.persona_name.as_ref() {
2827 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
2828 }
2829 if let Some(v) = self.profile_url.as_ref() {
2830 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(8, &v);
2831 }
2832 if let Some(v) = self.avatar_url.as_ref() {
2833 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
2834 }
2835 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2836 self.special_fields.cached_size().set(my_size as u32);
2837 my_size
2838 }
2839
2840 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2841 if let Some(v) = self.transid {
2842 os.write_uint64(1, v)?;
2843 }
2844 if let Some(v) = self.steamid {
2845 os.write_uint64(2, v)?;
2846 }
2847 if let Some(v) = self.amount.as_ref() {
2848 os.write_string(3, v)?;
2849 }
2850 if let Some(v) = self.time_created {
2851 os.write_int32(4, v)?;
2852 }
2853 if let Some(v) = self.purchase_status {
2854 os.write_int32(5, v)?;
2855 }
2856 if let Some(v) = self.hostname.as_ref() {
2857 os.write_string(6, v)?;
2858 }
2859 if let Some(v) = self.persona_name.as_ref() {
2860 os.write_string(7, v)?;
2861 }
2862 if let Some(v) = self.profile_url.as_ref() {
2863 os.write_string(8, v)?;
2864 }
2865 if let Some(v) = self.avatar_url.as_ref() {
2866 os.write_string(9, v)?;
2867 }
2868 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2869 ::std::result::Result::Ok(())
2870 }
2871
2872 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2873 &self.special_fields
2874 }
2875
2876 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2877 &mut self.special_fields
2878 }
2879
2880 fn new() -> Payment {
2881 Payment::new()
2882 }
2883
2884 fn clear(&mut self) {
2885 self.transid = ::std::option::Option::None;
2886 self.steamid = ::std::option::Option::None;
2887 self.amount = ::std::option::Option::None;
2888 self.time_created = ::std::option::Option::None;
2889 self.purchase_status = ::std::option::Option::None;
2890 self.hostname = ::std::option::Option::None;
2891 self.persona_name = ::std::option::Option::None;
2892 self.profile_url = ::std::option::Option::None;
2893 self.avatar_url = ::std::option::Option::None;
2894 self.special_fields.clear();
2895 }
2896
2897 fn default_instance() -> &'static Payment {
2898 static instance: Payment = Payment {
2899 transid: ::std::option::Option::None,
2900 steamid: ::std::option::Option::None,
2901 amount: ::std::option::Option::None,
2902 time_created: ::std::option::Option::None,
2903 purchase_status: ::std::option::Option::None,
2904 hostname: ::std::option::Option::None,
2905 persona_name: ::std::option::Option::None,
2906 profile_url: ::std::option::Option::None,
2907 avatar_url: ::std::option::Option::None,
2908 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2909 };
2910 &instance
2911 }
2912 }
2913}
2914
2915#[derive(PartialEq,Clone,Default,Debug)]
2917pub struct SiteServerUI_ContentCacheStatus_Request {
2918 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2921}
2922
2923impl<'a> ::std::default::Default for &'a SiteServerUI_ContentCacheStatus_Request {
2924 fn default() -> &'a SiteServerUI_ContentCacheStatus_Request {
2925 <SiteServerUI_ContentCacheStatus_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2926 }
2927}
2928
2929impl SiteServerUI_ContentCacheStatus_Request {
2930 pub fn new() -> SiteServerUI_ContentCacheStatus_Request {
2931 ::std::default::Default::default()
2932 }
2933}
2934
2935impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ContentCacheStatus_Request {
2936 const NAME: &'static str = "SiteServerUI_ContentCacheStatus_Request";
2937
2938 fn is_initialized(&self) -> bool {
2939 true
2940 }
2941
2942 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2943 while let Some(tag) = is.read_raw_tag_or_eof()? {
2944 match tag {
2945 tag => {
2946 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2947 },
2948 };
2949 }
2950 ::std::result::Result::Ok(())
2951 }
2952
2953 #[allow(unused_variables)]
2955 fn compute_size(&self) -> u64 {
2956 let mut my_size = 0;
2957 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2958 self.special_fields.cached_size().set(my_size as u32);
2959 my_size
2960 }
2961
2962 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2963 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2964 ::std::result::Result::Ok(())
2965 }
2966
2967 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2968 &self.special_fields
2969 }
2970
2971 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2972 &mut self.special_fields
2973 }
2974
2975 fn new() -> SiteServerUI_ContentCacheStatus_Request {
2976 SiteServerUI_ContentCacheStatus_Request::new()
2977 }
2978
2979 fn clear(&mut self) {
2980 self.special_fields.clear();
2981 }
2982
2983 fn default_instance() -> &'static SiteServerUI_ContentCacheStatus_Request {
2984 static instance: SiteServerUI_ContentCacheStatus_Request = SiteServerUI_ContentCacheStatus_Request {
2985 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2986 };
2987 &instance
2988 }
2989}
2990
2991#[derive(PartialEq,Clone,Default,Debug)]
2993pub struct SiteServerUI_ContentCacheStatus_Response {
2994 pub enabled: ::std::option::Option<bool>,
2997 pub port: ::std::option::Option<u32>,
2999 pub cache_location: ::std::option::Option<::std::string::String>,
3001 pub max_size_gb: ::std::option::Option<u32>,
3003 pub p2p_enabled: ::std::option::Option<bool>,
3005 pub explicit_ip_address: ::std::option::Option<::std::string::String>,
3007 pub external_process: ::std::option::Option<bool>,
3009 pub current_size_gb: ::std::option::Option<u32>,
3011 pub current_bw: ::std::option::Option<u64>,
3013 pub total_bytes_served: ::std::option::Option<u64>,
3015 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3018}
3019
3020impl<'a> ::std::default::Default for &'a SiteServerUI_ContentCacheStatus_Response {
3021 fn default() -> &'a SiteServerUI_ContentCacheStatus_Response {
3022 <SiteServerUI_ContentCacheStatus_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3023 }
3024}
3025
3026impl SiteServerUI_ContentCacheStatus_Response {
3027 pub fn new() -> SiteServerUI_ContentCacheStatus_Response {
3028 ::std::default::Default::default()
3029 }
3030
3031 pub fn enabled(&self) -> bool {
3034 self.enabled.unwrap_or(false)
3035 }
3036
3037 pub fn clear_enabled(&mut self) {
3038 self.enabled = ::std::option::Option::None;
3039 }
3040
3041 pub fn has_enabled(&self) -> bool {
3042 self.enabled.is_some()
3043 }
3044
3045 pub fn set_enabled(&mut self, v: bool) {
3047 self.enabled = ::std::option::Option::Some(v);
3048 }
3049
3050 pub fn port(&self) -> u32 {
3053 self.port.unwrap_or(0)
3054 }
3055
3056 pub fn clear_port(&mut self) {
3057 self.port = ::std::option::Option::None;
3058 }
3059
3060 pub fn has_port(&self) -> bool {
3061 self.port.is_some()
3062 }
3063
3064 pub fn set_port(&mut self, v: u32) {
3066 self.port = ::std::option::Option::Some(v);
3067 }
3068
3069 pub fn cache_location(&self) -> &str {
3072 match self.cache_location.as_ref() {
3073 Some(v) => v,
3074 None => "",
3075 }
3076 }
3077
3078 pub fn clear_cache_location(&mut self) {
3079 self.cache_location = ::std::option::Option::None;
3080 }
3081
3082 pub fn has_cache_location(&self) -> bool {
3083 self.cache_location.is_some()
3084 }
3085
3086 pub fn set_cache_location(&mut self, v: ::std::string::String) {
3088 self.cache_location = ::std::option::Option::Some(v);
3089 }
3090
3091 pub fn mut_cache_location(&mut self) -> &mut ::std::string::String {
3094 if self.cache_location.is_none() {
3095 self.cache_location = ::std::option::Option::Some(::std::string::String::new());
3096 }
3097 self.cache_location.as_mut().unwrap()
3098 }
3099
3100 pub fn take_cache_location(&mut self) -> ::std::string::String {
3102 self.cache_location.take().unwrap_or_else(|| ::std::string::String::new())
3103 }
3104
3105 pub fn max_size_gb(&self) -> u32 {
3108 self.max_size_gb.unwrap_or(0)
3109 }
3110
3111 pub fn clear_max_size_gb(&mut self) {
3112 self.max_size_gb = ::std::option::Option::None;
3113 }
3114
3115 pub fn has_max_size_gb(&self) -> bool {
3116 self.max_size_gb.is_some()
3117 }
3118
3119 pub fn set_max_size_gb(&mut self, v: u32) {
3121 self.max_size_gb = ::std::option::Option::Some(v);
3122 }
3123
3124 pub fn p2p_enabled(&self) -> bool {
3127 self.p2p_enabled.unwrap_or(false)
3128 }
3129
3130 pub fn clear_p2p_enabled(&mut self) {
3131 self.p2p_enabled = ::std::option::Option::None;
3132 }
3133
3134 pub fn has_p2p_enabled(&self) -> bool {
3135 self.p2p_enabled.is_some()
3136 }
3137
3138 pub fn set_p2p_enabled(&mut self, v: bool) {
3140 self.p2p_enabled = ::std::option::Option::Some(v);
3141 }
3142
3143 pub fn explicit_ip_address(&self) -> &str {
3146 match self.explicit_ip_address.as_ref() {
3147 Some(v) => v,
3148 None => "",
3149 }
3150 }
3151
3152 pub fn clear_explicit_ip_address(&mut self) {
3153 self.explicit_ip_address = ::std::option::Option::None;
3154 }
3155
3156 pub fn has_explicit_ip_address(&self) -> bool {
3157 self.explicit_ip_address.is_some()
3158 }
3159
3160 pub fn set_explicit_ip_address(&mut self, v: ::std::string::String) {
3162 self.explicit_ip_address = ::std::option::Option::Some(v);
3163 }
3164
3165 pub fn mut_explicit_ip_address(&mut self) -> &mut ::std::string::String {
3168 if self.explicit_ip_address.is_none() {
3169 self.explicit_ip_address = ::std::option::Option::Some(::std::string::String::new());
3170 }
3171 self.explicit_ip_address.as_mut().unwrap()
3172 }
3173
3174 pub fn take_explicit_ip_address(&mut self) -> ::std::string::String {
3176 self.explicit_ip_address.take().unwrap_or_else(|| ::std::string::String::new())
3177 }
3178
3179 pub fn external_process(&self) -> bool {
3182 self.external_process.unwrap_or(false)
3183 }
3184
3185 pub fn clear_external_process(&mut self) {
3186 self.external_process = ::std::option::Option::None;
3187 }
3188
3189 pub fn has_external_process(&self) -> bool {
3190 self.external_process.is_some()
3191 }
3192
3193 pub fn set_external_process(&mut self, v: bool) {
3195 self.external_process = ::std::option::Option::Some(v);
3196 }
3197
3198 pub fn current_size_gb(&self) -> u32 {
3201 self.current_size_gb.unwrap_or(0)
3202 }
3203
3204 pub fn clear_current_size_gb(&mut self) {
3205 self.current_size_gb = ::std::option::Option::None;
3206 }
3207
3208 pub fn has_current_size_gb(&self) -> bool {
3209 self.current_size_gb.is_some()
3210 }
3211
3212 pub fn set_current_size_gb(&mut self, v: u32) {
3214 self.current_size_gb = ::std::option::Option::Some(v);
3215 }
3216
3217 pub fn current_bw(&self) -> u64 {
3220 self.current_bw.unwrap_or(0)
3221 }
3222
3223 pub fn clear_current_bw(&mut self) {
3224 self.current_bw = ::std::option::Option::None;
3225 }
3226
3227 pub fn has_current_bw(&self) -> bool {
3228 self.current_bw.is_some()
3229 }
3230
3231 pub fn set_current_bw(&mut self, v: u64) {
3233 self.current_bw = ::std::option::Option::Some(v);
3234 }
3235
3236 pub fn total_bytes_served(&self) -> u64 {
3239 self.total_bytes_served.unwrap_or(0)
3240 }
3241
3242 pub fn clear_total_bytes_served(&mut self) {
3243 self.total_bytes_served = ::std::option::Option::None;
3244 }
3245
3246 pub fn has_total_bytes_served(&self) -> bool {
3247 self.total_bytes_served.is_some()
3248 }
3249
3250 pub fn set_total_bytes_served(&mut self, v: u64) {
3252 self.total_bytes_served = ::std::option::Option::Some(v);
3253 }
3254}
3255
3256impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ContentCacheStatus_Response {
3257 const NAME: &'static str = "SiteServerUI_ContentCacheStatus_Response";
3258
3259 fn is_initialized(&self) -> bool {
3260 true
3261 }
3262
3263 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3264 while let Some(tag) = is.read_raw_tag_or_eof()? {
3265 match tag {
3266 8 => {
3267 self.enabled = ::std::option::Option::Some(is.read_bool()?);
3268 },
3269 16 => {
3270 self.port = ::std::option::Option::Some(is.read_uint32()?);
3271 },
3272 26 => {
3273 self.cache_location = ::std::option::Option::Some(is.read_string()?);
3274 },
3275 32 => {
3276 self.max_size_gb = ::std::option::Option::Some(is.read_uint32()?);
3277 },
3278 40 => {
3279 self.p2p_enabled = ::std::option::Option::Some(is.read_bool()?);
3280 },
3281 74 => {
3282 self.explicit_ip_address = ::std::option::Option::Some(is.read_string()?);
3283 },
3284 80 => {
3285 self.external_process = ::std::option::Option::Some(is.read_bool()?);
3286 },
3287 48 => {
3288 self.current_size_gb = ::std::option::Option::Some(is.read_uint32()?);
3289 },
3290 56 => {
3291 self.current_bw = ::std::option::Option::Some(is.read_uint64()?);
3292 },
3293 64 => {
3294 self.total_bytes_served = ::std::option::Option::Some(is.read_uint64()?);
3295 },
3296 tag => {
3297 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3298 },
3299 };
3300 }
3301 ::std::result::Result::Ok(())
3302 }
3303
3304 #[allow(unused_variables)]
3306 fn compute_size(&self) -> u64 {
3307 let mut my_size = 0;
3308 if let Some(v) = self.enabled {
3309 my_size += 1 + 1;
3310 }
3311 if let Some(v) = self.port {
3312 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
3313 }
3314 if let Some(v) = self.cache_location.as_ref() {
3315 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
3316 }
3317 if let Some(v) = self.max_size_gb {
3318 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
3319 }
3320 if let Some(v) = self.p2p_enabled {
3321 my_size += 1 + 1;
3322 }
3323 if let Some(v) = self.explicit_ip_address.as_ref() {
3324 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(9, &v);
3325 }
3326 if let Some(v) = self.external_process {
3327 my_size += 1 + 1;
3328 }
3329 if let Some(v) = self.current_size_gb {
3330 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(6, v);
3331 }
3332 if let Some(v) = self.current_bw {
3333 my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(7, v);
3334 }
3335 if let Some(v) = self.total_bytes_served {
3336 my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(8, v);
3337 }
3338 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3339 self.special_fields.cached_size().set(my_size as u32);
3340 my_size
3341 }
3342
3343 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3344 if let Some(v) = self.enabled {
3345 os.write_bool(1, v)?;
3346 }
3347 if let Some(v) = self.port {
3348 os.write_uint32(2, v)?;
3349 }
3350 if let Some(v) = self.cache_location.as_ref() {
3351 os.write_string(3, v)?;
3352 }
3353 if let Some(v) = self.max_size_gb {
3354 os.write_uint32(4, v)?;
3355 }
3356 if let Some(v) = self.p2p_enabled {
3357 os.write_bool(5, v)?;
3358 }
3359 if let Some(v) = self.explicit_ip_address.as_ref() {
3360 os.write_string(9, v)?;
3361 }
3362 if let Some(v) = self.external_process {
3363 os.write_bool(10, v)?;
3364 }
3365 if let Some(v) = self.current_size_gb {
3366 os.write_uint32(6, v)?;
3367 }
3368 if let Some(v) = self.current_bw {
3369 os.write_uint64(7, v)?;
3370 }
3371 if let Some(v) = self.total_bytes_served {
3372 os.write_uint64(8, v)?;
3373 }
3374 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3375 ::std::result::Result::Ok(())
3376 }
3377
3378 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3379 &self.special_fields
3380 }
3381
3382 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3383 &mut self.special_fields
3384 }
3385
3386 fn new() -> SiteServerUI_ContentCacheStatus_Response {
3387 SiteServerUI_ContentCacheStatus_Response::new()
3388 }
3389
3390 fn clear(&mut self) {
3391 self.enabled = ::std::option::Option::None;
3392 self.port = ::std::option::Option::None;
3393 self.cache_location = ::std::option::Option::None;
3394 self.max_size_gb = ::std::option::Option::None;
3395 self.p2p_enabled = ::std::option::Option::None;
3396 self.explicit_ip_address = ::std::option::Option::None;
3397 self.external_process = ::std::option::Option::None;
3398 self.current_size_gb = ::std::option::Option::None;
3399 self.current_bw = ::std::option::Option::None;
3400 self.total_bytes_served = ::std::option::Option::None;
3401 self.special_fields.clear();
3402 }
3403
3404 fn default_instance() -> &'static SiteServerUI_ContentCacheStatus_Response {
3405 static instance: SiteServerUI_ContentCacheStatus_Response = SiteServerUI_ContentCacheStatus_Response {
3406 enabled: ::std::option::Option::None,
3407 port: ::std::option::Option::None,
3408 cache_location: ::std::option::Option::None,
3409 max_size_gb: ::std::option::Option::None,
3410 p2p_enabled: ::std::option::Option::None,
3411 explicit_ip_address: ::std::option::Option::None,
3412 external_process: ::std::option::Option::None,
3413 current_size_gb: ::std::option::Option::None,
3414 current_bw: ::std::option::Option::None,
3415 total_bytes_served: ::std::option::Option::None,
3416 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3417 };
3418 &instance
3419 }
3420}
3421
3422#[derive(PartialEq,Clone,Default,Debug)]
3424pub struct SiteServerUI_ContentCacheConfig_Request {
3425 pub enabled: ::std::option::Option<bool>,
3428 pub port: ::std::option::Option<u32>,
3430 pub cache_location: ::std::option::Option<::std::string::String>,
3432 pub max_size_gb: ::std::option::Option<u32>,
3434 pub p2p_enabled: ::std::option::Option<bool>,
3436 pub external_process: ::std::option::Option<bool>,
3438 pub explicit_ip_address: ::std::option::Option<::std::string::String>,
3440 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3443}
3444
3445impl<'a> ::std::default::Default for &'a SiteServerUI_ContentCacheConfig_Request {
3446 fn default() -> &'a SiteServerUI_ContentCacheConfig_Request {
3447 <SiteServerUI_ContentCacheConfig_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3448 }
3449}
3450
3451impl SiteServerUI_ContentCacheConfig_Request {
3452 pub fn new() -> SiteServerUI_ContentCacheConfig_Request {
3453 ::std::default::Default::default()
3454 }
3455
3456 pub fn enabled(&self) -> bool {
3459 self.enabled.unwrap_or(false)
3460 }
3461
3462 pub fn clear_enabled(&mut self) {
3463 self.enabled = ::std::option::Option::None;
3464 }
3465
3466 pub fn has_enabled(&self) -> bool {
3467 self.enabled.is_some()
3468 }
3469
3470 pub fn set_enabled(&mut self, v: bool) {
3472 self.enabled = ::std::option::Option::Some(v);
3473 }
3474
3475 pub fn port(&self) -> u32 {
3478 self.port.unwrap_or(0)
3479 }
3480
3481 pub fn clear_port(&mut self) {
3482 self.port = ::std::option::Option::None;
3483 }
3484
3485 pub fn has_port(&self) -> bool {
3486 self.port.is_some()
3487 }
3488
3489 pub fn set_port(&mut self, v: u32) {
3491 self.port = ::std::option::Option::Some(v);
3492 }
3493
3494 pub fn cache_location(&self) -> &str {
3497 match self.cache_location.as_ref() {
3498 Some(v) => v,
3499 None => "",
3500 }
3501 }
3502
3503 pub fn clear_cache_location(&mut self) {
3504 self.cache_location = ::std::option::Option::None;
3505 }
3506
3507 pub fn has_cache_location(&self) -> bool {
3508 self.cache_location.is_some()
3509 }
3510
3511 pub fn set_cache_location(&mut self, v: ::std::string::String) {
3513 self.cache_location = ::std::option::Option::Some(v);
3514 }
3515
3516 pub fn mut_cache_location(&mut self) -> &mut ::std::string::String {
3519 if self.cache_location.is_none() {
3520 self.cache_location = ::std::option::Option::Some(::std::string::String::new());
3521 }
3522 self.cache_location.as_mut().unwrap()
3523 }
3524
3525 pub fn take_cache_location(&mut self) -> ::std::string::String {
3527 self.cache_location.take().unwrap_or_else(|| ::std::string::String::new())
3528 }
3529
3530 pub fn max_size_gb(&self) -> u32 {
3533 self.max_size_gb.unwrap_or(0)
3534 }
3535
3536 pub fn clear_max_size_gb(&mut self) {
3537 self.max_size_gb = ::std::option::Option::None;
3538 }
3539
3540 pub fn has_max_size_gb(&self) -> bool {
3541 self.max_size_gb.is_some()
3542 }
3543
3544 pub fn set_max_size_gb(&mut self, v: u32) {
3546 self.max_size_gb = ::std::option::Option::Some(v);
3547 }
3548
3549 pub fn p2p_enabled(&self) -> bool {
3552 self.p2p_enabled.unwrap_or(false)
3553 }
3554
3555 pub fn clear_p2p_enabled(&mut self) {
3556 self.p2p_enabled = ::std::option::Option::None;
3557 }
3558
3559 pub fn has_p2p_enabled(&self) -> bool {
3560 self.p2p_enabled.is_some()
3561 }
3562
3563 pub fn set_p2p_enabled(&mut self, v: bool) {
3565 self.p2p_enabled = ::std::option::Option::Some(v);
3566 }
3567
3568 pub fn external_process(&self) -> bool {
3571 self.external_process.unwrap_or(false)
3572 }
3573
3574 pub fn clear_external_process(&mut self) {
3575 self.external_process = ::std::option::Option::None;
3576 }
3577
3578 pub fn has_external_process(&self) -> bool {
3579 self.external_process.is_some()
3580 }
3581
3582 pub fn set_external_process(&mut self, v: bool) {
3584 self.external_process = ::std::option::Option::Some(v);
3585 }
3586
3587 pub fn explicit_ip_address(&self) -> &str {
3590 match self.explicit_ip_address.as_ref() {
3591 Some(v) => v,
3592 None => "",
3593 }
3594 }
3595
3596 pub fn clear_explicit_ip_address(&mut self) {
3597 self.explicit_ip_address = ::std::option::Option::None;
3598 }
3599
3600 pub fn has_explicit_ip_address(&self) -> bool {
3601 self.explicit_ip_address.is_some()
3602 }
3603
3604 pub fn set_explicit_ip_address(&mut self, v: ::std::string::String) {
3606 self.explicit_ip_address = ::std::option::Option::Some(v);
3607 }
3608
3609 pub fn mut_explicit_ip_address(&mut self) -> &mut ::std::string::String {
3612 if self.explicit_ip_address.is_none() {
3613 self.explicit_ip_address = ::std::option::Option::Some(::std::string::String::new());
3614 }
3615 self.explicit_ip_address.as_mut().unwrap()
3616 }
3617
3618 pub fn take_explicit_ip_address(&mut self) -> ::std::string::String {
3620 self.explicit_ip_address.take().unwrap_or_else(|| ::std::string::String::new())
3621 }
3622}
3623
3624impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ContentCacheConfig_Request {
3625 const NAME: &'static str = "SiteServerUI_ContentCacheConfig_Request";
3626
3627 fn is_initialized(&self) -> bool {
3628 true
3629 }
3630
3631 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3632 while let Some(tag) = is.read_raw_tag_or_eof()? {
3633 match tag {
3634 8 => {
3635 self.enabled = ::std::option::Option::Some(is.read_bool()?);
3636 },
3637 16 => {
3638 self.port = ::std::option::Option::Some(is.read_uint32()?);
3639 },
3640 26 => {
3641 self.cache_location = ::std::option::Option::Some(is.read_string()?);
3642 },
3643 32 => {
3644 self.max_size_gb = ::std::option::Option::Some(is.read_uint32()?);
3645 },
3646 40 => {
3647 self.p2p_enabled = ::std::option::Option::Some(is.read_bool()?);
3648 },
3649 48 => {
3650 self.external_process = ::std::option::Option::Some(is.read_bool()?);
3651 },
3652 58 => {
3653 self.explicit_ip_address = ::std::option::Option::Some(is.read_string()?);
3654 },
3655 tag => {
3656 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3657 },
3658 };
3659 }
3660 ::std::result::Result::Ok(())
3661 }
3662
3663 #[allow(unused_variables)]
3665 fn compute_size(&self) -> u64 {
3666 let mut my_size = 0;
3667 if let Some(v) = self.enabled {
3668 my_size += 1 + 1;
3669 }
3670 if let Some(v) = self.port {
3671 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
3672 }
3673 if let Some(v) = self.cache_location.as_ref() {
3674 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
3675 }
3676 if let Some(v) = self.max_size_gb {
3677 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
3678 }
3679 if let Some(v) = self.p2p_enabled {
3680 my_size += 1 + 1;
3681 }
3682 if let Some(v) = self.external_process {
3683 my_size += 1 + 1;
3684 }
3685 if let Some(v) = self.explicit_ip_address.as_ref() {
3686 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
3687 }
3688 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3689 self.special_fields.cached_size().set(my_size as u32);
3690 my_size
3691 }
3692
3693 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3694 if let Some(v) = self.enabled {
3695 os.write_bool(1, v)?;
3696 }
3697 if let Some(v) = self.port {
3698 os.write_uint32(2, v)?;
3699 }
3700 if let Some(v) = self.cache_location.as_ref() {
3701 os.write_string(3, v)?;
3702 }
3703 if let Some(v) = self.max_size_gb {
3704 os.write_uint32(4, v)?;
3705 }
3706 if let Some(v) = self.p2p_enabled {
3707 os.write_bool(5, v)?;
3708 }
3709 if let Some(v) = self.external_process {
3710 os.write_bool(6, v)?;
3711 }
3712 if let Some(v) = self.explicit_ip_address.as_ref() {
3713 os.write_string(7, v)?;
3714 }
3715 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3716 ::std::result::Result::Ok(())
3717 }
3718
3719 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3720 &self.special_fields
3721 }
3722
3723 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3724 &mut self.special_fields
3725 }
3726
3727 fn new() -> SiteServerUI_ContentCacheConfig_Request {
3728 SiteServerUI_ContentCacheConfig_Request::new()
3729 }
3730
3731 fn clear(&mut self) {
3732 self.enabled = ::std::option::Option::None;
3733 self.port = ::std::option::Option::None;
3734 self.cache_location = ::std::option::Option::None;
3735 self.max_size_gb = ::std::option::Option::None;
3736 self.p2p_enabled = ::std::option::Option::None;
3737 self.external_process = ::std::option::Option::None;
3738 self.explicit_ip_address = ::std::option::Option::None;
3739 self.special_fields.clear();
3740 }
3741
3742 fn default_instance() -> &'static SiteServerUI_ContentCacheConfig_Request {
3743 static instance: SiteServerUI_ContentCacheConfig_Request = SiteServerUI_ContentCacheConfig_Request {
3744 enabled: ::std::option::Option::None,
3745 port: ::std::option::Option::None,
3746 cache_location: ::std::option::Option::None,
3747 max_size_gb: ::std::option::Option::None,
3748 p2p_enabled: ::std::option::Option::None,
3749 external_process: ::std::option::Option::None,
3750 explicit_ip_address: ::std::option::Option::None,
3751 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3752 };
3753 &instance
3754 }
3755}
3756
3757#[derive(PartialEq,Clone,Default,Debug)]
3759pub struct SiteServerUI_ContentCacheConfig_Response {
3760 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3763}
3764
3765impl<'a> ::std::default::Default for &'a SiteServerUI_ContentCacheConfig_Response {
3766 fn default() -> &'a SiteServerUI_ContentCacheConfig_Response {
3767 <SiteServerUI_ContentCacheConfig_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3768 }
3769}
3770
3771impl SiteServerUI_ContentCacheConfig_Response {
3772 pub fn new() -> SiteServerUI_ContentCacheConfig_Response {
3773 ::std::default::Default::default()
3774 }
3775}
3776
3777impl ::steam_vent_proto_common::protobuf::Message for SiteServerUI_ContentCacheConfig_Response {
3778 const NAME: &'static str = "SiteServerUI_ContentCacheConfig_Response";
3779
3780 fn is_initialized(&self) -> bool {
3781 true
3782 }
3783
3784 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3785 while let Some(tag) = is.read_raw_tag_or_eof()? {
3786 match tag {
3787 tag => {
3788 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3789 },
3790 };
3791 }
3792 ::std::result::Result::Ok(())
3793 }
3794
3795 #[allow(unused_variables)]
3797 fn compute_size(&self) -> u64 {
3798 let mut my_size = 0;
3799 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3800 self.special_fields.cached_size().set(my_size as u32);
3801 my_size
3802 }
3803
3804 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3805 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3806 ::std::result::Result::Ok(())
3807 }
3808
3809 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3810 &self.special_fields
3811 }
3812
3813 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3814 &mut self.special_fields
3815 }
3816
3817 fn new() -> SiteServerUI_ContentCacheConfig_Response {
3818 SiteServerUI_ContentCacheConfig_Response::new()
3819 }
3820
3821 fn clear(&mut self) {
3822 self.special_fields.clear();
3823 }
3824
3825 fn default_instance() -> &'static SiteServerUI_ContentCacheConfig_Response {
3826 static instance: SiteServerUI_ContentCacheConfig_Response = SiteServerUI_ContentCacheConfig_Response {
3827 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3828 };
3829 &instance
3830 }
3831}
3832
3833
3834const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
3835
3836#[allow(unused_imports)]
3837use crate::steammessages_base::*;
3838impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Login_Request {
3839 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3840 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3841 }
3842 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3843 use ::steam_vent_proto_common::protobuf::Message;
3844 self.write_to_writer(writer)
3845 }
3846 fn encode_size(&self) -> usize {
3847 use ::steam_vent_proto_common::protobuf::Message;
3848 self.compute_size() as usize
3849 }
3850}
3851impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Login_Response {
3852 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3853 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3854 }
3855 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3856 use ::steam_vent_proto_common::protobuf::Message;
3857 self.write_to_writer(writer)
3858 }
3859 fn encode_size(&self) -> usize {
3860 use ::steam_vent_proto_common::protobuf::Message;
3861 self.compute_size() as usize
3862 }
3863}
3864impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_LoginStatus_Request {
3865 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3866 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3867 }
3868 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3869 use ::steam_vent_proto_common::protobuf::Message;
3870 self.write_to_writer(writer)
3871 }
3872 fn encode_size(&self) -> usize {
3873 use ::steam_vent_proto_common::protobuf::Message;
3874 self.compute_size() as usize
3875 }
3876}
3877impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_LoginStatus_Response {
3878 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3879 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3880 }
3881 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3882 use ::steam_vent_proto_common::protobuf::Message;
3883 self.write_to_writer(writer)
3884 }
3885 fn encode_size(&self) -> usize {
3886 use ::steam_vent_proto_common::protobuf::Message;
3887 self.compute_size() as usize
3888 }
3889}
3890impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_CancelLogin_Request {
3891 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3892 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3893 }
3894 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3895 use ::steam_vent_proto_common::protobuf::Message;
3896 self.write_to_writer(writer)
3897 }
3898 fn encode_size(&self) -> usize {
3899 use ::steam_vent_proto_common::protobuf::Message;
3900 self.compute_size() as usize
3901 }
3902}
3903impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_CancelLogin_Response {
3904 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3905 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3906 }
3907 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3908 use ::steam_vent_proto_common::protobuf::Message;
3909 self.write_to_writer(writer)
3910 }
3911 fn encode_size(&self) -> usize {
3912 use ::steam_vent_proto_common::protobuf::Message;
3913 self.compute_size() as usize
3914 }
3915}
3916impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Logout_Request {
3917 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3918 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3919 }
3920 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3921 use ::steam_vent_proto_common::protobuf::Message;
3922 self.write_to_writer(writer)
3923 }
3924 fn encode_size(&self) -> usize {
3925 use ::steam_vent_proto_common::protobuf::Message;
3926 self.compute_size() as usize
3927 }
3928}
3929impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Logout_Response {
3930 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3931 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3932 }
3933 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3934 use ::steam_vent_proto_common::protobuf::Message;
3935 self.write_to_writer(writer)
3936 }
3937 fn encode_size(&self) -> usize {
3938 use ::steam_vent_proto_common::protobuf::Message;
3939 self.compute_size() as usize
3940 }
3941}
3942impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Quit_Request {
3943 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3944 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3945 }
3946 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3947 use ::steam_vent_proto_common::protobuf::Message;
3948 self.write_to_writer(writer)
3949 }
3950 fn encode_size(&self) -> usize {
3951 use ::steam_vent_proto_common::protobuf::Message;
3952 self.compute_size() as usize
3953 }
3954}
3955impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Quit_Response {
3956 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3957 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3958 }
3959 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3960 use ::steam_vent_proto_common::protobuf::Message;
3961 self.write_to_writer(writer)
3962 }
3963 fn encode_size(&self) -> usize {
3964 use ::steam_vent_proto_common::protobuf::Message;
3965 self.compute_size() as usize
3966 }
3967}
3968impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Status_Request {
3969 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3970 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3971 }
3972 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3973 use ::steam_vent_proto_common::protobuf::Message;
3974 self.write_to_writer(writer)
3975 }
3976 fn encode_size(&self) -> usize {
3977 use ::steam_vent_proto_common::protobuf::Message;
3978 self.compute_size() as usize
3979 }
3980}
3981impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_Status_Response {
3982 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3983 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3984 }
3985 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3986 use ::steam_vent_proto_common::protobuf::Message;
3987 self.write_to_writer(writer)
3988 }
3989 fn encode_size(&self) -> usize {
3990 use ::steam_vent_proto_common::protobuf::Message;
3991 self.compute_size() as usize
3992 }
3993}
3994impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_GetLanguage_Request {
3995 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
3996 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
3997 }
3998 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
3999 use ::steam_vent_proto_common::protobuf::Message;
4000 self.write_to_writer(writer)
4001 }
4002 fn encode_size(&self) -> usize {
4003 use ::steam_vent_proto_common::protobuf::Message;
4004 self.compute_size() as usize
4005 }
4006}
4007impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_GetLanguage_Response {
4008 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4009 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4010 }
4011 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4012 use ::steam_vent_proto_common::protobuf::Message;
4013 self.write_to_writer(writer)
4014 }
4015 fn encode_size(&self) -> usize {
4016 use ::steam_vent_proto_common::protobuf::Message;
4017 self.compute_size() as usize
4018 }
4019}
4020impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_SetLanguage_Request {
4021 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4022 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4023 }
4024 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4025 use ::steam_vent_proto_common::protobuf::Message;
4026 self.write_to_writer(writer)
4027 }
4028 fn encode_size(&self) -> usize {
4029 use ::steam_vent_proto_common::protobuf::Message;
4030 self.compute_size() as usize
4031 }
4032}
4033impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_SetLanguage_Response {
4034 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4035 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4036 }
4037 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4038 use ::steam_vent_proto_common::protobuf::Message;
4039 self.write_to_writer(writer)
4040 }
4041 fn encode_size(&self) -> usize {
4042 use ::steam_vent_proto_common::protobuf::Message;
4043 self.compute_size() as usize
4044 }
4045}
4046impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_ClientStatus_Request {
4047 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4048 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4049 }
4050 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4051 use ::steam_vent_proto_common::protobuf::Message;
4052 self.write_to_writer(writer)
4053 }
4054 fn encode_size(&self) -> usize {
4055 use ::steam_vent_proto_common::protobuf::Message;
4056 self.compute_size() as usize
4057 }
4058}
4059impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_ClientStatus_Response {
4060 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4061 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4062 }
4063 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4064 use ::steam_vent_proto_common::protobuf::Message;
4065 self.write_to_writer(writer)
4066 }
4067 fn encode_size(&self) -> usize {
4068 use ::steam_vent_proto_common::protobuf::Message;
4069 self.compute_size() as usize
4070 }
4071}
4072impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_ContentCacheStatus_Request {
4073 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4074 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4075 }
4076 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4077 use ::steam_vent_proto_common::protobuf::Message;
4078 self.write_to_writer(writer)
4079 }
4080 fn encode_size(&self) -> usize {
4081 use ::steam_vent_proto_common::protobuf::Message;
4082 self.compute_size() as usize
4083 }
4084}
4085impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_ContentCacheStatus_Response {
4086 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4087 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4088 }
4089 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4090 use ::steam_vent_proto_common::protobuf::Message;
4091 self.write_to_writer(writer)
4092 }
4093 fn encode_size(&self) -> usize {
4094 use ::steam_vent_proto_common::protobuf::Message;
4095 self.compute_size() as usize
4096 }
4097}
4098impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_ContentCacheConfig_Request {
4099 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4100 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4101 }
4102 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4103 use ::steam_vent_proto_common::protobuf::Message;
4104 self.write_to_writer(writer)
4105 }
4106 fn encode_size(&self) -> usize {
4107 use ::steam_vent_proto_common::protobuf::Message;
4108 self.compute_size() as usize
4109 }
4110}
4111impl ::steam_vent_proto_common::RpcMessage for SiteServerUI_ContentCacheConfig_Response {
4112 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
4113 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
4114 }
4115 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
4116 use ::steam_vent_proto_common::protobuf::Message;
4117 self.write_to_writer(writer)
4118 }
4119 fn encode_size(&self) -> usize {
4120 use ::steam_vent_proto_common::protobuf::Message;
4121 self.compute_size() as usize
4122 }
4123}