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 CRemoteClient_CreateSession_Request {
31 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
34}
35
36impl<'a> ::std::default::Default for &'a CRemoteClient_CreateSession_Request {
37 fn default() -> &'a CRemoteClient_CreateSession_Request {
38 <CRemoteClient_CreateSession_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
39 }
40}
41
42impl CRemoteClient_CreateSession_Request {
43 pub fn new() -> CRemoteClient_CreateSession_Request {
44 ::std::default::Default::default()
45 }
46}
47
48impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_CreateSession_Request {
49 const NAME: &'static str = "CRemoteClient_CreateSession_Request";
50
51 fn is_initialized(&self) -> bool {
52 true
53 }
54
55 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
56 while let Some(tag) = is.read_raw_tag_or_eof()? {
57 match tag {
58 tag => {
59 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
60 },
61 };
62 }
63 ::std::result::Result::Ok(())
64 }
65
66 #[allow(unused_variables)]
68 fn compute_size(&self) -> u64 {
69 let mut my_size = 0;
70 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
71 self.special_fields.cached_size().set(my_size as u32);
72 my_size
73 }
74
75 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
76 os.write_unknown_fields(self.special_fields.unknown_fields())?;
77 ::std::result::Result::Ok(())
78 }
79
80 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
81 &self.special_fields
82 }
83
84 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
85 &mut self.special_fields
86 }
87
88 fn new() -> CRemoteClient_CreateSession_Request {
89 CRemoteClient_CreateSession_Request::new()
90 }
91
92 fn clear(&mut self) {
93 self.special_fields.clear();
94 }
95
96 fn default_instance() -> &'static CRemoteClient_CreateSession_Request {
97 static instance: CRemoteClient_CreateSession_Request = CRemoteClient_CreateSession_Request {
98 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
99 };
100 &instance
101 }
102}
103
104#[derive(PartialEq,Clone,Default,Debug)]
106pub struct CRemoteClient_CreateSession_Response {
107 pub session_id: ::std::option::Option<u64>,
110 pub euniverse: ::std::option::Option<i32>,
112 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
115}
116
117impl<'a> ::std::default::Default for &'a CRemoteClient_CreateSession_Response {
118 fn default() -> &'a CRemoteClient_CreateSession_Response {
119 <CRemoteClient_CreateSession_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
120 }
121}
122
123impl CRemoteClient_CreateSession_Response {
124 pub fn new() -> CRemoteClient_CreateSession_Response {
125 ::std::default::Default::default()
126 }
127
128 pub fn session_id(&self) -> u64 {
131 self.session_id.unwrap_or(0)
132 }
133
134 pub fn clear_session_id(&mut self) {
135 self.session_id = ::std::option::Option::None;
136 }
137
138 pub fn has_session_id(&self) -> bool {
139 self.session_id.is_some()
140 }
141
142 pub fn set_session_id(&mut self, v: u64) {
144 self.session_id = ::std::option::Option::Some(v);
145 }
146
147 pub fn euniverse(&self) -> i32 {
150 self.euniverse.unwrap_or(0)
151 }
152
153 pub fn clear_euniverse(&mut self) {
154 self.euniverse = ::std::option::Option::None;
155 }
156
157 pub fn has_euniverse(&self) -> bool {
158 self.euniverse.is_some()
159 }
160
161 pub fn set_euniverse(&mut self, v: i32) {
163 self.euniverse = ::std::option::Option::Some(v);
164 }
165}
166
167impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_CreateSession_Response {
168 const NAME: &'static str = "CRemoteClient_CreateSession_Response";
169
170 fn is_initialized(&self) -> bool {
171 true
172 }
173
174 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
175 while let Some(tag) = is.read_raw_tag_or_eof()? {
176 match tag {
177 9 => {
178 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
179 },
180 16 => {
181 self.euniverse = ::std::option::Option::Some(is.read_int32()?);
182 },
183 tag => {
184 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
185 },
186 };
187 }
188 ::std::result::Result::Ok(())
189 }
190
191 #[allow(unused_variables)]
193 fn compute_size(&self) -> u64 {
194 let mut my_size = 0;
195 if let Some(v) = self.session_id {
196 my_size += 1 + 8;
197 }
198 if let Some(v) = self.euniverse {
199 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
200 }
201 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
202 self.special_fields.cached_size().set(my_size as u32);
203 my_size
204 }
205
206 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
207 if let Some(v) = self.session_id {
208 os.write_fixed64(1, v)?;
209 }
210 if let Some(v) = self.euniverse {
211 os.write_int32(2, v)?;
212 }
213 os.write_unknown_fields(self.special_fields.unknown_fields())?;
214 ::std::result::Result::Ok(())
215 }
216
217 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
218 &self.special_fields
219 }
220
221 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
222 &mut self.special_fields
223 }
224
225 fn new() -> CRemoteClient_CreateSession_Response {
226 CRemoteClient_CreateSession_Response::new()
227 }
228
229 fn clear(&mut self) {
230 self.session_id = ::std::option::Option::None;
231 self.euniverse = ::std::option::Option::None;
232 self.special_fields.clear();
233 }
234
235 fn default_instance() -> &'static CRemoteClient_CreateSession_Response {
236 static instance: CRemoteClient_CreateSession_Response = CRemoteClient_CreateSession_Response {
237 session_id: ::std::option::Option::None,
238 euniverse: ::std::option::Option::None,
239 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
240 };
241 &instance
242 }
243}
244
245#[derive(PartialEq,Clone,Default,Debug)]
247pub struct CRemoteClient_DeleteSession_Notification {
248 pub session_id: ::std::option::Option<u64>,
251 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
254}
255
256impl<'a> ::std::default::Default for &'a CRemoteClient_DeleteSession_Notification {
257 fn default() -> &'a CRemoteClient_DeleteSession_Notification {
258 <CRemoteClient_DeleteSession_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
259 }
260}
261
262impl CRemoteClient_DeleteSession_Notification {
263 pub fn new() -> CRemoteClient_DeleteSession_Notification {
264 ::std::default::Default::default()
265 }
266
267 pub fn session_id(&self) -> u64 {
270 self.session_id.unwrap_or(0)
271 }
272
273 pub fn clear_session_id(&mut self) {
274 self.session_id = ::std::option::Option::None;
275 }
276
277 pub fn has_session_id(&self) -> bool {
278 self.session_id.is_some()
279 }
280
281 pub fn set_session_id(&mut self, v: u64) {
283 self.session_id = ::std::option::Option::Some(v);
284 }
285}
286
287impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_DeleteSession_Notification {
288 const NAME: &'static str = "CRemoteClient_DeleteSession_Notification";
289
290 fn is_initialized(&self) -> bool {
291 true
292 }
293
294 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
295 while let Some(tag) = is.read_raw_tag_or_eof()? {
296 match tag {
297 9 => {
298 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
299 },
300 tag => {
301 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
302 },
303 };
304 }
305 ::std::result::Result::Ok(())
306 }
307
308 #[allow(unused_variables)]
310 fn compute_size(&self) -> u64 {
311 let mut my_size = 0;
312 if let Some(v) = self.session_id {
313 my_size += 1 + 8;
314 }
315 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
316 self.special_fields.cached_size().set(my_size as u32);
317 my_size
318 }
319
320 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
321 if let Some(v) = self.session_id {
322 os.write_fixed64(1, v)?;
323 }
324 os.write_unknown_fields(self.special_fields.unknown_fields())?;
325 ::std::result::Result::Ok(())
326 }
327
328 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
329 &self.special_fields
330 }
331
332 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
333 &mut self.special_fields
334 }
335
336 fn new() -> CRemoteClient_DeleteSession_Notification {
337 CRemoteClient_DeleteSession_Notification::new()
338 }
339
340 fn clear(&mut self) {
341 self.session_id = ::std::option::Option::None;
342 self.special_fields.clear();
343 }
344
345 fn default_instance() -> &'static CRemoteClient_DeleteSession_Notification {
346 static instance: CRemoteClient_DeleteSession_Notification = CRemoteClient_DeleteSession_Notification {
347 session_id: ::std::option::Option::None,
348 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
349 };
350 &instance
351 }
352}
353
354#[derive(PartialEq,Clone,Default,Debug)]
356pub struct CRemoteClient_StartPairing_Request {
357 pub session_id: ::std::option::Option<u64>,
360 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
363}
364
365impl<'a> ::std::default::Default for &'a CRemoteClient_StartPairing_Request {
366 fn default() -> &'a CRemoteClient_StartPairing_Request {
367 <CRemoteClient_StartPairing_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
368 }
369}
370
371impl CRemoteClient_StartPairing_Request {
372 pub fn new() -> CRemoteClient_StartPairing_Request {
373 ::std::default::Default::default()
374 }
375
376 pub fn session_id(&self) -> u64 {
379 self.session_id.unwrap_or(0)
380 }
381
382 pub fn clear_session_id(&mut self) {
383 self.session_id = ::std::option::Option::None;
384 }
385
386 pub fn has_session_id(&self) -> bool {
387 self.session_id.is_some()
388 }
389
390 pub fn set_session_id(&mut self, v: u64) {
392 self.session_id = ::std::option::Option::Some(v);
393 }
394}
395
396impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_StartPairing_Request {
397 const NAME: &'static str = "CRemoteClient_StartPairing_Request";
398
399 fn is_initialized(&self) -> bool {
400 true
401 }
402
403 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
404 while let Some(tag) = is.read_raw_tag_or_eof()? {
405 match tag {
406 9 => {
407 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
408 },
409 tag => {
410 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
411 },
412 };
413 }
414 ::std::result::Result::Ok(())
415 }
416
417 #[allow(unused_variables)]
419 fn compute_size(&self) -> u64 {
420 let mut my_size = 0;
421 if let Some(v) = self.session_id {
422 my_size += 1 + 8;
423 }
424 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
425 self.special_fields.cached_size().set(my_size as u32);
426 my_size
427 }
428
429 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
430 if let Some(v) = self.session_id {
431 os.write_fixed64(1, v)?;
432 }
433 os.write_unknown_fields(self.special_fields.unknown_fields())?;
434 ::std::result::Result::Ok(())
435 }
436
437 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
438 &self.special_fields
439 }
440
441 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
442 &mut self.special_fields
443 }
444
445 fn new() -> CRemoteClient_StartPairing_Request {
446 CRemoteClient_StartPairing_Request::new()
447 }
448
449 fn clear(&mut self) {
450 self.session_id = ::std::option::Option::None;
451 self.special_fields.clear();
452 }
453
454 fn default_instance() -> &'static CRemoteClient_StartPairing_Request {
455 static instance: CRemoteClient_StartPairing_Request = CRemoteClient_StartPairing_Request {
456 session_id: ::std::option::Option::None,
457 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
458 };
459 &instance
460 }
461}
462
463#[derive(PartialEq,Clone,Default,Debug)]
465pub struct CRemoteClient_StartPairing_Response {
466 pub pin: ::std::option::Option<u32>,
469 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
472}
473
474impl<'a> ::std::default::Default for &'a CRemoteClient_StartPairing_Response {
475 fn default() -> &'a CRemoteClient_StartPairing_Response {
476 <CRemoteClient_StartPairing_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
477 }
478}
479
480impl CRemoteClient_StartPairing_Response {
481 pub fn new() -> CRemoteClient_StartPairing_Response {
482 ::std::default::Default::default()
483 }
484
485 pub fn pin(&self) -> u32 {
488 self.pin.unwrap_or(0)
489 }
490
491 pub fn clear_pin(&mut self) {
492 self.pin = ::std::option::Option::None;
493 }
494
495 pub fn has_pin(&self) -> bool {
496 self.pin.is_some()
497 }
498
499 pub fn set_pin(&mut self, v: u32) {
501 self.pin = ::std::option::Option::Some(v);
502 }
503}
504
505impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_StartPairing_Response {
506 const NAME: &'static str = "CRemoteClient_StartPairing_Response";
507
508 fn is_initialized(&self) -> bool {
509 true
510 }
511
512 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
513 while let Some(tag) = is.read_raw_tag_or_eof()? {
514 match tag {
515 8 => {
516 self.pin = ::std::option::Option::Some(is.read_uint32()?);
517 },
518 tag => {
519 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
520 },
521 };
522 }
523 ::std::result::Result::Ok(())
524 }
525
526 #[allow(unused_variables)]
528 fn compute_size(&self) -> u64 {
529 let mut my_size = 0;
530 if let Some(v) = self.pin {
531 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
532 }
533 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
534 self.special_fields.cached_size().set(my_size as u32);
535 my_size
536 }
537
538 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
539 if let Some(v) = self.pin {
540 os.write_uint32(1, v)?;
541 }
542 os.write_unknown_fields(self.special_fields.unknown_fields())?;
543 ::std::result::Result::Ok(())
544 }
545
546 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
547 &self.special_fields
548 }
549
550 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
551 &mut self.special_fields
552 }
553
554 fn new() -> CRemoteClient_StartPairing_Response {
555 CRemoteClient_StartPairing_Response::new()
556 }
557
558 fn clear(&mut self) {
559 self.pin = ::std::option::Option::None;
560 self.special_fields.clear();
561 }
562
563 fn default_instance() -> &'static CRemoteClient_StartPairing_Response {
564 static instance: CRemoteClient_StartPairing_Response = CRemoteClient_StartPairing_Response {
565 pin: ::std::option::Option::None,
566 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
567 };
568 &instance
569 }
570}
571
572#[derive(PartialEq,Clone,Default,Debug)]
574pub struct CRemoteClient_SetPairingInfo_Request {
575 pub session_id: ::std::option::Option<u64>,
578 pub device_id: ::std::option::Option<u64>,
580 pub request: ::std::option::Option<::std::vec::Vec<u8>>,
582 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
585}
586
587impl<'a> ::std::default::Default for &'a CRemoteClient_SetPairingInfo_Request {
588 fn default() -> &'a CRemoteClient_SetPairingInfo_Request {
589 <CRemoteClient_SetPairingInfo_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
590 }
591}
592
593impl CRemoteClient_SetPairingInfo_Request {
594 pub fn new() -> CRemoteClient_SetPairingInfo_Request {
595 ::std::default::Default::default()
596 }
597
598 pub fn session_id(&self) -> u64 {
601 self.session_id.unwrap_or(0)
602 }
603
604 pub fn clear_session_id(&mut self) {
605 self.session_id = ::std::option::Option::None;
606 }
607
608 pub fn has_session_id(&self) -> bool {
609 self.session_id.is_some()
610 }
611
612 pub fn set_session_id(&mut self, v: u64) {
614 self.session_id = ::std::option::Option::Some(v);
615 }
616
617 pub fn device_id(&self) -> u64 {
620 self.device_id.unwrap_or(0)
621 }
622
623 pub fn clear_device_id(&mut self) {
624 self.device_id = ::std::option::Option::None;
625 }
626
627 pub fn has_device_id(&self) -> bool {
628 self.device_id.is_some()
629 }
630
631 pub fn set_device_id(&mut self, v: u64) {
633 self.device_id = ::std::option::Option::Some(v);
634 }
635
636 pub fn request(&self) -> &[u8] {
639 match self.request.as_ref() {
640 Some(v) => v,
641 None => &[],
642 }
643 }
644
645 pub fn clear_request(&mut self) {
646 self.request = ::std::option::Option::None;
647 }
648
649 pub fn has_request(&self) -> bool {
650 self.request.is_some()
651 }
652
653 pub fn set_request(&mut self, v: ::std::vec::Vec<u8>) {
655 self.request = ::std::option::Option::Some(v);
656 }
657
658 pub fn mut_request(&mut self) -> &mut ::std::vec::Vec<u8> {
661 if self.request.is_none() {
662 self.request = ::std::option::Option::Some(::std::vec::Vec::new());
663 }
664 self.request.as_mut().unwrap()
665 }
666
667 pub fn take_request(&mut self) -> ::std::vec::Vec<u8> {
669 self.request.take().unwrap_or_else(|| ::std::vec::Vec::new())
670 }
671}
672
673impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_SetPairingInfo_Request {
674 const NAME: &'static str = "CRemoteClient_SetPairingInfo_Request";
675
676 fn is_initialized(&self) -> bool {
677 true
678 }
679
680 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
681 while let Some(tag) = is.read_raw_tag_or_eof()? {
682 match tag {
683 9 => {
684 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
685 },
686 17 => {
687 self.device_id = ::std::option::Option::Some(is.read_fixed64()?);
688 },
689 26 => {
690 self.request = ::std::option::Option::Some(is.read_bytes()?);
691 },
692 tag => {
693 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
694 },
695 };
696 }
697 ::std::result::Result::Ok(())
698 }
699
700 #[allow(unused_variables)]
702 fn compute_size(&self) -> u64 {
703 let mut my_size = 0;
704 if let Some(v) = self.session_id {
705 my_size += 1 + 8;
706 }
707 if let Some(v) = self.device_id {
708 my_size += 1 + 8;
709 }
710 if let Some(v) = self.request.as_ref() {
711 my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
712 }
713 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
714 self.special_fields.cached_size().set(my_size as u32);
715 my_size
716 }
717
718 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
719 if let Some(v) = self.session_id {
720 os.write_fixed64(1, v)?;
721 }
722 if let Some(v) = self.device_id {
723 os.write_fixed64(2, v)?;
724 }
725 if let Some(v) = self.request.as_ref() {
726 os.write_bytes(3, v)?;
727 }
728 os.write_unknown_fields(self.special_fields.unknown_fields())?;
729 ::std::result::Result::Ok(())
730 }
731
732 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
733 &self.special_fields
734 }
735
736 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
737 &mut self.special_fields
738 }
739
740 fn new() -> CRemoteClient_SetPairingInfo_Request {
741 CRemoteClient_SetPairingInfo_Request::new()
742 }
743
744 fn clear(&mut self) {
745 self.session_id = ::std::option::Option::None;
746 self.device_id = ::std::option::Option::None;
747 self.request = ::std::option::Option::None;
748 self.special_fields.clear();
749 }
750
751 fn default_instance() -> &'static CRemoteClient_SetPairingInfo_Request {
752 static instance: CRemoteClient_SetPairingInfo_Request = CRemoteClient_SetPairingInfo_Request {
753 session_id: ::std::option::Option::None,
754 device_id: ::std::option::Option::None,
755 request: ::std::option::Option::None,
756 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
757 };
758 &instance
759 }
760}
761
762#[derive(PartialEq,Clone,Default,Debug)]
764pub struct CRemoteClient_SetPairingInfo_Response {
765 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
768}
769
770impl<'a> ::std::default::Default for &'a CRemoteClient_SetPairingInfo_Response {
771 fn default() -> &'a CRemoteClient_SetPairingInfo_Response {
772 <CRemoteClient_SetPairingInfo_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
773 }
774}
775
776impl CRemoteClient_SetPairingInfo_Response {
777 pub fn new() -> CRemoteClient_SetPairingInfo_Response {
778 ::std::default::Default::default()
779 }
780}
781
782impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_SetPairingInfo_Response {
783 const NAME: &'static str = "CRemoteClient_SetPairingInfo_Response";
784
785 fn is_initialized(&self) -> bool {
786 true
787 }
788
789 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
790 while let Some(tag) = is.read_raw_tag_or_eof()? {
791 match tag {
792 tag => {
793 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
794 },
795 };
796 }
797 ::std::result::Result::Ok(())
798 }
799
800 #[allow(unused_variables)]
802 fn compute_size(&self) -> u64 {
803 let mut my_size = 0;
804 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
805 self.special_fields.cached_size().set(my_size as u32);
806 my_size
807 }
808
809 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
810 os.write_unknown_fields(self.special_fields.unknown_fields())?;
811 ::std::result::Result::Ok(())
812 }
813
814 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
815 &self.special_fields
816 }
817
818 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
819 &mut self.special_fields
820 }
821
822 fn new() -> CRemoteClient_SetPairingInfo_Response {
823 CRemoteClient_SetPairingInfo_Response::new()
824 }
825
826 fn clear(&mut self) {
827 self.special_fields.clear();
828 }
829
830 fn default_instance() -> &'static CRemoteClient_SetPairingInfo_Response {
831 static instance: CRemoteClient_SetPairingInfo_Response = CRemoteClient_SetPairingInfo_Response {
832 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
833 };
834 &instance
835 }
836}
837
838#[derive(PartialEq,Clone,Default,Debug)]
840pub struct CRemoteClient_GetPairingInfo_Request {
841 pub pin: ::std::option::Option<u32>,
844 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
847}
848
849impl<'a> ::std::default::Default for &'a CRemoteClient_GetPairingInfo_Request {
850 fn default() -> &'a CRemoteClient_GetPairingInfo_Request {
851 <CRemoteClient_GetPairingInfo_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
852 }
853}
854
855impl CRemoteClient_GetPairingInfo_Request {
856 pub fn new() -> CRemoteClient_GetPairingInfo_Request {
857 ::std::default::Default::default()
858 }
859
860 pub fn pin(&self) -> u32 {
863 self.pin.unwrap_or(0)
864 }
865
866 pub fn clear_pin(&mut self) {
867 self.pin = ::std::option::Option::None;
868 }
869
870 pub fn has_pin(&self) -> bool {
871 self.pin.is_some()
872 }
873
874 pub fn set_pin(&mut self, v: u32) {
876 self.pin = ::std::option::Option::Some(v);
877 }
878}
879
880impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_GetPairingInfo_Request {
881 const NAME: &'static str = "CRemoteClient_GetPairingInfo_Request";
882
883 fn is_initialized(&self) -> bool {
884 true
885 }
886
887 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
888 while let Some(tag) = is.read_raw_tag_or_eof()? {
889 match tag {
890 8 => {
891 self.pin = ::std::option::Option::Some(is.read_uint32()?);
892 },
893 tag => {
894 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
895 },
896 };
897 }
898 ::std::result::Result::Ok(())
899 }
900
901 #[allow(unused_variables)]
903 fn compute_size(&self) -> u64 {
904 let mut my_size = 0;
905 if let Some(v) = self.pin {
906 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
907 }
908 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
909 self.special_fields.cached_size().set(my_size as u32);
910 my_size
911 }
912
913 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
914 if let Some(v) = self.pin {
915 os.write_uint32(1, v)?;
916 }
917 os.write_unknown_fields(self.special_fields.unknown_fields())?;
918 ::std::result::Result::Ok(())
919 }
920
921 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
922 &self.special_fields
923 }
924
925 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
926 &mut self.special_fields
927 }
928
929 fn new() -> CRemoteClient_GetPairingInfo_Request {
930 CRemoteClient_GetPairingInfo_Request::new()
931 }
932
933 fn clear(&mut self) {
934 self.pin = ::std::option::Option::None;
935 self.special_fields.clear();
936 }
937
938 fn default_instance() -> &'static CRemoteClient_GetPairingInfo_Request {
939 static instance: CRemoteClient_GetPairingInfo_Request = CRemoteClient_GetPairingInfo_Request {
940 pin: ::std::option::Option::None,
941 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
942 };
943 &instance
944 }
945}
946
947#[derive(PartialEq,Clone,Default,Debug)]
949pub struct CRemoteClient_GetPairingInfo_Response {
950 pub session_id: ::std::option::Option<u64>,
953 pub device_id: ::std::option::Option<u64>,
955 pub request: ::std::option::Option<::std::vec::Vec<u8>>,
957 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
960}
961
962impl<'a> ::std::default::Default for &'a CRemoteClient_GetPairingInfo_Response {
963 fn default() -> &'a CRemoteClient_GetPairingInfo_Response {
964 <CRemoteClient_GetPairingInfo_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
965 }
966}
967
968impl CRemoteClient_GetPairingInfo_Response {
969 pub fn new() -> CRemoteClient_GetPairingInfo_Response {
970 ::std::default::Default::default()
971 }
972
973 pub fn session_id(&self) -> u64 {
976 self.session_id.unwrap_or(0)
977 }
978
979 pub fn clear_session_id(&mut self) {
980 self.session_id = ::std::option::Option::None;
981 }
982
983 pub fn has_session_id(&self) -> bool {
984 self.session_id.is_some()
985 }
986
987 pub fn set_session_id(&mut self, v: u64) {
989 self.session_id = ::std::option::Option::Some(v);
990 }
991
992 pub fn device_id(&self) -> u64 {
995 self.device_id.unwrap_or(0)
996 }
997
998 pub fn clear_device_id(&mut self) {
999 self.device_id = ::std::option::Option::None;
1000 }
1001
1002 pub fn has_device_id(&self) -> bool {
1003 self.device_id.is_some()
1004 }
1005
1006 pub fn set_device_id(&mut self, v: u64) {
1008 self.device_id = ::std::option::Option::Some(v);
1009 }
1010
1011 pub fn request(&self) -> &[u8] {
1014 match self.request.as_ref() {
1015 Some(v) => v,
1016 None => &[],
1017 }
1018 }
1019
1020 pub fn clear_request(&mut self) {
1021 self.request = ::std::option::Option::None;
1022 }
1023
1024 pub fn has_request(&self) -> bool {
1025 self.request.is_some()
1026 }
1027
1028 pub fn set_request(&mut self, v: ::std::vec::Vec<u8>) {
1030 self.request = ::std::option::Option::Some(v);
1031 }
1032
1033 pub fn mut_request(&mut self) -> &mut ::std::vec::Vec<u8> {
1036 if self.request.is_none() {
1037 self.request = ::std::option::Option::Some(::std::vec::Vec::new());
1038 }
1039 self.request.as_mut().unwrap()
1040 }
1041
1042 pub fn take_request(&mut self) -> ::std::vec::Vec<u8> {
1044 self.request.take().unwrap_or_else(|| ::std::vec::Vec::new())
1045 }
1046}
1047
1048impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_GetPairingInfo_Response {
1049 const NAME: &'static str = "CRemoteClient_GetPairingInfo_Response";
1050
1051 fn is_initialized(&self) -> bool {
1052 true
1053 }
1054
1055 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1056 while let Some(tag) = is.read_raw_tag_or_eof()? {
1057 match tag {
1058 9 => {
1059 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
1060 },
1061 17 => {
1062 self.device_id = ::std::option::Option::Some(is.read_fixed64()?);
1063 },
1064 26 => {
1065 self.request = ::std::option::Option::Some(is.read_bytes()?);
1066 },
1067 tag => {
1068 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1069 },
1070 };
1071 }
1072 ::std::result::Result::Ok(())
1073 }
1074
1075 #[allow(unused_variables)]
1077 fn compute_size(&self) -> u64 {
1078 let mut my_size = 0;
1079 if let Some(v) = self.session_id {
1080 my_size += 1 + 8;
1081 }
1082 if let Some(v) = self.device_id {
1083 my_size += 1 + 8;
1084 }
1085 if let Some(v) = self.request.as_ref() {
1086 my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
1087 }
1088 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1089 self.special_fields.cached_size().set(my_size as u32);
1090 my_size
1091 }
1092
1093 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1094 if let Some(v) = self.session_id {
1095 os.write_fixed64(1, v)?;
1096 }
1097 if let Some(v) = self.device_id {
1098 os.write_fixed64(2, v)?;
1099 }
1100 if let Some(v) = self.request.as_ref() {
1101 os.write_bytes(3, v)?;
1102 }
1103 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1104 ::std::result::Result::Ok(())
1105 }
1106
1107 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1108 &self.special_fields
1109 }
1110
1111 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1112 &mut self.special_fields
1113 }
1114
1115 fn new() -> CRemoteClient_GetPairingInfo_Response {
1116 CRemoteClient_GetPairingInfo_Response::new()
1117 }
1118
1119 fn clear(&mut self) {
1120 self.session_id = ::std::option::Option::None;
1121 self.device_id = ::std::option::Option::None;
1122 self.request = ::std::option::Option::None;
1123 self.special_fields.clear();
1124 }
1125
1126 fn default_instance() -> &'static CRemoteClient_GetPairingInfo_Response {
1127 static instance: CRemoteClient_GetPairingInfo_Response = CRemoteClient_GetPairingInfo_Response {
1128 session_id: ::std::option::Option::None,
1129 device_id: ::std::option::Option::None,
1130 request: ::std::option::Option::None,
1131 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1132 };
1133 &instance
1134 }
1135}
1136
1137#[derive(PartialEq,Clone,Default,Debug)]
1139pub struct CRemoteClient_CancelPairing_Request {
1140 pub session_id: ::std::option::Option<u64>,
1143 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1146}
1147
1148impl<'a> ::std::default::Default for &'a CRemoteClient_CancelPairing_Request {
1149 fn default() -> &'a CRemoteClient_CancelPairing_Request {
1150 <CRemoteClient_CancelPairing_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1151 }
1152}
1153
1154impl CRemoteClient_CancelPairing_Request {
1155 pub fn new() -> CRemoteClient_CancelPairing_Request {
1156 ::std::default::Default::default()
1157 }
1158
1159 pub fn session_id(&self) -> u64 {
1162 self.session_id.unwrap_or(0)
1163 }
1164
1165 pub fn clear_session_id(&mut self) {
1166 self.session_id = ::std::option::Option::None;
1167 }
1168
1169 pub fn has_session_id(&self) -> bool {
1170 self.session_id.is_some()
1171 }
1172
1173 pub fn set_session_id(&mut self, v: u64) {
1175 self.session_id = ::std::option::Option::Some(v);
1176 }
1177}
1178
1179impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_CancelPairing_Request {
1180 const NAME: &'static str = "CRemoteClient_CancelPairing_Request";
1181
1182 fn is_initialized(&self) -> bool {
1183 true
1184 }
1185
1186 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1187 while let Some(tag) = is.read_raw_tag_or_eof()? {
1188 match tag {
1189 9 => {
1190 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
1191 },
1192 tag => {
1193 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1194 },
1195 };
1196 }
1197 ::std::result::Result::Ok(())
1198 }
1199
1200 #[allow(unused_variables)]
1202 fn compute_size(&self) -> u64 {
1203 let mut my_size = 0;
1204 if let Some(v) = self.session_id {
1205 my_size += 1 + 8;
1206 }
1207 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1208 self.special_fields.cached_size().set(my_size as u32);
1209 my_size
1210 }
1211
1212 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1213 if let Some(v) = self.session_id {
1214 os.write_fixed64(1, v)?;
1215 }
1216 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1217 ::std::result::Result::Ok(())
1218 }
1219
1220 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1221 &self.special_fields
1222 }
1223
1224 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1225 &mut self.special_fields
1226 }
1227
1228 fn new() -> CRemoteClient_CancelPairing_Request {
1229 CRemoteClient_CancelPairing_Request::new()
1230 }
1231
1232 fn clear(&mut self) {
1233 self.session_id = ::std::option::Option::None;
1234 self.special_fields.clear();
1235 }
1236
1237 fn default_instance() -> &'static CRemoteClient_CancelPairing_Request {
1238 static instance: CRemoteClient_CancelPairing_Request = CRemoteClient_CancelPairing_Request {
1239 session_id: ::std::option::Option::None,
1240 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1241 };
1242 &instance
1243 }
1244}
1245
1246#[derive(PartialEq,Clone,Default,Debug)]
1248pub struct CRemoteClient_CancelPairing_Response {
1249 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1252}
1253
1254impl<'a> ::std::default::Default for &'a CRemoteClient_CancelPairing_Response {
1255 fn default() -> &'a CRemoteClient_CancelPairing_Response {
1256 <CRemoteClient_CancelPairing_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1257 }
1258}
1259
1260impl CRemoteClient_CancelPairing_Response {
1261 pub fn new() -> CRemoteClient_CancelPairing_Response {
1262 ::std::default::Default::default()
1263 }
1264}
1265
1266impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_CancelPairing_Response {
1267 const NAME: &'static str = "CRemoteClient_CancelPairing_Response";
1268
1269 fn is_initialized(&self) -> bool {
1270 true
1271 }
1272
1273 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1274 while let Some(tag) = is.read_raw_tag_or_eof()? {
1275 match tag {
1276 tag => {
1277 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1278 },
1279 };
1280 }
1281 ::std::result::Result::Ok(())
1282 }
1283
1284 #[allow(unused_variables)]
1286 fn compute_size(&self) -> u64 {
1287 let mut my_size = 0;
1288 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1289 self.special_fields.cached_size().set(my_size as u32);
1290 my_size
1291 }
1292
1293 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1294 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1295 ::std::result::Result::Ok(())
1296 }
1297
1298 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1299 &self.special_fields
1300 }
1301
1302 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1303 &mut self.special_fields
1304 }
1305
1306 fn new() -> CRemoteClient_CancelPairing_Response {
1307 CRemoteClient_CancelPairing_Response::new()
1308 }
1309
1310 fn clear(&mut self) {
1311 self.special_fields.clear();
1312 }
1313
1314 fn default_instance() -> &'static CRemoteClient_CancelPairing_Response {
1315 static instance: CRemoteClient_CancelPairing_Response = CRemoteClient_CancelPairing_Response {
1316 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1317 };
1318 &instance
1319 }
1320}
1321
1322#[derive(PartialEq,Clone,Default,Debug)]
1324pub struct CRemoteClient_RegisterStatusUpdate_Notification {
1325 pub session_id: ::std::option::Option<u64>,
1328 pub steamid: ::std::option::Option<u64>,
1330 pub device_id: ::std::option::Option<u64>,
1332 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1335}
1336
1337impl<'a> ::std::default::Default for &'a CRemoteClient_RegisterStatusUpdate_Notification {
1338 fn default() -> &'a CRemoteClient_RegisterStatusUpdate_Notification {
1339 <CRemoteClient_RegisterStatusUpdate_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1340 }
1341}
1342
1343impl CRemoteClient_RegisterStatusUpdate_Notification {
1344 pub fn new() -> CRemoteClient_RegisterStatusUpdate_Notification {
1345 ::std::default::Default::default()
1346 }
1347
1348 pub fn session_id(&self) -> u64 {
1351 self.session_id.unwrap_or(0)
1352 }
1353
1354 pub fn clear_session_id(&mut self) {
1355 self.session_id = ::std::option::Option::None;
1356 }
1357
1358 pub fn has_session_id(&self) -> bool {
1359 self.session_id.is_some()
1360 }
1361
1362 pub fn set_session_id(&mut self, v: u64) {
1364 self.session_id = ::std::option::Option::Some(v);
1365 }
1366
1367 pub fn steamid(&self) -> u64 {
1370 self.steamid.unwrap_or(0)
1371 }
1372
1373 pub fn clear_steamid(&mut self) {
1374 self.steamid = ::std::option::Option::None;
1375 }
1376
1377 pub fn has_steamid(&self) -> bool {
1378 self.steamid.is_some()
1379 }
1380
1381 pub fn set_steamid(&mut self, v: u64) {
1383 self.steamid = ::std::option::Option::Some(v);
1384 }
1385
1386 pub fn device_id(&self) -> u64 {
1389 self.device_id.unwrap_or(0)
1390 }
1391
1392 pub fn clear_device_id(&mut self) {
1393 self.device_id = ::std::option::Option::None;
1394 }
1395
1396 pub fn has_device_id(&self) -> bool {
1397 self.device_id.is_some()
1398 }
1399
1400 pub fn set_device_id(&mut self, v: u64) {
1402 self.device_id = ::std::option::Option::Some(v);
1403 }
1404}
1405
1406impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_RegisterStatusUpdate_Notification {
1407 const NAME: &'static str = "CRemoteClient_RegisterStatusUpdate_Notification";
1408
1409 fn is_initialized(&self) -> bool {
1410 true
1411 }
1412
1413 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1414 while let Some(tag) = is.read_raw_tag_or_eof()? {
1415 match tag {
1416 9 => {
1417 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
1418 },
1419 17 => {
1420 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
1421 },
1422 25 => {
1423 self.device_id = ::std::option::Option::Some(is.read_fixed64()?);
1424 },
1425 tag => {
1426 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1427 },
1428 };
1429 }
1430 ::std::result::Result::Ok(())
1431 }
1432
1433 #[allow(unused_variables)]
1435 fn compute_size(&self) -> u64 {
1436 let mut my_size = 0;
1437 if let Some(v) = self.session_id {
1438 my_size += 1 + 8;
1439 }
1440 if let Some(v) = self.steamid {
1441 my_size += 1 + 8;
1442 }
1443 if let Some(v) = self.device_id {
1444 my_size += 1 + 8;
1445 }
1446 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1447 self.special_fields.cached_size().set(my_size as u32);
1448 my_size
1449 }
1450
1451 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1452 if let Some(v) = self.session_id {
1453 os.write_fixed64(1, v)?;
1454 }
1455 if let Some(v) = self.steamid {
1456 os.write_fixed64(2, v)?;
1457 }
1458 if let Some(v) = self.device_id {
1459 os.write_fixed64(3, v)?;
1460 }
1461 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1462 ::std::result::Result::Ok(())
1463 }
1464
1465 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1466 &self.special_fields
1467 }
1468
1469 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1470 &mut self.special_fields
1471 }
1472
1473 fn new() -> CRemoteClient_RegisterStatusUpdate_Notification {
1474 CRemoteClient_RegisterStatusUpdate_Notification::new()
1475 }
1476
1477 fn clear(&mut self) {
1478 self.session_id = ::std::option::Option::None;
1479 self.steamid = ::std::option::Option::None;
1480 self.device_id = ::std::option::Option::None;
1481 self.special_fields.clear();
1482 }
1483
1484 fn default_instance() -> &'static CRemoteClient_RegisterStatusUpdate_Notification {
1485 static instance: CRemoteClient_RegisterStatusUpdate_Notification = CRemoteClient_RegisterStatusUpdate_Notification {
1486 session_id: ::std::option::Option::None,
1487 steamid: ::std::option::Option::None,
1488 device_id: ::std::option::Option::None,
1489 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1490 };
1491 &instance
1492 }
1493}
1494
1495#[derive(PartialEq,Clone,Default,Debug)]
1497pub struct CRemoteClient_UnregisterStatusUpdate_Notification {
1498 pub session_id: ::std::option::Option<u64>,
1501 pub steamid: ::std::option::Option<u64>,
1503 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1506}
1507
1508impl<'a> ::std::default::Default for &'a CRemoteClient_UnregisterStatusUpdate_Notification {
1509 fn default() -> &'a CRemoteClient_UnregisterStatusUpdate_Notification {
1510 <CRemoteClient_UnregisterStatusUpdate_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1511 }
1512}
1513
1514impl CRemoteClient_UnregisterStatusUpdate_Notification {
1515 pub fn new() -> CRemoteClient_UnregisterStatusUpdate_Notification {
1516 ::std::default::Default::default()
1517 }
1518
1519 pub fn session_id(&self) -> u64 {
1522 self.session_id.unwrap_or(0)
1523 }
1524
1525 pub fn clear_session_id(&mut self) {
1526 self.session_id = ::std::option::Option::None;
1527 }
1528
1529 pub fn has_session_id(&self) -> bool {
1530 self.session_id.is_some()
1531 }
1532
1533 pub fn set_session_id(&mut self, v: u64) {
1535 self.session_id = ::std::option::Option::Some(v);
1536 }
1537
1538 pub fn steamid(&self) -> u64 {
1541 self.steamid.unwrap_or(0)
1542 }
1543
1544 pub fn clear_steamid(&mut self) {
1545 self.steamid = ::std::option::Option::None;
1546 }
1547
1548 pub fn has_steamid(&self) -> bool {
1549 self.steamid.is_some()
1550 }
1551
1552 pub fn set_steamid(&mut self, v: u64) {
1554 self.steamid = ::std::option::Option::Some(v);
1555 }
1556}
1557
1558impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_UnregisterStatusUpdate_Notification {
1559 const NAME: &'static str = "CRemoteClient_UnregisterStatusUpdate_Notification";
1560
1561 fn is_initialized(&self) -> bool {
1562 true
1563 }
1564
1565 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1566 while let Some(tag) = is.read_raw_tag_or_eof()? {
1567 match tag {
1568 9 => {
1569 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
1570 },
1571 17 => {
1572 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
1573 },
1574 tag => {
1575 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1576 },
1577 };
1578 }
1579 ::std::result::Result::Ok(())
1580 }
1581
1582 #[allow(unused_variables)]
1584 fn compute_size(&self) -> u64 {
1585 let mut my_size = 0;
1586 if let Some(v) = self.session_id {
1587 my_size += 1 + 8;
1588 }
1589 if let Some(v) = self.steamid {
1590 my_size += 1 + 8;
1591 }
1592 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1593 self.special_fields.cached_size().set(my_size as u32);
1594 my_size
1595 }
1596
1597 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1598 if let Some(v) = self.session_id {
1599 os.write_fixed64(1, v)?;
1600 }
1601 if let Some(v) = self.steamid {
1602 os.write_fixed64(2, v)?;
1603 }
1604 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1605 ::std::result::Result::Ok(())
1606 }
1607
1608 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1609 &self.special_fields
1610 }
1611
1612 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1613 &mut self.special_fields
1614 }
1615
1616 fn new() -> CRemoteClient_UnregisterStatusUpdate_Notification {
1617 CRemoteClient_UnregisterStatusUpdate_Notification::new()
1618 }
1619
1620 fn clear(&mut self) {
1621 self.session_id = ::std::option::Option::None;
1622 self.steamid = ::std::option::Option::None;
1623 self.special_fields.clear();
1624 }
1625
1626 fn default_instance() -> &'static CRemoteClient_UnregisterStatusUpdate_Notification {
1627 static instance: CRemoteClient_UnregisterStatusUpdate_Notification = CRemoteClient_UnregisterStatusUpdate_Notification {
1628 session_id: ::std::option::Option::None,
1629 steamid: ::std::option::Option::None,
1630 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1631 };
1632 &instance
1633 }
1634}
1635
1636#[derive(PartialEq,Clone,Default,Debug)]
1638pub struct CRemoteClient_DeviceDetails {
1639 pub device_friendly_name: ::std::option::Option<::std::string::String>,
1642 pub os_type: ::std::option::Option<i32>,
1644 pub gaming_device_type: ::std::option::Option<u32>,
1646 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1649}
1650
1651impl<'a> ::std::default::Default for &'a CRemoteClient_DeviceDetails {
1652 fn default() -> &'a CRemoteClient_DeviceDetails {
1653 <CRemoteClient_DeviceDetails as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1654 }
1655}
1656
1657impl CRemoteClient_DeviceDetails {
1658 pub fn new() -> CRemoteClient_DeviceDetails {
1659 ::std::default::Default::default()
1660 }
1661
1662 pub fn device_friendly_name(&self) -> &str {
1665 match self.device_friendly_name.as_ref() {
1666 Some(v) => v,
1667 None => "",
1668 }
1669 }
1670
1671 pub fn clear_device_friendly_name(&mut self) {
1672 self.device_friendly_name = ::std::option::Option::None;
1673 }
1674
1675 pub fn has_device_friendly_name(&self) -> bool {
1676 self.device_friendly_name.is_some()
1677 }
1678
1679 pub fn set_device_friendly_name(&mut self, v: ::std::string::String) {
1681 self.device_friendly_name = ::std::option::Option::Some(v);
1682 }
1683
1684 pub fn mut_device_friendly_name(&mut self) -> &mut ::std::string::String {
1687 if self.device_friendly_name.is_none() {
1688 self.device_friendly_name = ::std::option::Option::Some(::std::string::String::new());
1689 }
1690 self.device_friendly_name.as_mut().unwrap()
1691 }
1692
1693 pub fn take_device_friendly_name(&mut self) -> ::std::string::String {
1695 self.device_friendly_name.take().unwrap_or_else(|| ::std::string::String::new())
1696 }
1697
1698 pub fn os_type(&self) -> i32 {
1701 self.os_type.unwrap_or(0)
1702 }
1703
1704 pub fn clear_os_type(&mut self) {
1705 self.os_type = ::std::option::Option::None;
1706 }
1707
1708 pub fn has_os_type(&self) -> bool {
1709 self.os_type.is_some()
1710 }
1711
1712 pub fn set_os_type(&mut self, v: i32) {
1714 self.os_type = ::std::option::Option::Some(v);
1715 }
1716
1717 pub fn gaming_device_type(&self) -> u32 {
1720 self.gaming_device_type.unwrap_or(0)
1721 }
1722
1723 pub fn clear_gaming_device_type(&mut self) {
1724 self.gaming_device_type = ::std::option::Option::None;
1725 }
1726
1727 pub fn has_gaming_device_type(&self) -> bool {
1728 self.gaming_device_type.is_some()
1729 }
1730
1731 pub fn set_gaming_device_type(&mut self, v: u32) {
1733 self.gaming_device_type = ::std::option::Option::Some(v);
1734 }
1735}
1736
1737impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_DeviceDetails {
1738 const NAME: &'static str = "CRemoteClient_DeviceDetails";
1739
1740 fn is_initialized(&self) -> bool {
1741 true
1742 }
1743
1744 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1745 while let Some(tag) = is.read_raw_tag_or_eof()? {
1746 match tag {
1747 10 => {
1748 self.device_friendly_name = ::std::option::Option::Some(is.read_string()?);
1749 },
1750 16 => {
1751 self.os_type = ::std::option::Option::Some(is.read_int32()?);
1752 },
1753 24 => {
1754 self.gaming_device_type = ::std::option::Option::Some(is.read_uint32()?);
1755 },
1756 tag => {
1757 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1758 },
1759 };
1760 }
1761 ::std::result::Result::Ok(())
1762 }
1763
1764 #[allow(unused_variables)]
1766 fn compute_size(&self) -> u64 {
1767 let mut my_size = 0;
1768 if let Some(v) = self.device_friendly_name.as_ref() {
1769 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
1770 }
1771 if let Some(v) = self.os_type {
1772 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(2, v);
1773 }
1774 if let Some(v) = self.gaming_device_type {
1775 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
1776 }
1777 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1778 self.special_fields.cached_size().set(my_size as u32);
1779 my_size
1780 }
1781
1782 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1783 if let Some(v) = self.device_friendly_name.as_ref() {
1784 os.write_string(1, v)?;
1785 }
1786 if let Some(v) = self.os_type {
1787 os.write_int32(2, v)?;
1788 }
1789 if let Some(v) = self.gaming_device_type {
1790 os.write_uint32(3, v)?;
1791 }
1792 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1793 ::std::result::Result::Ok(())
1794 }
1795
1796 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1797 &self.special_fields
1798 }
1799
1800 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1801 &mut self.special_fields
1802 }
1803
1804 fn new() -> CRemoteClient_DeviceDetails {
1805 CRemoteClient_DeviceDetails::new()
1806 }
1807
1808 fn clear(&mut self) {
1809 self.device_friendly_name = ::std::option::Option::None;
1810 self.os_type = ::std::option::Option::None;
1811 self.gaming_device_type = ::std::option::Option::None;
1812 self.special_fields.clear();
1813 }
1814
1815 fn default_instance() -> &'static CRemoteClient_DeviceDetails {
1816 static instance: CRemoteClient_DeviceDetails = CRemoteClient_DeviceDetails {
1817 device_friendly_name: ::std::option::Option::None,
1818 os_type: ::std::option::Option::None,
1819 gaming_device_type: ::std::option::Option::None,
1820 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1821 };
1822 &instance
1823 }
1824}
1825
1826#[derive(PartialEq,Clone,Default,Debug)]
1828pub struct CRemoteClient_Online_Notification {
1829 pub steamid: ::std::option::Option<u64>,
1832 pub remote_client_id: ::std::option::Option<u64>,
1834 pub device_details: ::steam_vent_proto_common::protobuf::MessageField<CRemoteClient_DeviceDetails>,
1836 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1839}
1840
1841impl<'a> ::std::default::Default for &'a CRemoteClient_Online_Notification {
1842 fn default() -> &'a CRemoteClient_Online_Notification {
1843 <CRemoteClient_Online_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1844 }
1845}
1846
1847impl CRemoteClient_Online_Notification {
1848 pub fn new() -> CRemoteClient_Online_Notification {
1849 ::std::default::Default::default()
1850 }
1851
1852 pub fn steamid(&self) -> u64 {
1855 self.steamid.unwrap_or(0)
1856 }
1857
1858 pub fn clear_steamid(&mut self) {
1859 self.steamid = ::std::option::Option::None;
1860 }
1861
1862 pub fn has_steamid(&self) -> bool {
1863 self.steamid.is_some()
1864 }
1865
1866 pub fn set_steamid(&mut self, v: u64) {
1868 self.steamid = ::std::option::Option::Some(v);
1869 }
1870
1871 pub fn remote_client_id(&self) -> u64 {
1874 self.remote_client_id.unwrap_or(0)
1875 }
1876
1877 pub fn clear_remote_client_id(&mut self) {
1878 self.remote_client_id = ::std::option::Option::None;
1879 }
1880
1881 pub fn has_remote_client_id(&self) -> bool {
1882 self.remote_client_id.is_some()
1883 }
1884
1885 pub fn set_remote_client_id(&mut self, v: u64) {
1887 self.remote_client_id = ::std::option::Option::Some(v);
1888 }
1889}
1890
1891impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_Online_Notification {
1892 const NAME: &'static str = "CRemoteClient_Online_Notification";
1893
1894 fn is_initialized(&self) -> bool {
1895 true
1896 }
1897
1898 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1899 while let Some(tag) = is.read_raw_tag_or_eof()? {
1900 match tag {
1901 9 => {
1902 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
1903 },
1904 17 => {
1905 self.remote_client_id = ::std::option::Option::Some(is.read_fixed64()?);
1906 },
1907 26 => {
1908 ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.device_details)?;
1909 },
1910 tag => {
1911 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1912 },
1913 };
1914 }
1915 ::std::result::Result::Ok(())
1916 }
1917
1918 #[allow(unused_variables)]
1920 fn compute_size(&self) -> u64 {
1921 let mut my_size = 0;
1922 if let Some(v) = self.steamid {
1923 my_size += 1 + 8;
1924 }
1925 if let Some(v) = self.remote_client_id {
1926 my_size += 1 + 8;
1927 }
1928 if let Some(v) = self.device_details.as_ref() {
1929 let len = v.compute_size();
1930 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
1931 }
1932 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1933 self.special_fields.cached_size().set(my_size as u32);
1934 my_size
1935 }
1936
1937 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
1938 if let Some(v) = self.steamid {
1939 os.write_fixed64(1, v)?;
1940 }
1941 if let Some(v) = self.remote_client_id {
1942 os.write_fixed64(2, v)?;
1943 }
1944 if let Some(v) = self.device_details.as_ref() {
1945 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
1946 }
1947 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1948 ::std::result::Result::Ok(())
1949 }
1950
1951 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
1952 &self.special_fields
1953 }
1954
1955 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
1956 &mut self.special_fields
1957 }
1958
1959 fn new() -> CRemoteClient_Online_Notification {
1960 CRemoteClient_Online_Notification::new()
1961 }
1962
1963 fn clear(&mut self) {
1964 self.steamid = ::std::option::Option::None;
1965 self.remote_client_id = ::std::option::Option::None;
1966 self.device_details.clear();
1967 self.special_fields.clear();
1968 }
1969
1970 fn default_instance() -> &'static CRemoteClient_Online_Notification {
1971 static instance: CRemoteClient_Online_Notification = CRemoteClient_Online_Notification {
1972 steamid: ::std::option::Option::None,
1973 remote_client_id: ::std::option::Option::None,
1974 device_details: ::steam_vent_proto_common::protobuf::MessageField::none(),
1975 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
1976 };
1977 &instance
1978 }
1979}
1980
1981#[derive(PartialEq,Clone,Default,Debug)]
1983pub struct CRemoteClient_GetRecentClients_Request {
1984 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
1987}
1988
1989impl<'a> ::std::default::Default for &'a CRemoteClient_GetRecentClients_Request {
1990 fn default() -> &'a CRemoteClient_GetRecentClients_Request {
1991 <CRemoteClient_GetRecentClients_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
1992 }
1993}
1994
1995impl CRemoteClient_GetRecentClients_Request {
1996 pub fn new() -> CRemoteClient_GetRecentClients_Request {
1997 ::std::default::Default::default()
1998 }
1999}
2000
2001impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_GetRecentClients_Request {
2002 const NAME: &'static str = "CRemoteClient_GetRecentClients_Request";
2003
2004 fn is_initialized(&self) -> bool {
2005 true
2006 }
2007
2008 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2009 while let Some(tag) = is.read_raw_tag_or_eof()? {
2010 match tag {
2011 tag => {
2012 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2013 },
2014 };
2015 }
2016 ::std::result::Result::Ok(())
2017 }
2018
2019 #[allow(unused_variables)]
2021 fn compute_size(&self) -> u64 {
2022 let mut my_size = 0;
2023 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2024 self.special_fields.cached_size().set(my_size as u32);
2025 my_size
2026 }
2027
2028 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2029 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2030 ::std::result::Result::Ok(())
2031 }
2032
2033 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2034 &self.special_fields
2035 }
2036
2037 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2038 &mut self.special_fields
2039 }
2040
2041 fn new() -> CRemoteClient_GetRecentClients_Request {
2042 CRemoteClient_GetRecentClients_Request::new()
2043 }
2044
2045 fn clear(&mut self) {
2046 self.special_fields.clear();
2047 }
2048
2049 fn default_instance() -> &'static CRemoteClient_GetRecentClients_Request {
2050 static instance: CRemoteClient_GetRecentClients_Request = CRemoteClient_GetRecentClients_Request {
2051 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2052 };
2053 &instance
2054 }
2055}
2056
2057#[derive(PartialEq,Clone,Default,Debug)]
2059pub struct CRemoteClient_ClientLogin {
2060 pub remote_client_id: ::std::option::Option<u64>,
2063 pub token_id: ::std::option::Option<u64>,
2065 pub device_details: ::steam_vent_proto_common::protobuf::MessageField<CRemoteClient_DeviceDetails>,
2067 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2070}
2071
2072impl<'a> ::std::default::Default for &'a CRemoteClient_ClientLogin {
2073 fn default() -> &'a CRemoteClient_ClientLogin {
2074 <CRemoteClient_ClientLogin as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2075 }
2076}
2077
2078impl CRemoteClient_ClientLogin {
2079 pub fn new() -> CRemoteClient_ClientLogin {
2080 ::std::default::Default::default()
2081 }
2082
2083 pub fn remote_client_id(&self) -> u64 {
2086 self.remote_client_id.unwrap_or(0)
2087 }
2088
2089 pub fn clear_remote_client_id(&mut self) {
2090 self.remote_client_id = ::std::option::Option::None;
2091 }
2092
2093 pub fn has_remote_client_id(&self) -> bool {
2094 self.remote_client_id.is_some()
2095 }
2096
2097 pub fn set_remote_client_id(&mut self, v: u64) {
2099 self.remote_client_id = ::std::option::Option::Some(v);
2100 }
2101
2102 pub fn token_id(&self) -> u64 {
2105 self.token_id.unwrap_or(0)
2106 }
2107
2108 pub fn clear_token_id(&mut self) {
2109 self.token_id = ::std::option::Option::None;
2110 }
2111
2112 pub fn has_token_id(&self) -> bool {
2113 self.token_id.is_some()
2114 }
2115
2116 pub fn set_token_id(&mut self, v: u64) {
2118 self.token_id = ::std::option::Option::Some(v);
2119 }
2120}
2121
2122impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_ClientLogin {
2123 const NAME: &'static str = "CRemoteClient_ClientLogin";
2124
2125 fn is_initialized(&self) -> bool {
2126 true
2127 }
2128
2129 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2130 while let Some(tag) = is.read_raw_tag_or_eof()? {
2131 match tag {
2132 9 => {
2133 self.remote_client_id = ::std::option::Option::Some(is.read_fixed64()?);
2134 },
2135 17 => {
2136 self.token_id = ::std::option::Option::Some(is.read_fixed64()?);
2137 },
2138 26 => {
2139 ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.device_details)?;
2140 },
2141 tag => {
2142 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2143 },
2144 };
2145 }
2146 ::std::result::Result::Ok(())
2147 }
2148
2149 #[allow(unused_variables)]
2151 fn compute_size(&self) -> u64 {
2152 let mut my_size = 0;
2153 if let Some(v) = self.remote_client_id {
2154 my_size += 1 + 8;
2155 }
2156 if let Some(v) = self.token_id {
2157 my_size += 1 + 8;
2158 }
2159 if let Some(v) = self.device_details.as_ref() {
2160 let len = v.compute_size();
2161 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
2162 }
2163 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2164 self.special_fields.cached_size().set(my_size as u32);
2165 my_size
2166 }
2167
2168 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2169 if let Some(v) = self.remote_client_id {
2170 os.write_fixed64(1, v)?;
2171 }
2172 if let Some(v) = self.token_id {
2173 os.write_fixed64(2, v)?;
2174 }
2175 if let Some(v) = self.device_details.as_ref() {
2176 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
2177 }
2178 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2179 ::std::result::Result::Ok(())
2180 }
2181
2182 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2183 &self.special_fields
2184 }
2185
2186 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2187 &mut self.special_fields
2188 }
2189
2190 fn new() -> CRemoteClient_ClientLogin {
2191 CRemoteClient_ClientLogin::new()
2192 }
2193
2194 fn clear(&mut self) {
2195 self.remote_client_id = ::std::option::Option::None;
2196 self.token_id = ::std::option::Option::None;
2197 self.device_details.clear();
2198 self.special_fields.clear();
2199 }
2200
2201 fn default_instance() -> &'static CRemoteClient_ClientLogin {
2202 static instance: CRemoteClient_ClientLogin = CRemoteClient_ClientLogin {
2203 remote_client_id: ::std::option::Option::None,
2204 token_id: ::std::option::Option::None,
2205 device_details: ::steam_vent_proto_common::protobuf::MessageField::none(),
2206 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2207 };
2208 &instance
2209 }
2210}
2211
2212#[derive(PartialEq,Clone,Default,Debug)]
2214pub struct CRemoteClient_ClientDetails {
2215 pub remote_client_id: ::std::option::Option<u64>,
2218 pub device_details: ::steam_vent_proto_common::protobuf::MessageField<CRemoteClient_DeviceDetails>,
2220 pub last_seen: ::std::option::Option<u64>,
2222 pub city: ::std::option::Option<::std::string::String>,
2224 pub state: ::std::option::Option<::std::string::String>,
2226 pub country: ::std::option::Option<::std::string::String>,
2228 pub is_online: ::std::option::Option<bool>,
2230 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2233}
2234
2235impl<'a> ::std::default::Default for &'a CRemoteClient_ClientDetails {
2236 fn default() -> &'a CRemoteClient_ClientDetails {
2237 <CRemoteClient_ClientDetails as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2238 }
2239}
2240
2241impl CRemoteClient_ClientDetails {
2242 pub fn new() -> CRemoteClient_ClientDetails {
2243 ::std::default::Default::default()
2244 }
2245
2246 pub fn remote_client_id(&self) -> u64 {
2249 self.remote_client_id.unwrap_or(0)
2250 }
2251
2252 pub fn clear_remote_client_id(&mut self) {
2253 self.remote_client_id = ::std::option::Option::None;
2254 }
2255
2256 pub fn has_remote_client_id(&self) -> bool {
2257 self.remote_client_id.is_some()
2258 }
2259
2260 pub fn set_remote_client_id(&mut self, v: u64) {
2262 self.remote_client_id = ::std::option::Option::Some(v);
2263 }
2264
2265 pub fn last_seen(&self) -> u64 {
2268 self.last_seen.unwrap_or(0)
2269 }
2270
2271 pub fn clear_last_seen(&mut self) {
2272 self.last_seen = ::std::option::Option::None;
2273 }
2274
2275 pub fn has_last_seen(&self) -> bool {
2276 self.last_seen.is_some()
2277 }
2278
2279 pub fn set_last_seen(&mut self, v: u64) {
2281 self.last_seen = ::std::option::Option::Some(v);
2282 }
2283
2284 pub fn city(&self) -> &str {
2287 match self.city.as_ref() {
2288 Some(v) => v,
2289 None => "",
2290 }
2291 }
2292
2293 pub fn clear_city(&mut self) {
2294 self.city = ::std::option::Option::None;
2295 }
2296
2297 pub fn has_city(&self) -> bool {
2298 self.city.is_some()
2299 }
2300
2301 pub fn set_city(&mut self, v: ::std::string::String) {
2303 self.city = ::std::option::Option::Some(v);
2304 }
2305
2306 pub fn mut_city(&mut self) -> &mut ::std::string::String {
2309 if self.city.is_none() {
2310 self.city = ::std::option::Option::Some(::std::string::String::new());
2311 }
2312 self.city.as_mut().unwrap()
2313 }
2314
2315 pub fn take_city(&mut self) -> ::std::string::String {
2317 self.city.take().unwrap_or_else(|| ::std::string::String::new())
2318 }
2319
2320 pub fn state(&self) -> &str {
2323 match self.state.as_ref() {
2324 Some(v) => v,
2325 None => "",
2326 }
2327 }
2328
2329 pub fn clear_state(&mut self) {
2330 self.state = ::std::option::Option::None;
2331 }
2332
2333 pub fn has_state(&self) -> bool {
2334 self.state.is_some()
2335 }
2336
2337 pub fn set_state(&mut self, v: ::std::string::String) {
2339 self.state = ::std::option::Option::Some(v);
2340 }
2341
2342 pub fn mut_state(&mut self) -> &mut ::std::string::String {
2345 if self.state.is_none() {
2346 self.state = ::std::option::Option::Some(::std::string::String::new());
2347 }
2348 self.state.as_mut().unwrap()
2349 }
2350
2351 pub fn take_state(&mut self) -> ::std::string::String {
2353 self.state.take().unwrap_or_else(|| ::std::string::String::new())
2354 }
2355
2356 pub fn country(&self) -> &str {
2359 match self.country.as_ref() {
2360 Some(v) => v,
2361 None => "",
2362 }
2363 }
2364
2365 pub fn clear_country(&mut self) {
2366 self.country = ::std::option::Option::None;
2367 }
2368
2369 pub fn has_country(&self) -> bool {
2370 self.country.is_some()
2371 }
2372
2373 pub fn set_country(&mut self, v: ::std::string::String) {
2375 self.country = ::std::option::Option::Some(v);
2376 }
2377
2378 pub fn mut_country(&mut self) -> &mut ::std::string::String {
2381 if self.country.is_none() {
2382 self.country = ::std::option::Option::Some(::std::string::String::new());
2383 }
2384 self.country.as_mut().unwrap()
2385 }
2386
2387 pub fn take_country(&mut self) -> ::std::string::String {
2389 self.country.take().unwrap_or_else(|| ::std::string::String::new())
2390 }
2391
2392 pub fn is_online(&self) -> bool {
2395 self.is_online.unwrap_or(false)
2396 }
2397
2398 pub fn clear_is_online(&mut self) {
2399 self.is_online = ::std::option::Option::None;
2400 }
2401
2402 pub fn has_is_online(&self) -> bool {
2403 self.is_online.is_some()
2404 }
2405
2406 pub fn set_is_online(&mut self, v: bool) {
2408 self.is_online = ::std::option::Option::Some(v);
2409 }
2410}
2411
2412impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_ClientDetails {
2413 const NAME: &'static str = "CRemoteClient_ClientDetails";
2414
2415 fn is_initialized(&self) -> bool {
2416 true
2417 }
2418
2419 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2420 while let Some(tag) = is.read_raw_tag_or_eof()? {
2421 match tag {
2422 9 => {
2423 self.remote_client_id = ::std::option::Option::Some(is.read_fixed64()?);
2424 },
2425 18 => {
2426 ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.device_details)?;
2427 },
2428 32 => {
2429 self.last_seen = ::std::option::Option::Some(is.read_uint64()?);
2430 },
2431 42 => {
2432 self.city = ::std::option::Option::Some(is.read_string()?);
2433 },
2434 50 => {
2435 self.state = ::std::option::Option::Some(is.read_string()?);
2436 },
2437 58 => {
2438 self.country = ::std::option::Option::Some(is.read_string()?);
2439 },
2440 64 => {
2441 self.is_online = ::std::option::Option::Some(is.read_bool()?);
2442 },
2443 tag => {
2444 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2445 },
2446 };
2447 }
2448 ::std::result::Result::Ok(())
2449 }
2450
2451 #[allow(unused_variables)]
2453 fn compute_size(&self) -> u64 {
2454 let mut my_size = 0;
2455 if let Some(v) = self.remote_client_id {
2456 my_size += 1 + 8;
2457 }
2458 if let Some(v) = self.device_details.as_ref() {
2459 let len = v.compute_size();
2460 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
2461 }
2462 if let Some(v) = self.last_seen {
2463 my_size += ::steam_vent_proto_common::protobuf::rt::uint64_size(4, v);
2464 }
2465 if let Some(v) = self.city.as_ref() {
2466 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(5, &v);
2467 }
2468 if let Some(v) = self.state.as_ref() {
2469 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(6, &v);
2470 }
2471 if let Some(v) = self.country.as_ref() {
2472 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(7, &v);
2473 }
2474 if let Some(v) = self.is_online {
2475 my_size += 1 + 1;
2476 }
2477 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2478 self.special_fields.cached_size().set(my_size as u32);
2479 my_size
2480 }
2481
2482 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2483 if let Some(v) = self.remote_client_id {
2484 os.write_fixed64(1, v)?;
2485 }
2486 if let Some(v) = self.device_details.as_ref() {
2487 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
2488 }
2489 if let Some(v) = self.last_seen {
2490 os.write_uint64(4, v)?;
2491 }
2492 if let Some(v) = self.city.as_ref() {
2493 os.write_string(5, v)?;
2494 }
2495 if let Some(v) = self.state.as_ref() {
2496 os.write_string(6, v)?;
2497 }
2498 if let Some(v) = self.country.as_ref() {
2499 os.write_string(7, v)?;
2500 }
2501 if let Some(v) = self.is_online {
2502 os.write_bool(8, v)?;
2503 }
2504 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2505 ::std::result::Result::Ok(())
2506 }
2507
2508 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2509 &self.special_fields
2510 }
2511
2512 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2513 &mut self.special_fields
2514 }
2515
2516 fn new() -> CRemoteClient_ClientDetails {
2517 CRemoteClient_ClientDetails::new()
2518 }
2519
2520 fn clear(&mut self) {
2521 self.remote_client_id = ::std::option::Option::None;
2522 self.device_details.clear();
2523 self.last_seen = ::std::option::Option::None;
2524 self.city = ::std::option::Option::None;
2525 self.state = ::std::option::Option::None;
2526 self.country = ::std::option::Option::None;
2527 self.is_online = ::std::option::Option::None;
2528 self.special_fields.clear();
2529 }
2530
2531 fn default_instance() -> &'static CRemoteClient_ClientDetails {
2532 static instance: CRemoteClient_ClientDetails = CRemoteClient_ClientDetails {
2533 remote_client_id: ::std::option::Option::None,
2534 device_details: ::steam_vent_proto_common::protobuf::MessageField::none(),
2535 last_seen: ::std::option::Option::None,
2536 city: ::std::option::Option::None,
2537 state: ::std::option::Option::None,
2538 country: ::std::option::Option::None,
2539 is_online: ::std::option::Option::None,
2540 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2541 };
2542 &instance
2543 }
2544}
2545
2546#[derive(PartialEq,Clone,Default,Debug)]
2548pub struct CRemoteClient_GetRecentClients_Response {
2549 pub clients: ::std::vec::Vec<CRemoteClient_ClientDetails>,
2552 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2555}
2556
2557impl<'a> ::std::default::Default for &'a CRemoteClient_GetRecentClients_Response {
2558 fn default() -> &'a CRemoteClient_GetRecentClients_Response {
2559 <CRemoteClient_GetRecentClients_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2560 }
2561}
2562
2563impl CRemoteClient_GetRecentClients_Response {
2564 pub fn new() -> CRemoteClient_GetRecentClients_Response {
2565 ::std::default::Default::default()
2566 }
2567}
2568
2569impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_GetRecentClients_Response {
2570 const NAME: &'static str = "CRemoteClient_GetRecentClients_Response";
2571
2572 fn is_initialized(&self) -> bool {
2573 true
2574 }
2575
2576 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2577 while let Some(tag) = is.read_raw_tag_or_eof()? {
2578 match tag {
2579 10 => {
2580 self.clients.push(is.read_message()?);
2581 },
2582 tag => {
2583 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2584 },
2585 };
2586 }
2587 ::std::result::Result::Ok(())
2588 }
2589
2590 #[allow(unused_variables)]
2592 fn compute_size(&self) -> u64 {
2593 let mut my_size = 0;
2594 for value in &self.clients {
2595 let len = value.compute_size();
2596 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
2597 };
2598 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2599 self.special_fields.cached_size().set(my_size as u32);
2600 my_size
2601 }
2602
2603 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2604 for v in &self.clients {
2605 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
2606 };
2607 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2608 ::std::result::Result::Ok(())
2609 }
2610
2611 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2612 &self.special_fields
2613 }
2614
2615 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2616 &mut self.special_fields
2617 }
2618
2619 fn new() -> CRemoteClient_GetRecentClients_Response {
2620 CRemoteClient_GetRecentClients_Response::new()
2621 }
2622
2623 fn clear(&mut self) {
2624 self.clients.clear();
2625 self.special_fields.clear();
2626 }
2627
2628 fn default_instance() -> &'static CRemoteClient_GetRecentClients_Response {
2629 static instance: CRemoteClient_GetRecentClients_Response = CRemoteClient_GetRecentClients_Response {
2630 clients: ::std::vec::Vec::new(),
2631 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2632 };
2633 &instance
2634 }
2635}
2636
2637#[derive(PartialEq,Clone,Default,Debug)]
2639pub struct CRemoteClient_Task {
2640 pub type_: ::std::option::Option<::steam_vent_proto_common::protobuf::EnumOrUnknown<ECLientTaskListType>>,
2643 pub task_id: ::std::option::Option<u64>,
2645 pub url: ::std::option::Option<::std::string::String>,
2647 pub file_id: ::std::option::Option<i64>,
2649 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2652}
2653
2654impl<'a> ::std::default::Default for &'a CRemoteClient_Task {
2655 fn default() -> &'a CRemoteClient_Task {
2656 <CRemoteClient_Task as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2657 }
2658}
2659
2660impl CRemoteClient_Task {
2661 pub fn new() -> CRemoteClient_Task {
2662 ::std::default::Default::default()
2663 }
2664
2665 pub fn type_(&self) -> ECLientTaskListType {
2668 match self.type_ {
2669 Some(e) => e.enum_value_or(ECLientTaskListType::k_EClientTask_DownloadClip),
2670 None => ECLientTaskListType::k_EClientTask_DownloadClip,
2671 }
2672 }
2673
2674 pub fn clear_type_(&mut self) {
2675 self.type_ = ::std::option::Option::None;
2676 }
2677
2678 pub fn has_type(&self) -> bool {
2679 self.type_.is_some()
2680 }
2681
2682 pub fn set_type(&mut self, v: ECLientTaskListType) {
2684 self.type_ = ::std::option::Option::Some(::steam_vent_proto_common::protobuf::EnumOrUnknown::new(v));
2685 }
2686
2687 pub fn task_id(&self) -> u64 {
2690 self.task_id.unwrap_or(0)
2691 }
2692
2693 pub fn clear_task_id(&mut self) {
2694 self.task_id = ::std::option::Option::None;
2695 }
2696
2697 pub fn has_task_id(&self) -> bool {
2698 self.task_id.is_some()
2699 }
2700
2701 pub fn set_task_id(&mut self, v: u64) {
2703 self.task_id = ::std::option::Option::Some(v);
2704 }
2705
2706 pub fn url(&self) -> &str {
2709 match self.url.as_ref() {
2710 Some(v) => v,
2711 None => "",
2712 }
2713 }
2714
2715 pub fn clear_url(&mut self) {
2716 self.url = ::std::option::Option::None;
2717 }
2718
2719 pub fn has_url(&self) -> bool {
2720 self.url.is_some()
2721 }
2722
2723 pub fn set_url(&mut self, v: ::std::string::String) {
2725 self.url = ::std::option::Option::Some(v);
2726 }
2727
2728 pub fn mut_url(&mut self) -> &mut ::std::string::String {
2731 if self.url.is_none() {
2732 self.url = ::std::option::Option::Some(::std::string::String::new());
2733 }
2734 self.url.as_mut().unwrap()
2735 }
2736
2737 pub fn take_url(&mut self) -> ::std::string::String {
2739 self.url.take().unwrap_or_else(|| ::std::string::String::new())
2740 }
2741
2742 pub fn file_id(&self) -> i64 {
2745 self.file_id.unwrap_or(0)
2746 }
2747
2748 pub fn clear_file_id(&mut self) {
2749 self.file_id = ::std::option::Option::None;
2750 }
2751
2752 pub fn has_file_id(&self) -> bool {
2753 self.file_id.is_some()
2754 }
2755
2756 pub fn set_file_id(&mut self, v: i64) {
2758 self.file_id = ::std::option::Option::Some(v);
2759 }
2760}
2761
2762impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_Task {
2763 const NAME: &'static str = "CRemoteClient_Task";
2764
2765 fn is_initialized(&self) -> bool {
2766 true
2767 }
2768
2769 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2770 while let Some(tag) = is.read_raw_tag_or_eof()? {
2771 match tag {
2772 8 => {
2773 self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
2774 },
2775 17 => {
2776 self.task_id = ::std::option::Option::Some(is.read_fixed64()?);
2777 },
2778 26 => {
2779 self.url = ::std::option::Option::Some(is.read_string()?);
2780 },
2781 32 => {
2782 self.file_id = ::std::option::Option::Some(is.read_int64()?);
2783 },
2784 tag => {
2785 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2786 },
2787 };
2788 }
2789 ::std::result::Result::Ok(())
2790 }
2791
2792 #[allow(unused_variables)]
2794 fn compute_size(&self) -> u64 {
2795 let mut my_size = 0;
2796 if let Some(v) = self.type_ {
2797 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v.value());
2798 }
2799 if let Some(v) = self.task_id {
2800 my_size += 1 + 8;
2801 }
2802 if let Some(v) = self.url.as_ref() {
2803 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
2804 }
2805 if let Some(v) = self.file_id {
2806 my_size += ::steam_vent_proto_common::protobuf::rt::int64_size(4, v);
2807 }
2808 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2809 self.special_fields.cached_size().set(my_size as u32);
2810 my_size
2811 }
2812
2813 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2814 if let Some(v) = self.type_ {
2815 os.write_enum(1, ::steam_vent_proto_common::protobuf::EnumOrUnknown::value(&v))?;
2816 }
2817 if let Some(v) = self.task_id {
2818 os.write_fixed64(2, v)?;
2819 }
2820 if let Some(v) = self.url.as_ref() {
2821 os.write_string(3, v)?;
2822 }
2823 if let Some(v) = self.file_id {
2824 os.write_int64(4, v)?;
2825 }
2826 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2827 ::std::result::Result::Ok(())
2828 }
2829
2830 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2831 &self.special_fields
2832 }
2833
2834 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2835 &mut self.special_fields
2836 }
2837
2838 fn new() -> CRemoteClient_Task {
2839 CRemoteClient_Task::new()
2840 }
2841
2842 fn clear(&mut self) {
2843 self.type_ = ::std::option::Option::None;
2844 self.task_id = ::std::option::Option::None;
2845 self.url = ::std::option::Option::None;
2846 self.file_id = ::std::option::Option::None;
2847 self.special_fields.clear();
2848 }
2849
2850 fn default_instance() -> &'static CRemoteClient_Task {
2851 static instance: CRemoteClient_Task = CRemoteClient_Task {
2852 type_: ::std::option::Option::None,
2853 task_id: ::std::option::Option::None,
2854 url: ::std::option::Option::None,
2855 file_id: ::std::option::Option::None,
2856 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2857 };
2858 &instance
2859 }
2860}
2861
2862#[derive(PartialEq,Clone,Default,Debug)]
2864pub struct CRemoteClient_AddClientTask_Request {
2865 pub remote_client_id: ::std::option::Option<u64>,
2868 pub task: ::steam_vent_proto_common::protobuf::MessageField<CRemoteClient_Task>,
2870 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2873}
2874
2875impl<'a> ::std::default::Default for &'a CRemoteClient_AddClientTask_Request {
2876 fn default() -> &'a CRemoteClient_AddClientTask_Request {
2877 <CRemoteClient_AddClientTask_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2878 }
2879}
2880
2881impl CRemoteClient_AddClientTask_Request {
2882 pub fn new() -> CRemoteClient_AddClientTask_Request {
2883 ::std::default::Default::default()
2884 }
2885
2886 pub fn remote_client_id(&self) -> u64 {
2889 self.remote_client_id.unwrap_or(0)
2890 }
2891
2892 pub fn clear_remote_client_id(&mut self) {
2893 self.remote_client_id = ::std::option::Option::None;
2894 }
2895
2896 pub fn has_remote_client_id(&self) -> bool {
2897 self.remote_client_id.is_some()
2898 }
2899
2900 pub fn set_remote_client_id(&mut self, v: u64) {
2902 self.remote_client_id = ::std::option::Option::Some(v);
2903 }
2904}
2905
2906impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_AddClientTask_Request {
2907 const NAME: &'static str = "CRemoteClient_AddClientTask_Request";
2908
2909 fn is_initialized(&self) -> bool {
2910 true
2911 }
2912
2913 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2914 while let Some(tag) = is.read_raw_tag_or_eof()? {
2915 match tag {
2916 9 => {
2917 self.remote_client_id = ::std::option::Option::Some(is.read_fixed64()?);
2918 },
2919 18 => {
2920 ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.task)?;
2921 },
2922 tag => {
2923 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2924 },
2925 };
2926 }
2927 ::std::result::Result::Ok(())
2928 }
2929
2930 #[allow(unused_variables)]
2932 fn compute_size(&self) -> u64 {
2933 let mut my_size = 0;
2934 if let Some(v) = self.remote_client_id {
2935 my_size += 1 + 8;
2936 }
2937 if let Some(v) = self.task.as_ref() {
2938 let len = v.compute_size();
2939 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
2940 }
2941 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2942 self.special_fields.cached_size().set(my_size as u32);
2943 my_size
2944 }
2945
2946 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
2947 if let Some(v) = self.remote_client_id {
2948 os.write_fixed64(1, v)?;
2949 }
2950 if let Some(v) = self.task.as_ref() {
2951 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
2952 }
2953 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2954 ::std::result::Result::Ok(())
2955 }
2956
2957 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
2958 &self.special_fields
2959 }
2960
2961 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
2962 &mut self.special_fields
2963 }
2964
2965 fn new() -> CRemoteClient_AddClientTask_Request {
2966 CRemoteClient_AddClientTask_Request::new()
2967 }
2968
2969 fn clear(&mut self) {
2970 self.remote_client_id = ::std::option::Option::None;
2971 self.task.clear();
2972 self.special_fields.clear();
2973 }
2974
2975 fn default_instance() -> &'static CRemoteClient_AddClientTask_Request {
2976 static instance: CRemoteClient_AddClientTask_Request = CRemoteClient_AddClientTask_Request {
2977 remote_client_id: ::std::option::Option::None,
2978 task: ::steam_vent_proto_common::protobuf::MessageField::none(),
2979 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
2980 };
2981 &instance
2982 }
2983}
2984
2985#[derive(PartialEq,Clone,Default,Debug)]
2987pub struct CRemoteClient_AddClientTask_Response {
2988 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
2991}
2992
2993impl<'a> ::std::default::Default for &'a CRemoteClient_AddClientTask_Response {
2994 fn default() -> &'a CRemoteClient_AddClientTask_Response {
2995 <CRemoteClient_AddClientTask_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
2996 }
2997}
2998
2999impl CRemoteClient_AddClientTask_Response {
3000 pub fn new() -> CRemoteClient_AddClientTask_Response {
3001 ::std::default::Default::default()
3002 }
3003}
3004
3005impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_AddClientTask_Response {
3006 const NAME: &'static str = "CRemoteClient_AddClientTask_Response";
3007
3008 fn is_initialized(&self) -> bool {
3009 true
3010 }
3011
3012 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3013 while let Some(tag) = is.read_raw_tag_or_eof()? {
3014 match tag {
3015 tag => {
3016 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3017 },
3018 };
3019 }
3020 ::std::result::Result::Ok(())
3021 }
3022
3023 #[allow(unused_variables)]
3025 fn compute_size(&self) -> u64 {
3026 let mut my_size = 0;
3027 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3028 self.special_fields.cached_size().set(my_size as u32);
3029 my_size
3030 }
3031
3032 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3033 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3034 ::std::result::Result::Ok(())
3035 }
3036
3037 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3038 &self.special_fields
3039 }
3040
3041 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3042 &mut self.special_fields
3043 }
3044
3045 fn new() -> CRemoteClient_AddClientTask_Response {
3046 CRemoteClient_AddClientTask_Response::new()
3047 }
3048
3049 fn clear(&mut self) {
3050 self.special_fields.clear();
3051 }
3052
3053 fn default_instance() -> &'static CRemoteClient_AddClientTask_Response {
3054 static instance: CRemoteClient_AddClientTask_Response = CRemoteClient_AddClientTask_Response {
3055 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3056 };
3057 &instance
3058 }
3059}
3060
3061#[derive(PartialEq,Clone,Default,Debug)]
3063pub struct CRemoteClient_TaskList_Notification {
3064 pub remote_client_id: ::std::option::Option<u64>,
3067 pub tasklist: ::std::vec::Vec<CRemoteClient_Task>,
3069 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3072}
3073
3074impl<'a> ::std::default::Default for &'a CRemoteClient_TaskList_Notification {
3075 fn default() -> &'a CRemoteClient_TaskList_Notification {
3076 <CRemoteClient_TaskList_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3077 }
3078}
3079
3080impl CRemoteClient_TaskList_Notification {
3081 pub fn new() -> CRemoteClient_TaskList_Notification {
3082 ::std::default::Default::default()
3083 }
3084
3085 pub fn remote_client_id(&self) -> u64 {
3088 self.remote_client_id.unwrap_or(0)
3089 }
3090
3091 pub fn clear_remote_client_id(&mut self) {
3092 self.remote_client_id = ::std::option::Option::None;
3093 }
3094
3095 pub fn has_remote_client_id(&self) -> bool {
3096 self.remote_client_id.is_some()
3097 }
3098
3099 pub fn set_remote_client_id(&mut self, v: u64) {
3101 self.remote_client_id = ::std::option::Option::Some(v);
3102 }
3103}
3104
3105impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_TaskList_Notification {
3106 const NAME: &'static str = "CRemoteClient_TaskList_Notification";
3107
3108 fn is_initialized(&self) -> bool {
3109 true
3110 }
3111
3112 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3113 while let Some(tag) = is.read_raw_tag_or_eof()? {
3114 match tag {
3115 9 => {
3116 self.remote_client_id = ::std::option::Option::Some(is.read_fixed64()?);
3117 },
3118 18 => {
3119 self.tasklist.push(is.read_message()?);
3120 },
3121 tag => {
3122 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3123 },
3124 };
3125 }
3126 ::std::result::Result::Ok(())
3127 }
3128
3129 #[allow(unused_variables)]
3131 fn compute_size(&self) -> u64 {
3132 let mut my_size = 0;
3133 if let Some(v) = self.remote_client_id {
3134 my_size += 1 + 8;
3135 }
3136 for value in &self.tasklist {
3137 let len = value.compute_size();
3138 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
3139 };
3140 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3141 self.special_fields.cached_size().set(my_size as u32);
3142 my_size
3143 }
3144
3145 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3146 if let Some(v) = self.remote_client_id {
3147 os.write_fixed64(1, v)?;
3148 }
3149 for v in &self.tasklist {
3150 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
3151 };
3152 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3153 ::std::result::Result::Ok(())
3154 }
3155
3156 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3157 &self.special_fields
3158 }
3159
3160 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3161 &mut self.special_fields
3162 }
3163
3164 fn new() -> CRemoteClient_TaskList_Notification {
3165 CRemoteClient_TaskList_Notification::new()
3166 }
3167
3168 fn clear(&mut self) {
3169 self.remote_client_id = ::std::option::Option::None;
3170 self.tasklist.clear();
3171 self.special_fields.clear();
3172 }
3173
3174 fn default_instance() -> &'static CRemoteClient_TaskList_Notification {
3175 static instance: CRemoteClient_TaskList_Notification = CRemoteClient_TaskList_Notification {
3176 remote_client_id: ::std::option::Option::None,
3177 tasklist: ::std::vec::Vec::new(),
3178 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3179 };
3180 &instance
3181 }
3182}
3183
3184#[derive(PartialEq,Clone,Default,Debug)]
3186pub struct CRemoteClient_MarkTaskComplete_Request {
3187 pub remote_client_id: ::std::option::Option<u64>,
3190 pub task_id: ::std::option::Option<u64>,
3192 pub content_id: ::std::option::Option<::std::string::String>,
3194 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3197}
3198
3199impl<'a> ::std::default::Default for &'a CRemoteClient_MarkTaskComplete_Request {
3200 fn default() -> &'a CRemoteClient_MarkTaskComplete_Request {
3201 <CRemoteClient_MarkTaskComplete_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3202 }
3203}
3204
3205impl CRemoteClient_MarkTaskComplete_Request {
3206 pub fn new() -> CRemoteClient_MarkTaskComplete_Request {
3207 ::std::default::Default::default()
3208 }
3209
3210 pub fn remote_client_id(&self) -> u64 {
3213 self.remote_client_id.unwrap_or(0)
3214 }
3215
3216 pub fn clear_remote_client_id(&mut self) {
3217 self.remote_client_id = ::std::option::Option::None;
3218 }
3219
3220 pub fn has_remote_client_id(&self) -> bool {
3221 self.remote_client_id.is_some()
3222 }
3223
3224 pub fn set_remote_client_id(&mut self, v: u64) {
3226 self.remote_client_id = ::std::option::Option::Some(v);
3227 }
3228
3229 pub fn task_id(&self) -> u64 {
3232 self.task_id.unwrap_or(0)
3233 }
3234
3235 pub fn clear_task_id(&mut self) {
3236 self.task_id = ::std::option::Option::None;
3237 }
3238
3239 pub fn has_task_id(&self) -> bool {
3240 self.task_id.is_some()
3241 }
3242
3243 pub fn set_task_id(&mut self, v: u64) {
3245 self.task_id = ::std::option::Option::Some(v);
3246 }
3247
3248 pub fn content_id(&self) -> &str {
3251 match self.content_id.as_ref() {
3252 Some(v) => v,
3253 None => "",
3254 }
3255 }
3256
3257 pub fn clear_content_id(&mut self) {
3258 self.content_id = ::std::option::Option::None;
3259 }
3260
3261 pub fn has_content_id(&self) -> bool {
3262 self.content_id.is_some()
3263 }
3264
3265 pub fn set_content_id(&mut self, v: ::std::string::String) {
3267 self.content_id = ::std::option::Option::Some(v);
3268 }
3269
3270 pub fn mut_content_id(&mut self) -> &mut ::std::string::String {
3273 if self.content_id.is_none() {
3274 self.content_id = ::std::option::Option::Some(::std::string::String::new());
3275 }
3276 self.content_id.as_mut().unwrap()
3277 }
3278
3279 pub fn take_content_id(&mut self) -> ::std::string::String {
3281 self.content_id.take().unwrap_or_else(|| ::std::string::String::new())
3282 }
3283}
3284
3285impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_MarkTaskComplete_Request {
3286 const NAME: &'static str = "CRemoteClient_MarkTaskComplete_Request";
3287
3288 fn is_initialized(&self) -> bool {
3289 true
3290 }
3291
3292 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3293 while let Some(tag) = is.read_raw_tag_or_eof()? {
3294 match tag {
3295 9 => {
3296 self.remote_client_id = ::std::option::Option::Some(is.read_fixed64()?);
3297 },
3298 17 => {
3299 self.task_id = ::std::option::Option::Some(is.read_fixed64()?);
3300 },
3301 26 => {
3302 self.content_id = ::std::option::Option::Some(is.read_string()?);
3303 },
3304 tag => {
3305 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3306 },
3307 };
3308 }
3309 ::std::result::Result::Ok(())
3310 }
3311
3312 #[allow(unused_variables)]
3314 fn compute_size(&self) -> u64 {
3315 let mut my_size = 0;
3316 if let Some(v) = self.remote_client_id {
3317 my_size += 1 + 8;
3318 }
3319 if let Some(v) = self.task_id {
3320 my_size += 1 + 8;
3321 }
3322 if let Some(v) = self.content_id.as_ref() {
3323 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(3, &v);
3324 }
3325 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3326 self.special_fields.cached_size().set(my_size as u32);
3327 my_size
3328 }
3329
3330 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3331 if let Some(v) = self.remote_client_id {
3332 os.write_fixed64(1, v)?;
3333 }
3334 if let Some(v) = self.task_id {
3335 os.write_fixed64(2, v)?;
3336 }
3337 if let Some(v) = self.content_id.as_ref() {
3338 os.write_string(3, v)?;
3339 }
3340 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3341 ::std::result::Result::Ok(())
3342 }
3343
3344 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3345 &self.special_fields
3346 }
3347
3348 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3349 &mut self.special_fields
3350 }
3351
3352 fn new() -> CRemoteClient_MarkTaskComplete_Request {
3353 CRemoteClient_MarkTaskComplete_Request::new()
3354 }
3355
3356 fn clear(&mut self) {
3357 self.remote_client_id = ::std::option::Option::None;
3358 self.task_id = ::std::option::Option::None;
3359 self.content_id = ::std::option::Option::None;
3360 self.special_fields.clear();
3361 }
3362
3363 fn default_instance() -> &'static CRemoteClient_MarkTaskComplete_Request {
3364 static instance: CRemoteClient_MarkTaskComplete_Request = CRemoteClient_MarkTaskComplete_Request {
3365 remote_client_id: ::std::option::Option::None,
3366 task_id: ::std::option::Option::None,
3367 content_id: ::std::option::Option::None,
3368 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3369 };
3370 &instance
3371 }
3372}
3373
3374#[derive(PartialEq,Clone,Default,Debug)]
3376pub struct CRemoteClient_MarkTaskComplete_Response {
3377 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3380}
3381
3382impl<'a> ::std::default::Default for &'a CRemoteClient_MarkTaskComplete_Response {
3383 fn default() -> &'a CRemoteClient_MarkTaskComplete_Response {
3384 <CRemoteClient_MarkTaskComplete_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3385 }
3386}
3387
3388impl CRemoteClient_MarkTaskComplete_Response {
3389 pub fn new() -> CRemoteClient_MarkTaskComplete_Response {
3390 ::std::default::Default::default()
3391 }
3392}
3393
3394impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_MarkTaskComplete_Response {
3395 const NAME: &'static str = "CRemoteClient_MarkTaskComplete_Response";
3396
3397 fn is_initialized(&self) -> bool {
3398 true
3399 }
3400
3401 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3402 while let Some(tag) = is.read_raw_tag_or_eof()? {
3403 match tag {
3404 tag => {
3405 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3406 },
3407 };
3408 }
3409 ::std::result::Result::Ok(())
3410 }
3411
3412 #[allow(unused_variables)]
3414 fn compute_size(&self) -> u64 {
3415 let mut my_size = 0;
3416 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3417 self.special_fields.cached_size().set(my_size as u32);
3418 my_size
3419 }
3420
3421 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3422 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3423 ::std::result::Result::Ok(())
3424 }
3425
3426 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3427 &self.special_fields
3428 }
3429
3430 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3431 &mut self.special_fields
3432 }
3433
3434 fn new() -> CRemoteClient_MarkTaskComplete_Response {
3435 CRemoteClient_MarkTaskComplete_Response::new()
3436 }
3437
3438 fn clear(&mut self) {
3439 self.special_fields.clear();
3440 }
3441
3442 fn default_instance() -> &'static CRemoteClient_MarkTaskComplete_Response {
3443 static instance: CRemoteClient_MarkTaskComplete_Response = CRemoteClient_MarkTaskComplete_Response {
3444 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3445 };
3446 &instance
3447 }
3448}
3449
3450#[derive(PartialEq,Clone,Default,Debug)]
3452pub struct CRemoteClient_RemotePacket_Notification {
3453 pub session_id: ::std::option::Option<u64>,
3456 pub steamid: ::std::option::Option<u64>,
3458 pub payload: ::std::option::Option<::std::vec::Vec<u8>>,
3460 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3463}
3464
3465impl<'a> ::std::default::Default for &'a CRemoteClient_RemotePacket_Notification {
3466 fn default() -> &'a CRemoteClient_RemotePacket_Notification {
3467 <CRemoteClient_RemotePacket_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3468 }
3469}
3470
3471impl CRemoteClient_RemotePacket_Notification {
3472 pub fn new() -> CRemoteClient_RemotePacket_Notification {
3473 ::std::default::Default::default()
3474 }
3475
3476 pub fn session_id(&self) -> u64 {
3479 self.session_id.unwrap_or(0)
3480 }
3481
3482 pub fn clear_session_id(&mut self) {
3483 self.session_id = ::std::option::Option::None;
3484 }
3485
3486 pub fn has_session_id(&self) -> bool {
3487 self.session_id.is_some()
3488 }
3489
3490 pub fn set_session_id(&mut self, v: u64) {
3492 self.session_id = ::std::option::Option::Some(v);
3493 }
3494
3495 pub fn steamid(&self) -> u64 {
3498 self.steamid.unwrap_or(0)
3499 }
3500
3501 pub fn clear_steamid(&mut self) {
3502 self.steamid = ::std::option::Option::None;
3503 }
3504
3505 pub fn has_steamid(&self) -> bool {
3506 self.steamid.is_some()
3507 }
3508
3509 pub fn set_steamid(&mut self, v: u64) {
3511 self.steamid = ::std::option::Option::Some(v);
3512 }
3513
3514 pub fn payload(&self) -> &[u8] {
3517 match self.payload.as_ref() {
3518 Some(v) => v,
3519 None => &[],
3520 }
3521 }
3522
3523 pub fn clear_payload(&mut self) {
3524 self.payload = ::std::option::Option::None;
3525 }
3526
3527 pub fn has_payload(&self) -> bool {
3528 self.payload.is_some()
3529 }
3530
3531 pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
3533 self.payload = ::std::option::Option::Some(v);
3534 }
3535
3536 pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
3539 if self.payload.is_none() {
3540 self.payload = ::std::option::Option::Some(::std::vec::Vec::new());
3541 }
3542 self.payload.as_mut().unwrap()
3543 }
3544
3545 pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
3547 self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
3548 }
3549}
3550
3551impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_RemotePacket_Notification {
3552 const NAME: &'static str = "CRemoteClient_RemotePacket_Notification";
3553
3554 fn is_initialized(&self) -> bool {
3555 true
3556 }
3557
3558 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3559 while let Some(tag) = is.read_raw_tag_or_eof()? {
3560 match tag {
3561 9 => {
3562 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
3563 },
3564 17 => {
3565 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
3566 },
3567 34 => {
3568 self.payload = ::std::option::Option::Some(is.read_bytes()?);
3569 },
3570 tag => {
3571 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3572 },
3573 };
3574 }
3575 ::std::result::Result::Ok(())
3576 }
3577
3578 #[allow(unused_variables)]
3580 fn compute_size(&self) -> u64 {
3581 let mut my_size = 0;
3582 if let Some(v) = self.session_id {
3583 my_size += 1 + 8;
3584 }
3585 if let Some(v) = self.steamid {
3586 my_size += 1 + 8;
3587 }
3588 if let Some(v) = self.payload.as_ref() {
3589 my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(4, &v);
3590 }
3591 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3592 self.special_fields.cached_size().set(my_size as u32);
3593 my_size
3594 }
3595
3596 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3597 if let Some(v) = self.session_id {
3598 os.write_fixed64(1, v)?;
3599 }
3600 if let Some(v) = self.steamid {
3601 os.write_fixed64(2, v)?;
3602 }
3603 if let Some(v) = self.payload.as_ref() {
3604 os.write_bytes(4, v)?;
3605 }
3606 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3607 ::std::result::Result::Ok(())
3608 }
3609
3610 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3611 &self.special_fields
3612 }
3613
3614 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3615 &mut self.special_fields
3616 }
3617
3618 fn new() -> CRemoteClient_RemotePacket_Notification {
3619 CRemoteClient_RemotePacket_Notification::new()
3620 }
3621
3622 fn clear(&mut self) {
3623 self.session_id = ::std::option::Option::None;
3624 self.steamid = ::std::option::Option::None;
3625 self.payload = ::std::option::Option::None;
3626 self.special_fields.clear();
3627 }
3628
3629 fn default_instance() -> &'static CRemoteClient_RemotePacket_Notification {
3630 static instance: CRemoteClient_RemotePacket_Notification = CRemoteClient_RemotePacket_Notification {
3631 session_id: ::std::option::Option::None,
3632 steamid: ::std::option::Option::None,
3633 payload: ::std::option::Option::None,
3634 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3635 };
3636 &instance
3637 }
3638}
3639
3640#[derive(PartialEq,Clone,Default,Debug)]
3642pub struct CRemoteClient_ReplyPacket_Notification {
3643 pub session_id: ::std::option::Option<u64>,
3646 pub payload: ::std::option::Option<::std::vec::Vec<u8>>,
3648 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3651}
3652
3653impl<'a> ::std::default::Default for &'a CRemoteClient_ReplyPacket_Notification {
3654 fn default() -> &'a CRemoteClient_ReplyPacket_Notification {
3655 <CRemoteClient_ReplyPacket_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3656 }
3657}
3658
3659impl CRemoteClient_ReplyPacket_Notification {
3660 pub fn new() -> CRemoteClient_ReplyPacket_Notification {
3661 ::std::default::Default::default()
3662 }
3663
3664 pub fn session_id(&self) -> u64 {
3667 self.session_id.unwrap_or(0)
3668 }
3669
3670 pub fn clear_session_id(&mut self) {
3671 self.session_id = ::std::option::Option::None;
3672 }
3673
3674 pub fn has_session_id(&self) -> bool {
3675 self.session_id.is_some()
3676 }
3677
3678 pub fn set_session_id(&mut self, v: u64) {
3680 self.session_id = ::std::option::Option::Some(v);
3681 }
3682
3683 pub fn payload(&self) -> &[u8] {
3686 match self.payload.as_ref() {
3687 Some(v) => v,
3688 None => &[],
3689 }
3690 }
3691
3692 pub fn clear_payload(&mut self) {
3693 self.payload = ::std::option::Option::None;
3694 }
3695
3696 pub fn has_payload(&self) -> bool {
3697 self.payload.is_some()
3698 }
3699
3700 pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
3702 self.payload = ::std::option::Option::Some(v);
3703 }
3704
3705 pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
3708 if self.payload.is_none() {
3709 self.payload = ::std::option::Option::Some(::std::vec::Vec::new());
3710 }
3711 self.payload.as_mut().unwrap()
3712 }
3713
3714 pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
3716 self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
3717 }
3718}
3719
3720impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_ReplyPacket_Notification {
3721 const NAME: &'static str = "CRemoteClient_ReplyPacket_Notification";
3722
3723 fn is_initialized(&self) -> bool {
3724 true
3725 }
3726
3727 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3728 while let Some(tag) = is.read_raw_tag_or_eof()? {
3729 match tag {
3730 9 => {
3731 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
3732 },
3733 18 => {
3734 self.payload = ::std::option::Option::Some(is.read_bytes()?);
3735 },
3736 tag => {
3737 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3738 },
3739 };
3740 }
3741 ::std::result::Result::Ok(())
3742 }
3743
3744 #[allow(unused_variables)]
3746 fn compute_size(&self) -> u64 {
3747 let mut my_size = 0;
3748 if let Some(v) = self.session_id {
3749 my_size += 1 + 8;
3750 }
3751 if let Some(v) = self.payload.as_ref() {
3752 my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(2, &v);
3753 }
3754 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3755 self.special_fields.cached_size().set(my_size as u32);
3756 my_size
3757 }
3758
3759 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3760 if let Some(v) = self.session_id {
3761 os.write_fixed64(1, v)?;
3762 }
3763 if let Some(v) = self.payload.as_ref() {
3764 os.write_bytes(2, v)?;
3765 }
3766 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3767 ::std::result::Result::Ok(())
3768 }
3769
3770 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3771 &self.special_fields
3772 }
3773
3774 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3775 &mut self.special_fields
3776 }
3777
3778 fn new() -> CRemoteClient_ReplyPacket_Notification {
3779 CRemoteClient_ReplyPacket_Notification::new()
3780 }
3781
3782 fn clear(&mut self) {
3783 self.session_id = ::std::option::Option::None;
3784 self.payload = ::std::option::Option::None;
3785 self.special_fields.clear();
3786 }
3787
3788 fn default_instance() -> &'static CRemoteClient_ReplyPacket_Notification {
3789 static instance: CRemoteClient_ReplyPacket_Notification = CRemoteClient_ReplyPacket_Notification {
3790 session_id: ::std::option::Option::None,
3791 payload: ::std::option::Option::None,
3792 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3793 };
3794 &instance
3795 }
3796}
3797
3798#[derive(PartialEq,Clone,Default,Debug)]
3800pub struct CRemoteClient_GetReplies_Request {
3801 pub session_id: ::std::option::Option<u64>,
3804 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3807}
3808
3809impl<'a> ::std::default::Default for &'a CRemoteClient_GetReplies_Request {
3810 fn default() -> &'a CRemoteClient_GetReplies_Request {
3811 <CRemoteClient_GetReplies_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3812 }
3813}
3814
3815impl CRemoteClient_GetReplies_Request {
3816 pub fn new() -> CRemoteClient_GetReplies_Request {
3817 ::std::default::Default::default()
3818 }
3819
3820 pub fn session_id(&self) -> u64 {
3823 self.session_id.unwrap_or(0)
3824 }
3825
3826 pub fn clear_session_id(&mut self) {
3827 self.session_id = ::std::option::Option::None;
3828 }
3829
3830 pub fn has_session_id(&self) -> bool {
3831 self.session_id.is_some()
3832 }
3833
3834 pub fn set_session_id(&mut self, v: u64) {
3836 self.session_id = ::std::option::Option::Some(v);
3837 }
3838}
3839
3840impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_GetReplies_Request {
3841 const NAME: &'static str = "CRemoteClient_GetReplies_Request";
3842
3843 fn is_initialized(&self) -> bool {
3844 true
3845 }
3846
3847 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3848 while let Some(tag) = is.read_raw_tag_or_eof()? {
3849 match tag {
3850 9 => {
3851 self.session_id = ::std::option::Option::Some(is.read_fixed64()?);
3852 },
3853 tag => {
3854 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3855 },
3856 };
3857 }
3858 ::std::result::Result::Ok(())
3859 }
3860
3861 #[allow(unused_variables)]
3863 fn compute_size(&self) -> u64 {
3864 let mut my_size = 0;
3865 if let Some(v) = self.session_id {
3866 my_size += 1 + 8;
3867 }
3868 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3869 self.special_fields.cached_size().set(my_size as u32);
3870 my_size
3871 }
3872
3873 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3874 if let Some(v) = self.session_id {
3875 os.write_fixed64(1, v)?;
3876 }
3877 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3878 ::std::result::Result::Ok(())
3879 }
3880
3881 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3882 &self.special_fields
3883 }
3884
3885 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3886 &mut self.special_fields
3887 }
3888
3889 fn new() -> CRemoteClient_GetReplies_Request {
3890 CRemoteClient_GetReplies_Request::new()
3891 }
3892
3893 fn clear(&mut self) {
3894 self.session_id = ::std::option::Option::None;
3895 self.special_fields.clear();
3896 }
3897
3898 fn default_instance() -> &'static CRemoteClient_GetReplies_Request {
3899 static instance: CRemoteClient_GetReplies_Request = CRemoteClient_GetReplies_Request {
3900 session_id: ::std::option::Option::None,
3901 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3902 };
3903 &instance
3904 }
3905}
3906
3907#[derive(PartialEq,Clone,Default,Debug)]
3909pub struct CRemoteClient_GetReplies_Response {
3910 pub payload: ::std::vec::Vec<::std::vec::Vec<u8>>,
3913 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
3916}
3917
3918impl<'a> ::std::default::Default for &'a CRemoteClient_GetReplies_Response {
3919 fn default() -> &'a CRemoteClient_GetReplies_Response {
3920 <CRemoteClient_GetReplies_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
3921 }
3922}
3923
3924impl CRemoteClient_GetReplies_Response {
3925 pub fn new() -> CRemoteClient_GetReplies_Response {
3926 ::std::default::Default::default()
3927 }
3928}
3929
3930impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_GetReplies_Response {
3931 const NAME: &'static str = "CRemoteClient_GetReplies_Response";
3932
3933 fn is_initialized(&self) -> bool {
3934 true
3935 }
3936
3937 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3938 while let Some(tag) = is.read_raw_tag_or_eof()? {
3939 match tag {
3940 10 => {
3941 self.payload.push(is.read_bytes()?);
3942 },
3943 tag => {
3944 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3945 },
3946 };
3947 }
3948 ::std::result::Result::Ok(())
3949 }
3950
3951 #[allow(unused_variables)]
3953 fn compute_size(&self) -> u64 {
3954 let mut my_size = 0;
3955 for value in &self.payload {
3956 my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(1, &value);
3957 };
3958 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3959 self.special_fields.cached_size().set(my_size as u32);
3960 my_size
3961 }
3962
3963 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
3964 for v in &self.payload {
3965 os.write_bytes(1, &v)?;
3966 };
3967 os.write_unknown_fields(self.special_fields.unknown_fields())?;
3968 ::std::result::Result::Ok(())
3969 }
3970
3971 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
3972 &self.special_fields
3973 }
3974
3975 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
3976 &mut self.special_fields
3977 }
3978
3979 fn new() -> CRemoteClient_GetReplies_Response {
3980 CRemoteClient_GetReplies_Response::new()
3981 }
3982
3983 fn clear(&mut self) {
3984 self.payload.clear();
3985 self.special_fields.clear();
3986 }
3987
3988 fn default_instance() -> &'static CRemoteClient_GetReplies_Response {
3989 static instance: CRemoteClient_GetReplies_Response = CRemoteClient_GetReplies_Response {
3990 payload: ::std::vec::Vec::new(),
3991 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
3992 };
3993 &instance
3994 }
3995}
3996
3997#[derive(PartialEq,Clone,Default,Debug)]
3999pub struct CRemoteClient_AllocateRelayServer_Request {
4000 pub cellid: ::std::option::Option<u32>,
4003 pub credentials: ::std::option::Option<::std::string::String>,
4005 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
4008}
4009
4010impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateRelayServer_Request {
4011 fn default() -> &'a CRemoteClient_AllocateRelayServer_Request {
4012 <CRemoteClient_AllocateRelayServer_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
4013 }
4014}
4015
4016impl CRemoteClient_AllocateRelayServer_Request {
4017 pub fn new() -> CRemoteClient_AllocateRelayServer_Request {
4018 ::std::default::Default::default()
4019 }
4020
4021 pub fn cellid(&self) -> u32 {
4024 self.cellid.unwrap_or(0)
4025 }
4026
4027 pub fn clear_cellid(&mut self) {
4028 self.cellid = ::std::option::Option::None;
4029 }
4030
4031 pub fn has_cellid(&self) -> bool {
4032 self.cellid.is_some()
4033 }
4034
4035 pub fn set_cellid(&mut self, v: u32) {
4037 self.cellid = ::std::option::Option::Some(v);
4038 }
4039
4040 pub fn credentials(&self) -> &str {
4043 match self.credentials.as_ref() {
4044 Some(v) => v,
4045 None => "",
4046 }
4047 }
4048
4049 pub fn clear_credentials(&mut self) {
4050 self.credentials = ::std::option::Option::None;
4051 }
4052
4053 pub fn has_credentials(&self) -> bool {
4054 self.credentials.is_some()
4055 }
4056
4057 pub fn set_credentials(&mut self, v: ::std::string::String) {
4059 self.credentials = ::std::option::Option::Some(v);
4060 }
4061
4062 pub fn mut_credentials(&mut self) -> &mut ::std::string::String {
4065 if self.credentials.is_none() {
4066 self.credentials = ::std::option::Option::Some(::std::string::String::new());
4067 }
4068 self.credentials.as_mut().unwrap()
4069 }
4070
4071 pub fn take_credentials(&mut self) -> ::std::string::String {
4073 self.credentials.take().unwrap_or_else(|| ::std::string::String::new())
4074 }
4075}
4076
4077impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_AllocateRelayServer_Request {
4078 const NAME: &'static str = "CRemoteClient_AllocateRelayServer_Request";
4079
4080 fn is_initialized(&self) -> bool {
4081 true
4082 }
4083
4084 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4085 while let Some(tag) = is.read_raw_tag_or_eof()? {
4086 match tag {
4087 8 => {
4088 self.cellid = ::std::option::Option::Some(is.read_uint32()?);
4089 },
4090 18 => {
4091 self.credentials = ::std::option::Option::Some(is.read_string()?);
4092 },
4093 tag => {
4094 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4095 },
4096 };
4097 }
4098 ::std::result::Result::Ok(())
4099 }
4100
4101 #[allow(unused_variables)]
4103 fn compute_size(&self) -> u64 {
4104 let mut my_size = 0;
4105 if let Some(v) = self.cellid {
4106 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
4107 }
4108 if let Some(v) = self.credentials.as_ref() {
4109 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
4110 }
4111 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4112 self.special_fields.cached_size().set(my_size as u32);
4113 my_size
4114 }
4115
4116 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4117 if let Some(v) = self.cellid {
4118 os.write_uint32(1, v)?;
4119 }
4120 if let Some(v) = self.credentials.as_ref() {
4121 os.write_string(2, v)?;
4122 }
4123 os.write_unknown_fields(self.special_fields.unknown_fields())?;
4124 ::std::result::Result::Ok(())
4125 }
4126
4127 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
4128 &self.special_fields
4129 }
4130
4131 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
4132 &mut self.special_fields
4133 }
4134
4135 fn new() -> CRemoteClient_AllocateRelayServer_Request {
4136 CRemoteClient_AllocateRelayServer_Request::new()
4137 }
4138
4139 fn clear(&mut self) {
4140 self.cellid = ::std::option::Option::None;
4141 self.credentials = ::std::option::Option::None;
4142 self.special_fields.clear();
4143 }
4144
4145 fn default_instance() -> &'static CRemoteClient_AllocateRelayServer_Request {
4146 static instance: CRemoteClient_AllocateRelayServer_Request = CRemoteClient_AllocateRelayServer_Request {
4147 cellid: ::std::option::Option::None,
4148 credentials: ::std::option::Option::None,
4149 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
4150 };
4151 &instance
4152 }
4153}
4154
4155#[derive(PartialEq,Clone,Default,Debug)]
4157pub struct CRemoteClient_AllocateRelayServer_Response {
4158 pub relay_server: ::std::option::Option<::std::string::String>,
4161 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
4164}
4165
4166impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateRelayServer_Response {
4167 fn default() -> &'a CRemoteClient_AllocateRelayServer_Response {
4168 <CRemoteClient_AllocateRelayServer_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
4169 }
4170}
4171
4172impl CRemoteClient_AllocateRelayServer_Response {
4173 pub fn new() -> CRemoteClient_AllocateRelayServer_Response {
4174 ::std::default::Default::default()
4175 }
4176
4177 pub fn relay_server(&self) -> &str {
4180 match self.relay_server.as_ref() {
4181 Some(v) => v,
4182 None => "",
4183 }
4184 }
4185
4186 pub fn clear_relay_server(&mut self) {
4187 self.relay_server = ::std::option::Option::None;
4188 }
4189
4190 pub fn has_relay_server(&self) -> bool {
4191 self.relay_server.is_some()
4192 }
4193
4194 pub fn set_relay_server(&mut self, v: ::std::string::String) {
4196 self.relay_server = ::std::option::Option::Some(v);
4197 }
4198
4199 pub fn mut_relay_server(&mut self) -> &mut ::std::string::String {
4202 if self.relay_server.is_none() {
4203 self.relay_server = ::std::option::Option::Some(::std::string::String::new());
4204 }
4205 self.relay_server.as_mut().unwrap()
4206 }
4207
4208 pub fn take_relay_server(&mut self) -> ::std::string::String {
4210 self.relay_server.take().unwrap_or_else(|| ::std::string::String::new())
4211 }
4212}
4213
4214impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_AllocateRelayServer_Response {
4215 const NAME: &'static str = "CRemoteClient_AllocateRelayServer_Response";
4216
4217 fn is_initialized(&self) -> bool {
4218 true
4219 }
4220
4221 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4222 while let Some(tag) = is.read_raw_tag_or_eof()? {
4223 match tag {
4224 10 => {
4225 self.relay_server = ::std::option::Option::Some(is.read_string()?);
4226 },
4227 tag => {
4228 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4229 },
4230 };
4231 }
4232 ::std::result::Result::Ok(())
4233 }
4234
4235 #[allow(unused_variables)]
4237 fn compute_size(&self) -> u64 {
4238 let mut my_size = 0;
4239 if let Some(v) = self.relay_server.as_ref() {
4240 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
4241 }
4242 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4243 self.special_fields.cached_size().set(my_size as u32);
4244 my_size
4245 }
4246
4247 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4248 if let Some(v) = self.relay_server.as_ref() {
4249 os.write_string(1, v)?;
4250 }
4251 os.write_unknown_fields(self.special_fields.unknown_fields())?;
4252 ::std::result::Result::Ok(())
4253 }
4254
4255 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
4256 &self.special_fields
4257 }
4258
4259 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
4260 &mut self.special_fields
4261 }
4262
4263 fn new() -> CRemoteClient_AllocateRelayServer_Response {
4264 CRemoteClient_AllocateRelayServer_Response::new()
4265 }
4266
4267 fn clear(&mut self) {
4268 self.relay_server = ::std::option::Option::None;
4269 self.special_fields.clear();
4270 }
4271
4272 fn default_instance() -> &'static CRemoteClient_AllocateRelayServer_Response {
4273 static instance: CRemoteClient_AllocateRelayServer_Response = CRemoteClient_AllocateRelayServer_Response {
4274 relay_server: ::std::option::Option::None,
4275 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
4276 };
4277 &instance
4278 }
4279}
4280
4281#[derive(PartialEq,Clone,Default,Debug)]
4283pub struct CRemoteClient_AllocateSDR_Request {
4284 pub appid: ::std::option::Option<u32>,
4287 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
4290}
4291
4292impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateSDR_Request {
4293 fn default() -> &'a CRemoteClient_AllocateSDR_Request {
4294 <CRemoteClient_AllocateSDR_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
4295 }
4296}
4297
4298impl CRemoteClient_AllocateSDR_Request {
4299 pub fn new() -> CRemoteClient_AllocateSDR_Request {
4300 ::std::default::Default::default()
4301 }
4302
4303 pub fn appid(&self) -> u32 {
4306 self.appid.unwrap_or(0)
4307 }
4308
4309 pub fn clear_appid(&mut self) {
4310 self.appid = ::std::option::Option::None;
4311 }
4312
4313 pub fn has_appid(&self) -> bool {
4314 self.appid.is_some()
4315 }
4316
4317 pub fn set_appid(&mut self, v: u32) {
4319 self.appid = ::std::option::Option::Some(v);
4320 }
4321}
4322
4323impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_AllocateSDR_Request {
4324 const NAME: &'static str = "CRemoteClient_AllocateSDR_Request";
4325
4326 fn is_initialized(&self) -> bool {
4327 true
4328 }
4329
4330 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4331 while let Some(tag) = is.read_raw_tag_or_eof()? {
4332 match tag {
4333 8 => {
4334 self.appid = ::std::option::Option::Some(is.read_uint32()?);
4335 },
4336 tag => {
4337 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4338 },
4339 };
4340 }
4341 ::std::result::Result::Ok(())
4342 }
4343
4344 #[allow(unused_variables)]
4346 fn compute_size(&self) -> u64 {
4347 let mut my_size = 0;
4348 if let Some(v) = self.appid {
4349 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
4350 }
4351 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4352 self.special_fields.cached_size().set(my_size as u32);
4353 my_size
4354 }
4355
4356 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4357 if let Some(v) = self.appid {
4358 os.write_uint32(1, v)?;
4359 }
4360 os.write_unknown_fields(self.special_fields.unknown_fields())?;
4361 ::std::result::Result::Ok(())
4362 }
4363
4364 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
4365 &self.special_fields
4366 }
4367
4368 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
4369 &mut self.special_fields
4370 }
4371
4372 fn new() -> CRemoteClient_AllocateSDR_Request {
4373 CRemoteClient_AllocateSDR_Request::new()
4374 }
4375
4376 fn clear(&mut self) {
4377 self.appid = ::std::option::Option::None;
4378 self.special_fields.clear();
4379 }
4380
4381 fn default_instance() -> &'static CRemoteClient_AllocateSDR_Request {
4382 static instance: CRemoteClient_AllocateSDR_Request = CRemoteClient_AllocateSDR_Request {
4383 appid: ::std::option::Option::None,
4384 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
4385 };
4386 &instance
4387 }
4388}
4389
4390#[derive(PartialEq,Clone,Default,Debug)]
4392pub struct CRemoteClient_AllocateSDR_Response {
4393 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
4396}
4397
4398impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateSDR_Response {
4399 fn default() -> &'a CRemoteClient_AllocateSDR_Response {
4400 <CRemoteClient_AllocateSDR_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
4401 }
4402}
4403
4404impl CRemoteClient_AllocateSDR_Response {
4405 pub fn new() -> CRemoteClient_AllocateSDR_Response {
4406 ::std::default::Default::default()
4407 }
4408}
4409
4410impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_AllocateSDR_Response {
4411 const NAME: &'static str = "CRemoteClient_AllocateSDR_Response";
4412
4413 fn is_initialized(&self) -> bool {
4414 true
4415 }
4416
4417 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4418 while let Some(tag) = is.read_raw_tag_or_eof()? {
4419 match tag {
4420 tag => {
4421 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4422 },
4423 };
4424 }
4425 ::std::result::Result::Ok(())
4426 }
4427
4428 #[allow(unused_variables)]
4430 fn compute_size(&self) -> u64 {
4431 let mut my_size = 0;
4432 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4433 self.special_fields.cached_size().set(my_size as u32);
4434 my_size
4435 }
4436
4437 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4438 os.write_unknown_fields(self.special_fields.unknown_fields())?;
4439 ::std::result::Result::Ok(())
4440 }
4441
4442 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
4443 &self.special_fields
4444 }
4445
4446 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
4447 &mut self.special_fields
4448 }
4449
4450 fn new() -> CRemoteClient_AllocateSDR_Response {
4451 CRemoteClient_AllocateSDR_Response::new()
4452 }
4453
4454 fn clear(&mut self) {
4455 self.special_fields.clear();
4456 }
4457
4458 fn default_instance() -> &'static CRemoteClient_AllocateSDR_Response {
4459 static instance: CRemoteClient_AllocateSDR_Response = CRemoteClient_AllocateSDR_Response {
4460 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
4461 };
4462 &instance
4463 }
4464}
4465
4466#[derive(PartialEq,Clone,Default,Debug)]
4468pub struct CRemoteClient_SteamBroadcast_Notification {
4469 pub steamid: ::std::option::Option<u64>,
4472 pub clientid: ::std::option::Option<u64>,
4474 pub payload: ::std::option::Option<::std::vec::Vec<u8>>,
4476 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
4479}
4480
4481impl<'a> ::std::default::Default for &'a CRemoteClient_SteamBroadcast_Notification {
4482 fn default() -> &'a CRemoteClient_SteamBroadcast_Notification {
4483 <CRemoteClient_SteamBroadcast_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
4484 }
4485}
4486
4487impl CRemoteClient_SteamBroadcast_Notification {
4488 pub fn new() -> CRemoteClient_SteamBroadcast_Notification {
4489 ::std::default::Default::default()
4490 }
4491
4492 pub fn steamid(&self) -> u64 {
4495 self.steamid.unwrap_or(0)
4496 }
4497
4498 pub fn clear_steamid(&mut self) {
4499 self.steamid = ::std::option::Option::None;
4500 }
4501
4502 pub fn has_steamid(&self) -> bool {
4503 self.steamid.is_some()
4504 }
4505
4506 pub fn set_steamid(&mut self, v: u64) {
4508 self.steamid = ::std::option::Option::Some(v);
4509 }
4510
4511 pub fn clientid(&self) -> u64 {
4514 self.clientid.unwrap_or(0)
4515 }
4516
4517 pub fn clear_clientid(&mut self) {
4518 self.clientid = ::std::option::Option::None;
4519 }
4520
4521 pub fn has_clientid(&self) -> bool {
4522 self.clientid.is_some()
4523 }
4524
4525 pub fn set_clientid(&mut self, v: u64) {
4527 self.clientid = ::std::option::Option::Some(v);
4528 }
4529
4530 pub fn payload(&self) -> &[u8] {
4533 match self.payload.as_ref() {
4534 Some(v) => v,
4535 None => &[],
4536 }
4537 }
4538
4539 pub fn clear_payload(&mut self) {
4540 self.payload = ::std::option::Option::None;
4541 }
4542
4543 pub fn has_payload(&self) -> bool {
4544 self.payload.is_some()
4545 }
4546
4547 pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
4549 self.payload = ::std::option::Option::Some(v);
4550 }
4551
4552 pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
4555 if self.payload.is_none() {
4556 self.payload = ::std::option::Option::Some(::std::vec::Vec::new());
4557 }
4558 self.payload.as_mut().unwrap()
4559 }
4560
4561 pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
4563 self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
4564 }
4565}
4566
4567impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_SteamBroadcast_Notification {
4568 const NAME: &'static str = "CRemoteClient_SteamBroadcast_Notification";
4569
4570 fn is_initialized(&self) -> bool {
4571 true
4572 }
4573
4574 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4575 while let Some(tag) = is.read_raw_tag_or_eof()? {
4576 match tag {
4577 9 => {
4578 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
4579 },
4580 17 => {
4581 self.clientid = ::std::option::Option::Some(is.read_fixed64()?);
4582 },
4583 26 => {
4584 self.payload = ::std::option::Option::Some(is.read_bytes()?);
4585 },
4586 tag => {
4587 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4588 },
4589 };
4590 }
4591 ::std::result::Result::Ok(())
4592 }
4593
4594 #[allow(unused_variables)]
4596 fn compute_size(&self) -> u64 {
4597 let mut my_size = 0;
4598 if let Some(v) = self.steamid {
4599 my_size += 1 + 8;
4600 }
4601 if let Some(v) = self.clientid {
4602 my_size += 1 + 8;
4603 }
4604 if let Some(v) = self.payload.as_ref() {
4605 my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
4606 }
4607 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4608 self.special_fields.cached_size().set(my_size as u32);
4609 my_size
4610 }
4611
4612 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4613 if let Some(v) = self.steamid {
4614 os.write_fixed64(1, v)?;
4615 }
4616 if let Some(v) = self.clientid {
4617 os.write_fixed64(2, v)?;
4618 }
4619 if let Some(v) = self.payload.as_ref() {
4620 os.write_bytes(3, v)?;
4621 }
4622 os.write_unknown_fields(self.special_fields.unknown_fields())?;
4623 ::std::result::Result::Ok(())
4624 }
4625
4626 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
4627 &self.special_fields
4628 }
4629
4630 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
4631 &mut self.special_fields
4632 }
4633
4634 fn new() -> CRemoteClient_SteamBroadcast_Notification {
4635 CRemoteClient_SteamBroadcast_Notification::new()
4636 }
4637
4638 fn clear(&mut self) {
4639 self.steamid = ::std::option::Option::None;
4640 self.clientid = ::std::option::Option::None;
4641 self.payload = ::std::option::Option::None;
4642 self.special_fields.clear();
4643 }
4644
4645 fn default_instance() -> &'static CRemoteClient_SteamBroadcast_Notification {
4646 static instance: CRemoteClient_SteamBroadcast_Notification = CRemoteClient_SteamBroadcast_Notification {
4647 steamid: ::std::option::Option::None,
4648 clientid: ::std::option::Option::None,
4649 payload: ::std::option::Option::None,
4650 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
4651 };
4652 &instance
4653 }
4654}
4655
4656#[derive(PartialEq,Clone,Default,Debug)]
4658pub struct CRemoteClient_SteamToSteam_Notification {
4659 pub steamid: ::std::option::Option<u64>,
4662 pub src_clientid: ::std::option::Option<u64>,
4664 pub dst_clientid: ::std::option::Option<u64>,
4666 pub secretid: ::std::option::Option<u32>,
4668 pub encrypted_payload: ::std::option::Option<::std::vec::Vec<u8>>,
4670 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
4673}
4674
4675impl<'a> ::std::default::Default for &'a CRemoteClient_SteamToSteam_Notification {
4676 fn default() -> &'a CRemoteClient_SteamToSteam_Notification {
4677 <CRemoteClient_SteamToSteam_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
4678 }
4679}
4680
4681impl CRemoteClient_SteamToSteam_Notification {
4682 pub fn new() -> CRemoteClient_SteamToSteam_Notification {
4683 ::std::default::Default::default()
4684 }
4685
4686 pub fn steamid(&self) -> u64 {
4689 self.steamid.unwrap_or(0)
4690 }
4691
4692 pub fn clear_steamid(&mut self) {
4693 self.steamid = ::std::option::Option::None;
4694 }
4695
4696 pub fn has_steamid(&self) -> bool {
4697 self.steamid.is_some()
4698 }
4699
4700 pub fn set_steamid(&mut self, v: u64) {
4702 self.steamid = ::std::option::Option::Some(v);
4703 }
4704
4705 pub fn src_clientid(&self) -> u64 {
4708 self.src_clientid.unwrap_or(0)
4709 }
4710
4711 pub fn clear_src_clientid(&mut self) {
4712 self.src_clientid = ::std::option::Option::None;
4713 }
4714
4715 pub fn has_src_clientid(&self) -> bool {
4716 self.src_clientid.is_some()
4717 }
4718
4719 pub fn set_src_clientid(&mut self, v: u64) {
4721 self.src_clientid = ::std::option::Option::Some(v);
4722 }
4723
4724 pub fn dst_clientid(&self) -> u64 {
4727 self.dst_clientid.unwrap_or(0)
4728 }
4729
4730 pub fn clear_dst_clientid(&mut self) {
4731 self.dst_clientid = ::std::option::Option::None;
4732 }
4733
4734 pub fn has_dst_clientid(&self) -> bool {
4735 self.dst_clientid.is_some()
4736 }
4737
4738 pub fn set_dst_clientid(&mut self, v: u64) {
4740 self.dst_clientid = ::std::option::Option::Some(v);
4741 }
4742
4743 pub fn secretid(&self) -> u32 {
4746 self.secretid.unwrap_or(0)
4747 }
4748
4749 pub fn clear_secretid(&mut self) {
4750 self.secretid = ::std::option::Option::None;
4751 }
4752
4753 pub fn has_secretid(&self) -> bool {
4754 self.secretid.is_some()
4755 }
4756
4757 pub fn set_secretid(&mut self, v: u32) {
4759 self.secretid = ::std::option::Option::Some(v);
4760 }
4761
4762 pub fn encrypted_payload(&self) -> &[u8] {
4765 match self.encrypted_payload.as_ref() {
4766 Some(v) => v,
4767 None => &[],
4768 }
4769 }
4770
4771 pub fn clear_encrypted_payload(&mut self) {
4772 self.encrypted_payload = ::std::option::Option::None;
4773 }
4774
4775 pub fn has_encrypted_payload(&self) -> bool {
4776 self.encrypted_payload.is_some()
4777 }
4778
4779 pub fn set_encrypted_payload(&mut self, v: ::std::vec::Vec<u8>) {
4781 self.encrypted_payload = ::std::option::Option::Some(v);
4782 }
4783
4784 pub fn mut_encrypted_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
4787 if self.encrypted_payload.is_none() {
4788 self.encrypted_payload = ::std::option::Option::Some(::std::vec::Vec::new());
4789 }
4790 self.encrypted_payload.as_mut().unwrap()
4791 }
4792
4793 pub fn take_encrypted_payload(&mut self) -> ::std::vec::Vec<u8> {
4795 self.encrypted_payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
4796 }
4797}
4798
4799impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_SteamToSteam_Notification {
4800 const NAME: &'static str = "CRemoteClient_SteamToSteam_Notification";
4801
4802 fn is_initialized(&self) -> bool {
4803 true
4804 }
4805
4806 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4807 while let Some(tag) = is.read_raw_tag_or_eof()? {
4808 match tag {
4809 9 => {
4810 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
4811 },
4812 17 => {
4813 self.src_clientid = ::std::option::Option::Some(is.read_fixed64()?);
4814 },
4815 25 => {
4816 self.dst_clientid = ::std::option::Option::Some(is.read_fixed64()?);
4817 },
4818 32 => {
4819 self.secretid = ::std::option::Option::Some(is.read_uint32()?);
4820 },
4821 42 => {
4822 self.encrypted_payload = ::std::option::Option::Some(is.read_bytes()?);
4823 },
4824 tag => {
4825 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4826 },
4827 };
4828 }
4829 ::std::result::Result::Ok(())
4830 }
4831
4832 #[allow(unused_variables)]
4834 fn compute_size(&self) -> u64 {
4835 let mut my_size = 0;
4836 if let Some(v) = self.steamid {
4837 my_size += 1 + 8;
4838 }
4839 if let Some(v) = self.src_clientid {
4840 my_size += 1 + 8;
4841 }
4842 if let Some(v) = self.dst_clientid {
4843 my_size += 1 + 8;
4844 }
4845 if let Some(v) = self.secretid {
4846 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(4, v);
4847 }
4848 if let Some(v) = self.encrypted_payload.as_ref() {
4849 my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(5, &v);
4850 }
4851 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4852 self.special_fields.cached_size().set(my_size as u32);
4853 my_size
4854 }
4855
4856 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
4857 if let Some(v) = self.steamid {
4858 os.write_fixed64(1, v)?;
4859 }
4860 if let Some(v) = self.src_clientid {
4861 os.write_fixed64(2, v)?;
4862 }
4863 if let Some(v) = self.dst_clientid {
4864 os.write_fixed64(3, v)?;
4865 }
4866 if let Some(v) = self.secretid {
4867 os.write_uint32(4, v)?;
4868 }
4869 if let Some(v) = self.encrypted_payload.as_ref() {
4870 os.write_bytes(5, v)?;
4871 }
4872 os.write_unknown_fields(self.special_fields.unknown_fields())?;
4873 ::std::result::Result::Ok(())
4874 }
4875
4876 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
4877 &self.special_fields
4878 }
4879
4880 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
4881 &mut self.special_fields
4882 }
4883
4884 fn new() -> CRemoteClient_SteamToSteam_Notification {
4885 CRemoteClient_SteamToSteam_Notification::new()
4886 }
4887
4888 fn clear(&mut self) {
4889 self.steamid = ::std::option::Option::None;
4890 self.src_clientid = ::std::option::Option::None;
4891 self.dst_clientid = ::std::option::Option::None;
4892 self.secretid = ::std::option::Option::None;
4893 self.encrypted_payload = ::std::option::Option::None;
4894 self.special_fields.clear();
4895 }
4896
4897 fn default_instance() -> &'static CRemoteClient_SteamToSteam_Notification {
4898 static instance: CRemoteClient_SteamToSteam_Notification = CRemoteClient_SteamToSteam_Notification {
4899 steamid: ::std::option::Option::None,
4900 src_clientid: ::std::option::Option::None,
4901 dst_clientid: ::std::option::Option::None,
4902 secretid: ::std::option::Option::None,
4903 encrypted_payload: ::std::option::Option::None,
4904 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
4905 };
4906 &instance
4907 }
4908}
4909
4910#[derive(PartialEq,Clone,Default,Debug)]
4912pub struct CRemotePlay_SessionStarted_Request {
4913 pub host_account_id: ::std::option::Option<u32>,
4916 pub client_account_id: ::std::option::Option<u32>,
4918 pub appid: ::std::option::Option<u32>,
4920 pub device_form_factor: ::std::option::Option<i32>,
4922 pub remote_play_together: ::std::option::Option<bool>,
4924 pub guest_session: ::std::option::Option<bool>,
4926 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
4929}
4930
4931impl<'a> ::std::default::Default for &'a CRemotePlay_SessionStarted_Request {
4932 fn default() -> &'a CRemotePlay_SessionStarted_Request {
4933 <CRemotePlay_SessionStarted_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
4934 }
4935}
4936
4937impl CRemotePlay_SessionStarted_Request {
4938 pub fn new() -> CRemotePlay_SessionStarted_Request {
4939 ::std::default::Default::default()
4940 }
4941
4942 pub fn host_account_id(&self) -> u32 {
4945 self.host_account_id.unwrap_or(0)
4946 }
4947
4948 pub fn clear_host_account_id(&mut self) {
4949 self.host_account_id = ::std::option::Option::None;
4950 }
4951
4952 pub fn has_host_account_id(&self) -> bool {
4953 self.host_account_id.is_some()
4954 }
4955
4956 pub fn set_host_account_id(&mut self, v: u32) {
4958 self.host_account_id = ::std::option::Option::Some(v);
4959 }
4960
4961 pub fn client_account_id(&self) -> u32 {
4964 self.client_account_id.unwrap_or(0)
4965 }
4966
4967 pub fn clear_client_account_id(&mut self) {
4968 self.client_account_id = ::std::option::Option::None;
4969 }
4970
4971 pub fn has_client_account_id(&self) -> bool {
4972 self.client_account_id.is_some()
4973 }
4974
4975 pub fn set_client_account_id(&mut self, v: u32) {
4977 self.client_account_id = ::std::option::Option::Some(v);
4978 }
4979
4980 pub fn appid(&self) -> u32 {
4983 self.appid.unwrap_or(0)
4984 }
4985
4986 pub fn clear_appid(&mut self) {
4987 self.appid = ::std::option::Option::None;
4988 }
4989
4990 pub fn has_appid(&self) -> bool {
4991 self.appid.is_some()
4992 }
4993
4994 pub fn set_appid(&mut self, v: u32) {
4996 self.appid = ::std::option::Option::Some(v);
4997 }
4998
4999 pub fn device_form_factor(&self) -> i32 {
5002 self.device_form_factor.unwrap_or(0)
5003 }
5004
5005 pub fn clear_device_form_factor(&mut self) {
5006 self.device_form_factor = ::std::option::Option::None;
5007 }
5008
5009 pub fn has_device_form_factor(&self) -> bool {
5010 self.device_form_factor.is_some()
5011 }
5012
5013 pub fn set_device_form_factor(&mut self, v: i32) {
5015 self.device_form_factor = ::std::option::Option::Some(v);
5016 }
5017
5018 pub fn remote_play_together(&self) -> bool {
5021 self.remote_play_together.unwrap_or(false)
5022 }
5023
5024 pub fn clear_remote_play_together(&mut self) {
5025 self.remote_play_together = ::std::option::Option::None;
5026 }
5027
5028 pub fn has_remote_play_together(&self) -> bool {
5029 self.remote_play_together.is_some()
5030 }
5031
5032 pub fn set_remote_play_together(&mut self, v: bool) {
5034 self.remote_play_together = ::std::option::Option::Some(v);
5035 }
5036
5037 pub fn guest_session(&self) -> bool {
5040 self.guest_session.unwrap_or(false)
5041 }
5042
5043 pub fn clear_guest_session(&mut self) {
5044 self.guest_session = ::std::option::Option::None;
5045 }
5046
5047 pub fn has_guest_session(&self) -> bool {
5048 self.guest_session.is_some()
5049 }
5050
5051 pub fn set_guest_session(&mut self, v: bool) {
5053 self.guest_session = ::std::option::Option::Some(v);
5054 }
5055}
5056
5057impl ::steam_vent_proto_common::protobuf::Message for CRemotePlay_SessionStarted_Request {
5058 const NAME: &'static str = "CRemotePlay_SessionStarted_Request";
5059
5060 fn is_initialized(&self) -> bool {
5061 true
5062 }
5063
5064 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5065 while let Some(tag) = is.read_raw_tag_or_eof()? {
5066 match tag {
5067 8 => {
5068 self.host_account_id = ::std::option::Option::Some(is.read_uint32()?);
5069 },
5070 16 => {
5071 self.client_account_id = ::std::option::Option::Some(is.read_uint32()?);
5072 },
5073 24 => {
5074 self.appid = ::std::option::Option::Some(is.read_uint32()?);
5075 },
5076 32 => {
5077 self.device_form_factor = ::std::option::Option::Some(is.read_int32()?);
5078 },
5079 40 => {
5080 self.remote_play_together = ::std::option::Option::Some(is.read_bool()?);
5081 },
5082 48 => {
5083 self.guest_session = ::std::option::Option::Some(is.read_bool()?);
5084 },
5085 tag => {
5086 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5087 },
5088 };
5089 }
5090 ::std::result::Result::Ok(())
5091 }
5092
5093 #[allow(unused_variables)]
5095 fn compute_size(&self) -> u64 {
5096 let mut my_size = 0;
5097 if let Some(v) = self.host_account_id {
5098 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
5099 }
5100 if let Some(v) = self.client_account_id {
5101 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
5102 }
5103 if let Some(v) = self.appid {
5104 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(3, v);
5105 }
5106 if let Some(v) = self.device_form_factor {
5107 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(4, v);
5108 }
5109 if let Some(v) = self.remote_play_together {
5110 my_size += 1 + 1;
5111 }
5112 if let Some(v) = self.guest_session {
5113 my_size += 1 + 1;
5114 }
5115 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5116 self.special_fields.cached_size().set(my_size as u32);
5117 my_size
5118 }
5119
5120 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5121 if let Some(v) = self.host_account_id {
5122 os.write_uint32(1, v)?;
5123 }
5124 if let Some(v) = self.client_account_id {
5125 os.write_uint32(2, v)?;
5126 }
5127 if let Some(v) = self.appid {
5128 os.write_uint32(3, v)?;
5129 }
5130 if let Some(v) = self.device_form_factor {
5131 os.write_int32(4, v)?;
5132 }
5133 if let Some(v) = self.remote_play_together {
5134 os.write_bool(5, v)?;
5135 }
5136 if let Some(v) = self.guest_session {
5137 os.write_bool(6, v)?;
5138 }
5139 os.write_unknown_fields(self.special_fields.unknown_fields())?;
5140 ::std::result::Result::Ok(())
5141 }
5142
5143 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
5144 &self.special_fields
5145 }
5146
5147 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
5148 &mut self.special_fields
5149 }
5150
5151 fn new() -> CRemotePlay_SessionStarted_Request {
5152 CRemotePlay_SessionStarted_Request::new()
5153 }
5154
5155 fn clear(&mut self) {
5156 self.host_account_id = ::std::option::Option::None;
5157 self.client_account_id = ::std::option::Option::None;
5158 self.appid = ::std::option::Option::None;
5159 self.device_form_factor = ::std::option::Option::None;
5160 self.remote_play_together = ::std::option::Option::None;
5161 self.guest_session = ::std::option::Option::None;
5162 self.special_fields.clear();
5163 }
5164
5165 fn default_instance() -> &'static CRemotePlay_SessionStarted_Request {
5166 static instance: CRemotePlay_SessionStarted_Request = CRemotePlay_SessionStarted_Request {
5167 host_account_id: ::std::option::Option::None,
5168 client_account_id: ::std::option::Option::None,
5169 appid: ::std::option::Option::None,
5170 device_form_factor: ::std::option::Option::None,
5171 remote_play_together: ::std::option::Option::None,
5172 guest_session: ::std::option::Option::None,
5173 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
5174 };
5175 &instance
5176 }
5177}
5178
5179#[derive(PartialEq,Clone,Default,Debug)]
5181pub struct CRemotePlay_SessionStarted_Response {
5182 pub record_id: ::std::option::Option<u64>,
5185 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
5188}
5189
5190impl<'a> ::std::default::Default for &'a CRemotePlay_SessionStarted_Response {
5191 fn default() -> &'a CRemotePlay_SessionStarted_Response {
5192 <CRemotePlay_SessionStarted_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
5193 }
5194}
5195
5196impl CRemotePlay_SessionStarted_Response {
5197 pub fn new() -> CRemotePlay_SessionStarted_Response {
5198 ::std::default::Default::default()
5199 }
5200
5201 pub fn record_id(&self) -> u64 {
5204 self.record_id.unwrap_or(0)
5205 }
5206
5207 pub fn clear_record_id(&mut self) {
5208 self.record_id = ::std::option::Option::None;
5209 }
5210
5211 pub fn has_record_id(&self) -> bool {
5212 self.record_id.is_some()
5213 }
5214
5215 pub fn set_record_id(&mut self, v: u64) {
5217 self.record_id = ::std::option::Option::Some(v);
5218 }
5219}
5220
5221impl ::steam_vent_proto_common::protobuf::Message for CRemotePlay_SessionStarted_Response {
5222 const NAME: &'static str = "CRemotePlay_SessionStarted_Response";
5223
5224 fn is_initialized(&self) -> bool {
5225 true
5226 }
5227
5228 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5229 while let Some(tag) = is.read_raw_tag_or_eof()? {
5230 match tag {
5231 9 => {
5232 self.record_id = ::std::option::Option::Some(is.read_fixed64()?);
5233 },
5234 tag => {
5235 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5236 },
5237 };
5238 }
5239 ::std::result::Result::Ok(())
5240 }
5241
5242 #[allow(unused_variables)]
5244 fn compute_size(&self) -> u64 {
5245 let mut my_size = 0;
5246 if let Some(v) = self.record_id {
5247 my_size += 1 + 8;
5248 }
5249 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5250 self.special_fields.cached_size().set(my_size as u32);
5251 my_size
5252 }
5253
5254 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5255 if let Some(v) = self.record_id {
5256 os.write_fixed64(1, v)?;
5257 }
5258 os.write_unknown_fields(self.special_fields.unknown_fields())?;
5259 ::std::result::Result::Ok(())
5260 }
5261
5262 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
5263 &self.special_fields
5264 }
5265
5266 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
5267 &mut self.special_fields
5268 }
5269
5270 fn new() -> CRemotePlay_SessionStarted_Response {
5271 CRemotePlay_SessionStarted_Response::new()
5272 }
5273
5274 fn clear(&mut self) {
5275 self.record_id = ::std::option::Option::None;
5276 self.special_fields.clear();
5277 }
5278
5279 fn default_instance() -> &'static CRemotePlay_SessionStarted_Response {
5280 static instance: CRemotePlay_SessionStarted_Response = CRemotePlay_SessionStarted_Response {
5281 record_id: ::std::option::Option::None,
5282 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
5283 };
5284 &instance
5285 }
5286}
5287
5288#[derive(PartialEq,Clone,Default,Debug)]
5290pub struct CRemotePlay_SessionStopped_Notification {
5291 pub record_id: ::std::option::Option<u64>,
5294 pub used_x264: ::std::option::Option<bool>,
5296 pub used_h264: ::std::option::Option<bool>,
5298 pub used_hevc: ::std::option::Option<bool>,
5300 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
5303}
5304
5305impl<'a> ::std::default::Default for &'a CRemotePlay_SessionStopped_Notification {
5306 fn default() -> &'a CRemotePlay_SessionStopped_Notification {
5307 <CRemotePlay_SessionStopped_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
5308 }
5309}
5310
5311impl CRemotePlay_SessionStopped_Notification {
5312 pub fn new() -> CRemotePlay_SessionStopped_Notification {
5313 ::std::default::Default::default()
5314 }
5315
5316 pub fn record_id(&self) -> u64 {
5319 self.record_id.unwrap_or(0)
5320 }
5321
5322 pub fn clear_record_id(&mut self) {
5323 self.record_id = ::std::option::Option::None;
5324 }
5325
5326 pub fn has_record_id(&self) -> bool {
5327 self.record_id.is_some()
5328 }
5329
5330 pub fn set_record_id(&mut self, v: u64) {
5332 self.record_id = ::std::option::Option::Some(v);
5333 }
5334
5335 pub fn used_x264(&self) -> bool {
5338 self.used_x264.unwrap_or(false)
5339 }
5340
5341 pub fn clear_used_x264(&mut self) {
5342 self.used_x264 = ::std::option::Option::None;
5343 }
5344
5345 pub fn has_used_x264(&self) -> bool {
5346 self.used_x264.is_some()
5347 }
5348
5349 pub fn set_used_x264(&mut self, v: bool) {
5351 self.used_x264 = ::std::option::Option::Some(v);
5352 }
5353
5354 pub fn used_h264(&self) -> bool {
5357 self.used_h264.unwrap_or(false)
5358 }
5359
5360 pub fn clear_used_h264(&mut self) {
5361 self.used_h264 = ::std::option::Option::None;
5362 }
5363
5364 pub fn has_used_h264(&self) -> bool {
5365 self.used_h264.is_some()
5366 }
5367
5368 pub fn set_used_h264(&mut self, v: bool) {
5370 self.used_h264 = ::std::option::Option::Some(v);
5371 }
5372
5373 pub fn used_hevc(&self) -> bool {
5376 self.used_hevc.unwrap_or(false)
5377 }
5378
5379 pub fn clear_used_hevc(&mut self) {
5380 self.used_hevc = ::std::option::Option::None;
5381 }
5382
5383 pub fn has_used_hevc(&self) -> bool {
5384 self.used_hevc.is_some()
5385 }
5386
5387 pub fn set_used_hevc(&mut self, v: bool) {
5389 self.used_hevc = ::std::option::Option::Some(v);
5390 }
5391}
5392
5393impl ::steam_vent_proto_common::protobuf::Message for CRemotePlay_SessionStopped_Notification {
5394 const NAME: &'static str = "CRemotePlay_SessionStopped_Notification";
5395
5396 fn is_initialized(&self) -> bool {
5397 true
5398 }
5399
5400 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5401 while let Some(tag) = is.read_raw_tag_or_eof()? {
5402 match tag {
5403 9 => {
5404 self.record_id = ::std::option::Option::Some(is.read_fixed64()?);
5405 },
5406 16 => {
5407 self.used_x264 = ::std::option::Option::Some(is.read_bool()?);
5408 },
5409 24 => {
5410 self.used_h264 = ::std::option::Option::Some(is.read_bool()?);
5411 },
5412 32 => {
5413 self.used_hevc = ::std::option::Option::Some(is.read_bool()?);
5414 },
5415 tag => {
5416 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5417 },
5418 };
5419 }
5420 ::std::result::Result::Ok(())
5421 }
5422
5423 #[allow(unused_variables)]
5425 fn compute_size(&self) -> u64 {
5426 let mut my_size = 0;
5427 if let Some(v) = self.record_id {
5428 my_size += 1 + 8;
5429 }
5430 if let Some(v) = self.used_x264 {
5431 my_size += 1 + 1;
5432 }
5433 if let Some(v) = self.used_h264 {
5434 my_size += 1 + 1;
5435 }
5436 if let Some(v) = self.used_hevc {
5437 my_size += 1 + 1;
5438 }
5439 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5440 self.special_fields.cached_size().set(my_size as u32);
5441 my_size
5442 }
5443
5444 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5445 if let Some(v) = self.record_id {
5446 os.write_fixed64(1, v)?;
5447 }
5448 if let Some(v) = self.used_x264 {
5449 os.write_bool(2, v)?;
5450 }
5451 if let Some(v) = self.used_h264 {
5452 os.write_bool(3, v)?;
5453 }
5454 if let Some(v) = self.used_hevc {
5455 os.write_bool(4, v)?;
5456 }
5457 os.write_unknown_fields(self.special_fields.unknown_fields())?;
5458 ::std::result::Result::Ok(())
5459 }
5460
5461 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
5462 &self.special_fields
5463 }
5464
5465 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
5466 &mut self.special_fields
5467 }
5468
5469 fn new() -> CRemotePlay_SessionStopped_Notification {
5470 CRemotePlay_SessionStopped_Notification::new()
5471 }
5472
5473 fn clear(&mut self) {
5474 self.record_id = ::std::option::Option::None;
5475 self.used_x264 = ::std::option::Option::None;
5476 self.used_h264 = ::std::option::Option::None;
5477 self.used_hevc = ::std::option::Option::None;
5478 self.special_fields.clear();
5479 }
5480
5481 fn default_instance() -> &'static CRemotePlay_SessionStopped_Notification {
5482 static instance: CRemotePlay_SessionStopped_Notification = CRemotePlay_SessionStopped_Notification {
5483 record_id: ::std::option::Option::None,
5484 used_x264: ::std::option::Option::None,
5485 used_h264: ::std::option::Option::None,
5486 used_hevc: ::std::option::Option::None,
5487 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
5488 };
5489 &instance
5490 }
5491}
5492
5493#[derive(PartialEq,Clone,Default,Debug)]
5495pub struct CRemotePlayTogether_Notification {
5496 pub steamid: ::std::option::Option<u64>,
5499 pub Message: ::std::option::Option<cremote_play_together_notification::Message>,
5501 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
5504}
5505
5506impl<'a> ::std::default::Default for &'a CRemotePlayTogether_Notification {
5507 fn default() -> &'a CRemotePlayTogether_Notification {
5508 <CRemotePlayTogether_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance()
5509 }
5510}
5511
5512impl CRemotePlayTogether_Notification {
5513 pub fn new() -> CRemotePlayTogether_Notification {
5514 ::std::default::Default::default()
5515 }
5516
5517 pub fn steamid(&self) -> u64 {
5520 self.steamid.unwrap_or(0)
5521 }
5522
5523 pub fn clear_steamid(&mut self) {
5524 self.steamid = ::std::option::Option::None;
5525 }
5526
5527 pub fn has_steamid(&self) -> bool {
5528 self.steamid.is_some()
5529 }
5530
5531 pub fn set_steamid(&mut self, v: u64) {
5533 self.steamid = ::std::option::Option::Some(v);
5534 }
5535
5536 pub fn group_updated(&self) -> &cremote_play_together_notification::GroupUpdated {
5539 match self.Message {
5540 ::std::option::Option::Some(cremote_play_together_notification::Message::GroupUpdated(ref v)) => v,
5541 _ => <cremote_play_together_notification::GroupUpdated as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
5542 }
5543 }
5544
5545 pub fn clear_group_updated(&mut self) {
5546 self.Message = ::std::option::Option::None;
5547 }
5548
5549 pub fn has_group_updated(&self) -> bool {
5550 match self.Message {
5551 ::std::option::Option::Some(cremote_play_together_notification::Message::GroupUpdated(..)) => true,
5552 _ => false,
5553 }
5554 }
5555
5556 pub fn set_group_updated(&mut self, v: cremote_play_together_notification::GroupUpdated) {
5558 self.Message = ::std::option::Option::Some(cremote_play_together_notification::Message::GroupUpdated(v))
5559 }
5560
5561 pub fn mut_group_updated(&mut self) -> &mut cremote_play_together_notification::GroupUpdated {
5563 if let ::std::option::Option::Some(cremote_play_together_notification::Message::GroupUpdated(_)) = self.Message {
5564 } else {
5565 self.Message = ::std::option::Option::Some(cremote_play_together_notification::Message::GroupUpdated(cremote_play_together_notification::GroupUpdated::new()));
5566 }
5567 match self.Message {
5568 ::std::option::Option::Some(cremote_play_together_notification::Message::GroupUpdated(ref mut v)) => v,
5569 _ => panic!(),
5570 }
5571 }
5572
5573 pub fn take_group_updated(&mut self) -> cremote_play_together_notification::GroupUpdated {
5575 if self.has_group_updated() {
5576 match self.Message.take() {
5577 ::std::option::Option::Some(cremote_play_together_notification::Message::GroupUpdated(v)) => v,
5578 _ => panic!(),
5579 }
5580 } else {
5581 cremote_play_together_notification::GroupUpdated::new()
5582 }
5583 }
5584}
5585
5586impl ::steam_vent_proto_common::protobuf::Message for CRemotePlayTogether_Notification {
5587 const NAME: &'static str = "CRemotePlayTogether_Notification";
5588
5589 fn is_initialized(&self) -> bool {
5590 true
5591 }
5592
5593 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5594 while let Some(tag) = is.read_raw_tag_or_eof()? {
5595 match tag {
5596 9 => {
5597 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
5598 },
5599 18 => {
5600 self.Message = ::std::option::Option::Some(cremote_play_together_notification::Message::GroupUpdated(is.read_message()?));
5601 },
5602 tag => {
5603 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5604 },
5605 };
5606 }
5607 ::std::result::Result::Ok(())
5608 }
5609
5610 #[allow(unused_variables)]
5612 fn compute_size(&self) -> u64 {
5613 let mut my_size = 0;
5614 if let Some(v) = self.steamid {
5615 my_size += 1 + 8;
5616 }
5617 if let ::std::option::Option::Some(ref v) = self.Message {
5618 match v {
5619 &cremote_play_together_notification::Message::GroupUpdated(ref v) => {
5620 let len = v.compute_size();
5621 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
5622 },
5623 };
5624 }
5625 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5626 self.special_fields.cached_size().set(my_size as u32);
5627 my_size
5628 }
5629
5630 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5631 if let Some(v) = self.steamid {
5632 os.write_fixed64(1, v)?;
5633 }
5634 if let ::std::option::Option::Some(ref v) = self.Message {
5635 match v {
5636 &cremote_play_together_notification::Message::GroupUpdated(ref v) => {
5637 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
5638 },
5639 };
5640 }
5641 os.write_unknown_fields(self.special_fields.unknown_fields())?;
5642 ::std::result::Result::Ok(())
5643 }
5644
5645 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
5646 &self.special_fields
5647 }
5648
5649 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
5650 &mut self.special_fields
5651 }
5652
5653 fn new() -> CRemotePlayTogether_Notification {
5654 CRemotePlayTogether_Notification::new()
5655 }
5656
5657 fn clear(&mut self) {
5658 self.steamid = ::std::option::Option::None;
5659 self.Message = ::std::option::Option::None;
5660 self.special_fields.clear();
5661 }
5662
5663 fn default_instance() -> &'static CRemotePlayTogether_Notification {
5664 static instance: CRemotePlayTogether_Notification = CRemotePlayTogether_Notification {
5665 steamid: ::std::option::Option::None,
5666 Message: ::std::option::Option::None,
5667 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
5668 };
5669 &instance
5670 }
5671}
5672
5673pub mod cremote_play_together_notification {
5675
5676 #[derive(Clone,PartialEq,Debug)]
5677 #[non_exhaustive]
5678 pub enum Message {
5680 GroupUpdated(GroupUpdated),
5682 }
5683
5684 impl ::steam_vent_proto_common::protobuf::Oneof for Message {
5685 }
5686
5687 impl Message {
5688 }
5689 #[derive(PartialEq,Clone,Default,Debug)]
5691 pub struct Player {
5692 pub steamid: ::std::option::Option<u64>,
5695 pub guestid: ::std::option::Option<u32>,
5697 pub avatar_hash: ::std::option::Option<::std::vec::Vec<u8>>,
5699 pub keyboard_enabled: ::std::option::Option<bool>,
5701 pub mouse_enabled: ::std::option::Option<bool>,
5703 pub controller_enabled: ::std::option::Option<bool>,
5705 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
5708 }
5709
5710 impl<'a> ::std::default::Default for &'a Player {
5711 fn default() -> &'a Player {
5712 <Player as ::steam_vent_proto_common::protobuf::Message>::default_instance()
5713 }
5714 }
5715
5716 impl Player {
5717 pub fn new() -> Player {
5718 ::std::default::Default::default()
5719 }
5720
5721 pub fn steamid(&self) -> u64 {
5724 self.steamid.unwrap_or(0)
5725 }
5726
5727 pub fn clear_steamid(&mut self) {
5728 self.steamid = ::std::option::Option::None;
5729 }
5730
5731 pub fn has_steamid(&self) -> bool {
5732 self.steamid.is_some()
5733 }
5734
5735 pub fn set_steamid(&mut self, v: u64) {
5737 self.steamid = ::std::option::Option::Some(v);
5738 }
5739
5740 pub fn guestid(&self) -> u32 {
5743 self.guestid.unwrap_or(0)
5744 }
5745
5746 pub fn clear_guestid(&mut self) {
5747 self.guestid = ::std::option::Option::None;
5748 }
5749
5750 pub fn has_guestid(&self) -> bool {
5751 self.guestid.is_some()
5752 }
5753
5754 pub fn set_guestid(&mut self, v: u32) {
5756 self.guestid = ::std::option::Option::Some(v);
5757 }
5758
5759 pub fn avatar_hash(&self) -> &[u8] {
5762 match self.avatar_hash.as_ref() {
5763 Some(v) => v,
5764 None => &[],
5765 }
5766 }
5767
5768 pub fn clear_avatar_hash(&mut self) {
5769 self.avatar_hash = ::std::option::Option::None;
5770 }
5771
5772 pub fn has_avatar_hash(&self) -> bool {
5773 self.avatar_hash.is_some()
5774 }
5775
5776 pub fn set_avatar_hash(&mut self, v: ::std::vec::Vec<u8>) {
5778 self.avatar_hash = ::std::option::Option::Some(v);
5779 }
5780
5781 pub fn mut_avatar_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
5784 if self.avatar_hash.is_none() {
5785 self.avatar_hash = ::std::option::Option::Some(::std::vec::Vec::new());
5786 }
5787 self.avatar_hash.as_mut().unwrap()
5788 }
5789
5790 pub fn take_avatar_hash(&mut self) -> ::std::vec::Vec<u8> {
5792 self.avatar_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
5793 }
5794
5795 pub fn keyboard_enabled(&self) -> bool {
5798 self.keyboard_enabled.unwrap_or(false)
5799 }
5800
5801 pub fn clear_keyboard_enabled(&mut self) {
5802 self.keyboard_enabled = ::std::option::Option::None;
5803 }
5804
5805 pub fn has_keyboard_enabled(&self) -> bool {
5806 self.keyboard_enabled.is_some()
5807 }
5808
5809 pub fn set_keyboard_enabled(&mut self, v: bool) {
5811 self.keyboard_enabled = ::std::option::Option::Some(v);
5812 }
5813
5814 pub fn mouse_enabled(&self) -> bool {
5817 self.mouse_enabled.unwrap_or(false)
5818 }
5819
5820 pub fn clear_mouse_enabled(&mut self) {
5821 self.mouse_enabled = ::std::option::Option::None;
5822 }
5823
5824 pub fn has_mouse_enabled(&self) -> bool {
5825 self.mouse_enabled.is_some()
5826 }
5827
5828 pub fn set_mouse_enabled(&mut self, v: bool) {
5830 self.mouse_enabled = ::std::option::Option::Some(v);
5831 }
5832
5833 pub fn controller_enabled(&self) -> bool {
5836 self.controller_enabled.unwrap_or(false)
5837 }
5838
5839 pub fn clear_controller_enabled(&mut self) {
5840 self.controller_enabled = ::std::option::Option::None;
5841 }
5842
5843 pub fn has_controller_enabled(&self) -> bool {
5844 self.controller_enabled.is_some()
5845 }
5846
5847 pub fn set_controller_enabled(&mut self, v: bool) {
5849 self.controller_enabled = ::std::option::Option::Some(v);
5850 }
5851 }
5852
5853 impl ::steam_vent_proto_common::protobuf::Message for Player {
5854 const NAME: &'static str = "Player";
5855
5856 fn is_initialized(&self) -> bool {
5857 true
5858 }
5859
5860 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5861 while let Some(tag) = is.read_raw_tag_or_eof()? {
5862 match tag {
5863 9 => {
5864 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
5865 },
5866 16 => {
5867 self.guestid = ::std::option::Option::Some(is.read_uint32()?);
5868 },
5869 26 => {
5870 self.avatar_hash = ::std::option::Option::Some(is.read_bytes()?);
5871 },
5872 32 => {
5873 self.keyboard_enabled = ::std::option::Option::Some(is.read_bool()?);
5874 },
5875 40 => {
5876 self.mouse_enabled = ::std::option::Option::Some(is.read_bool()?);
5877 },
5878 48 => {
5879 self.controller_enabled = ::std::option::Option::Some(is.read_bool()?);
5880 },
5881 tag => {
5882 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5883 },
5884 };
5885 }
5886 ::std::result::Result::Ok(())
5887 }
5888
5889 #[allow(unused_variables)]
5891 fn compute_size(&self) -> u64 {
5892 let mut my_size = 0;
5893 if let Some(v) = self.steamid {
5894 my_size += 1 + 8;
5895 }
5896 if let Some(v) = self.guestid {
5897 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(2, v);
5898 }
5899 if let Some(v) = self.avatar_hash.as_ref() {
5900 my_size += ::steam_vent_proto_common::protobuf::rt::bytes_size(3, &v);
5901 }
5902 if let Some(v) = self.keyboard_enabled {
5903 my_size += 1 + 1;
5904 }
5905 if let Some(v) = self.mouse_enabled {
5906 my_size += 1 + 1;
5907 }
5908 if let Some(v) = self.controller_enabled {
5909 my_size += 1 + 1;
5910 }
5911 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5912 self.special_fields.cached_size().set(my_size as u32);
5913 my_size
5914 }
5915
5916 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
5917 if let Some(v) = self.steamid {
5918 os.write_fixed64(1, v)?;
5919 }
5920 if let Some(v) = self.guestid {
5921 os.write_uint32(2, v)?;
5922 }
5923 if let Some(v) = self.avatar_hash.as_ref() {
5924 os.write_bytes(3, v)?;
5925 }
5926 if let Some(v) = self.keyboard_enabled {
5927 os.write_bool(4, v)?;
5928 }
5929 if let Some(v) = self.mouse_enabled {
5930 os.write_bool(5, v)?;
5931 }
5932 if let Some(v) = self.controller_enabled {
5933 os.write_bool(6, v)?;
5934 }
5935 os.write_unknown_fields(self.special_fields.unknown_fields())?;
5936 ::std::result::Result::Ok(())
5937 }
5938
5939 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
5940 &self.special_fields
5941 }
5942
5943 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
5944 &mut self.special_fields
5945 }
5946
5947 fn new() -> Player {
5948 Player::new()
5949 }
5950
5951 fn clear(&mut self) {
5952 self.steamid = ::std::option::Option::None;
5953 self.guestid = ::std::option::Option::None;
5954 self.avatar_hash = ::std::option::Option::None;
5955 self.keyboard_enabled = ::std::option::Option::None;
5956 self.mouse_enabled = ::std::option::Option::None;
5957 self.controller_enabled = ::std::option::Option::None;
5958 self.special_fields.clear();
5959 }
5960
5961 fn default_instance() -> &'static Player {
5962 static instance: Player = Player {
5963 steamid: ::std::option::Option::None,
5964 guestid: ::std::option::Option::None,
5965 avatar_hash: ::std::option::Option::None,
5966 keyboard_enabled: ::std::option::Option::None,
5967 mouse_enabled: ::std::option::Option::None,
5968 controller_enabled: ::std::option::Option::None,
5969 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
5970 };
5971 &instance
5972 }
5973 }
5974
5975 #[derive(PartialEq,Clone,Default,Debug)]
5977 pub struct ControllerSlot_obsolete {
5978 pub slotid: ::std::option::Option<u32>,
5981 pub steamid: ::std::option::Option<u64>,
5983 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
5986 }
5987
5988 impl<'a> ::std::default::Default for &'a ControllerSlot_obsolete {
5989 fn default() -> &'a ControllerSlot_obsolete {
5990 <ControllerSlot_obsolete as ::steam_vent_proto_common::protobuf::Message>::default_instance()
5991 }
5992 }
5993
5994 impl ControllerSlot_obsolete {
5995 pub fn new() -> ControllerSlot_obsolete {
5996 ::std::default::Default::default()
5997 }
5998
5999 pub fn slotid(&self) -> u32 {
6002 self.slotid.unwrap_or(0)
6003 }
6004
6005 pub fn clear_slotid(&mut self) {
6006 self.slotid = ::std::option::Option::None;
6007 }
6008
6009 pub fn has_slotid(&self) -> bool {
6010 self.slotid.is_some()
6011 }
6012
6013 pub fn set_slotid(&mut self, v: u32) {
6015 self.slotid = ::std::option::Option::Some(v);
6016 }
6017
6018 pub fn steamid(&self) -> u64 {
6021 self.steamid.unwrap_or(0)
6022 }
6023
6024 pub fn clear_steamid(&mut self) {
6025 self.steamid = ::std::option::Option::None;
6026 }
6027
6028 pub fn has_steamid(&self) -> bool {
6029 self.steamid.is_some()
6030 }
6031
6032 pub fn set_steamid(&mut self, v: u64) {
6034 self.steamid = ::std::option::Option::Some(v);
6035 }
6036 }
6037
6038 impl ::steam_vent_proto_common::protobuf::Message for ControllerSlot_obsolete {
6039 const NAME: &'static str = "ControllerSlot_obsolete";
6040
6041 fn is_initialized(&self) -> bool {
6042 true
6043 }
6044
6045 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6046 while let Some(tag) = is.read_raw_tag_or_eof()? {
6047 match tag {
6048 8 => {
6049 self.slotid = ::std::option::Option::Some(is.read_uint32()?);
6050 },
6051 17 => {
6052 self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
6053 },
6054 tag => {
6055 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6056 },
6057 };
6058 }
6059 ::std::result::Result::Ok(())
6060 }
6061
6062 #[allow(unused_variables)]
6064 fn compute_size(&self) -> u64 {
6065 let mut my_size = 0;
6066 if let Some(v) = self.slotid {
6067 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
6068 }
6069 if let Some(v) = self.steamid {
6070 my_size += 1 + 8;
6071 }
6072 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6073 self.special_fields.cached_size().set(my_size as u32);
6074 my_size
6075 }
6076
6077 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6078 if let Some(v) = self.slotid {
6079 os.write_uint32(1, v)?;
6080 }
6081 if let Some(v) = self.steamid {
6082 os.write_fixed64(2, v)?;
6083 }
6084 os.write_unknown_fields(self.special_fields.unknown_fields())?;
6085 ::std::result::Result::Ok(())
6086 }
6087
6088 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
6089 &self.special_fields
6090 }
6091
6092 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
6093 &mut self.special_fields
6094 }
6095
6096 fn new() -> ControllerSlot_obsolete {
6097 ControllerSlot_obsolete::new()
6098 }
6099
6100 fn clear(&mut self) {
6101 self.slotid = ::std::option::Option::None;
6102 self.steamid = ::std::option::Option::None;
6103 self.special_fields.clear();
6104 }
6105
6106 fn default_instance() -> &'static ControllerSlot_obsolete {
6107 static instance: ControllerSlot_obsolete = ControllerSlot_obsolete {
6108 slotid: ::std::option::Option::None,
6109 steamid: ::std::option::Option::None,
6110 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
6111 };
6112 &instance
6113 }
6114 }
6115
6116 #[derive(PartialEq,Clone,Default,Debug)]
6118 pub struct ControllerSlot {
6119 pub slotid: ::std::option::Option<u32>,
6122 pub player: ::steam_vent_proto_common::protobuf::MessageField<Player>,
6124 pub controller_type: ::std::option::Option<i32>,
6126 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
6129 }
6130
6131 impl<'a> ::std::default::Default for &'a ControllerSlot {
6132 fn default() -> &'a ControllerSlot {
6133 <ControllerSlot as ::steam_vent_proto_common::protobuf::Message>::default_instance()
6134 }
6135 }
6136
6137 impl ControllerSlot {
6138 pub fn new() -> ControllerSlot {
6139 ::std::default::Default::default()
6140 }
6141
6142 pub fn slotid(&self) -> u32 {
6145 self.slotid.unwrap_or(0)
6146 }
6147
6148 pub fn clear_slotid(&mut self) {
6149 self.slotid = ::std::option::Option::None;
6150 }
6151
6152 pub fn has_slotid(&self) -> bool {
6153 self.slotid.is_some()
6154 }
6155
6156 pub fn set_slotid(&mut self, v: u32) {
6158 self.slotid = ::std::option::Option::Some(v);
6159 }
6160
6161 pub fn controller_type(&self) -> i32 {
6164 self.controller_type.unwrap_or(0)
6165 }
6166
6167 pub fn clear_controller_type(&mut self) {
6168 self.controller_type = ::std::option::Option::None;
6169 }
6170
6171 pub fn has_controller_type(&self) -> bool {
6172 self.controller_type.is_some()
6173 }
6174
6175 pub fn set_controller_type(&mut self, v: i32) {
6177 self.controller_type = ::std::option::Option::Some(v);
6178 }
6179 }
6180
6181 impl ::steam_vent_proto_common::protobuf::Message for ControllerSlot {
6182 const NAME: &'static str = "ControllerSlot";
6183
6184 fn is_initialized(&self) -> bool {
6185 true
6186 }
6187
6188 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6189 while let Some(tag) = is.read_raw_tag_or_eof()? {
6190 match tag {
6191 8 => {
6192 self.slotid = ::std::option::Option::Some(is.read_uint32()?);
6193 },
6194 18 => {
6195 ::steam_vent_proto_common::protobuf::rt::read_singular_message_into_field(is, &mut self.player)?;
6196 },
6197 24 => {
6198 self.controller_type = ::std::option::Option::Some(is.read_int32()?);
6199 },
6200 tag => {
6201 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6202 },
6203 };
6204 }
6205 ::std::result::Result::Ok(())
6206 }
6207
6208 #[allow(unused_variables)]
6210 fn compute_size(&self) -> u64 {
6211 let mut my_size = 0;
6212 if let Some(v) = self.slotid {
6213 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
6214 }
6215 if let Some(v) = self.player.as_ref() {
6216 let len = v.compute_size();
6217 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
6218 }
6219 if let Some(v) = self.controller_type {
6220 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(3, v);
6221 }
6222 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6223 self.special_fields.cached_size().set(my_size as u32);
6224 my_size
6225 }
6226
6227 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6228 if let Some(v) = self.slotid {
6229 os.write_uint32(1, v)?;
6230 }
6231 if let Some(v) = self.player.as_ref() {
6232 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
6233 }
6234 if let Some(v) = self.controller_type {
6235 os.write_int32(3, v)?;
6236 }
6237 os.write_unknown_fields(self.special_fields.unknown_fields())?;
6238 ::std::result::Result::Ok(())
6239 }
6240
6241 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
6242 &self.special_fields
6243 }
6244
6245 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
6246 &mut self.special_fields
6247 }
6248
6249 fn new() -> ControllerSlot {
6250 ControllerSlot::new()
6251 }
6252
6253 fn clear(&mut self) {
6254 self.slotid = ::std::option::Option::None;
6255 self.player.clear();
6256 self.controller_type = ::std::option::Option::None;
6257 self.special_fields.clear();
6258 }
6259
6260 fn default_instance() -> &'static ControllerSlot {
6261 static instance: ControllerSlot = ControllerSlot {
6262 slotid: ::std::option::Option::None,
6263 player: ::steam_vent_proto_common::protobuf::MessageField::none(),
6264 controller_type: ::std::option::Option::None,
6265 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
6266 };
6267 &instance
6268 }
6269 }
6270
6271 #[derive(PartialEq,Clone,Default,Debug)]
6273 pub struct GroupUpdated {
6274 pub host_steamid: ::std::option::Option<u64>,
6277 pub host_clientid: ::std::option::Option<u64>,
6279 pub players_obsolete: ::std::vec::Vec<u64>,
6281 pub host_gameid: ::std::option::Option<u64>,
6283 pub controller_slots_obsolete: ::std::vec::Vec<ControllerSlot_obsolete>,
6285 pub has_new_players: ::std::option::Option<bool>,
6287 pub player_slots: ::std::vec::Vec<Player>,
6289 pub controller_slots: ::std::vec::Vec<ControllerSlot>,
6291 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
6294 }
6295
6296 impl<'a> ::std::default::Default for &'a GroupUpdated {
6297 fn default() -> &'a GroupUpdated {
6298 <GroupUpdated as ::steam_vent_proto_common::protobuf::Message>::default_instance()
6299 }
6300 }
6301
6302 impl GroupUpdated {
6303 pub fn new() -> GroupUpdated {
6304 ::std::default::Default::default()
6305 }
6306
6307 pub fn host_steamid(&self) -> u64 {
6310 self.host_steamid.unwrap_or(0)
6311 }
6312
6313 pub fn clear_host_steamid(&mut self) {
6314 self.host_steamid = ::std::option::Option::None;
6315 }
6316
6317 pub fn has_host_steamid(&self) -> bool {
6318 self.host_steamid.is_some()
6319 }
6320
6321 pub fn set_host_steamid(&mut self, v: u64) {
6323 self.host_steamid = ::std::option::Option::Some(v);
6324 }
6325
6326 pub fn host_clientid(&self) -> u64 {
6329 self.host_clientid.unwrap_or(0)
6330 }
6331
6332 pub fn clear_host_clientid(&mut self) {
6333 self.host_clientid = ::std::option::Option::None;
6334 }
6335
6336 pub fn has_host_clientid(&self) -> bool {
6337 self.host_clientid.is_some()
6338 }
6339
6340 pub fn set_host_clientid(&mut self, v: u64) {
6342 self.host_clientid = ::std::option::Option::Some(v);
6343 }
6344
6345 pub fn host_gameid(&self) -> u64 {
6348 self.host_gameid.unwrap_or(0)
6349 }
6350
6351 pub fn clear_host_gameid(&mut self) {
6352 self.host_gameid = ::std::option::Option::None;
6353 }
6354
6355 pub fn has_host_gameid(&self) -> bool {
6356 self.host_gameid.is_some()
6357 }
6358
6359 pub fn set_host_gameid(&mut self, v: u64) {
6361 self.host_gameid = ::std::option::Option::Some(v);
6362 }
6363
6364 pub fn has_new_players(&self) -> bool {
6367 self.has_new_players.unwrap_or(false)
6368 }
6369
6370 pub fn clear_has_new_players(&mut self) {
6371 self.has_new_players = ::std::option::Option::None;
6372 }
6373
6374 pub fn has_has_new_players(&self) -> bool {
6375 self.has_new_players.is_some()
6376 }
6377
6378 pub fn set_has_new_players(&mut self, v: bool) {
6380 self.has_new_players = ::std::option::Option::Some(v);
6381 }
6382 }
6383
6384 impl ::steam_vent_proto_common::protobuf::Message for GroupUpdated {
6385 const NAME: &'static str = "GroupUpdated";
6386
6387 fn is_initialized(&self) -> bool {
6388 true
6389 }
6390
6391 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6392 while let Some(tag) = is.read_raw_tag_or_eof()? {
6393 match tag {
6394 9 => {
6395 self.host_steamid = ::std::option::Option::Some(is.read_fixed64()?);
6396 },
6397 17 => {
6398 self.host_clientid = ::std::option::Option::Some(is.read_fixed64()?);
6399 },
6400 26 => {
6401 is.read_repeated_packed_fixed64_into(&mut self.players_obsolete)?;
6402 },
6403 25 => {
6404 self.players_obsolete.push(is.read_fixed64()?);
6405 },
6406 33 => {
6407 self.host_gameid = ::std::option::Option::Some(is.read_fixed64()?);
6408 },
6409 42 => {
6410 self.controller_slots_obsolete.push(is.read_message()?);
6411 },
6412 48 => {
6413 self.has_new_players = ::std::option::Option::Some(is.read_bool()?);
6414 },
6415 58 => {
6416 self.player_slots.push(is.read_message()?);
6417 },
6418 66 => {
6419 self.controller_slots.push(is.read_message()?);
6420 },
6421 tag => {
6422 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6423 },
6424 };
6425 }
6426 ::std::result::Result::Ok(())
6427 }
6428
6429 #[allow(unused_variables)]
6431 fn compute_size(&self) -> u64 {
6432 let mut my_size = 0;
6433 if let Some(v) = self.host_steamid {
6434 my_size += 1 + 8;
6435 }
6436 if let Some(v) = self.host_clientid {
6437 my_size += 1 + 8;
6438 }
6439 my_size += 9 * self.players_obsolete.len() as u64;
6440 if let Some(v) = self.host_gameid {
6441 my_size += 1 + 8;
6442 }
6443 for value in &self.controller_slots_obsolete {
6444 let len = value.compute_size();
6445 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
6446 };
6447 if let Some(v) = self.has_new_players {
6448 my_size += 1 + 1;
6449 }
6450 for value in &self.player_slots {
6451 let len = value.compute_size();
6452 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
6453 };
6454 for value in &self.controller_slots {
6455 let len = value.compute_size();
6456 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
6457 };
6458 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6459 self.special_fields.cached_size().set(my_size as u32);
6460 my_size
6461 }
6462
6463 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6464 if let Some(v) = self.host_steamid {
6465 os.write_fixed64(1, v)?;
6466 }
6467 if let Some(v) = self.host_clientid {
6468 os.write_fixed64(2, v)?;
6469 }
6470 for v in &self.players_obsolete {
6471 os.write_fixed64(3, *v)?;
6472 };
6473 if let Some(v) = self.host_gameid {
6474 os.write_fixed64(4, v)?;
6475 }
6476 for v in &self.controller_slots_obsolete {
6477 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
6478 };
6479 if let Some(v) = self.has_new_players {
6480 os.write_bool(6, v)?;
6481 }
6482 for v in &self.player_slots {
6483 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
6484 };
6485 for v in &self.controller_slots {
6486 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
6487 };
6488 os.write_unknown_fields(self.special_fields.unknown_fields())?;
6489 ::std::result::Result::Ok(())
6490 }
6491
6492 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
6493 &self.special_fields
6494 }
6495
6496 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
6497 &mut self.special_fields
6498 }
6499
6500 fn new() -> GroupUpdated {
6501 GroupUpdated::new()
6502 }
6503
6504 fn clear(&mut self) {
6505 self.host_steamid = ::std::option::Option::None;
6506 self.host_clientid = ::std::option::Option::None;
6507 self.players_obsolete.clear();
6508 self.host_gameid = ::std::option::Option::None;
6509 self.controller_slots_obsolete.clear();
6510 self.has_new_players = ::std::option::Option::None;
6511 self.player_slots.clear();
6512 self.controller_slots.clear();
6513 self.special_fields.clear();
6514 }
6515
6516 fn default_instance() -> &'static GroupUpdated {
6517 static instance: GroupUpdated = GroupUpdated {
6518 host_steamid: ::std::option::Option::None,
6519 host_clientid: ::std::option::Option::None,
6520 players_obsolete: ::std::vec::Vec::new(),
6521 host_gameid: ::std::option::Option::None,
6522 controller_slots_obsolete: ::std::vec::Vec::new(),
6523 has_new_players: ::std::option::Option::None,
6524 player_slots: ::std::vec::Vec::new(),
6525 controller_slots: ::std::vec::Vec::new(),
6526 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
6527 };
6528 &instance
6529 }
6530 }
6531}
6532
6533#[derive(PartialEq,Clone,Default,Debug)]
6535pub struct CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6536 pub appid: ::std::option::Option<u32>,
6539 pub launch_parameters: ::std::option::Option<::std::string::String>,
6541 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
6544}
6545
6546impl<'a> ::std::default::Default for &'a CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6547 fn default() -> &'a CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6548 <CRemoteClient_CreateRemotePlayTogetherInvitation_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
6549 }
6550}
6551
6552impl CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6553 pub fn new() -> CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6554 ::std::default::Default::default()
6555 }
6556
6557 pub fn appid(&self) -> u32 {
6560 self.appid.unwrap_or(0)
6561 }
6562
6563 pub fn clear_appid(&mut self) {
6564 self.appid = ::std::option::Option::None;
6565 }
6566
6567 pub fn has_appid(&self) -> bool {
6568 self.appid.is_some()
6569 }
6570
6571 pub fn set_appid(&mut self, v: u32) {
6573 self.appid = ::std::option::Option::Some(v);
6574 }
6575
6576 pub fn launch_parameters(&self) -> &str {
6579 match self.launch_parameters.as_ref() {
6580 Some(v) => v,
6581 None => "",
6582 }
6583 }
6584
6585 pub fn clear_launch_parameters(&mut self) {
6586 self.launch_parameters = ::std::option::Option::None;
6587 }
6588
6589 pub fn has_launch_parameters(&self) -> bool {
6590 self.launch_parameters.is_some()
6591 }
6592
6593 pub fn set_launch_parameters(&mut self, v: ::std::string::String) {
6595 self.launch_parameters = ::std::option::Option::Some(v);
6596 }
6597
6598 pub fn mut_launch_parameters(&mut self) -> &mut ::std::string::String {
6601 if self.launch_parameters.is_none() {
6602 self.launch_parameters = ::std::option::Option::Some(::std::string::String::new());
6603 }
6604 self.launch_parameters.as_mut().unwrap()
6605 }
6606
6607 pub fn take_launch_parameters(&mut self) -> ::std::string::String {
6609 self.launch_parameters.take().unwrap_or_else(|| ::std::string::String::new())
6610 }
6611}
6612
6613impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6614 const NAME: &'static str = "CRemoteClient_CreateRemotePlayTogetherInvitation_Request";
6615
6616 fn is_initialized(&self) -> bool {
6617 true
6618 }
6619
6620 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6621 while let Some(tag) = is.read_raw_tag_or_eof()? {
6622 match tag {
6623 8 => {
6624 self.appid = ::std::option::Option::Some(is.read_uint32()?);
6625 },
6626 18 => {
6627 self.launch_parameters = ::std::option::Option::Some(is.read_string()?);
6628 },
6629 tag => {
6630 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6631 },
6632 };
6633 }
6634 ::std::result::Result::Ok(())
6635 }
6636
6637 #[allow(unused_variables)]
6639 fn compute_size(&self) -> u64 {
6640 let mut my_size = 0;
6641 if let Some(v) = self.appid {
6642 my_size += ::steam_vent_proto_common::protobuf::rt::uint32_size(1, v);
6643 }
6644 if let Some(v) = self.launch_parameters.as_ref() {
6645 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(2, &v);
6646 }
6647 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6648 self.special_fields.cached_size().set(my_size as u32);
6649 my_size
6650 }
6651
6652 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6653 if let Some(v) = self.appid {
6654 os.write_uint32(1, v)?;
6655 }
6656 if let Some(v) = self.launch_parameters.as_ref() {
6657 os.write_string(2, v)?;
6658 }
6659 os.write_unknown_fields(self.special_fields.unknown_fields())?;
6660 ::std::result::Result::Ok(())
6661 }
6662
6663 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
6664 &self.special_fields
6665 }
6666
6667 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
6668 &mut self.special_fields
6669 }
6670
6671 fn new() -> CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6672 CRemoteClient_CreateRemotePlayTogetherInvitation_Request::new()
6673 }
6674
6675 fn clear(&mut self) {
6676 self.appid = ::std::option::Option::None;
6677 self.launch_parameters = ::std::option::Option::None;
6678 self.special_fields.clear();
6679 }
6680
6681 fn default_instance() -> &'static CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6682 static instance: CRemoteClient_CreateRemotePlayTogetherInvitation_Request = CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
6683 appid: ::std::option::Option::None,
6684 launch_parameters: ::std::option::Option::None,
6685 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
6686 };
6687 &instance
6688 }
6689}
6690
6691#[derive(PartialEq,Clone,Default,Debug)]
6693pub struct CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6694 pub invitation_code: ::std::option::Option<::std::string::String>,
6697 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
6700}
6701
6702impl<'a> ::std::default::Default for &'a CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6703 fn default() -> &'a CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6704 <CRemoteClient_CreateRemotePlayTogetherInvitation_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
6705 }
6706}
6707
6708impl CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6709 pub fn new() -> CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6710 ::std::default::Default::default()
6711 }
6712
6713 pub fn invitation_code(&self) -> &str {
6716 match self.invitation_code.as_ref() {
6717 Some(v) => v,
6718 None => "",
6719 }
6720 }
6721
6722 pub fn clear_invitation_code(&mut self) {
6723 self.invitation_code = ::std::option::Option::None;
6724 }
6725
6726 pub fn has_invitation_code(&self) -> bool {
6727 self.invitation_code.is_some()
6728 }
6729
6730 pub fn set_invitation_code(&mut self, v: ::std::string::String) {
6732 self.invitation_code = ::std::option::Option::Some(v);
6733 }
6734
6735 pub fn mut_invitation_code(&mut self) -> &mut ::std::string::String {
6738 if self.invitation_code.is_none() {
6739 self.invitation_code = ::std::option::Option::Some(::std::string::String::new());
6740 }
6741 self.invitation_code.as_mut().unwrap()
6742 }
6743
6744 pub fn take_invitation_code(&mut self) -> ::std::string::String {
6746 self.invitation_code.take().unwrap_or_else(|| ::std::string::String::new())
6747 }
6748}
6749
6750impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6751 const NAME: &'static str = "CRemoteClient_CreateRemotePlayTogetherInvitation_Response";
6752
6753 fn is_initialized(&self) -> bool {
6754 true
6755 }
6756
6757 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6758 while let Some(tag) = is.read_raw_tag_or_eof()? {
6759 match tag {
6760 10 => {
6761 self.invitation_code = ::std::option::Option::Some(is.read_string()?);
6762 },
6763 tag => {
6764 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6765 },
6766 };
6767 }
6768 ::std::result::Result::Ok(())
6769 }
6770
6771 #[allow(unused_variables)]
6773 fn compute_size(&self) -> u64 {
6774 let mut my_size = 0;
6775 if let Some(v) = self.invitation_code.as_ref() {
6776 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
6777 }
6778 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6779 self.special_fields.cached_size().set(my_size as u32);
6780 my_size
6781 }
6782
6783 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6784 if let Some(v) = self.invitation_code.as_ref() {
6785 os.write_string(1, v)?;
6786 }
6787 os.write_unknown_fields(self.special_fields.unknown_fields())?;
6788 ::std::result::Result::Ok(())
6789 }
6790
6791 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
6792 &self.special_fields
6793 }
6794
6795 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
6796 &mut self.special_fields
6797 }
6798
6799 fn new() -> CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6800 CRemoteClient_CreateRemotePlayTogetherInvitation_Response::new()
6801 }
6802
6803 fn clear(&mut self) {
6804 self.invitation_code = ::std::option::Option::None;
6805 self.special_fields.clear();
6806 }
6807
6808 fn default_instance() -> &'static CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6809 static instance: CRemoteClient_CreateRemotePlayTogetherInvitation_Response = CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
6810 invitation_code: ::std::option::Option::None,
6811 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
6812 };
6813 &instance
6814 }
6815}
6816
6817#[derive(PartialEq,Clone,Default,Debug)]
6819pub struct CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6820 pub invitation_code: ::std::option::Option<::std::string::String>,
6823 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
6826}
6827
6828impl<'a> ::std::default::Default for &'a CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6829 fn default() -> &'a CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6830 <CRemoteClient_DeleteRemotePlayTogetherInvitation_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
6831 }
6832}
6833
6834impl CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6835 pub fn new() -> CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6836 ::std::default::Default::default()
6837 }
6838
6839 pub fn invitation_code(&self) -> &str {
6842 match self.invitation_code.as_ref() {
6843 Some(v) => v,
6844 None => "",
6845 }
6846 }
6847
6848 pub fn clear_invitation_code(&mut self) {
6849 self.invitation_code = ::std::option::Option::None;
6850 }
6851
6852 pub fn has_invitation_code(&self) -> bool {
6853 self.invitation_code.is_some()
6854 }
6855
6856 pub fn set_invitation_code(&mut self, v: ::std::string::String) {
6858 self.invitation_code = ::std::option::Option::Some(v);
6859 }
6860
6861 pub fn mut_invitation_code(&mut self) -> &mut ::std::string::String {
6864 if self.invitation_code.is_none() {
6865 self.invitation_code = ::std::option::Option::Some(::std::string::String::new());
6866 }
6867 self.invitation_code.as_mut().unwrap()
6868 }
6869
6870 pub fn take_invitation_code(&mut self) -> ::std::string::String {
6872 self.invitation_code.take().unwrap_or_else(|| ::std::string::String::new())
6873 }
6874}
6875
6876impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6877 const NAME: &'static str = "CRemoteClient_DeleteRemotePlayTogetherInvitation_Request";
6878
6879 fn is_initialized(&self) -> bool {
6880 true
6881 }
6882
6883 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6884 while let Some(tag) = is.read_raw_tag_or_eof()? {
6885 match tag {
6886 10 => {
6887 self.invitation_code = ::std::option::Option::Some(is.read_string()?);
6888 },
6889 tag => {
6890 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6891 },
6892 };
6893 }
6894 ::std::result::Result::Ok(())
6895 }
6896
6897 #[allow(unused_variables)]
6899 fn compute_size(&self) -> u64 {
6900 let mut my_size = 0;
6901 if let Some(v) = self.invitation_code.as_ref() {
6902 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
6903 }
6904 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6905 self.special_fields.cached_size().set(my_size as u32);
6906 my_size
6907 }
6908
6909 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6910 if let Some(v) = self.invitation_code.as_ref() {
6911 os.write_string(1, v)?;
6912 }
6913 os.write_unknown_fields(self.special_fields.unknown_fields())?;
6914 ::std::result::Result::Ok(())
6915 }
6916
6917 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
6918 &self.special_fields
6919 }
6920
6921 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
6922 &mut self.special_fields
6923 }
6924
6925 fn new() -> CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6926 CRemoteClient_DeleteRemotePlayTogetherInvitation_Request::new()
6927 }
6928
6929 fn clear(&mut self) {
6930 self.invitation_code = ::std::option::Option::None;
6931 self.special_fields.clear();
6932 }
6933
6934 fn default_instance() -> &'static CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6935 static instance: CRemoteClient_DeleteRemotePlayTogetherInvitation_Request = CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
6936 invitation_code: ::std::option::Option::None,
6937 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
6938 };
6939 &instance
6940 }
6941}
6942
6943#[derive(PartialEq,Clone,Default,Debug)]
6945pub struct CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
6946 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
6949}
6950
6951impl<'a> ::std::default::Default for &'a CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
6952 fn default() -> &'a CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
6953 <CRemoteClient_DeleteRemotePlayTogetherInvitation_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
6954 }
6955}
6956
6957impl CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
6958 pub fn new() -> CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
6959 ::std::default::Default::default()
6960 }
6961}
6962
6963impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
6964 const NAME: &'static str = "CRemoteClient_DeleteRemotePlayTogetherInvitation_Response";
6965
6966 fn is_initialized(&self) -> bool {
6967 true
6968 }
6969
6970 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6971 while let Some(tag) = is.read_raw_tag_or_eof()? {
6972 match tag {
6973 tag => {
6974 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6975 },
6976 };
6977 }
6978 ::std::result::Result::Ok(())
6979 }
6980
6981 #[allow(unused_variables)]
6983 fn compute_size(&self) -> u64 {
6984 let mut my_size = 0;
6985 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6986 self.special_fields.cached_size().set(my_size as u32);
6987 my_size
6988 }
6989
6990 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
6991 os.write_unknown_fields(self.special_fields.unknown_fields())?;
6992 ::std::result::Result::Ok(())
6993 }
6994
6995 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
6996 &self.special_fields
6997 }
6998
6999 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
7000 &mut self.special_fields
7001 }
7002
7003 fn new() -> CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
7004 CRemoteClient_DeleteRemotePlayTogetherInvitation_Response::new()
7005 }
7006
7007 fn clear(&mut self) {
7008 self.special_fields.clear();
7009 }
7010
7011 fn default_instance() -> &'static CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
7012 static instance: CRemoteClient_DeleteRemotePlayTogetherInvitation_Response = CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
7013 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
7014 };
7015 &instance
7016 }
7017}
7018
7019#[derive(PartialEq,Clone,Default,Debug)]
7021pub struct CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7022 pub invitation_code: ::std::option::Option<::std::string::String>,
7025 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
7028}
7029
7030impl<'a> ::std::default::Default for &'a CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7031 fn default() -> &'a CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7032 <CRemoteClient_LookupRemotePlayTogetherInvitation_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance()
7033 }
7034}
7035
7036impl CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7037 pub fn new() -> CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7038 ::std::default::Default::default()
7039 }
7040
7041 pub fn invitation_code(&self) -> &str {
7044 match self.invitation_code.as_ref() {
7045 Some(v) => v,
7046 None => "",
7047 }
7048 }
7049
7050 pub fn clear_invitation_code(&mut self) {
7051 self.invitation_code = ::std::option::Option::None;
7052 }
7053
7054 pub fn has_invitation_code(&self) -> bool {
7055 self.invitation_code.is_some()
7056 }
7057
7058 pub fn set_invitation_code(&mut self, v: ::std::string::String) {
7060 self.invitation_code = ::std::option::Option::Some(v);
7061 }
7062
7063 pub fn mut_invitation_code(&mut self) -> &mut ::std::string::String {
7066 if self.invitation_code.is_none() {
7067 self.invitation_code = ::std::option::Option::Some(::std::string::String::new());
7068 }
7069 self.invitation_code.as_mut().unwrap()
7070 }
7071
7072 pub fn take_invitation_code(&mut self) -> ::std::string::String {
7074 self.invitation_code.take().unwrap_or_else(|| ::std::string::String::new())
7075 }
7076}
7077
7078impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7079 const NAME: &'static str = "CRemoteClient_LookupRemotePlayTogetherInvitation_Request";
7080
7081 fn is_initialized(&self) -> bool {
7082 true
7083 }
7084
7085 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
7086 while let Some(tag) = is.read_raw_tag_or_eof()? {
7087 match tag {
7088 10 => {
7089 self.invitation_code = ::std::option::Option::Some(is.read_string()?);
7090 },
7091 tag => {
7092 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7093 },
7094 };
7095 }
7096 ::std::result::Result::Ok(())
7097 }
7098
7099 #[allow(unused_variables)]
7101 fn compute_size(&self) -> u64 {
7102 let mut my_size = 0;
7103 if let Some(v) = self.invitation_code.as_ref() {
7104 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
7105 }
7106 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
7107 self.special_fields.cached_size().set(my_size as u32);
7108 my_size
7109 }
7110
7111 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
7112 if let Some(v) = self.invitation_code.as_ref() {
7113 os.write_string(1, v)?;
7114 }
7115 os.write_unknown_fields(self.special_fields.unknown_fields())?;
7116 ::std::result::Result::Ok(())
7117 }
7118
7119 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
7120 &self.special_fields
7121 }
7122
7123 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
7124 &mut self.special_fields
7125 }
7126
7127 fn new() -> CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7128 CRemoteClient_LookupRemotePlayTogetherInvitation_Request::new()
7129 }
7130
7131 fn clear(&mut self) {
7132 self.invitation_code = ::std::option::Option::None;
7133 self.special_fields.clear();
7134 }
7135
7136 fn default_instance() -> &'static CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7137 static instance: CRemoteClient_LookupRemotePlayTogetherInvitation_Request = CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
7138 invitation_code: ::std::option::Option::None,
7139 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
7140 };
7141 &instance
7142 }
7143}
7144
7145#[derive(PartialEq,Clone,Default,Debug)]
7147pub struct CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7148 pub invitation_url: ::std::option::Option<::std::string::String>,
7151 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
7154}
7155
7156impl<'a> ::std::default::Default for &'a CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7157 fn default() -> &'a CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7158 <CRemoteClient_LookupRemotePlayTogetherInvitation_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance()
7159 }
7160}
7161
7162impl CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7163 pub fn new() -> CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7164 ::std::default::Default::default()
7165 }
7166
7167 pub fn invitation_url(&self) -> &str {
7170 match self.invitation_url.as_ref() {
7171 Some(v) => v,
7172 None => "",
7173 }
7174 }
7175
7176 pub fn clear_invitation_url(&mut self) {
7177 self.invitation_url = ::std::option::Option::None;
7178 }
7179
7180 pub fn has_invitation_url(&self) -> bool {
7181 self.invitation_url.is_some()
7182 }
7183
7184 pub fn set_invitation_url(&mut self, v: ::std::string::String) {
7186 self.invitation_url = ::std::option::Option::Some(v);
7187 }
7188
7189 pub fn mut_invitation_url(&mut self) -> &mut ::std::string::String {
7192 if self.invitation_url.is_none() {
7193 self.invitation_url = ::std::option::Option::Some(::std::string::String::new());
7194 }
7195 self.invitation_url.as_mut().unwrap()
7196 }
7197
7198 pub fn take_invitation_url(&mut self) -> ::std::string::String {
7200 self.invitation_url.take().unwrap_or_else(|| ::std::string::String::new())
7201 }
7202}
7203
7204impl ::steam_vent_proto_common::protobuf::Message for CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7205 const NAME: &'static str = "CRemoteClient_LookupRemotePlayTogetherInvitation_Response";
7206
7207 fn is_initialized(&self) -> bool {
7208 true
7209 }
7210
7211 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
7212 while let Some(tag) = is.read_raw_tag_or_eof()? {
7213 match tag {
7214 10 => {
7215 self.invitation_url = ::std::option::Option::Some(is.read_string()?);
7216 },
7217 tag => {
7218 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7219 },
7220 };
7221 }
7222 ::std::result::Result::Ok(())
7223 }
7224
7225 #[allow(unused_variables)]
7227 fn compute_size(&self) -> u64 {
7228 let mut my_size = 0;
7229 if let Some(v) = self.invitation_url.as_ref() {
7230 my_size += ::steam_vent_proto_common::protobuf::rt::string_size(1, &v);
7231 }
7232 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
7233 self.special_fields.cached_size().set(my_size as u32);
7234 my_size
7235 }
7236
7237 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
7238 if let Some(v) = self.invitation_url.as_ref() {
7239 os.write_string(1, v)?;
7240 }
7241 os.write_unknown_fields(self.special_fields.unknown_fields())?;
7242 ::std::result::Result::Ok(())
7243 }
7244
7245 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
7246 &self.special_fields
7247 }
7248
7249 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
7250 &mut self.special_fields
7251 }
7252
7253 fn new() -> CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7254 CRemoteClient_LookupRemotePlayTogetherInvitation_Response::new()
7255 }
7256
7257 fn clear(&mut self) {
7258 self.invitation_url = ::std::option::Option::None;
7259 self.special_fields.clear();
7260 }
7261
7262 fn default_instance() -> &'static CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7263 static instance: CRemoteClient_LookupRemotePlayTogetherInvitation_Response = CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
7264 invitation_url: ::std::option::Option::None,
7265 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
7266 };
7267 &instance
7268 }
7269}
7270
7271#[derive(PartialEq,Clone,Default,Debug)]
7273pub struct CCMRemoteClient_ClientMessage {
7274 pub Message: ::std::option::Option<ccmremote_client_client_message::Message>,
7276 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
7279}
7280
7281impl<'a> ::std::default::Default for &'a CCMRemoteClient_ClientMessage {
7282 fn default() -> &'a CCMRemoteClient_ClientMessage {
7283 <CCMRemoteClient_ClientMessage as ::steam_vent_proto_common::protobuf::Message>::default_instance()
7284 }
7285}
7286
7287impl CCMRemoteClient_ClientMessage {
7288 pub fn new() -> CCMRemoteClient_ClientMessage {
7289 ::std::default::Default::default()
7290 }
7291
7292 pub fn create_session_request(&self) -> &CRemoteClient_CreateSession_Request {
7295 match self.Message {
7296 ::std::option::Option::Some(ccmremote_client_client_message::Message::CreateSessionRequest(ref v)) => v,
7297 _ => <CRemoteClient_CreateSession_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7298 }
7299 }
7300
7301 pub fn clear_create_session_request(&mut self) {
7302 self.Message = ::std::option::Option::None;
7303 }
7304
7305 pub fn has_create_session_request(&self) -> bool {
7306 match self.Message {
7307 ::std::option::Option::Some(ccmremote_client_client_message::Message::CreateSessionRequest(..)) => true,
7308 _ => false,
7309 }
7310 }
7311
7312 pub fn set_create_session_request(&mut self, v: CRemoteClient_CreateSession_Request) {
7314 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::CreateSessionRequest(v))
7315 }
7316
7317 pub fn mut_create_session_request(&mut self) -> &mut CRemoteClient_CreateSession_Request {
7319 if let ::std::option::Option::Some(ccmremote_client_client_message::Message::CreateSessionRequest(_)) = self.Message {
7320 } else {
7321 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::CreateSessionRequest(CRemoteClient_CreateSession_Request::new()));
7322 }
7323 match self.Message {
7324 ::std::option::Option::Some(ccmremote_client_client_message::Message::CreateSessionRequest(ref mut v)) => v,
7325 _ => panic!(),
7326 }
7327 }
7328
7329 pub fn take_create_session_request(&mut self) -> CRemoteClient_CreateSession_Request {
7331 if self.has_create_session_request() {
7332 match self.Message.take() {
7333 ::std::option::Option::Some(ccmremote_client_client_message::Message::CreateSessionRequest(v)) => v,
7334 _ => panic!(),
7335 }
7336 } else {
7337 CRemoteClient_CreateSession_Request::new()
7338 }
7339 }
7340
7341 pub fn start_pairing_request(&self) -> &CRemoteClient_StartPairing_Request {
7344 match self.Message {
7345 ::std::option::Option::Some(ccmremote_client_client_message::Message::StartPairingRequest(ref v)) => v,
7346 _ => <CRemoteClient_StartPairing_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7347 }
7348 }
7349
7350 pub fn clear_start_pairing_request(&mut self) {
7351 self.Message = ::std::option::Option::None;
7352 }
7353
7354 pub fn has_start_pairing_request(&self) -> bool {
7355 match self.Message {
7356 ::std::option::Option::Some(ccmremote_client_client_message::Message::StartPairingRequest(..)) => true,
7357 _ => false,
7358 }
7359 }
7360
7361 pub fn set_start_pairing_request(&mut self, v: CRemoteClient_StartPairing_Request) {
7363 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::StartPairingRequest(v))
7364 }
7365
7366 pub fn mut_start_pairing_request(&mut self) -> &mut CRemoteClient_StartPairing_Request {
7368 if let ::std::option::Option::Some(ccmremote_client_client_message::Message::StartPairingRequest(_)) = self.Message {
7369 } else {
7370 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::StartPairingRequest(CRemoteClient_StartPairing_Request::new()));
7371 }
7372 match self.Message {
7373 ::std::option::Option::Some(ccmremote_client_client_message::Message::StartPairingRequest(ref mut v)) => v,
7374 _ => panic!(),
7375 }
7376 }
7377
7378 pub fn take_start_pairing_request(&mut self) -> CRemoteClient_StartPairing_Request {
7380 if self.has_start_pairing_request() {
7381 match self.Message.take() {
7382 ::std::option::Option::Some(ccmremote_client_client_message::Message::StartPairingRequest(v)) => v,
7383 _ => panic!(),
7384 }
7385 } else {
7386 CRemoteClient_StartPairing_Request::new()
7387 }
7388 }
7389
7390 pub fn set_pairing_info_request(&self) -> &CRemoteClient_SetPairingInfo_Request {
7393 match self.Message {
7394 ::std::option::Option::Some(ccmremote_client_client_message::Message::SetPairingInfoRequest(ref v)) => v,
7395 _ => <CRemoteClient_SetPairingInfo_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7396 }
7397 }
7398
7399 pub fn clear_set_pairing_info_request(&mut self) {
7400 self.Message = ::std::option::Option::None;
7401 }
7402
7403 pub fn has_set_pairing_info_request(&self) -> bool {
7404 match self.Message {
7405 ::std::option::Option::Some(ccmremote_client_client_message::Message::SetPairingInfoRequest(..)) => true,
7406 _ => false,
7407 }
7408 }
7409
7410 pub fn set_set_pairing_info_request(&mut self, v: CRemoteClient_SetPairingInfo_Request) {
7412 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::SetPairingInfoRequest(v))
7413 }
7414
7415 pub fn mut_set_pairing_info_request(&mut self) -> &mut CRemoteClient_SetPairingInfo_Request {
7417 if let ::std::option::Option::Some(ccmremote_client_client_message::Message::SetPairingInfoRequest(_)) = self.Message {
7418 } else {
7419 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::SetPairingInfoRequest(CRemoteClient_SetPairingInfo_Request::new()));
7420 }
7421 match self.Message {
7422 ::std::option::Option::Some(ccmremote_client_client_message::Message::SetPairingInfoRequest(ref mut v)) => v,
7423 _ => panic!(),
7424 }
7425 }
7426
7427 pub fn take_set_pairing_info_request(&mut self) -> CRemoteClient_SetPairingInfo_Request {
7429 if self.has_set_pairing_info_request() {
7430 match self.Message.take() {
7431 ::std::option::Option::Some(ccmremote_client_client_message::Message::SetPairingInfoRequest(v)) => v,
7432 _ => panic!(),
7433 }
7434 } else {
7435 CRemoteClient_SetPairingInfo_Request::new()
7436 }
7437 }
7438
7439 pub fn cancel_pairing_request(&self) -> &CRemoteClient_CancelPairing_Request {
7442 match self.Message {
7443 ::std::option::Option::Some(ccmremote_client_client_message::Message::CancelPairingRequest(ref v)) => v,
7444 _ => <CRemoteClient_CancelPairing_Request as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7445 }
7446 }
7447
7448 pub fn clear_cancel_pairing_request(&mut self) {
7449 self.Message = ::std::option::Option::None;
7450 }
7451
7452 pub fn has_cancel_pairing_request(&self) -> bool {
7453 match self.Message {
7454 ::std::option::Option::Some(ccmremote_client_client_message::Message::CancelPairingRequest(..)) => true,
7455 _ => false,
7456 }
7457 }
7458
7459 pub fn set_cancel_pairing_request(&mut self, v: CRemoteClient_CancelPairing_Request) {
7461 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::CancelPairingRequest(v))
7462 }
7463
7464 pub fn mut_cancel_pairing_request(&mut self) -> &mut CRemoteClient_CancelPairing_Request {
7466 if let ::std::option::Option::Some(ccmremote_client_client_message::Message::CancelPairingRequest(_)) = self.Message {
7467 } else {
7468 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::CancelPairingRequest(CRemoteClient_CancelPairing_Request::new()));
7469 }
7470 match self.Message {
7471 ::std::option::Option::Some(ccmremote_client_client_message::Message::CancelPairingRequest(ref mut v)) => v,
7472 _ => panic!(),
7473 }
7474 }
7475
7476 pub fn take_cancel_pairing_request(&mut self) -> CRemoteClient_CancelPairing_Request {
7478 if self.has_cancel_pairing_request() {
7479 match self.Message.take() {
7480 ::std::option::Option::Some(ccmremote_client_client_message::Message::CancelPairingRequest(v)) => v,
7481 _ => panic!(),
7482 }
7483 } else {
7484 CRemoteClient_CancelPairing_Request::new()
7485 }
7486 }
7487
7488 pub fn register_status_update(&self) -> &CRemoteClient_RegisterStatusUpdate_Notification {
7491 match self.Message {
7492 ::std::option::Option::Some(ccmremote_client_client_message::Message::RegisterStatusUpdate(ref v)) => v,
7493 _ => <CRemoteClient_RegisterStatusUpdate_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7494 }
7495 }
7496
7497 pub fn clear_register_status_update(&mut self) {
7498 self.Message = ::std::option::Option::None;
7499 }
7500
7501 pub fn has_register_status_update(&self) -> bool {
7502 match self.Message {
7503 ::std::option::Option::Some(ccmremote_client_client_message::Message::RegisterStatusUpdate(..)) => true,
7504 _ => false,
7505 }
7506 }
7507
7508 pub fn set_register_status_update(&mut self, v: CRemoteClient_RegisterStatusUpdate_Notification) {
7510 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::RegisterStatusUpdate(v))
7511 }
7512
7513 pub fn mut_register_status_update(&mut self) -> &mut CRemoteClient_RegisterStatusUpdate_Notification {
7515 if let ::std::option::Option::Some(ccmremote_client_client_message::Message::RegisterStatusUpdate(_)) = self.Message {
7516 } else {
7517 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::RegisterStatusUpdate(CRemoteClient_RegisterStatusUpdate_Notification::new()));
7518 }
7519 match self.Message {
7520 ::std::option::Option::Some(ccmremote_client_client_message::Message::RegisterStatusUpdate(ref mut v)) => v,
7521 _ => panic!(),
7522 }
7523 }
7524
7525 pub fn take_register_status_update(&mut self) -> CRemoteClient_RegisterStatusUpdate_Notification {
7527 if self.has_register_status_update() {
7528 match self.Message.take() {
7529 ::std::option::Option::Some(ccmremote_client_client_message::Message::RegisterStatusUpdate(v)) => v,
7530 _ => panic!(),
7531 }
7532 } else {
7533 CRemoteClient_RegisterStatusUpdate_Notification::new()
7534 }
7535 }
7536
7537 pub fn unregister_status_update(&self) -> &CRemoteClient_UnregisterStatusUpdate_Notification {
7540 match self.Message {
7541 ::std::option::Option::Some(ccmremote_client_client_message::Message::UnregisterStatusUpdate(ref v)) => v,
7542 _ => <CRemoteClient_UnregisterStatusUpdate_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7543 }
7544 }
7545
7546 pub fn clear_unregister_status_update(&mut self) {
7547 self.Message = ::std::option::Option::None;
7548 }
7549
7550 pub fn has_unregister_status_update(&self) -> bool {
7551 match self.Message {
7552 ::std::option::Option::Some(ccmremote_client_client_message::Message::UnregisterStatusUpdate(..)) => true,
7553 _ => false,
7554 }
7555 }
7556
7557 pub fn set_unregister_status_update(&mut self, v: CRemoteClient_UnregisterStatusUpdate_Notification) {
7559 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::UnregisterStatusUpdate(v))
7560 }
7561
7562 pub fn mut_unregister_status_update(&mut self) -> &mut CRemoteClient_UnregisterStatusUpdate_Notification {
7564 if let ::std::option::Option::Some(ccmremote_client_client_message::Message::UnregisterStatusUpdate(_)) = self.Message {
7565 } else {
7566 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::UnregisterStatusUpdate(CRemoteClient_UnregisterStatusUpdate_Notification::new()));
7567 }
7568 match self.Message {
7569 ::std::option::Option::Some(ccmremote_client_client_message::Message::UnregisterStatusUpdate(ref mut v)) => v,
7570 _ => panic!(),
7571 }
7572 }
7573
7574 pub fn take_unregister_status_update(&mut self) -> CRemoteClient_UnregisterStatusUpdate_Notification {
7576 if self.has_unregister_status_update() {
7577 match self.Message.take() {
7578 ::std::option::Option::Some(ccmremote_client_client_message::Message::UnregisterStatusUpdate(v)) => v,
7579 _ => panic!(),
7580 }
7581 } else {
7582 CRemoteClient_UnregisterStatusUpdate_Notification::new()
7583 }
7584 }
7585
7586 pub fn remote_packet(&self) -> &CRemoteClient_RemotePacket_Notification {
7589 match self.Message {
7590 ::std::option::Option::Some(ccmremote_client_client_message::Message::RemotePacket(ref v)) => v,
7591 _ => <CRemoteClient_RemotePacket_Notification as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7592 }
7593 }
7594
7595 pub fn clear_remote_packet(&mut self) {
7596 self.Message = ::std::option::Option::None;
7597 }
7598
7599 pub fn has_remote_packet(&self) -> bool {
7600 match self.Message {
7601 ::std::option::Option::Some(ccmremote_client_client_message::Message::RemotePacket(..)) => true,
7602 _ => false,
7603 }
7604 }
7605
7606 pub fn set_remote_packet(&mut self, v: CRemoteClient_RemotePacket_Notification) {
7608 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::RemotePacket(v))
7609 }
7610
7611 pub fn mut_remote_packet(&mut self) -> &mut CRemoteClient_RemotePacket_Notification {
7613 if let ::std::option::Option::Some(ccmremote_client_client_message::Message::RemotePacket(_)) = self.Message {
7614 } else {
7615 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::RemotePacket(CRemoteClient_RemotePacket_Notification::new()));
7616 }
7617 match self.Message {
7618 ::std::option::Option::Some(ccmremote_client_client_message::Message::RemotePacket(ref mut v)) => v,
7619 _ => panic!(),
7620 }
7621 }
7622
7623 pub fn take_remote_packet(&mut self) -> CRemoteClient_RemotePacket_Notification {
7625 if self.has_remote_packet() {
7626 match self.Message.take() {
7627 ::std::option::Option::Some(ccmremote_client_client_message::Message::RemotePacket(v)) => v,
7628 _ => panic!(),
7629 }
7630 } else {
7631 CRemoteClient_RemotePacket_Notification::new()
7632 }
7633 }
7634}
7635
7636impl ::steam_vent_proto_common::protobuf::Message for CCMRemoteClient_ClientMessage {
7637 const NAME: &'static str = "CCMRemoteClient_ClientMessage";
7638
7639 fn is_initialized(&self) -> bool {
7640 true
7641 }
7642
7643 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
7644 while let Some(tag) = is.read_raw_tag_or_eof()? {
7645 match tag {
7646 10 => {
7647 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::CreateSessionRequest(is.read_message()?));
7648 },
7649 18 => {
7650 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::StartPairingRequest(is.read_message()?));
7651 },
7652 26 => {
7653 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::SetPairingInfoRequest(is.read_message()?));
7654 },
7655 34 => {
7656 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::CancelPairingRequest(is.read_message()?));
7657 },
7658 42 => {
7659 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::RegisterStatusUpdate(is.read_message()?));
7660 },
7661 50 => {
7662 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::UnregisterStatusUpdate(is.read_message()?));
7663 },
7664 58 => {
7665 self.Message = ::std::option::Option::Some(ccmremote_client_client_message::Message::RemotePacket(is.read_message()?));
7666 },
7667 tag => {
7668 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7669 },
7670 };
7671 }
7672 ::std::result::Result::Ok(())
7673 }
7674
7675 #[allow(unused_variables)]
7677 fn compute_size(&self) -> u64 {
7678 let mut my_size = 0;
7679 if let ::std::option::Option::Some(ref v) = self.Message {
7680 match v {
7681 &ccmremote_client_client_message::Message::CreateSessionRequest(ref v) => {
7682 let len = v.compute_size();
7683 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
7684 },
7685 &ccmremote_client_client_message::Message::StartPairingRequest(ref v) => {
7686 let len = v.compute_size();
7687 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
7688 },
7689 &ccmremote_client_client_message::Message::SetPairingInfoRequest(ref v) => {
7690 let len = v.compute_size();
7691 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
7692 },
7693 &ccmremote_client_client_message::Message::CancelPairingRequest(ref v) => {
7694 let len = v.compute_size();
7695 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
7696 },
7697 &ccmremote_client_client_message::Message::RegisterStatusUpdate(ref v) => {
7698 let len = v.compute_size();
7699 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
7700 },
7701 &ccmremote_client_client_message::Message::UnregisterStatusUpdate(ref v) => {
7702 let len = v.compute_size();
7703 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
7704 },
7705 &ccmremote_client_client_message::Message::RemotePacket(ref v) => {
7706 let len = v.compute_size();
7707 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
7708 },
7709 };
7710 }
7711 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
7712 self.special_fields.cached_size().set(my_size as u32);
7713 my_size
7714 }
7715
7716 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
7717 if let ::std::option::Option::Some(ref v) = self.Message {
7718 match v {
7719 &ccmremote_client_client_message::Message::CreateSessionRequest(ref v) => {
7720 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
7721 },
7722 &ccmremote_client_client_message::Message::StartPairingRequest(ref v) => {
7723 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
7724 },
7725 &ccmremote_client_client_message::Message::SetPairingInfoRequest(ref v) => {
7726 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
7727 },
7728 &ccmremote_client_client_message::Message::CancelPairingRequest(ref v) => {
7729 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
7730 },
7731 &ccmremote_client_client_message::Message::RegisterStatusUpdate(ref v) => {
7732 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
7733 },
7734 &ccmremote_client_client_message::Message::UnregisterStatusUpdate(ref v) => {
7735 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
7736 },
7737 &ccmremote_client_client_message::Message::RemotePacket(ref v) => {
7738 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
7739 },
7740 };
7741 }
7742 os.write_unknown_fields(self.special_fields.unknown_fields())?;
7743 ::std::result::Result::Ok(())
7744 }
7745
7746 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
7747 &self.special_fields
7748 }
7749
7750 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
7751 &mut self.special_fields
7752 }
7753
7754 fn new() -> CCMRemoteClient_ClientMessage {
7755 CCMRemoteClient_ClientMessage::new()
7756 }
7757
7758 fn clear(&mut self) {
7759 self.Message = ::std::option::Option::None;
7760 self.Message = ::std::option::Option::None;
7761 self.Message = ::std::option::Option::None;
7762 self.Message = ::std::option::Option::None;
7763 self.Message = ::std::option::Option::None;
7764 self.Message = ::std::option::Option::None;
7765 self.Message = ::std::option::Option::None;
7766 self.special_fields.clear();
7767 }
7768
7769 fn default_instance() -> &'static CCMRemoteClient_ClientMessage {
7770 static instance: CCMRemoteClient_ClientMessage = CCMRemoteClient_ClientMessage {
7771 Message: ::std::option::Option::None,
7772 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
7773 };
7774 &instance
7775 }
7776}
7777
7778pub mod ccmremote_client_client_message {
7780
7781 #[derive(Clone,PartialEq,Debug)]
7782 #[non_exhaustive]
7783 pub enum Message {
7785 CreateSessionRequest(super::CRemoteClient_CreateSession_Request),
7787 StartPairingRequest(super::CRemoteClient_StartPairing_Request),
7789 SetPairingInfoRequest(super::CRemoteClient_SetPairingInfo_Request),
7791 CancelPairingRequest(super::CRemoteClient_CancelPairing_Request),
7793 RegisterStatusUpdate(super::CRemoteClient_RegisterStatusUpdate_Notification),
7795 UnregisterStatusUpdate(super::CRemoteClient_UnregisterStatusUpdate_Notification),
7797 RemotePacket(super::CRemoteClient_RemotePacket_Notification),
7799 }
7800
7801 impl ::steam_vent_proto_common::protobuf::Oneof for Message {
7802 }
7803
7804 impl Message {
7805 }
7806}
7807
7808#[derive(PartialEq,Clone,Default,Debug)]
7810pub struct CCMRemoteClient_ServerMessage {
7811 pub result: ::std::option::Option<i32>,
7814 pub Message: ::std::option::Option<ccmremote_client_server_message::Message>,
7816 pub special_fields: ::steam_vent_proto_common::protobuf::SpecialFields,
7819}
7820
7821impl<'a> ::std::default::Default for &'a CCMRemoteClient_ServerMessage {
7822 fn default() -> &'a CCMRemoteClient_ServerMessage {
7823 <CCMRemoteClient_ServerMessage as ::steam_vent_proto_common::protobuf::Message>::default_instance()
7824 }
7825}
7826
7827impl CCMRemoteClient_ServerMessage {
7828 pub fn new() -> CCMRemoteClient_ServerMessage {
7829 ::std::default::Default::default()
7830 }
7831
7832 pub fn result(&self) -> i32 {
7835 self.result.unwrap_or(0)
7836 }
7837
7838 pub fn clear_result(&mut self) {
7839 self.result = ::std::option::Option::None;
7840 }
7841
7842 pub fn has_result(&self) -> bool {
7843 self.result.is_some()
7844 }
7845
7846 pub fn set_result(&mut self, v: i32) {
7848 self.result = ::std::option::Option::Some(v);
7849 }
7850
7851 pub fn create_session_response(&self) -> &CRemoteClient_CreateSession_Response {
7854 match self.Message {
7855 ::std::option::Option::Some(ccmremote_client_server_message::Message::CreateSessionResponse(ref v)) => v,
7856 _ => <CRemoteClient_CreateSession_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7857 }
7858 }
7859
7860 pub fn clear_create_session_response(&mut self) {
7861 self.Message = ::std::option::Option::None;
7862 }
7863
7864 pub fn has_create_session_response(&self) -> bool {
7865 match self.Message {
7866 ::std::option::Option::Some(ccmremote_client_server_message::Message::CreateSessionResponse(..)) => true,
7867 _ => false,
7868 }
7869 }
7870
7871 pub fn set_create_session_response(&mut self, v: CRemoteClient_CreateSession_Response) {
7873 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::CreateSessionResponse(v))
7874 }
7875
7876 pub fn mut_create_session_response(&mut self) -> &mut CRemoteClient_CreateSession_Response {
7878 if let ::std::option::Option::Some(ccmremote_client_server_message::Message::CreateSessionResponse(_)) = self.Message {
7879 } else {
7880 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::CreateSessionResponse(CRemoteClient_CreateSession_Response::new()));
7881 }
7882 match self.Message {
7883 ::std::option::Option::Some(ccmremote_client_server_message::Message::CreateSessionResponse(ref mut v)) => v,
7884 _ => panic!(),
7885 }
7886 }
7887
7888 pub fn take_create_session_response(&mut self) -> CRemoteClient_CreateSession_Response {
7890 if self.has_create_session_response() {
7891 match self.Message.take() {
7892 ::std::option::Option::Some(ccmremote_client_server_message::Message::CreateSessionResponse(v)) => v,
7893 _ => panic!(),
7894 }
7895 } else {
7896 CRemoteClient_CreateSession_Response::new()
7897 }
7898 }
7899
7900 pub fn start_pairing_response(&self) -> &CRemoteClient_StartPairing_Response {
7903 match self.Message {
7904 ::std::option::Option::Some(ccmremote_client_server_message::Message::StartPairingResponse(ref v)) => v,
7905 _ => <CRemoteClient_StartPairing_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7906 }
7907 }
7908
7909 pub fn clear_start_pairing_response(&mut self) {
7910 self.Message = ::std::option::Option::None;
7911 }
7912
7913 pub fn has_start_pairing_response(&self) -> bool {
7914 match self.Message {
7915 ::std::option::Option::Some(ccmremote_client_server_message::Message::StartPairingResponse(..)) => true,
7916 _ => false,
7917 }
7918 }
7919
7920 pub fn set_start_pairing_response(&mut self, v: CRemoteClient_StartPairing_Response) {
7922 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::StartPairingResponse(v))
7923 }
7924
7925 pub fn mut_start_pairing_response(&mut self) -> &mut CRemoteClient_StartPairing_Response {
7927 if let ::std::option::Option::Some(ccmremote_client_server_message::Message::StartPairingResponse(_)) = self.Message {
7928 } else {
7929 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::StartPairingResponse(CRemoteClient_StartPairing_Response::new()));
7930 }
7931 match self.Message {
7932 ::std::option::Option::Some(ccmremote_client_server_message::Message::StartPairingResponse(ref mut v)) => v,
7933 _ => panic!(),
7934 }
7935 }
7936
7937 pub fn take_start_pairing_response(&mut self) -> CRemoteClient_StartPairing_Response {
7939 if self.has_start_pairing_response() {
7940 match self.Message.take() {
7941 ::std::option::Option::Some(ccmremote_client_server_message::Message::StartPairingResponse(v)) => v,
7942 _ => panic!(),
7943 }
7944 } else {
7945 CRemoteClient_StartPairing_Response::new()
7946 }
7947 }
7948
7949 pub fn set_pairing_info_response(&self) -> &CRemoteClient_SetPairingInfo_Response {
7952 match self.Message {
7953 ::std::option::Option::Some(ccmremote_client_server_message::Message::SetPairingInfoResponse(ref v)) => v,
7954 _ => <CRemoteClient_SetPairingInfo_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
7955 }
7956 }
7957
7958 pub fn clear_set_pairing_info_response(&mut self) {
7959 self.Message = ::std::option::Option::None;
7960 }
7961
7962 pub fn has_set_pairing_info_response(&self) -> bool {
7963 match self.Message {
7964 ::std::option::Option::Some(ccmremote_client_server_message::Message::SetPairingInfoResponse(..)) => true,
7965 _ => false,
7966 }
7967 }
7968
7969 pub fn set_set_pairing_info_response(&mut self, v: CRemoteClient_SetPairingInfo_Response) {
7971 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::SetPairingInfoResponse(v))
7972 }
7973
7974 pub fn mut_set_pairing_info_response(&mut self) -> &mut CRemoteClient_SetPairingInfo_Response {
7976 if let ::std::option::Option::Some(ccmremote_client_server_message::Message::SetPairingInfoResponse(_)) = self.Message {
7977 } else {
7978 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::SetPairingInfoResponse(CRemoteClient_SetPairingInfo_Response::new()));
7979 }
7980 match self.Message {
7981 ::std::option::Option::Some(ccmremote_client_server_message::Message::SetPairingInfoResponse(ref mut v)) => v,
7982 _ => panic!(),
7983 }
7984 }
7985
7986 pub fn take_set_pairing_info_response(&mut self) -> CRemoteClient_SetPairingInfo_Response {
7988 if self.has_set_pairing_info_response() {
7989 match self.Message.take() {
7990 ::std::option::Option::Some(ccmremote_client_server_message::Message::SetPairingInfoResponse(v)) => v,
7991 _ => panic!(),
7992 }
7993 } else {
7994 CRemoteClient_SetPairingInfo_Response::new()
7995 }
7996 }
7997
7998 pub fn cancel_pairing_response(&self) -> &CRemoteClient_CancelPairing_Response {
8001 match self.Message {
8002 ::std::option::Option::Some(ccmremote_client_server_message::Message::CancelPairingResponse(ref v)) => v,
8003 _ => <CRemoteClient_CancelPairing_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
8004 }
8005 }
8006
8007 pub fn clear_cancel_pairing_response(&mut self) {
8008 self.Message = ::std::option::Option::None;
8009 }
8010
8011 pub fn has_cancel_pairing_response(&self) -> bool {
8012 match self.Message {
8013 ::std::option::Option::Some(ccmremote_client_server_message::Message::CancelPairingResponse(..)) => true,
8014 _ => false,
8015 }
8016 }
8017
8018 pub fn set_cancel_pairing_response(&mut self, v: CRemoteClient_CancelPairing_Response) {
8020 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::CancelPairingResponse(v))
8021 }
8022
8023 pub fn mut_cancel_pairing_response(&mut self) -> &mut CRemoteClient_CancelPairing_Response {
8025 if let ::std::option::Option::Some(ccmremote_client_server_message::Message::CancelPairingResponse(_)) = self.Message {
8026 } else {
8027 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::CancelPairingResponse(CRemoteClient_CancelPairing_Response::new()));
8028 }
8029 match self.Message {
8030 ::std::option::Option::Some(ccmremote_client_server_message::Message::CancelPairingResponse(ref mut v)) => v,
8031 _ => panic!(),
8032 }
8033 }
8034
8035 pub fn take_cancel_pairing_response(&mut self) -> CRemoteClient_CancelPairing_Response {
8037 if self.has_cancel_pairing_response() {
8038 match self.Message.take() {
8039 ::std::option::Option::Some(ccmremote_client_server_message::Message::CancelPairingResponse(v)) => v,
8040 _ => panic!(),
8041 }
8042 } else {
8043 CRemoteClient_CancelPairing_Response::new()
8044 }
8045 }
8046
8047 pub fn reply_packet(&self) -> &CRemoteClient_GetReplies_Response {
8050 match self.Message {
8051 ::std::option::Option::Some(ccmremote_client_server_message::Message::ReplyPacket(ref v)) => v,
8052 _ => <CRemoteClient_GetReplies_Response as ::steam_vent_proto_common::protobuf::Message>::default_instance(),
8053 }
8054 }
8055
8056 pub fn clear_reply_packet(&mut self) {
8057 self.Message = ::std::option::Option::None;
8058 }
8059
8060 pub fn has_reply_packet(&self) -> bool {
8061 match self.Message {
8062 ::std::option::Option::Some(ccmremote_client_server_message::Message::ReplyPacket(..)) => true,
8063 _ => false,
8064 }
8065 }
8066
8067 pub fn set_reply_packet(&mut self, v: CRemoteClient_GetReplies_Response) {
8069 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::ReplyPacket(v))
8070 }
8071
8072 pub fn mut_reply_packet(&mut self) -> &mut CRemoteClient_GetReplies_Response {
8074 if let ::std::option::Option::Some(ccmremote_client_server_message::Message::ReplyPacket(_)) = self.Message {
8075 } else {
8076 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::ReplyPacket(CRemoteClient_GetReplies_Response::new()));
8077 }
8078 match self.Message {
8079 ::std::option::Option::Some(ccmremote_client_server_message::Message::ReplyPacket(ref mut v)) => v,
8080 _ => panic!(),
8081 }
8082 }
8083
8084 pub fn take_reply_packet(&mut self) -> CRemoteClient_GetReplies_Response {
8086 if self.has_reply_packet() {
8087 match self.Message.take() {
8088 ::std::option::Option::Some(ccmremote_client_server_message::Message::ReplyPacket(v)) => v,
8089 _ => panic!(),
8090 }
8091 } else {
8092 CRemoteClient_GetReplies_Response::new()
8093 }
8094 }
8095}
8096
8097impl ::steam_vent_proto_common::protobuf::Message for CCMRemoteClient_ServerMessage {
8098 const NAME: &'static str = "CCMRemoteClient_ServerMessage";
8099
8100 fn is_initialized(&self) -> bool {
8101 true
8102 }
8103
8104 fn merge_from(&mut self, is: &mut ::steam_vent_proto_common::protobuf::CodedInputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
8105 while let Some(tag) = is.read_raw_tag_or_eof()? {
8106 match tag {
8107 8 => {
8108 self.result = ::std::option::Option::Some(is.read_int32()?);
8109 },
8110 18 => {
8111 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::CreateSessionResponse(is.read_message()?));
8112 },
8113 26 => {
8114 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::StartPairingResponse(is.read_message()?));
8115 },
8116 34 => {
8117 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::SetPairingInfoResponse(is.read_message()?));
8118 },
8119 42 => {
8120 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::CancelPairingResponse(is.read_message()?));
8121 },
8122 50 => {
8123 self.Message = ::std::option::Option::Some(ccmremote_client_server_message::Message::ReplyPacket(is.read_message()?));
8124 },
8125 tag => {
8126 ::steam_vent_proto_common::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
8127 },
8128 };
8129 }
8130 ::std::result::Result::Ok(())
8131 }
8132
8133 #[allow(unused_variables)]
8135 fn compute_size(&self) -> u64 {
8136 let mut my_size = 0;
8137 if let Some(v) = self.result {
8138 my_size += ::steam_vent_proto_common::protobuf::rt::int32_size(1, v);
8139 }
8140 if let ::std::option::Option::Some(ref v) = self.Message {
8141 match v {
8142 &ccmremote_client_server_message::Message::CreateSessionResponse(ref v) => {
8143 let len = v.compute_size();
8144 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
8145 },
8146 &ccmremote_client_server_message::Message::StartPairingResponse(ref v) => {
8147 let len = v.compute_size();
8148 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
8149 },
8150 &ccmremote_client_server_message::Message::SetPairingInfoResponse(ref v) => {
8151 let len = v.compute_size();
8152 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
8153 },
8154 &ccmremote_client_server_message::Message::CancelPairingResponse(ref v) => {
8155 let len = v.compute_size();
8156 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
8157 },
8158 &ccmremote_client_server_message::Message::ReplyPacket(ref v) => {
8159 let len = v.compute_size();
8160 my_size += 1 + ::steam_vent_proto_common::protobuf::rt::compute_raw_varint64_size(len) + len;
8161 },
8162 };
8163 }
8164 my_size += ::steam_vent_proto_common::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
8165 self.special_fields.cached_size().set(my_size as u32);
8166 my_size
8167 }
8168
8169 fn write_to_with_cached_sizes(&self, os: &mut ::steam_vent_proto_common::protobuf::CodedOutputStream<'_>) -> ::steam_vent_proto_common::protobuf::Result<()> {
8170 if let Some(v) = self.result {
8171 os.write_int32(1, v)?;
8172 }
8173 if let ::std::option::Option::Some(ref v) = self.Message {
8174 match v {
8175 &ccmremote_client_server_message::Message::CreateSessionResponse(ref v) => {
8176 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
8177 },
8178 &ccmremote_client_server_message::Message::StartPairingResponse(ref v) => {
8179 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
8180 },
8181 &ccmremote_client_server_message::Message::SetPairingInfoResponse(ref v) => {
8182 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
8183 },
8184 &ccmremote_client_server_message::Message::CancelPairingResponse(ref v) => {
8185 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
8186 },
8187 &ccmremote_client_server_message::Message::ReplyPacket(ref v) => {
8188 ::steam_vent_proto_common::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
8189 },
8190 };
8191 }
8192 os.write_unknown_fields(self.special_fields.unknown_fields())?;
8193 ::std::result::Result::Ok(())
8194 }
8195
8196 fn special_fields(&self) -> &::steam_vent_proto_common::protobuf::SpecialFields {
8197 &self.special_fields
8198 }
8199
8200 fn mut_special_fields(&mut self) -> &mut ::steam_vent_proto_common::protobuf::SpecialFields {
8201 &mut self.special_fields
8202 }
8203
8204 fn new() -> CCMRemoteClient_ServerMessage {
8205 CCMRemoteClient_ServerMessage::new()
8206 }
8207
8208 fn clear(&mut self) {
8209 self.result = ::std::option::Option::None;
8210 self.Message = ::std::option::Option::None;
8211 self.Message = ::std::option::Option::None;
8212 self.Message = ::std::option::Option::None;
8213 self.Message = ::std::option::Option::None;
8214 self.Message = ::std::option::Option::None;
8215 self.special_fields.clear();
8216 }
8217
8218 fn default_instance() -> &'static CCMRemoteClient_ServerMessage {
8219 static instance: CCMRemoteClient_ServerMessage = CCMRemoteClient_ServerMessage {
8220 result: ::std::option::Option::None,
8221 Message: ::std::option::Option::None,
8222 special_fields: ::steam_vent_proto_common::protobuf::SpecialFields::new(),
8223 };
8224 &instance
8225 }
8226}
8227
8228pub mod ccmremote_client_server_message {
8230
8231 #[derive(Clone,PartialEq,Debug)]
8232 #[non_exhaustive]
8233 pub enum Message {
8235 CreateSessionResponse(super::CRemoteClient_CreateSession_Response),
8237 StartPairingResponse(super::CRemoteClient_StartPairing_Response),
8239 SetPairingInfoResponse(super::CRemoteClient_SetPairingInfo_Response),
8241 CancelPairingResponse(super::CRemoteClient_CancelPairing_Response),
8243 ReplyPacket(super::CRemoteClient_GetReplies_Response),
8245 }
8246
8247 impl ::steam_vent_proto_common::protobuf::Oneof for Message {
8248 }
8249
8250 impl Message {
8251 }
8252}
8253
8254#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
8255pub enum ECLientTaskListType {
8257 k_EClientTask_DownloadClip = 1,
8259}
8260
8261impl ::steam_vent_proto_common::protobuf::Enum for ECLientTaskListType {
8262 const NAME: &'static str = "ECLientTaskListType";
8263
8264 fn value(&self) -> i32 {
8265 *self as i32
8266 }
8267
8268 fn from_i32(value: i32) -> ::std::option::Option<ECLientTaskListType> {
8269 match value {
8270 1 => ::std::option::Option::Some(ECLientTaskListType::k_EClientTask_DownloadClip),
8271 _ => ::std::option::Option::None
8272 }
8273 }
8274
8275 fn from_str(str: &str) -> ::std::option::Option<ECLientTaskListType> {
8276 match str {
8277 "k_EClientTask_DownloadClip" => ::std::option::Option::Some(ECLientTaskListType::k_EClientTask_DownloadClip),
8278 _ => ::std::option::Option::None
8279 }
8280 }
8281
8282 const VALUES: &'static [ECLientTaskListType] = &[
8283 ECLientTaskListType::k_EClientTask_DownloadClip,
8284 ];
8285}
8286
8287impl ::std::default::Default for ECLientTaskListType {
8289 fn default() -> Self {
8290 ECLientTaskListType::k_EClientTask_DownloadClip
8291 }
8292}
8293
8294
8295
8296const _VENT_PROTO_VERSION_CHECK: () = ::steam_vent_proto_common::VERSION_0_5_0;
8297
8298impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_CreateSession_Request {
8299 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8300 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8301 }
8302 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8303 use ::steam_vent_proto_common::protobuf::Message;
8304 self.write_to_writer(writer)
8305 }
8306 fn encode_size(&self) -> usize {
8307 use ::steam_vent_proto_common::protobuf::Message;
8308 self.compute_size() as usize
8309 }
8310}
8311impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_CreateSession_Response {
8312 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8313 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8314 }
8315 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8316 use ::steam_vent_proto_common::protobuf::Message;
8317 self.write_to_writer(writer)
8318 }
8319 fn encode_size(&self) -> usize {
8320 use ::steam_vent_proto_common::protobuf::Message;
8321 self.compute_size() as usize
8322 }
8323}
8324impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_DeleteSession_Notification {
8325 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8326 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8327 }
8328 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8329 use ::steam_vent_proto_common::protobuf::Message;
8330 self.write_to_writer(writer)
8331 }
8332 fn encode_size(&self) -> usize {
8333 use ::steam_vent_proto_common::protobuf::Message;
8334 self.compute_size() as usize
8335 }
8336}
8337impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_StartPairing_Request {
8338 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8339 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8340 }
8341 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8342 use ::steam_vent_proto_common::protobuf::Message;
8343 self.write_to_writer(writer)
8344 }
8345 fn encode_size(&self) -> usize {
8346 use ::steam_vent_proto_common::protobuf::Message;
8347 self.compute_size() as usize
8348 }
8349}
8350impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_StartPairing_Response {
8351 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8352 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8353 }
8354 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8355 use ::steam_vent_proto_common::protobuf::Message;
8356 self.write_to_writer(writer)
8357 }
8358 fn encode_size(&self) -> usize {
8359 use ::steam_vent_proto_common::protobuf::Message;
8360 self.compute_size() as usize
8361 }
8362}
8363impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_SetPairingInfo_Request {
8364 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8365 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8366 }
8367 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8368 use ::steam_vent_proto_common::protobuf::Message;
8369 self.write_to_writer(writer)
8370 }
8371 fn encode_size(&self) -> usize {
8372 use ::steam_vent_proto_common::protobuf::Message;
8373 self.compute_size() as usize
8374 }
8375}
8376impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_SetPairingInfo_Response {
8377 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8378 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8379 }
8380 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8381 use ::steam_vent_proto_common::protobuf::Message;
8382 self.write_to_writer(writer)
8383 }
8384 fn encode_size(&self) -> usize {
8385 use ::steam_vent_proto_common::protobuf::Message;
8386 self.compute_size() as usize
8387 }
8388}
8389impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_GetPairingInfo_Request {
8390 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8391 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8392 }
8393 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8394 use ::steam_vent_proto_common::protobuf::Message;
8395 self.write_to_writer(writer)
8396 }
8397 fn encode_size(&self) -> usize {
8398 use ::steam_vent_proto_common::protobuf::Message;
8399 self.compute_size() as usize
8400 }
8401}
8402impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_GetPairingInfo_Response {
8403 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8404 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8405 }
8406 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8407 use ::steam_vent_proto_common::protobuf::Message;
8408 self.write_to_writer(writer)
8409 }
8410 fn encode_size(&self) -> usize {
8411 use ::steam_vent_proto_common::protobuf::Message;
8412 self.compute_size() as usize
8413 }
8414}
8415impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_CancelPairing_Request {
8416 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8417 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8418 }
8419 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8420 use ::steam_vent_proto_common::protobuf::Message;
8421 self.write_to_writer(writer)
8422 }
8423 fn encode_size(&self) -> usize {
8424 use ::steam_vent_proto_common::protobuf::Message;
8425 self.compute_size() as usize
8426 }
8427}
8428impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_CancelPairing_Response {
8429 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8430 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8431 }
8432 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8433 use ::steam_vent_proto_common::protobuf::Message;
8434 self.write_to_writer(writer)
8435 }
8436 fn encode_size(&self) -> usize {
8437 use ::steam_vent_proto_common::protobuf::Message;
8438 self.compute_size() as usize
8439 }
8440}
8441impl ::steam_vent_proto_common::RpcMessage
8442for CRemoteClient_RegisterStatusUpdate_Notification {
8443 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8444 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8445 }
8446 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8447 use ::steam_vent_proto_common::protobuf::Message;
8448 self.write_to_writer(writer)
8449 }
8450 fn encode_size(&self) -> usize {
8451 use ::steam_vent_proto_common::protobuf::Message;
8452 self.compute_size() as usize
8453 }
8454}
8455impl ::steam_vent_proto_common::RpcMessage
8456for CRemoteClient_UnregisterStatusUpdate_Notification {
8457 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8458 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8459 }
8460 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8461 use ::steam_vent_proto_common::protobuf::Message;
8462 self.write_to_writer(writer)
8463 }
8464 fn encode_size(&self) -> usize {
8465 use ::steam_vent_proto_common::protobuf::Message;
8466 self.compute_size() as usize
8467 }
8468}
8469impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_DeviceDetails {
8470 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8471 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8472 }
8473 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8474 use ::steam_vent_proto_common::protobuf::Message;
8475 self.write_to_writer(writer)
8476 }
8477 fn encode_size(&self) -> usize {
8478 use ::steam_vent_proto_common::protobuf::Message;
8479 self.compute_size() as usize
8480 }
8481}
8482impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_Online_Notification {
8483 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8484 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8485 }
8486 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8487 use ::steam_vent_proto_common::protobuf::Message;
8488 self.write_to_writer(writer)
8489 }
8490 fn encode_size(&self) -> usize {
8491 use ::steam_vent_proto_common::protobuf::Message;
8492 self.compute_size() as usize
8493 }
8494}
8495impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_GetRecentClients_Request {
8496 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8497 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8498 }
8499 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8500 use ::steam_vent_proto_common::protobuf::Message;
8501 self.write_to_writer(writer)
8502 }
8503 fn encode_size(&self) -> usize {
8504 use ::steam_vent_proto_common::protobuf::Message;
8505 self.compute_size() as usize
8506 }
8507}
8508impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_ClientLogin {
8509 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8510 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8511 }
8512 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8513 use ::steam_vent_proto_common::protobuf::Message;
8514 self.write_to_writer(writer)
8515 }
8516 fn encode_size(&self) -> usize {
8517 use ::steam_vent_proto_common::protobuf::Message;
8518 self.compute_size() as usize
8519 }
8520}
8521impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_ClientDetails {
8522 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8523 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8524 }
8525 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8526 use ::steam_vent_proto_common::protobuf::Message;
8527 self.write_to_writer(writer)
8528 }
8529 fn encode_size(&self) -> usize {
8530 use ::steam_vent_proto_common::protobuf::Message;
8531 self.compute_size() as usize
8532 }
8533}
8534impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_GetRecentClients_Response {
8535 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8536 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8537 }
8538 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8539 use ::steam_vent_proto_common::protobuf::Message;
8540 self.write_to_writer(writer)
8541 }
8542 fn encode_size(&self) -> usize {
8543 use ::steam_vent_proto_common::protobuf::Message;
8544 self.compute_size() as usize
8545 }
8546}
8547impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_Task {
8548 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8549 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8550 }
8551 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8552 use ::steam_vent_proto_common::protobuf::Message;
8553 self.write_to_writer(writer)
8554 }
8555 fn encode_size(&self) -> usize {
8556 use ::steam_vent_proto_common::protobuf::Message;
8557 self.compute_size() as usize
8558 }
8559}
8560impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_AddClientTask_Request {
8561 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8562 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8563 }
8564 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8565 use ::steam_vent_proto_common::protobuf::Message;
8566 self.write_to_writer(writer)
8567 }
8568 fn encode_size(&self) -> usize {
8569 use ::steam_vent_proto_common::protobuf::Message;
8570 self.compute_size() as usize
8571 }
8572}
8573impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_AddClientTask_Response {
8574 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8575 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8576 }
8577 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8578 use ::steam_vent_proto_common::protobuf::Message;
8579 self.write_to_writer(writer)
8580 }
8581 fn encode_size(&self) -> usize {
8582 use ::steam_vent_proto_common::protobuf::Message;
8583 self.compute_size() as usize
8584 }
8585}
8586impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_TaskList_Notification {
8587 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8588 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8589 }
8590 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8591 use ::steam_vent_proto_common::protobuf::Message;
8592 self.write_to_writer(writer)
8593 }
8594 fn encode_size(&self) -> usize {
8595 use ::steam_vent_proto_common::protobuf::Message;
8596 self.compute_size() as usize
8597 }
8598}
8599impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_MarkTaskComplete_Request {
8600 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8601 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8602 }
8603 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8604 use ::steam_vent_proto_common::protobuf::Message;
8605 self.write_to_writer(writer)
8606 }
8607 fn encode_size(&self) -> usize {
8608 use ::steam_vent_proto_common::protobuf::Message;
8609 self.compute_size() as usize
8610 }
8611}
8612impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_MarkTaskComplete_Response {
8613 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8614 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8615 }
8616 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8617 use ::steam_vent_proto_common::protobuf::Message;
8618 self.write_to_writer(writer)
8619 }
8620 fn encode_size(&self) -> usize {
8621 use ::steam_vent_proto_common::protobuf::Message;
8622 self.compute_size() as usize
8623 }
8624}
8625impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_RemotePacket_Notification {
8626 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8627 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8628 }
8629 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8630 use ::steam_vent_proto_common::protobuf::Message;
8631 self.write_to_writer(writer)
8632 }
8633 fn encode_size(&self) -> usize {
8634 use ::steam_vent_proto_common::protobuf::Message;
8635 self.compute_size() as usize
8636 }
8637}
8638impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_ReplyPacket_Notification {
8639 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8640 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8641 }
8642 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8643 use ::steam_vent_proto_common::protobuf::Message;
8644 self.write_to_writer(writer)
8645 }
8646 fn encode_size(&self) -> usize {
8647 use ::steam_vent_proto_common::protobuf::Message;
8648 self.compute_size() as usize
8649 }
8650}
8651impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_GetReplies_Request {
8652 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8653 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8654 }
8655 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8656 use ::steam_vent_proto_common::protobuf::Message;
8657 self.write_to_writer(writer)
8658 }
8659 fn encode_size(&self) -> usize {
8660 use ::steam_vent_proto_common::protobuf::Message;
8661 self.compute_size() as usize
8662 }
8663}
8664impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_GetReplies_Response {
8665 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8666 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8667 }
8668 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8669 use ::steam_vent_proto_common::protobuf::Message;
8670 self.write_to_writer(writer)
8671 }
8672 fn encode_size(&self) -> usize {
8673 use ::steam_vent_proto_common::protobuf::Message;
8674 self.compute_size() as usize
8675 }
8676}
8677impl ::steam_vent_proto_common::RpcMessage
8678for CRemoteClient_AllocateRelayServer_Request {
8679 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8680 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8681 }
8682 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8683 use ::steam_vent_proto_common::protobuf::Message;
8684 self.write_to_writer(writer)
8685 }
8686 fn encode_size(&self) -> usize {
8687 use ::steam_vent_proto_common::protobuf::Message;
8688 self.compute_size() as usize
8689 }
8690}
8691impl ::steam_vent_proto_common::RpcMessage
8692for CRemoteClient_AllocateRelayServer_Response {
8693 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8694 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8695 }
8696 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8697 use ::steam_vent_proto_common::protobuf::Message;
8698 self.write_to_writer(writer)
8699 }
8700 fn encode_size(&self) -> usize {
8701 use ::steam_vent_proto_common::protobuf::Message;
8702 self.compute_size() as usize
8703 }
8704}
8705impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_AllocateSDR_Request {
8706 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8707 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8708 }
8709 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8710 use ::steam_vent_proto_common::protobuf::Message;
8711 self.write_to_writer(writer)
8712 }
8713 fn encode_size(&self) -> usize {
8714 use ::steam_vent_proto_common::protobuf::Message;
8715 self.compute_size() as usize
8716 }
8717}
8718impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_AllocateSDR_Response {
8719 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8720 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8721 }
8722 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8723 use ::steam_vent_proto_common::protobuf::Message;
8724 self.write_to_writer(writer)
8725 }
8726 fn encode_size(&self) -> usize {
8727 use ::steam_vent_proto_common::protobuf::Message;
8728 self.compute_size() as usize
8729 }
8730}
8731impl ::steam_vent_proto_common::RpcMessage
8732for CRemoteClient_SteamBroadcast_Notification {
8733 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8734 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8735 }
8736 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8737 use ::steam_vent_proto_common::protobuf::Message;
8738 self.write_to_writer(writer)
8739 }
8740 fn encode_size(&self) -> usize {
8741 use ::steam_vent_proto_common::protobuf::Message;
8742 self.compute_size() as usize
8743 }
8744}
8745impl ::steam_vent_proto_common::RpcMessage for CRemoteClient_SteamToSteam_Notification {
8746 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8747 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8748 }
8749 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8750 use ::steam_vent_proto_common::protobuf::Message;
8751 self.write_to_writer(writer)
8752 }
8753 fn encode_size(&self) -> usize {
8754 use ::steam_vent_proto_common::protobuf::Message;
8755 self.compute_size() as usize
8756 }
8757}
8758impl ::steam_vent_proto_common::RpcMessage for CRemotePlay_SessionStarted_Request {
8759 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8760 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8761 }
8762 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8763 use ::steam_vent_proto_common::protobuf::Message;
8764 self.write_to_writer(writer)
8765 }
8766 fn encode_size(&self) -> usize {
8767 use ::steam_vent_proto_common::protobuf::Message;
8768 self.compute_size() as usize
8769 }
8770}
8771impl ::steam_vent_proto_common::RpcMessage for CRemotePlay_SessionStarted_Response {
8772 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8773 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8774 }
8775 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8776 use ::steam_vent_proto_common::protobuf::Message;
8777 self.write_to_writer(writer)
8778 }
8779 fn encode_size(&self) -> usize {
8780 use ::steam_vent_proto_common::protobuf::Message;
8781 self.compute_size() as usize
8782 }
8783}
8784impl ::steam_vent_proto_common::RpcMessage for CRemotePlay_SessionStopped_Notification {
8785 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8786 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8787 }
8788 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8789 use ::steam_vent_proto_common::protobuf::Message;
8790 self.write_to_writer(writer)
8791 }
8792 fn encode_size(&self) -> usize {
8793 use ::steam_vent_proto_common::protobuf::Message;
8794 self.compute_size() as usize
8795 }
8796}
8797impl ::steam_vent_proto_common::RpcMessage for CRemotePlayTogether_Notification {
8798 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8799 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8800 }
8801 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8802 use ::steam_vent_proto_common::protobuf::Message;
8803 self.write_to_writer(writer)
8804 }
8805 fn encode_size(&self) -> usize {
8806 use ::steam_vent_proto_common::protobuf::Message;
8807 self.compute_size() as usize
8808 }
8809}
8810impl ::steam_vent_proto_common::RpcMessage
8811for CRemoteClient_CreateRemotePlayTogetherInvitation_Request {
8812 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8813 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8814 }
8815 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8816 use ::steam_vent_proto_common::protobuf::Message;
8817 self.write_to_writer(writer)
8818 }
8819 fn encode_size(&self) -> usize {
8820 use ::steam_vent_proto_common::protobuf::Message;
8821 self.compute_size() as usize
8822 }
8823}
8824impl ::steam_vent_proto_common::RpcMessage
8825for CRemoteClient_CreateRemotePlayTogetherInvitation_Response {
8826 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8827 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8828 }
8829 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8830 use ::steam_vent_proto_common::protobuf::Message;
8831 self.write_to_writer(writer)
8832 }
8833 fn encode_size(&self) -> usize {
8834 use ::steam_vent_proto_common::protobuf::Message;
8835 self.compute_size() as usize
8836 }
8837}
8838impl ::steam_vent_proto_common::RpcMessage
8839for CRemoteClient_DeleteRemotePlayTogetherInvitation_Request {
8840 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8841 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8842 }
8843 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8844 use ::steam_vent_proto_common::protobuf::Message;
8845 self.write_to_writer(writer)
8846 }
8847 fn encode_size(&self) -> usize {
8848 use ::steam_vent_proto_common::protobuf::Message;
8849 self.compute_size() as usize
8850 }
8851}
8852impl ::steam_vent_proto_common::RpcMessage
8853for CRemoteClient_DeleteRemotePlayTogetherInvitation_Response {
8854 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8855 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8856 }
8857 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8858 use ::steam_vent_proto_common::protobuf::Message;
8859 self.write_to_writer(writer)
8860 }
8861 fn encode_size(&self) -> usize {
8862 use ::steam_vent_proto_common::protobuf::Message;
8863 self.compute_size() as usize
8864 }
8865}
8866impl ::steam_vent_proto_common::RpcMessage
8867for CRemoteClient_LookupRemotePlayTogetherInvitation_Request {
8868 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8869 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8870 }
8871 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8872 use ::steam_vent_proto_common::protobuf::Message;
8873 self.write_to_writer(writer)
8874 }
8875 fn encode_size(&self) -> usize {
8876 use ::steam_vent_proto_common::protobuf::Message;
8877 self.compute_size() as usize
8878 }
8879}
8880impl ::steam_vent_proto_common::RpcMessage
8881for CRemoteClient_LookupRemotePlayTogetherInvitation_Response {
8882 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8883 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8884 }
8885 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8886 use ::steam_vent_proto_common::protobuf::Message;
8887 self.write_to_writer(writer)
8888 }
8889 fn encode_size(&self) -> usize {
8890 use ::steam_vent_proto_common::protobuf::Message;
8891 self.compute_size() as usize
8892 }
8893}
8894impl ::steam_vent_proto_common::RpcMessage for CCMRemoteClient_ClientMessage {
8895 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8896 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8897 }
8898 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8899 use ::steam_vent_proto_common::protobuf::Message;
8900 self.write_to_writer(writer)
8901 }
8902 fn encode_size(&self) -> usize {
8903 use ::steam_vent_proto_common::protobuf::Message;
8904 self.compute_size() as usize
8905 }
8906}
8907impl ::steam_vent_proto_common::RpcMessage for CCMRemoteClient_ServerMessage {
8908 fn parse(reader: &mut dyn std::io::Read) -> ::steam_vent_proto_common::protobuf::Result<Self> {
8909 <Self as ::steam_vent_proto_common::protobuf::Message>::parse_from_reader(reader)
8910 }
8911 fn write(&self, writer: &mut dyn std::io::Write) -> ::steam_vent_proto_common::protobuf::Result<()> {
8912 use ::steam_vent_proto_common::protobuf::Message;
8913 self.write_to_writer(writer)
8914 }
8915 fn encode_size(&self) -> usize {
8916 use ::steam_vent_proto_common::protobuf::Message;
8917 self.compute_size() as usize
8918 }
8919}