#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_4_0;
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientStatus {
pub client_id: ::std::option::Option<u64>,
pub instance_id: ::std::option::Option<u64>,
pub status: ::protobuf::MessageField<super::steammessages_remoteclient_discovery::CMsgRemoteClientBroadcastStatus>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientStatus {
fn default() -> &'a CMsgRemoteClientStatus {
<CMsgRemoteClientStatus as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientStatus {
pub fn new() -> CMsgRemoteClientStatus {
::std::default::Default::default()
}
pub fn client_id(&self) -> u64 {
self.client_id.unwrap_or(0)
}
pub fn clear_client_id(&mut self) {
self.client_id = ::std::option::Option::None;
}
pub fn has_client_id(&self) -> bool {
self.client_id.is_some()
}
pub fn set_client_id(&mut self, v: u64) {
self.client_id = ::std::option::Option::Some(v);
}
pub fn instance_id(&self) -> u64 {
self.instance_id.unwrap_or(0)
}
pub fn clear_instance_id(&mut self) {
self.instance_id = ::std::option::Option::None;
}
pub fn has_instance_id(&self) -> bool {
self.instance_id.is_some()
}
pub fn set_instance_id(&mut self, v: u64) {
self.instance_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CMsgRemoteClientStatus {
const NAME: &'static str = "CMsgRemoteClientStatus";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.client_id = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.instance_id = ::std::option::Option::Some(is.read_uint64()?);
},
26 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.status)?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.client_id {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.instance_id {
my_size += ::protobuf::rt::uint64_size(2, v);
}
if let Some(v) = self.status.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.client_id {
os.write_uint64(1, v)?;
}
if let Some(v) = self.instance_id {
os.write_uint64(2, v)?;
}
if let Some(v) = self.status.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientStatus {
CMsgRemoteClientStatus::new()
}
fn clear(&mut self) {
self.client_id = ::std::option::Option::None;
self.instance_id = ::std::option::Option::None;
self.status.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientStatus {
static instance: CMsgRemoteClientStatus = CMsgRemoteClientStatus {
client_id: ::std::option::Option::None,
instance_id: ::std::option::Option::None,
status: ::protobuf::MessageField::none(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientAppStatus {
pub status_updates: ::std::vec::Vec<cmsg_remote_client_app_status::AppStatus>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientAppStatus {
fn default() -> &'a CMsgRemoteClientAppStatus {
<CMsgRemoteClientAppStatus as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientAppStatus {
pub fn new() -> CMsgRemoteClientAppStatus {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CMsgRemoteClientAppStatus {
const NAME: &'static str = "CMsgRemoteClientAppStatus";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.status_updates.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.status_updates {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.status_updates {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientAppStatus {
CMsgRemoteClientAppStatus::new()
}
fn clear(&mut self) {
self.status_updates.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientAppStatus {
static instance: CMsgRemoteClientAppStatus = CMsgRemoteClientAppStatus {
status_updates: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cmsg_remote_client_app_status {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AppUpdateInfo {
pub time_update_start: ::std::option::Option<u32>,
pub bytes_to_download: ::std::option::Option<u64>,
pub bytes_downloaded: ::std::option::Option<u64>,
pub bytes_to_process: ::std::option::Option<u64>,
pub bytes_processed: ::std::option::Option<u64>,
pub estimated_seconds_remaining: ::std::option::Option<i32>,
pub update_result: ::std::option::Option<i32>,
pub update_state: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a AppUpdateInfo {
fn default() -> &'a AppUpdateInfo {
<AppUpdateInfo as ::protobuf::Message>::default_instance()
}
}
impl AppUpdateInfo {
pub fn new() -> AppUpdateInfo {
::std::default::Default::default()
}
pub fn time_update_start(&self) -> u32 {
self.time_update_start.unwrap_or(0)
}
pub fn clear_time_update_start(&mut self) {
self.time_update_start = ::std::option::Option::None;
}
pub fn has_time_update_start(&self) -> bool {
self.time_update_start.is_some()
}
pub fn set_time_update_start(&mut self, v: u32) {
self.time_update_start = ::std::option::Option::Some(v);
}
pub fn bytes_to_download(&self) -> u64 {
self.bytes_to_download.unwrap_or(0)
}
pub fn clear_bytes_to_download(&mut self) {
self.bytes_to_download = ::std::option::Option::None;
}
pub fn has_bytes_to_download(&self) -> bool {
self.bytes_to_download.is_some()
}
pub fn set_bytes_to_download(&mut self, v: u64) {
self.bytes_to_download = ::std::option::Option::Some(v);
}
pub fn bytes_downloaded(&self) -> u64 {
self.bytes_downloaded.unwrap_or(0)
}
pub fn clear_bytes_downloaded(&mut self) {
self.bytes_downloaded = ::std::option::Option::None;
}
pub fn has_bytes_downloaded(&self) -> bool {
self.bytes_downloaded.is_some()
}
pub fn set_bytes_downloaded(&mut self, v: u64) {
self.bytes_downloaded = ::std::option::Option::Some(v);
}
pub fn bytes_to_process(&self) -> u64 {
self.bytes_to_process.unwrap_or(0)
}
pub fn clear_bytes_to_process(&mut self) {
self.bytes_to_process = ::std::option::Option::None;
}
pub fn has_bytes_to_process(&self) -> bool {
self.bytes_to_process.is_some()
}
pub fn set_bytes_to_process(&mut self, v: u64) {
self.bytes_to_process = ::std::option::Option::Some(v);
}
pub fn bytes_processed(&self) -> u64 {
self.bytes_processed.unwrap_or(0)
}
pub fn clear_bytes_processed(&mut self) {
self.bytes_processed = ::std::option::Option::None;
}
pub fn has_bytes_processed(&self) -> bool {
self.bytes_processed.is_some()
}
pub fn set_bytes_processed(&mut self, v: u64) {
self.bytes_processed = ::std::option::Option::Some(v);
}
pub fn estimated_seconds_remaining(&self) -> i32 {
self.estimated_seconds_remaining.unwrap_or(-1i32)
}
pub fn clear_estimated_seconds_remaining(&mut self) {
self.estimated_seconds_remaining = ::std::option::Option::None;
}
pub fn has_estimated_seconds_remaining(&self) -> bool {
self.estimated_seconds_remaining.is_some()
}
pub fn set_estimated_seconds_remaining(&mut self, v: i32) {
self.estimated_seconds_remaining = ::std::option::Option::Some(v);
}
pub fn update_result(&self) -> i32 {
self.update_result.unwrap_or(0)
}
pub fn clear_update_result(&mut self) {
self.update_result = ::std::option::Option::None;
}
pub fn has_update_result(&self) -> bool {
self.update_result.is_some()
}
pub fn set_update_result(&mut self, v: i32) {
self.update_result = ::std::option::Option::Some(v);
}
pub fn update_state(&self) -> u32 {
self.update_state.unwrap_or(0)
}
pub fn clear_update_state(&mut self) {
self.update_state = ::std::option::Option::None;
}
pub fn has_update_state(&self) -> bool {
self.update_state.is_some()
}
pub fn set_update_state(&mut self, v: u32) {
self.update_state = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for AppUpdateInfo {
const NAME: &'static str = "AppUpdateInfo";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
13 => {
self.time_update_start = ::std::option::Option::Some(is.read_fixed32()?);
},
16 => {
self.bytes_to_download = ::std::option::Option::Some(is.read_uint64()?);
},
24 => {
self.bytes_downloaded = ::std::option::Option::Some(is.read_uint64()?);
},
32 => {
self.bytes_to_process = ::std::option::Option::Some(is.read_uint64()?);
},
40 => {
self.bytes_processed = ::std::option::Option::Some(is.read_uint64()?);
},
48 => {
self.estimated_seconds_remaining = ::std::option::Option::Some(is.read_int32()?);
},
56 => {
self.update_result = ::std::option::Option::Some(is.read_int32()?);
},
64 => {
self.update_state = ::std::option::Option::Some(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.time_update_start {
my_size += 1 + 4;
}
if let Some(v) = self.bytes_to_download {
my_size += ::protobuf::rt::uint64_size(2, v);
}
if let Some(v) = self.bytes_downloaded {
my_size += ::protobuf::rt::uint64_size(3, v);
}
if let Some(v) = self.bytes_to_process {
my_size += ::protobuf::rt::uint64_size(4, v);
}
if let Some(v) = self.bytes_processed {
my_size += ::protobuf::rt::uint64_size(5, v);
}
if let Some(v) = self.estimated_seconds_remaining {
my_size += ::protobuf::rt::int32_size(6, v);
}
if let Some(v) = self.update_result {
my_size += ::protobuf::rt::int32_size(7, v);
}
if let Some(v) = self.update_state {
my_size += ::protobuf::rt::uint32_size(8, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.time_update_start {
os.write_fixed32(1, v)?;
}
if let Some(v) = self.bytes_to_download {
os.write_uint64(2, v)?;
}
if let Some(v) = self.bytes_downloaded {
os.write_uint64(3, v)?;
}
if let Some(v) = self.bytes_to_process {
os.write_uint64(4, v)?;
}
if let Some(v) = self.bytes_processed {
os.write_uint64(5, v)?;
}
if let Some(v) = self.estimated_seconds_remaining {
os.write_int32(6, v)?;
}
if let Some(v) = self.update_result {
os.write_int32(7, v)?;
}
if let Some(v) = self.update_state {
os.write_uint32(8, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> AppUpdateInfo {
AppUpdateInfo::new()
}
fn clear(&mut self) {
self.time_update_start = ::std::option::Option::None;
self.bytes_to_download = ::std::option::Option::None;
self.bytes_downloaded = ::std::option::Option::None;
self.bytes_to_process = ::std::option::Option::None;
self.bytes_processed = ::std::option::Option::None;
self.estimated_seconds_remaining = ::std::option::Option::None;
self.update_result = ::std::option::Option::None;
self.update_state = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static AppUpdateInfo {
static instance: AppUpdateInfo = AppUpdateInfo {
time_update_start: ::std::option::Option::None,
bytes_to_download: ::std::option::Option::None,
bytes_downloaded: ::std::option::Option::None,
bytes_to_process: ::std::option::Option::None,
bytes_processed: ::std::option::Option::None,
estimated_seconds_remaining: ::std::option::Option::None,
update_result: ::std::option::Option::None,
update_state: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ShortcutInfo {
pub name: ::std::option::Option<::std::string::String>,
pub icon: ::std::option::Option<::std::string::String>,
pub categories: ::std::vec::Vec<::std::string::String>,
pub exepath: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ShortcutInfo {
fn default() -> &'a ShortcutInfo {
<ShortcutInfo as ::protobuf::Message>::default_instance()
}
}
impl ShortcutInfo {
pub fn new() -> ShortcutInfo {
::std::default::Default::default()
}
pub fn name(&self) -> &str {
match self.name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_name(&mut self) {
self.name = ::std::option::Option::None;
}
pub fn has_name(&self) -> bool {
self.name.is_some()
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = ::std::option::Option::Some(v);
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
if self.name.is_none() {
self.name = ::std::option::Option::Some(::std::string::String::new());
}
self.name.as_mut().unwrap()
}
pub fn take_name(&mut self) -> ::std::string::String {
self.name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn icon(&self) -> &str {
match self.icon.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_icon(&mut self) {
self.icon = ::std::option::Option::None;
}
pub fn has_icon(&self) -> bool {
self.icon.is_some()
}
pub fn set_icon(&mut self, v: ::std::string::String) {
self.icon = ::std::option::Option::Some(v);
}
pub fn mut_icon(&mut self) -> &mut ::std::string::String {
if self.icon.is_none() {
self.icon = ::std::option::Option::Some(::std::string::String::new());
}
self.icon.as_mut().unwrap()
}
pub fn take_icon(&mut self) -> ::std::string::String {
self.icon.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn exepath(&self) -> &str {
match self.exepath.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_exepath(&mut self) {
self.exepath = ::std::option::Option::None;
}
pub fn has_exepath(&self) -> bool {
self.exepath.is_some()
}
pub fn set_exepath(&mut self, v: ::std::string::String) {
self.exepath = ::std::option::Option::Some(v);
}
pub fn mut_exepath(&mut self) -> &mut ::std::string::String {
if self.exepath.is_none() {
self.exepath = ::std::option::Option::Some(::std::string::String::new());
}
self.exepath.as_mut().unwrap()
}
pub fn take_exepath(&mut self) -> ::std::string::String {
self.exepath.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for ShortcutInfo {
const NAME: &'static str = "ShortcutInfo";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.name = ::std::option::Option::Some(is.read_string()?);
},
18 => {
self.icon = ::std::option::Option::Some(is.read_string()?);
},
26 => {
self.categories.push(is.read_string()?);
},
34 => {
self.exepath = ::std::option::Option::Some(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.name.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(v) = self.icon.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
for value in &self.categories {
my_size += ::protobuf::rt::string_size(3, &value);
};
if let Some(v) = self.exepath.as_ref() {
my_size += ::protobuf::rt::string_size(4, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.name.as_ref() {
os.write_string(1, v)?;
}
if let Some(v) = self.icon.as_ref() {
os.write_string(2, v)?;
}
for v in &self.categories {
os.write_string(3, &v)?;
};
if let Some(v) = self.exepath.as_ref() {
os.write_string(4, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> ShortcutInfo {
ShortcutInfo::new()
}
fn clear(&mut self) {
self.name = ::std::option::Option::None;
self.icon = ::std::option::Option::None;
self.categories.clear();
self.exepath = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static ShortcutInfo {
static instance: ShortcutInfo = ShortcutInfo {
name: ::std::option::Option::None,
icon: ::std::option::Option::None,
categories: ::std::vec::Vec::new(),
exepath: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AppStatus {
pub app_id: ::std::option::Option<u32>,
pub app_state: ::std::option::Option<u32>,
pub update_info: ::protobuf::MessageField<AppUpdateInfo>,
pub shortcut_info: ::protobuf::MessageField<ShortcutInfo>,
pub launch_available: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a AppStatus {
fn default() -> &'a AppStatus {
<AppStatus as ::protobuf::Message>::default_instance()
}
}
impl AppStatus {
pub fn new() -> AppStatus {
::std::default::Default::default()
}
pub fn app_id(&self) -> u32 {
self.app_id.unwrap_or(0)
}
pub fn clear_app_id(&mut self) {
self.app_id = ::std::option::Option::None;
}
pub fn has_app_id(&self) -> bool {
self.app_id.is_some()
}
pub fn set_app_id(&mut self, v: u32) {
self.app_id = ::std::option::Option::Some(v);
}
pub fn app_state(&self) -> u32 {
self.app_state.unwrap_or(0)
}
pub fn clear_app_state(&mut self) {
self.app_state = ::std::option::Option::None;
}
pub fn has_app_state(&self) -> bool {
self.app_state.is_some()
}
pub fn set_app_state(&mut self, v: u32) {
self.app_state = ::std::option::Option::Some(v);
}
pub fn launch_available(&self) -> bool {
self.launch_available.unwrap_or(true)
}
pub fn clear_launch_available(&mut self) {
self.launch_available = ::std::option::Option::None;
}
pub fn has_launch_available(&self) -> bool {
self.launch_available.is_some()
}
pub fn set_launch_available(&mut self, v: bool) {
self.launch_available = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for AppStatus {
const NAME: &'static str = "AppStatus";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.app_id = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.app_state = ::std::option::Option::Some(is.read_uint32()?);
},
26 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.update_info)?;
},
34 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.shortcut_info)?;
},
40 => {
self.launch_available = ::std::option::Option::Some(is.read_bool()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.app_id {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.app_state {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.update_info.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self.shortcut_info.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self.launch_available {
my_size += 1 + 1;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.app_id {
os.write_uint32(1, v)?;
}
if let Some(v) = self.app_state {
os.write_uint32(2, v)?;
}
if let Some(v) = self.update_info.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
}
if let Some(v) = self.shortcut_info.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
}
if let Some(v) = self.launch_available {
os.write_bool(5, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> AppStatus {
AppStatus::new()
}
fn clear(&mut self) {
self.app_id = ::std::option::Option::None;
self.app_state = ::std::option::Option::None;
self.update_info.clear();
self.shortcut_info.clear();
self.launch_available = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static AppStatus {
static instance: AppStatus = AppStatus {
app_id: ::std::option::Option::None,
app_state: ::std::option::Option::None,
update_info: ::protobuf::MessageField::none(),
shortcut_info: ::protobuf::MessageField::none(),
launch_available: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientStartStream {
pub app_id: ::std::option::Option<u32>,
pub environment: ::std::option::Option<i32>,
pub gamepad_count: ::std::option::Option<i32>,
pub launch_option: ::std::option::Option<i32>,
pub lock_parental_lock: ::std::option::Option<bool>,
pub unlock_parental_lock: ::std::option::Option<::std::string::String>,
pub maximum_resolution_x: ::std::option::Option<i32>,
pub maximum_resolution_y: ::std::option::Option<i32>,
pub gamepads: ::std::vec::Vec<cmsg_remote_client_start_stream::ReservedGamepad>,
pub audio_channel_count: ::std::option::Option<i32>,
pub supported_transport: ::std::vec::Vec<::protobuf::EnumOrUnknown<super::steammessages_remoteclient_discovery::EStreamTransport>>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientStartStream {
fn default() -> &'a CMsgRemoteClientStartStream {
<CMsgRemoteClientStartStream as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientStartStream {
pub fn new() -> CMsgRemoteClientStartStream {
::std::default::Default::default()
}
pub fn app_id(&self) -> u32 {
self.app_id.unwrap_or(0)
}
pub fn clear_app_id(&mut self) {
self.app_id = ::std::option::Option::None;
}
pub fn has_app_id(&self) -> bool {
self.app_id.is_some()
}
pub fn set_app_id(&mut self, v: u32) {
self.app_id = ::std::option::Option::Some(v);
}
pub fn environment(&self) -> i32 {
self.environment.unwrap_or(0)
}
pub fn clear_environment(&mut self) {
self.environment = ::std::option::Option::None;
}
pub fn has_environment(&self) -> bool {
self.environment.is_some()
}
pub fn set_environment(&mut self, v: i32) {
self.environment = ::std::option::Option::Some(v);
}
pub fn gamepad_count(&self) -> i32 {
self.gamepad_count.unwrap_or(0)
}
pub fn clear_gamepad_count(&mut self) {
self.gamepad_count = ::std::option::Option::None;
}
pub fn has_gamepad_count(&self) -> bool {
self.gamepad_count.is_some()
}
pub fn set_gamepad_count(&mut self, v: i32) {
self.gamepad_count = ::std::option::Option::Some(v);
}
pub fn launch_option(&self) -> i32 {
self.launch_option.unwrap_or(-1i32)
}
pub fn clear_launch_option(&mut self) {
self.launch_option = ::std::option::Option::None;
}
pub fn has_launch_option(&self) -> bool {
self.launch_option.is_some()
}
pub fn set_launch_option(&mut self, v: i32) {
self.launch_option = ::std::option::Option::Some(v);
}
pub fn lock_parental_lock(&self) -> bool {
self.lock_parental_lock.unwrap_or(false)
}
pub fn clear_lock_parental_lock(&mut self) {
self.lock_parental_lock = ::std::option::Option::None;
}
pub fn has_lock_parental_lock(&self) -> bool {
self.lock_parental_lock.is_some()
}
pub fn set_lock_parental_lock(&mut self, v: bool) {
self.lock_parental_lock = ::std::option::Option::Some(v);
}
pub fn unlock_parental_lock(&self) -> &str {
match self.unlock_parental_lock.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_unlock_parental_lock(&mut self) {
self.unlock_parental_lock = ::std::option::Option::None;
}
pub fn has_unlock_parental_lock(&self) -> bool {
self.unlock_parental_lock.is_some()
}
pub fn set_unlock_parental_lock(&mut self, v: ::std::string::String) {
self.unlock_parental_lock = ::std::option::Option::Some(v);
}
pub fn mut_unlock_parental_lock(&mut self) -> &mut ::std::string::String {
if self.unlock_parental_lock.is_none() {
self.unlock_parental_lock = ::std::option::Option::Some(::std::string::String::new());
}
self.unlock_parental_lock.as_mut().unwrap()
}
pub fn take_unlock_parental_lock(&mut self) -> ::std::string::String {
self.unlock_parental_lock.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn maximum_resolution_x(&self) -> i32 {
self.maximum_resolution_x.unwrap_or(0)
}
pub fn clear_maximum_resolution_x(&mut self) {
self.maximum_resolution_x = ::std::option::Option::None;
}
pub fn has_maximum_resolution_x(&self) -> bool {
self.maximum_resolution_x.is_some()
}
pub fn set_maximum_resolution_x(&mut self, v: i32) {
self.maximum_resolution_x = ::std::option::Option::Some(v);
}
pub fn maximum_resolution_y(&self) -> i32 {
self.maximum_resolution_y.unwrap_or(0)
}
pub fn clear_maximum_resolution_y(&mut self) {
self.maximum_resolution_y = ::std::option::Option::None;
}
pub fn has_maximum_resolution_y(&self) -> bool {
self.maximum_resolution_y.is_some()
}
pub fn set_maximum_resolution_y(&mut self, v: i32) {
self.maximum_resolution_y = ::std::option::Option::Some(v);
}
pub fn audio_channel_count(&self) -> i32 {
self.audio_channel_count.unwrap_or(2i32)
}
pub fn clear_audio_channel_count(&mut self) {
self.audio_channel_count = ::std::option::Option::None;
}
pub fn has_audio_channel_count(&self) -> bool {
self.audio_channel_count.is_some()
}
pub fn set_audio_channel_count(&mut self, v: i32) {
self.audio_channel_count = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CMsgRemoteClientStartStream {
const NAME: &'static str = "CMsgRemoteClientStartStream";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.app_id = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.environment = ::std::option::Option::Some(is.read_int32()?);
},
24 => {
self.gamepad_count = ::std::option::Option::Some(is.read_int32()?);
},
32 => {
self.launch_option = ::std::option::Option::Some(is.read_int32()?);
},
40 => {
self.lock_parental_lock = ::std::option::Option::Some(is.read_bool()?);
},
50 => {
self.unlock_parental_lock = ::std::option::Option::Some(is.read_string()?);
},
56 => {
self.maximum_resolution_x = ::std::option::Option::Some(is.read_int32()?);
},
64 => {
self.maximum_resolution_y = ::std::option::Option::Some(is.read_int32()?);
},
74 => {
self.gamepads.push(is.read_message()?);
},
80 => {
self.audio_channel_count = ::std::option::Option::Some(is.read_int32()?);
},
88 => {
self.supported_transport.push(is.read_enum_or_unknown()?);
},
90 => {
::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.supported_transport)?
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.app_id {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.environment {
my_size += ::protobuf::rt::int32_size(2, v);
}
if let Some(v) = self.gamepad_count {
my_size += ::protobuf::rt::int32_size(3, v);
}
if let Some(v) = self.launch_option {
my_size += ::protobuf::rt::int32_size(4, v);
}
if let Some(v) = self.lock_parental_lock {
my_size += 1 + 1;
}
if let Some(v) = self.unlock_parental_lock.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
if let Some(v) = self.maximum_resolution_x {
my_size += ::protobuf::rt::int32_size(7, v);
}
if let Some(v) = self.maximum_resolution_y {
my_size += ::protobuf::rt::int32_size(8, v);
}
for value in &self.gamepads {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self.audio_channel_count {
my_size += ::protobuf::rt::int32_size(10, v);
}
for value in &self.supported_transport {
my_size += ::protobuf::rt::int32_size(11, value.value());
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.app_id {
os.write_uint32(1, v)?;
}
if let Some(v) = self.environment {
os.write_int32(2, v)?;
}
if let Some(v) = self.gamepad_count {
os.write_int32(3, v)?;
}
if let Some(v) = self.launch_option {
os.write_int32(4, v)?;
}
if let Some(v) = self.lock_parental_lock {
os.write_bool(5, v)?;
}
if let Some(v) = self.unlock_parental_lock.as_ref() {
os.write_string(6, v)?;
}
if let Some(v) = self.maximum_resolution_x {
os.write_int32(7, v)?;
}
if let Some(v) = self.maximum_resolution_y {
os.write_int32(8, v)?;
}
for v in &self.gamepads {
::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
};
if let Some(v) = self.audio_channel_count {
os.write_int32(10, v)?;
}
for v in &self.supported_transport {
os.write_enum(11, ::protobuf::EnumOrUnknown::value(v))?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientStartStream {
CMsgRemoteClientStartStream::new()
}
fn clear(&mut self) {
self.app_id = ::std::option::Option::None;
self.environment = ::std::option::Option::None;
self.gamepad_count = ::std::option::Option::None;
self.launch_option = ::std::option::Option::None;
self.lock_parental_lock = ::std::option::Option::None;
self.unlock_parental_lock = ::std::option::Option::None;
self.maximum_resolution_x = ::std::option::Option::None;
self.maximum_resolution_y = ::std::option::Option::None;
self.gamepads.clear();
self.audio_channel_count = ::std::option::Option::None;
self.supported_transport.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientStartStream {
static instance: CMsgRemoteClientStartStream = CMsgRemoteClientStartStream {
app_id: ::std::option::Option::None,
environment: ::std::option::Option::None,
gamepad_count: ::std::option::Option::None,
launch_option: ::std::option::Option::None,
lock_parental_lock: ::std::option::Option::None,
unlock_parental_lock: ::std::option::Option::None,
maximum_resolution_x: ::std::option::Option::None,
maximum_resolution_y: ::std::option::Option::None,
gamepads: ::std::vec::Vec::new(),
audio_channel_count: ::std::option::Option::None,
supported_transport: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cmsg_remote_client_start_stream {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ReservedGamepad {
pub controller_type: ::std::option::Option<u32>,
pub controller_subtype: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ReservedGamepad {
fn default() -> &'a ReservedGamepad {
<ReservedGamepad as ::protobuf::Message>::default_instance()
}
}
impl ReservedGamepad {
pub fn new() -> ReservedGamepad {
::std::default::Default::default()
}
pub fn controller_type(&self) -> u32 {
self.controller_type.unwrap_or(0)
}
pub fn clear_controller_type(&mut self) {
self.controller_type = ::std::option::Option::None;
}
pub fn has_controller_type(&self) -> bool {
self.controller_type.is_some()
}
pub fn set_controller_type(&mut self, v: u32) {
self.controller_type = ::std::option::Option::Some(v);
}
pub fn controller_subtype(&self) -> u32 {
self.controller_subtype.unwrap_or(0)
}
pub fn clear_controller_subtype(&mut self) {
self.controller_subtype = ::std::option::Option::None;
}
pub fn has_controller_subtype(&self) -> bool {
self.controller_subtype.is_some()
}
pub fn set_controller_subtype(&mut self, v: u32) {
self.controller_subtype = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for ReservedGamepad {
const NAME: &'static str = "ReservedGamepad";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.controller_type = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.controller_subtype = ::std::option::Option::Some(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.controller_type {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.controller_subtype {
my_size += ::protobuf::rt::uint32_size(2, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.controller_type {
os.write_uint32(1, v)?;
}
if let Some(v) = self.controller_subtype {
os.write_uint32(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> ReservedGamepad {
ReservedGamepad::new()
}
fn clear(&mut self) {
self.controller_type = ::std::option::Option::None;
self.controller_subtype = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static ReservedGamepad {
static instance: ReservedGamepad = ReservedGamepad {
controller_type: ::std::option::Option::None,
controller_subtype: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientStartStreamResponse {
pub e_launch_result: ::std::option::Option<i32>,
pub stream_port: ::std::option::Option<u32>,
pub launch_options: ::std::vec::Vec<i32>,
pub auth_token: ::std::option::Option<::std::vec::Vec<u8>>,
pub transport: ::std::option::Option<::protobuf::EnumOrUnknown<super::steammessages_remoteclient_discovery::EStreamTransport>>,
pub relay_server: ::std::option::Option<::std::string::String>,
pub launch_task: ::std::option::Option<::std::string::String>,
pub launch_task_detail: ::std::option::Option<::std::string::String>,
pub launch_tasks_done: ::std::option::Option<i32>,
pub launch_tasks_total: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientStartStreamResponse {
fn default() -> &'a CMsgRemoteClientStartStreamResponse {
<CMsgRemoteClientStartStreamResponse as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientStartStreamResponse {
pub fn new() -> CMsgRemoteClientStartStreamResponse {
::std::default::Default::default()
}
pub fn e_launch_result(&self) -> i32 {
self.e_launch_result.unwrap_or(2i32)
}
pub fn clear_e_launch_result(&mut self) {
self.e_launch_result = ::std::option::Option::None;
}
pub fn has_e_launch_result(&self) -> bool {
self.e_launch_result.is_some()
}
pub fn set_e_launch_result(&mut self, v: i32) {
self.e_launch_result = ::std::option::Option::Some(v);
}
pub fn stream_port(&self) -> u32 {
self.stream_port.unwrap_or(0)
}
pub fn clear_stream_port(&mut self) {
self.stream_port = ::std::option::Option::None;
}
pub fn has_stream_port(&self) -> bool {
self.stream_port.is_some()
}
pub fn set_stream_port(&mut self, v: u32) {
self.stream_port = ::std::option::Option::Some(v);
}
pub fn auth_token(&self) -> &[u8] {
match self.auth_token.as_ref() {
Some(v) => v,
None => &[],
}
}
pub fn clear_auth_token(&mut self) {
self.auth_token = ::std::option::Option::None;
}
pub fn has_auth_token(&self) -> bool {
self.auth_token.is_some()
}
pub fn set_auth_token(&mut self, v: ::std::vec::Vec<u8>) {
self.auth_token = ::std::option::Option::Some(v);
}
pub fn mut_auth_token(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.auth_token.is_none() {
self.auth_token = ::std::option::Option::Some(::std::vec::Vec::new());
}
self.auth_token.as_mut().unwrap()
}
pub fn take_auth_token(&mut self) -> ::std::vec::Vec<u8> {
self.auth_token.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
pub fn transport(&self) -> super::steammessages_remoteclient_discovery::EStreamTransport {
match self.transport {
Some(e) => e.enum_value_or(super::steammessages_remoteclient_discovery::EStreamTransport::k_EStreamTransportUDP),
None => super::steammessages_remoteclient_discovery::EStreamTransport::k_EStreamTransportUDP,
}
}
pub fn clear_transport(&mut self) {
self.transport = ::std::option::Option::None;
}
pub fn has_transport(&self) -> bool {
self.transport.is_some()
}
pub fn set_transport(&mut self, v: super::steammessages_remoteclient_discovery::EStreamTransport) {
self.transport = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn relay_server(&self) -> &str {
match self.relay_server.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_relay_server(&mut self) {
self.relay_server = ::std::option::Option::None;
}
pub fn has_relay_server(&self) -> bool {
self.relay_server.is_some()
}
pub fn set_relay_server(&mut self, v: ::std::string::String) {
self.relay_server = ::std::option::Option::Some(v);
}
pub fn mut_relay_server(&mut self) -> &mut ::std::string::String {
if self.relay_server.is_none() {
self.relay_server = ::std::option::Option::Some(::std::string::String::new());
}
self.relay_server.as_mut().unwrap()
}
pub fn take_relay_server(&mut self) -> ::std::string::String {
self.relay_server.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn launch_task(&self) -> &str {
match self.launch_task.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_launch_task(&mut self) {
self.launch_task = ::std::option::Option::None;
}
pub fn has_launch_task(&self) -> bool {
self.launch_task.is_some()
}
pub fn set_launch_task(&mut self, v: ::std::string::String) {
self.launch_task = ::std::option::Option::Some(v);
}
pub fn mut_launch_task(&mut self) -> &mut ::std::string::String {
if self.launch_task.is_none() {
self.launch_task = ::std::option::Option::Some(::std::string::String::new());
}
self.launch_task.as_mut().unwrap()
}
pub fn take_launch_task(&mut self) -> ::std::string::String {
self.launch_task.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn launch_task_detail(&self) -> &str {
match self.launch_task_detail.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_launch_task_detail(&mut self) {
self.launch_task_detail = ::std::option::Option::None;
}
pub fn has_launch_task_detail(&self) -> bool {
self.launch_task_detail.is_some()
}
pub fn set_launch_task_detail(&mut self, v: ::std::string::String) {
self.launch_task_detail = ::std::option::Option::Some(v);
}
pub fn mut_launch_task_detail(&mut self) -> &mut ::std::string::String {
if self.launch_task_detail.is_none() {
self.launch_task_detail = ::std::option::Option::Some(::std::string::String::new());
}
self.launch_task_detail.as_mut().unwrap()
}
pub fn take_launch_task_detail(&mut self) -> ::std::string::String {
self.launch_task_detail.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn launch_tasks_done(&self) -> i32 {
self.launch_tasks_done.unwrap_or(0)
}
pub fn clear_launch_tasks_done(&mut self) {
self.launch_tasks_done = ::std::option::Option::None;
}
pub fn has_launch_tasks_done(&self) -> bool {
self.launch_tasks_done.is_some()
}
pub fn set_launch_tasks_done(&mut self, v: i32) {
self.launch_tasks_done = ::std::option::Option::Some(v);
}
pub fn launch_tasks_total(&self) -> i32 {
self.launch_tasks_total.unwrap_or(0)
}
pub fn clear_launch_tasks_total(&mut self) {
self.launch_tasks_total = ::std::option::Option::None;
}
pub fn has_launch_tasks_total(&self) -> bool {
self.launch_tasks_total.is_some()
}
pub fn set_launch_tasks_total(&mut self, v: i32) {
self.launch_tasks_total = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CMsgRemoteClientStartStreamResponse {
const NAME: &'static str = "CMsgRemoteClientStartStreamResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.e_launch_result = ::std::option::Option::Some(is.read_int32()?);
},
16 => {
self.stream_port = ::std::option::Option::Some(is.read_uint32()?);
},
26 => {
is.read_repeated_packed_int32_into(&mut self.launch_options)?;
},
24 => {
self.launch_options.push(is.read_int32()?);
},
34 => {
self.auth_token = ::std::option::Option::Some(is.read_bytes()?);
},
40 => {
self.transport = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
50 => {
self.relay_server = ::std::option::Option::Some(is.read_string()?);
},
58 => {
self.launch_task = ::std::option::Option::Some(is.read_string()?);
},
66 => {
self.launch_task_detail = ::std::option::Option::Some(is.read_string()?);
},
72 => {
self.launch_tasks_done = ::std::option::Option::Some(is.read_int32()?);
},
80 => {
self.launch_tasks_total = ::std::option::Option::Some(is.read_int32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.e_launch_result {
my_size += ::protobuf::rt::int32_size(1, v);
}
if let Some(v) = self.stream_port {
my_size += ::protobuf::rt::uint32_size(2, v);
}
for value in &self.launch_options {
my_size += ::protobuf::rt::int32_size(3, *value);
};
if let Some(v) = self.auth_token.as_ref() {
my_size += ::protobuf::rt::bytes_size(4, &v);
}
if let Some(v) = self.transport {
my_size += ::protobuf::rt::int32_size(5, v.value());
}
if let Some(v) = self.relay_server.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
if let Some(v) = self.launch_task.as_ref() {
my_size += ::protobuf::rt::string_size(7, &v);
}
if let Some(v) = self.launch_task_detail.as_ref() {
my_size += ::protobuf::rt::string_size(8, &v);
}
if let Some(v) = self.launch_tasks_done {
my_size += ::protobuf::rt::int32_size(9, v);
}
if let Some(v) = self.launch_tasks_total {
my_size += ::protobuf::rt::int32_size(10, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.e_launch_result {
os.write_int32(1, v)?;
}
if let Some(v) = self.stream_port {
os.write_uint32(2, v)?;
}
for v in &self.launch_options {
os.write_int32(3, *v)?;
};
if let Some(v) = self.auth_token.as_ref() {
os.write_bytes(4, v)?;
}
if let Some(v) = self.transport {
os.write_enum(5, ::protobuf::EnumOrUnknown::value(&v))?;
}
if let Some(v) = self.relay_server.as_ref() {
os.write_string(6, v)?;
}
if let Some(v) = self.launch_task.as_ref() {
os.write_string(7, v)?;
}
if let Some(v) = self.launch_task_detail.as_ref() {
os.write_string(8, v)?;
}
if let Some(v) = self.launch_tasks_done {
os.write_int32(9, v)?;
}
if let Some(v) = self.launch_tasks_total {
os.write_int32(10, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientStartStreamResponse {
CMsgRemoteClientStartStreamResponse::new()
}
fn clear(&mut self) {
self.e_launch_result = ::std::option::Option::None;
self.stream_port = ::std::option::Option::None;
self.launch_options.clear();
self.auth_token = ::std::option::Option::None;
self.transport = ::std::option::Option::None;
self.relay_server = ::std::option::Option::None;
self.launch_task = ::std::option::Option::None;
self.launch_task_detail = ::std::option::Option::None;
self.launch_tasks_done = ::std::option::Option::None;
self.launch_tasks_total = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientStartStreamResponse {
static instance: CMsgRemoteClientStartStreamResponse = CMsgRemoteClientStartStreamResponse {
e_launch_result: ::std::option::Option::None,
stream_port: ::std::option::Option::None,
launch_options: ::std::vec::Vec::new(),
auth_token: ::std::option::Option::None,
transport: ::std::option::Option::None,
relay_server: ::std::option::Option::None,
launch_task: ::std::option::Option::None,
launch_task_detail: ::std::option::Option::None,
launch_tasks_done: ::std::option::Option::None,
launch_tasks_total: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientPing {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientPing {
fn default() -> &'a CMsgRemoteClientPing {
<CMsgRemoteClientPing as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientPing {
pub fn new() -> CMsgRemoteClientPing {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CMsgRemoteClientPing {
const NAME: &'static str = "CMsgRemoteClientPing";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientPing {
CMsgRemoteClientPing::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientPing {
static instance: CMsgRemoteClientPing = CMsgRemoteClientPing {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientPingResponse {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientPingResponse {
fn default() -> &'a CMsgRemoteClientPingResponse {
<CMsgRemoteClientPingResponse as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientPingResponse {
pub fn new() -> CMsgRemoteClientPingResponse {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CMsgRemoteClientPingResponse {
const NAME: &'static str = "CMsgRemoteClientPingResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientPingResponse {
CMsgRemoteClientPingResponse::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientPingResponse {
static instance: CMsgRemoteClientPingResponse = CMsgRemoteClientPingResponse {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientAcceptEULA {
pub app_id: ::std::vec::Vec<u32>,
pub eula_id: ::std::vec::Vec<::std::string::String>,
pub eula_version: ::std::vec::Vec<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientAcceptEULA {
fn default() -> &'a CMsgRemoteClientAcceptEULA {
<CMsgRemoteClientAcceptEULA as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientAcceptEULA {
pub fn new() -> CMsgRemoteClientAcceptEULA {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CMsgRemoteClientAcceptEULA {
const NAME: &'static str = "CMsgRemoteClientAcceptEULA";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
is.read_repeated_packed_uint32_into(&mut self.app_id)?;
},
8 => {
self.app_id.push(is.read_uint32()?);
},
18 => {
self.eula_id.push(is.read_string()?);
},
26 => {
is.read_repeated_packed_uint32_into(&mut self.eula_version)?;
},
24 => {
self.eula_version.push(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.app_id {
my_size += ::protobuf::rt::uint32_size(1, *value);
};
for value in &self.eula_id {
my_size += ::protobuf::rt::string_size(2, &value);
};
for value in &self.eula_version {
my_size += ::protobuf::rt::uint32_size(3, *value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.app_id {
os.write_uint32(1, *v)?;
};
for v in &self.eula_id {
os.write_string(2, &v)?;
};
for v in &self.eula_version {
os.write_uint32(3, *v)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientAcceptEULA {
CMsgRemoteClientAcceptEULA::new()
}
fn clear(&mut self) {
self.app_id.clear();
self.eula_id.clear();
self.eula_version.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientAcceptEULA {
static instance: CMsgRemoteClientAcceptEULA = CMsgRemoteClientAcceptEULA {
app_id: ::std::vec::Vec::new(),
eula_id: ::std::vec::Vec::new(),
eula_version: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientGetControllerConfig {
pub app_id: ::std::option::Option<u32>,
pub controller_index: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientGetControllerConfig {
fn default() -> &'a CMsgRemoteClientGetControllerConfig {
<CMsgRemoteClientGetControllerConfig as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientGetControllerConfig {
pub fn new() -> CMsgRemoteClientGetControllerConfig {
::std::default::Default::default()
}
pub fn app_id(&self) -> u32 {
self.app_id.unwrap_or(0)
}
pub fn clear_app_id(&mut self) {
self.app_id = ::std::option::Option::None;
}
pub fn has_app_id(&self) -> bool {
self.app_id.is_some()
}
pub fn set_app_id(&mut self, v: u32) {
self.app_id = ::std::option::Option::Some(v);
}
pub fn controller_index(&self) -> u32 {
self.controller_index.unwrap_or(0)
}
pub fn clear_controller_index(&mut self) {
self.controller_index = ::std::option::Option::None;
}
pub fn has_controller_index(&self) -> bool {
self.controller_index.is_some()
}
pub fn set_controller_index(&mut self, v: u32) {
self.controller_index = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CMsgRemoteClientGetControllerConfig {
const NAME: &'static str = "CMsgRemoteClientGetControllerConfig";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.app_id = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.controller_index = ::std::option::Option::Some(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.app_id {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.controller_index {
my_size += ::protobuf::rt::uint32_size(3, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.app_id {
os.write_uint32(1, v)?;
}
if let Some(v) = self.controller_index {
os.write_uint32(3, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientGetControllerConfig {
CMsgRemoteClientGetControllerConfig::new()
}
fn clear(&mut self) {
self.app_id = ::std::option::Option::None;
self.controller_index = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientGetControllerConfig {
static instance: CMsgRemoteClientGetControllerConfig = CMsgRemoteClientGetControllerConfig {
app_id: ::std::option::Option::None,
controller_index: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientGetControllerConfigResponse {
pub eresult: ::std::option::Option<i32>,
pub config_vdf: ::std::option::Option<::std::vec::Vec<u8>>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientGetControllerConfigResponse {
fn default() -> &'a CMsgRemoteClientGetControllerConfigResponse {
<CMsgRemoteClientGetControllerConfigResponse as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientGetControllerConfigResponse {
pub fn new() -> CMsgRemoteClientGetControllerConfigResponse {
::std::default::Default::default()
}
pub fn eresult(&self) -> i32 {
self.eresult.unwrap_or(2i32)
}
pub fn clear_eresult(&mut self) {
self.eresult = ::std::option::Option::None;
}
pub fn has_eresult(&self) -> bool {
self.eresult.is_some()
}
pub fn set_eresult(&mut self, v: i32) {
self.eresult = ::std::option::Option::Some(v);
}
pub fn config_vdf(&self) -> &[u8] {
match self.config_vdf.as_ref() {
Some(v) => v,
None => &[],
}
}
pub fn clear_config_vdf(&mut self) {
self.config_vdf = ::std::option::Option::None;
}
pub fn has_config_vdf(&self) -> bool {
self.config_vdf.is_some()
}
pub fn set_config_vdf(&mut self, v: ::std::vec::Vec<u8>) {
self.config_vdf = ::std::option::Option::Some(v);
}
pub fn mut_config_vdf(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.config_vdf.is_none() {
self.config_vdf = ::std::option::Option::Some(::std::vec::Vec::new());
}
self.config_vdf.as_mut().unwrap()
}
pub fn take_config_vdf(&mut self) -> ::std::vec::Vec<u8> {
self.config_vdf.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CMsgRemoteClientGetControllerConfigResponse {
const NAME: &'static str = "CMsgRemoteClientGetControllerConfigResponse";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.eresult = ::std::option::Option::Some(is.read_int32()?);
},
18 => {
self.config_vdf = ::std::option::Option::Some(is.read_bytes()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.eresult {
my_size += ::protobuf::rt::int32_size(1, v);
}
if let Some(v) = self.config_vdf.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.eresult {
os.write_int32(1, v)?;
}
if let Some(v) = self.config_vdf.as_ref() {
os.write_bytes(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientGetControllerConfigResponse {
CMsgRemoteClientGetControllerConfigResponse::new()
}
fn clear(&mut self) {
self.eresult = ::std::option::Option::None;
self.config_vdf = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientGetControllerConfigResponse {
static instance: CMsgRemoteClientGetControllerConfigResponse = CMsgRemoteClientGetControllerConfigResponse {
eresult: ::std::option::Option::None,
config_vdf: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CMsgRemoteClientStreamingEnabled {
pub enabled: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CMsgRemoteClientStreamingEnabled {
fn default() -> &'a CMsgRemoteClientStreamingEnabled {
<CMsgRemoteClientStreamingEnabled as ::protobuf::Message>::default_instance()
}
}
impl CMsgRemoteClientStreamingEnabled {
pub fn new() -> CMsgRemoteClientStreamingEnabled {
::std::default::Default::default()
}
pub fn enabled(&self) -> bool {
self.enabled.unwrap_or(false)
}
pub fn clear_enabled(&mut self) {
self.enabled = ::std::option::Option::None;
}
pub fn has_enabled(&self) -> bool {
self.enabled.is_some()
}
pub fn set_enabled(&mut self, v: bool) {
self.enabled = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CMsgRemoteClientStreamingEnabled {
const NAME: &'static str = "CMsgRemoteClientStreamingEnabled";
fn is_initialized(&self) -> bool {
if self.enabled.is_none() {
return false;
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.enabled = ::std::option::Option::Some(is.read_bool()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.enabled {
my_size += 1 + 1;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.enabled {
os.write_bool(1, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CMsgRemoteClientStreamingEnabled {
CMsgRemoteClientStreamingEnabled::new()
}
fn clear(&mut self) {
self.enabled = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CMsgRemoteClientStreamingEnabled {
static instance: CMsgRemoteClientStreamingEnabled = CMsgRemoteClientStreamingEnabled {
enabled: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_remoteclient_discovery::*;
impl crate::RpcMessage for CMsgRemoteClientStatus {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CMsgRemoteClientAppStatus {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientAppStatus {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientAppStatus;
}
impl crate::RpcMessage for CMsgRemoteClientStartStream {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientStartStream {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientStartStream;
}
impl crate::RpcMessage for CMsgRemoteClientStartStreamResponse {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientStartStreamResponse {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientStartStreamResponse;
}
impl crate::RpcMessage for CMsgRemoteClientPing {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientPing {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientPing;
}
impl crate::RpcMessage for CMsgRemoteClientPingResponse {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientPingResponse {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientPingResponse;
}
impl crate::RpcMessage for CMsgRemoteClientAcceptEULA {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientAcceptEULA {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientAcceptEULA;
}
impl crate::RpcMessage for CMsgRemoteClientGetControllerConfig {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientGetControllerConfig {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientGetControllerConfig;
}
impl crate::RpcMessage for CMsgRemoteClientGetControllerConfigResponse {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientGetControllerConfigResponse {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientGetControllerConfigResponse;
}
impl crate::RpcMessage for CMsgRemoteClientStreamingEnabled {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessageWithKind for CMsgRemoteClientStreamingEnabled {
const KIND: crate::enums_clientserver::EMsg = crate::enums_clientserver::EMsg::k_EMsgRemoteClientStreamingEnabled;
}