#![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_imports)]
#![allow(unused_results)]
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_CreateSession_Request {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_CreateSession_Request {
fn default() -> &'a CRemoteClient_CreateSession_Request {
<CRemoteClient_CreateSession_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_CreateSession_Request {
pub fn new() -> CRemoteClient_CreateSession_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CRemoteClient_CreateSession_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_CreateSession_Request {
CRemoteClient_CreateSession_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_CreateSession_Request>(
"CRemoteClient_CreateSession_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_CreateSession_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_CreateSession_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_CreateSession_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_CreateSession_Request {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_CreateSession_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_CreateSession_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_CreateSession_Response {
session_id: ::std::option::Option<u64>,
euniverse: ::std::option::Option<i32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_CreateSession_Response {
fn default() -> &'a CRemoteClient_CreateSession_Response {
<CRemoteClient_CreateSession_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_CreateSession_Response {
pub fn new() -> CRemoteClient_CreateSession_Response {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
pub fn get_euniverse(&self) -> i32 {
self.euniverse.unwrap_or(0)
}
pub fn clear_euniverse(&mut self) {
self.euniverse = ::std::option::Option::None;
}
pub fn has_euniverse(&self) -> bool {
self.euniverse.is_some()
}
pub fn set_euniverse(&mut self, v: i32) {
self.euniverse = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_CreateSession_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int32()?;
self.euniverse = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
if let Some(v) = self.euniverse {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.euniverse {
os.write_int32(2, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_CreateSession_Response {
CRemoteClient_CreateSession_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_CreateSession_Response| { &m.session_id },
|m: &mut CRemoteClient_CreateSession_Response| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"euniverse",
|m: &CRemoteClient_CreateSession_Response| { &m.euniverse },
|m: &mut CRemoteClient_CreateSession_Response| { &mut m.euniverse },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_CreateSession_Response>(
"CRemoteClient_CreateSession_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_CreateSession_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_CreateSession_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_CreateSession_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_CreateSession_Response {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.euniverse = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_CreateSession_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_CreateSession_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_StartPairing_Request {
session_id: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_StartPairing_Request {
fn default() -> &'a CRemoteClient_StartPairing_Request {
<CRemoteClient_StartPairing_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_StartPairing_Request {
pub fn new() -> CRemoteClient_StartPairing_Request {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_StartPairing_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_StartPairing_Request {
CRemoteClient_StartPairing_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_StartPairing_Request| { &m.session_id },
|m: &mut CRemoteClient_StartPairing_Request| { &mut m.session_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_StartPairing_Request>(
"CRemoteClient_StartPairing_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_StartPairing_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_StartPairing_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_StartPairing_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_StartPairing_Request {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_StartPairing_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_StartPairing_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_StartPairing_Response {
pin: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_StartPairing_Response {
fn default() -> &'a CRemoteClient_StartPairing_Response {
<CRemoteClient_StartPairing_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_StartPairing_Response {
pub fn new() -> CRemoteClient_StartPairing_Response {
::std::default::Default::default()
}
pub fn get_pin(&self) -> u32 {
self.pin.unwrap_or(0)
}
pub fn clear_pin(&mut self) {
self.pin = ::std::option::Option::None;
}
pub fn has_pin(&self) -> bool {
self.pin.is_some()
}
pub fn set_pin(&mut self, v: u32) {
self.pin = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_StartPairing_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.pin = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.pin {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.pin {
os.write_uint32(1, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_StartPairing_Response {
CRemoteClient_StartPairing_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"pin",
|m: &CRemoteClient_StartPairing_Response| { &m.pin },
|m: &mut CRemoteClient_StartPairing_Response| { &mut m.pin },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_StartPairing_Response>(
"CRemoteClient_StartPairing_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_StartPairing_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_StartPairing_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_StartPairing_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_StartPairing_Response {
fn clear(&mut self) {
self.pin = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_StartPairing_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_StartPairing_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_SetPairingInfo_Request {
session_id: ::std::option::Option<u64>,
device_id: ::std::option::Option<u64>,
request: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_SetPairingInfo_Request {
fn default() -> &'a CRemoteClient_SetPairingInfo_Request {
<CRemoteClient_SetPairingInfo_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_SetPairingInfo_Request {
pub fn new() -> CRemoteClient_SetPairingInfo_Request {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
pub fn get_device_id(&self) -> u64 {
self.device_id.unwrap_or(0)
}
pub fn clear_device_id(&mut self) {
self.device_id = ::std::option::Option::None;
}
pub fn has_device_id(&self) -> bool {
self.device_id.is_some()
}
pub fn set_device_id(&mut self, v: u64) {
self.device_id = ::std::option::Option::Some(v);
}
pub fn get_request(&self) -> &[u8] {
match self.request.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_request(&mut self) {
self.request.clear();
}
pub fn has_request(&self) -> bool {
self.request.is_some()
}
pub fn set_request(&mut self, v: ::std::vec::Vec<u8>) {
self.request = ::protobuf::SingularField::some(v);
}
pub fn mut_request(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.request.is_none() {
self.request.set_default();
}
self.request.as_mut().unwrap()
}
pub fn take_request(&mut self) -> ::std::vec::Vec<u8> {
self.request.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CRemoteClient_SetPairingInfo_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.device_id = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.request)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
if let Some(v) = self.device_id {
my_size += 9;
}
if let Some(ref v) = self.request.as_ref() {
my_size += ::protobuf::rt::bytes_size(3, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.device_id {
os.write_fixed64(2, v)?;
}
if let Some(ref v) = self.request.as_ref() {
os.write_bytes(3, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_SetPairingInfo_Request {
CRemoteClient_SetPairingInfo_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_SetPairingInfo_Request| { &m.session_id },
|m: &mut CRemoteClient_SetPairingInfo_Request| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"device_id",
|m: &CRemoteClient_SetPairingInfo_Request| { &m.device_id },
|m: &mut CRemoteClient_SetPairingInfo_Request| { &mut m.device_id },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"request",
|m: &CRemoteClient_SetPairingInfo_Request| { &m.request },
|m: &mut CRemoteClient_SetPairingInfo_Request| { &mut m.request },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_SetPairingInfo_Request>(
"CRemoteClient_SetPairingInfo_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_SetPairingInfo_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_SetPairingInfo_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_SetPairingInfo_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_SetPairingInfo_Request {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.device_id = ::std::option::Option::None;
self.request.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_SetPairingInfo_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_SetPairingInfo_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_SetPairingInfo_Response {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_SetPairingInfo_Response {
fn default() -> &'a CRemoteClient_SetPairingInfo_Response {
<CRemoteClient_SetPairingInfo_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_SetPairingInfo_Response {
pub fn new() -> CRemoteClient_SetPairingInfo_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CRemoteClient_SetPairingInfo_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_SetPairingInfo_Response {
CRemoteClient_SetPairingInfo_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_SetPairingInfo_Response>(
"CRemoteClient_SetPairingInfo_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_SetPairingInfo_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_SetPairingInfo_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_SetPairingInfo_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_SetPairingInfo_Response {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_SetPairingInfo_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_SetPairingInfo_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_GetPairingInfo_Request {
pin: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_GetPairingInfo_Request {
fn default() -> &'a CRemoteClient_GetPairingInfo_Request {
<CRemoteClient_GetPairingInfo_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_GetPairingInfo_Request {
pub fn new() -> CRemoteClient_GetPairingInfo_Request {
::std::default::Default::default()
}
pub fn get_pin(&self) -> u32 {
self.pin.unwrap_or(0)
}
pub fn clear_pin(&mut self) {
self.pin = ::std::option::Option::None;
}
pub fn has_pin(&self) -> bool {
self.pin.is_some()
}
pub fn set_pin(&mut self, v: u32) {
self.pin = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_GetPairingInfo_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.pin = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.pin {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.pin {
os.write_uint32(1, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_GetPairingInfo_Request {
CRemoteClient_GetPairingInfo_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"pin",
|m: &CRemoteClient_GetPairingInfo_Request| { &m.pin },
|m: &mut CRemoteClient_GetPairingInfo_Request| { &mut m.pin },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_GetPairingInfo_Request>(
"CRemoteClient_GetPairingInfo_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_GetPairingInfo_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_GetPairingInfo_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_GetPairingInfo_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_GetPairingInfo_Request {
fn clear(&mut self) {
self.pin = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_GetPairingInfo_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_GetPairingInfo_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_GetPairingInfo_Response {
session_id: ::std::option::Option<u64>,
device_id: ::std::option::Option<u64>,
request: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_GetPairingInfo_Response {
fn default() -> &'a CRemoteClient_GetPairingInfo_Response {
<CRemoteClient_GetPairingInfo_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_GetPairingInfo_Response {
pub fn new() -> CRemoteClient_GetPairingInfo_Response {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
pub fn get_device_id(&self) -> u64 {
self.device_id.unwrap_or(0)
}
pub fn clear_device_id(&mut self) {
self.device_id = ::std::option::Option::None;
}
pub fn has_device_id(&self) -> bool {
self.device_id.is_some()
}
pub fn set_device_id(&mut self, v: u64) {
self.device_id = ::std::option::Option::Some(v);
}
pub fn get_request(&self) -> &[u8] {
match self.request.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_request(&mut self) {
self.request.clear();
}
pub fn has_request(&self) -> bool {
self.request.is_some()
}
pub fn set_request(&mut self, v: ::std::vec::Vec<u8>) {
self.request = ::protobuf::SingularField::some(v);
}
pub fn mut_request(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.request.is_none() {
self.request.set_default();
}
self.request.as_mut().unwrap()
}
pub fn take_request(&mut self) -> ::std::vec::Vec<u8> {
self.request.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CRemoteClient_GetPairingInfo_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.device_id = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.request)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
if let Some(v) = self.device_id {
my_size += 9;
}
if let Some(ref v) = self.request.as_ref() {
my_size += ::protobuf::rt::bytes_size(3, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.device_id {
os.write_fixed64(2, v)?;
}
if let Some(ref v) = self.request.as_ref() {
os.write_bytes(3, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_GetPairingInfo_Response {
CRemoteClient_GetPairingInfo_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_GetPairingInfo_Response| { &m.session_id },
|m: &mut CRemoteClient_GetPairingInfo_Response| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"device_id",
|m: &CRemoteClient_GetPairingInfo_Response| { &m.device_id },
|m: &mut CRemoteClient_GetPairingInfo_Response| { &mut m.device_id },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"request",
|m: &CRemoteClient_GetPairingInfo_Response| { &m.request },
|m: &mut CRemoteClient_GetPairingInfo_Response| { &mut m.request },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_GetPairingInfo_Response>(
"CRemoteClient_GetPairingInfo_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_GetPairingInfo_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_GetPairingInfo_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_GetPairingInfo_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_GetPairingInfo_Response {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.device_id = ::std::option::Option::None;
self.request.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_GetPairingInfo_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_GetPairingInfo_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_CancelPairing_Request {
session_id: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_CancelPairing_Request {
fn default() -> &'a CRemoteClient_CancelPairing_Request {
<CRemoteClient_CancelPairing_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_CancelPairing_Request {
pub fn new() -> CRemoteClient_CancelPairing_Request {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_CancelPairing_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_CancelPairing_Request {
CRemoteClient_CancelPairing_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_CancelPairing_Request| { &m.session_id },
|m: &mut CRemoteClient_CancelPairing_Request| { &mut m.session_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_CancelPairing_Request>(
"CRemoteClient_CancelPairing_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_CancelPairing_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_CancelPairing_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_CancelPairing_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_CancelPairing_Request {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_CancelPairing_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_CancelPairing_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_CancelPairing_Response {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_CancelPairing_Response {
fn default() -> &'a CRemoteClient_CancelPairing_Response {
<CRemoteClient_CancelPairing_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_CancelPairing_Response {
pub fn new() -> CRemoteClient_CancelPairing_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CRemoteClient_CancelPairing_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_CancelPairing_Response {
CRemoteClient_CancelPairing_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_CancelPairing_Response>(
"CRemoteClient_CancelPairing_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_CancelPairing_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_CancelPairing_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_CancelPairing_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_CancelPairing_Response {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_CancelPairing_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_CancelPairing_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_RegisterStatusUpdate_Notification {
session_id: ::std::option::Option<u64>,
steamid: ::std::option::Option<u64>,
device_id: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_RegisterStatusUpdate_Notification {
fn default() -> &'a CRemoteClient_RegisterStatusUpdate_Notification {
<CRemoteClient_RegisterStatusUpdate_Notification as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_RegisterStatusUpdate_Notification {
pub fn new() -> CRemoteClient_RegisterStatusUpdate_Notification {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn get_device_id(&self) -> u64 {
self.device_id.unwrap_or(0)
}
pub fn clear_device_id(&mut self) {
self.device_id = ::std::option::Option::None;
}
pub fn has_device_id(&self) -> bool {
self.device_id.is_some()
}
pub fn set_device_id(&mut self, v: u64) {
self.device_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_RegisterStatusUpdate_Notification {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.device_id = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
if let Some(v) = self.steamid {
my_size += 9;
}
if let Some(v) = self.device_id {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.steamid {
os.write_fixed64(2, v)?;
}
if let Some(v) = self.device_id {
os.write_fixed64(3, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_RegisterStatusUpdate_Notification {
CRemoteClient_RegisterStatusUpdate_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_RegisterStatusUpdate_Notification| { &m.session_id },
|m: &mut CRemoteClient_RegisterStatusUpdate_Notification| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"steamid",
|m: &CRemoteClient_RegisterStatusUpdate_Notification| { &m.steamid },
|m: &mut CRemoteClient_RegisterStatusUpdate_Notification| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"device_id",
|m: &CRemoteClient_RegisterStatusUpdate_Notification| { &m.device_id },
|m: &mut CRemoteClient_RegisterStatusUpdate_Notification| { &mut m.device_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_RegisterStatusUpdate_Notification>(
"CRemoteClient_RegisterStatusUpdate_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_RegisterStatusUpdate_Notification {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_RegisterStatusUpdate_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_RegisterStatusUpdate_Notification::new)
}
}
impl ::protobuf::Clear for CRemoteClient_RegisterStatusUpdate_Notification {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.steamid = ::std::option::Option::None;
self.device_id = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_RegisterStatusUpdate_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_RegisterStatusUpdate_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_UnregisterStatusUpdate_Notification {
session_id: ::std::option::Option<u64>,
steamid: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_UnregisterStatusUpdate_Notification {
fn default() -> &'a CRemoteClient_UnregisterStatusUpdate_Notification {
<CRemoteClient_UnregisterStatusUpdate_Notification as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_UnregisterStatusUpdate_Notification {
pub fn new() -> CRemoteClient_UnregisterStatusUpdate_Notification {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_UnregisterStatusUpdate_Notification {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
if let Some(v) = self.steamid {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.steamid {
os.write_fixed64(2, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_UnregisterStatusUpdate_Notification {
CRemoteClient_UnregisterStatusUpdate_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_UnregisterStatusUpdate_Notification| { &m.session_id },
|m: &mut CRemoteClient_UnregisterStatusUpdate_Notification| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"steamid",
|m: &CRemoteClient_UnregisterStatusUpdate_Notification| { &m.steamid },
|m: &mut CRemoteClient_UnregisterStatusUpdate_Notification| { &mut m.steamid },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_UnregisterStatusUpdate_Notification>(
"CRemoteClient_UnregisterStatusUpdate_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_UnregisterStatusUpdate_Notification {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_UnregisterStatusUpdate_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_UnregisterStatusUpdate_Notification::new)
}
}
impl ::protobuf::Clear for CRemoteClient_UnregisterStatusUpdate_Notification {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.steamid = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_UnregisterStatusUpdate_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_UnregisterStatusUpdate_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_Online_Notification {
steamid: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_Online_Notification {
fn default() -> &'a CRemoteClient_Online_Notification {
<CRemoteClient_Online_Notification as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_Online_Notification {
pub fn new() -> CRemoteClient_Online_Notification {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_Online_Notification {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.steamid {
os.write_fixed64(1, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_Online_Notification {
CRemoteClient_Online_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"steamid",
|m: &CRemoteClient_Online_Notification| { &m.steamid },
|m: &mut CRemoteClient_Online_Notification| { &mut m.steamid },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_Online_Notification>(
"CRemoteClient_Online_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_Online_Notification {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_Online_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_Online_Notification::new)
}
}
impl ::protobuf::Clear for CRemoteClient_Online_Notification {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_Online_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_Online_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_RemotePacket_Notification {
session_id: ::std::option::Option<u64>,
steamid: ::std::option::Option<u64>,
payload: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_RemotePacket_Notification {
fn default() -> &'a CRemoteClient_RemotePacket_Notification {
<CRemoteClient_RemotePacket_Notification as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_RemotePacket_Notification {
pub fn new() -> CRemoteClient_RemotePacket_Notification {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn get_payload(&self) -> &[u8] {
match self.payload.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_payload(&mut self) {
self.payload.clear();
}
pub fn has_payload(&self) -> bool {
self.payload.is_some()
}
pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
self.payload = ::protobuf::SingularField::some(v);
}
pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.payload.is_none() {
self.payload.set_default();
}
self.payload.as_mut().unwrap()
}
pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CRemoteClient_RemotePacket_Notification {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
4 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.payload)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
if let Some(v) = self.steamid {
my_size += 9;
}
if let Some(ref v) = self.payload.as_ref() {
my_size += ::protobuf::rt::bytes_size(4, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.steamid {
os.write_fixed64(2, v)?;
}
if let Some(ref v) = self.payload.as_ref() {
os.write_bytes(4, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_RemotePacket_Notification {
CRemoteClient_RemotePacket_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_RemotePacket_Notification| { &m.session_id },
|m: &mut CRemoteClient_RemotePacket_Notification| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"steamid",
|m: &CRemoteClient_RemotePacket_Notification| { &m.steamid },
|m: &mut CRemoteClient_RemotePacket_Notification| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"payload",
|m: &CRemoteClient_RemotePacket_Notification| { &m.payload },
|m: &mut CRemoteClient_RemotePacket_Notification| { &mut m.payload },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_RemotePacket_Notification>(
"CRemoteClient_RemotePacket_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_RemotePacket_Notification {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_RemotePacket_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_RemotePacket_Notification::new)
}
}
impl ::protobuf::Clear for CRemoteClient_RemotePacket_Notification {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.steamid = ::std::option::Option::None;
self.payload.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_RemotePacket_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_RemotePacket_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_ReplyPacket_Notification {
session_id: ::std::option::Option<u64>,
payload: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_ReplyPacket_Notification {
fn default() -> &'a CRemoteClient_ReplyPacket_Notification {
<CRemoteClient_ReplyPacket_Notification as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_ReplyPacket_Notification {
pub fn new() -> CRemoteClient_ReplyPacket_Notification {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
pub fn get_payload(&self) -> &[u8] {
match self.payload.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_payload(&mut self) {
self.payload.clear();
}
pub fn has_payload(&self) -> bool {
self.payload.is_some()
}
pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
self.payload = ::protobuf::SingularField::some(v);
}
pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.payload.is_none() {
self.payload.set_default();
}
self.payload.as_mut().unwrap()
}
pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CRemoteClient_ReplyPacket_Notification {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.payload)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
if let Some(ref v) = self.payload.as_ref() {
my_size += ::protobuf::rt::bytes_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
if let Some(ref v) = self.payload.as_ref() {
os.write_bytes(2, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_ReplyPacket_Notification {
CRemoteClient_ReplyPacket_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_ReplyPacket_Notification| { &m.session_id },
|m: &mut CRemoteClient_ReplyPacket_Notification| { &mut m.session_id },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"payload",
|m: &CRemoteClient_ReplyPacket_Notification| { &m.payload },
|m: &mut CRemoteClient_ReplyPacket_Notification| { &mut m.payload },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_ReplyPacket_Notification>(
"CRemoteClient_ReplyPacket_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_ReplyPacket_Notification {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_ReplyPacket_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_ReplyPacket_Notification::new)
}
}
impl ::protobuf::Clear for CRemoteClient_ReplyPacket_Notification {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.payload.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_ReplyPacket_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_ReplyPacket_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_GetReplies_Request {
session_id: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_GetReplies_Request {
fn default() -> &'a CRemoteClient_GetReplies_Request {
<CRemoteClient_GetReplies_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_GetReplies_Request {
pub fn new() -> CRemoteClient_GetReplies_Request {
::std::default::Default::default()
}
pub fn get_session_id(&self) -> u64 {
self.session_id.unwrap_or(0)
}
pub fn clear_session_id(&mut self) {
self.session_id = ::std::option::Option::None;
}
pub fn has_session_id(&self) -> bool {
self.session_id.is_some()
}
pub fn set_session_id(&mut self, v: u64) {
self.session_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_GetReplies_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.session_id = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.session_id {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.session_id {
os.write_fixed64(1, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_GetReplies_Request {
CRemoteClient_GetReplies_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"session_id",
|m: &CRemoteClient_GetReplies_Request| { &m.session_id },
|m: &mut CRemoteClient_GetReplies_Request| { &mut m.session_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_GetReplies_Request>(
"CRemoteClient_GetReplies_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_GetReplies_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_GetReplies_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_GetReplies_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_GetReplies_Request {
fn clear(&mut self) {
self.session_id = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_GetReplies_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_GetReplies_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_GetReplies_Response {
pub payload: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_GetReplies_Response {
fn default() -> &'a CRemoteClient_GetReplies_Response {
<CRemoteClient_GetReplies_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_GetReplies_Response {
pub fn new() -> CRemoteClient_GetReplies_Response {
::std::default::Default::default()
}
pub fn get_payload(&self) -> &[::std::vec::Vec<u8>] {
&self.payload
}
pub fn clear_payload(&mut self) {
self.payload.clear();
}
pub fn set_payload(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec<u8>>) {
self.payload = v;
}
pub fn mut_payload(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
&mut self.payload
}
pub fn take_payload(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec<u8>> {
::std::mem::replace(&mut self.payload, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CRemoteClient_GetReplies_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.payload)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.payload {
my_size += ::protobuf::rt::bytes_size(1, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
for v in &self.payload {
os.write_bytes(1, &v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_GetReplies_Response {
CRemoteClient_GetReplies_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"payload",
|m: &CRemoteClient_GetReplies_Response| { &m.payload },
|m: &mut CRemoteClient_GetReplies_Response| { &mut m.payload },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_GetReplies_Response>(
"CRemoteClient_GetReplies_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_GetReplies_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_GetReplies_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_GetReplies_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_GetReplies_Response {
fn clear(&mut self) {
self.payload.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_GetReplies_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_GetReplies_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_AllocateTURNServer_Request {
cellid: ::std::option::Option<u32>,
credentials: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateTURNServer_Request {
fn default() -> &'a CRemoteClient_AllocateTURNServer_Request {
<CRemoteClient_AllocateTURNServer_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_AllocateTURNServer_Request {
pub fn new() -> CRemoteClient_AllocateTURNServer_Request {
::std::default::Default::default()
}
pub fn get_cellid(&self) -> u32 {
self.cellid.unwrap_or(0)
}
pub fn clear_cellid(&mut self) {
self.cellid = ::std::option::Option::None;
}
pub fn has_cellid(&self) -> bool {
self.cellid.is_some()
}
pub fn set_cellid(&mut self, v: u32) {
self.cellid = ::std::option::Option::Some(v);
}
pub fn get_credentials(&self) -> &str {
match self.credentials.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_credentials(&mut self) {
self.credentials.clear();
}
pub fn has_credentials(&self) -> bool {
self.credentials.is_some()
}
pub fn set_credentials(&mut self, v: ::std::string::String) {
self.credentials = ::protobuf::SingularField::some(v);
}
pub fn mut_credentials(&mut self) -> &mut ::std::string::String {
if self.credentials.is_none() {
self.credentials.set_default();
}
self.credentials.as_mut().unwrap()
}
pub fn take_credentials(&mut self) -> ::std::string::String {
self.credentials.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CRemoteClient_AllocateTURNServer_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.cellid = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.credentials)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.cellid {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.credentials.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.cellid {
os.write_uint32(1, v)?;
}
if let Some(ref v) = self.credentials.as_ref() {
os.write_string(2, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_AllocateTURNServer_Request {
CRemoteClient_AllocateTURNServer_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"cellid",
|m: &CRemoteClient_AllocateTURNServer_Request| { &m.cellid },
|m: &mut CRemoteClient_AllocateTURNServer_Request| { &mut m.cellid },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"credentials",
|m: &CRemoteClient_AllocateTURNServer_Request| { &m.credentials },
|m: &mut CRemoteClient_AllocateTURNServer_Request| { &mut m.credentials },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_AllocateTURNServer_Request>(
"CRemoteClient_AllocateTURNServer_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_AllocateTURNServer_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_AllocateTURNServer_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_AllocateTURNServer_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_AllocateTURNServer_Request {
fn clear(&mut self) {
self.cellid = ::std::option::Option::None;
self.credentials.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_AllocateTURNServer_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_AllocateTURNServer_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_AllocateTURNServer_Response {
turn_server: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateTURNServer_Response {
fn default() -> &'a CRemoteClient_AllocateTURNServer_Response {
<CRemoteClient_AllocateTURNServer_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_AllocateTURNServer_Response {
pub fn new() -> CRemoteClient_AllocateTURNServer_Response {
::std::default::Default::default()
}
pub fn get_turn_server(&self) -> &str {
match self.turn_server.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_turn_server(&mut self) {
self.turn_server.clear();
}
pub fn has_turn_server(&self) -> bool {
self.turn_server.is_some()
}
pub fn set_turn_server(&mut self, v: ::std::string::String) {
self.turn_server = ::protobuf::SingularField::some(v);
}
pub fn mut_turn_server(&mut self) -> &mut ::std::string::String {
if self.turn_server.is_none() {
self.turn_server.set_default();
}
self.turn_server.as_mut().unwrap()
}
pub fn take_turn_server(&mut self) -> ::std::string::String {
self.turn_server.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CRemoteClient_AllocateTURNServer_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.turn_server)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.turn_server.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.turn_server.as_ref() {
os.write_string(1, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_AllocateTURNServer_Response {
CRemoteClient_AllocateTURNServer_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"turn_server",
|m: &CRemoteClient_AllocateTURNServer_Response| { &m.turn_server },
|m: &mut CRemoteClient_AllocateTURNServer_Response| { &mut m.turn_server },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_AllocateTURNServer_Response>(
"CRemoteClient_AllocateTURNServer_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_AllocateTURNServer_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_AllocateTURNServer_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_AllocateTURNServer_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_AllocateTURNServer_Response {
fn clear(&mut self) {
self.turn_server.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_AllocateTURNServer_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_AllocateTURNServer_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_AllocateRelayServer_Request {
cellid: ::std::option::Option<u32>,
credentials: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateRelayServer_Request {
fn default() -> &'a CRemoteClient_AllocateRelayServer_Request {
<CRemoteClient_AllocateRelayServer_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_AllocateRelayServer_Request {
pub fn new() -> CRemoteClient_AllocateRelayServer_Request {
::std::default::Default::default()
}
pub fn get_cellid(&self) -> u32 {
self.cellid.unwrap_or(0)
}
pub fn clear_cellid(&mut self) {
self.cellid = ::std::option::Option::None;
}
pub fn has_cellid(&self) -> bool {
self.cellid.is_some()
}
pub fn set_cellid(&mut self, v: u32) {
self.cellid = ::std::option::Option::Some(v);
}
pub fn get_credentials(&self) -> &str {
match self.credentials.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_credentials(&mut self) {
self.credentials.clear();
}
pub fn has_credentials(&self) -> bool {
self.credentials.is_some()
}
pub fn set_credentials(&mut self, v: ::std::string::String) {
self.credentials = ::protobuf::SingularField::some(v);
}
pub fn mut_credentials(&mut self) -> &mut ::std::string::String {
if self.credentials.is_none() {
self.credentials.set_default();
}
self.credentials.as_mut().unwrap()
}
pub fn take_credentials(&mut self) -> ::std::string::String {
self.credentials.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CRemoteClient_AllocateRelayServer_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.cellid = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.credentials)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.cellid {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.credentials.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.cellid {
os.write_uint32(1, v)?;
}
if let Some(ref v) = self.credentials.as_ref() {
os.write_string(2, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_AllocateRelayServer_Request {
CRemoteClient_AllocateRelayServer_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"cellid",
|m: &CRemoteClient_AllocateRelayServer_Request| { &m.cellid },
|m: &mut CRemoteClient_AllocateRelayServer_Request| { &mut m.cellid },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"credentials",
|m: &CRemoteClient_AllocateRelayServer_Request| { &m.credentials },
|m: &mut CRemoteClient_AllocateRelayServer_Request| { &mut m.credentials },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_AllocateRelayServer_Request>(
"CRemoteClient_AllocateRelayServer_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_AllocateRelayServer_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_AllocateRelayServer_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_AllocateRelayServer_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_AllocateRelayServer_Request {
fn clear(&mut self) {
self.cellid = ::std::option::Option::None;
self.credentials.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_AllocateRelayServer_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_AllocateRelayServer_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_AllocateRelayServer_Response {
relay_server: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateRelayServer_Response {
fn default() -> &'a CRemoteClient_AllocateRelayServer_Response {
<CRemoteClient_AllocateRelayServer_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_AllocateRelayServer_Response {
pub fn new() -> CRemoteClient_AllocateRelayServer_Response {
::std::default::Default::default()
}
pub fn get_relay_server(&self) -> &str {
match self.relay_server.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_relay_server(&mut self) {
self.relay_server.clear();
}
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 = ::protobuf::SingularField::some(v);
}
pub fn mut_relay_server(&mut self) -> &mut ::std::string::String {
if self.relay_server.is_none() {
self.relay_server.set_default();
}
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())
}
}
impl ::protobuf::Message for CRemoteClient_AllocateRelayServer_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.relay_server)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.relay_server.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.relay_server.as_ref() {
os.write_string(1, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_AllocateRelayServer_Response {
CRemoteClient_AllocateRelayServer_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"relay_server",
|m: &CRemoteClient_AllocateRelayServer_Response| { &m.relay_server },
|m: &mut CRemoteClient_AllocateRelayServer_Response| { &mut m.relay_server },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_AllocateRelayServer_Response>(
"CRemoteClient_AllocateRelayServer_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_AllocateRelayServer_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_AllocateRelayServer_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_AllocateRelayServer_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_AllocateRelayServer_Response {
fn clear(&mut self) {
self.relay_server.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_AllocateRelayServer_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_AllocateRelayServer_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_AllocateSDR_Request {
appid: ::std::option::Option<u32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateSDR_Request {
fn default() -> &'a CRemoteClient_AllocateSDR_Request {
<CRemoteClient_AllocateSDR_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_AllocateSDR_Request {
pub fn new() -> CRemoteClient_AllocateSDR_Request {
::std::default::Default::default()
}
pub fn get_appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemoteClient_AllocateSDR_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.appid = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.appid {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.appid {
os.write_uint32(1, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_AllocateSDR_Request {
CRemoteClient_AllocateSDR_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"appid",
|m: &CRemoteClient_AllocateSDR_Request| { &m.appid },
|m: &mut CRemoteClient_AllocateSDR_Request| { &mut m.appid },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_AllocateSDR_Request>(
"CRemoteClient_AllocateSDR_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_AllocateSDR_Request {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_AllocateSDR_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_AllocateSDR_Request::new)
}
}
impl ::protobuf::Clear for CRemoteClient_AllocateSDR_Request {
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_AllocateSDR_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_AllocateSDR_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_AllocateSDR_Response {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_AllocateSDR_Response {
fn default() -> &'a CRemoteClient_AllocateSDR_Response {
<CRemoteClient_AllocateSDR_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_AllocateSDR_Response {
pub fn new() -> CRemoteClient_AllocateSDR_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CRemoteClient_AllocateSDR_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_AllocateSDR_Response {
CRemoteClient_AllocateSDR_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_AllocateSDR_Response>(
"CRemoteClient_AllocateSDR_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_AllocateSDR_Response {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_AllocateSDR_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_AllocateSDR_Response::new)
}
}
impl ::protobuf::Clear for CRemoteClient_AllocateSDR_Response {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_AllocateSDR_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_AllocateSDR_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_SteamBroadcast_Notification {
steamid: ::std::option::Option<u64>,
clientid: ::std::option::Option<u64>,
payload: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_SteamBroadcast_Notification {
fn default() -> &'a CRemoteClient_SteamBroadcast_Notification {
<CRemoteClient_SteamBroadcast_Notification as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_SteamBroadcast_Notification {
pub fn new() -> CRemoteClient_SteamBroadcast_Notification {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn get_clientid(&self) -> u64 {
self.clientid.unwrap_or(0)
}
pub fn clear_clientid(&mut self) {
self.clientid = ::std::option::Option::None;
}
pub fn has_clientid(&self) -> bool {
self.clientid.is_some()
}
pub fn set_clientid(&mut self, v: u64) {
self.clientid = ::std::option::Option::Some(v);
}
pub fn get_payload(&self) -> &[u8] {
match self.payload.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_payload(&mut self) {
self.payload.clear();
}
pub fn has_payload(&self) -> bool {
self.payload.is_some()
}
pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
self.payload = ::protobuf::SingularField::some(v);
}
pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.payload.is_none() {
self.payload.set_default();
}
self.payload.as_mut().unwrap()
}
pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
self.payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CRemoteClient_SteamBroadcast_Notification {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.clientid = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.payload)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
if let Some(v) = self.clientid {
my_size += 9;
}
if let Some(ref v) = self.payload.as_ref() {
my_size += ::protobuf::rt::bytes_size(3, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.steamid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.clientid {
os.write_fixed64(2, v)?;
}
if let Some(ref v) = self.payload.as_ref() {
os.write_bytes(3, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_SteamBroadcast_Notification {
CRemoteClient_SteamBroadcast_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"steamid",
|m: &CRemoteClient_SteamBroadcast_Notification| { &m.steamid },
|m: &mut CRemoteClient_SteamBroadcast_Notification| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"clientid",
|m: &CRemoteClient_SteamBroadcast_Notification| { &m.clientid },
|m: &mut CRemoteClient_SteamBroadcast_Notification| { &mut m.clientid },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"payload",
|m: &CRemoteClient_SteamBroadcast_Notification| { &m.payload },
|m: &mut CRemoteClient_SteamBroadcast_Notification| { &mut m.payload },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_SteamBroadcast_Notification>(
"CRemoteClient_SteamBroadcast_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_SteamBroadcast_Notification {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_SteamBroadcast_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_SteamBroadcast_Notification::new)
}
}
impl ::protobuf::Clear for CRemoteClient_SteamBroadcast_Notification {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.clientid = ::std::option::Option::None;
self.payload.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_SteamBroadcast_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_SteamBroadcast_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemoteClient_SteamToSteam_Notification {
steamid: ::std::option::Option<u64>,
src_clientid: ::std::option::Option<u64>,
dst_clientid: ::std::option::Option<u64>,
secretid: ::std::option::Option<u32>,
encrypted_payload: ::protobuf::SingularField<::std::vec::Vec<u8>>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemoteClient_SteamToSteam_Notification {
fn default() -> &'a CRemoteClient_SteamToSteam_Notification {
<CRemoteClient_SteamToSteam_Notification as ::protobuf::Message>::default_instance()
}
}
impl CRemoteClient_SteamToSteam_Notification {
pub fn new() -> CRemoteClient_SteamToSteam_Notification {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn get_src_clientid(&self) -> u64 {
self.src_clientid.unwrap_or(0)
}
pub fn clear_src_clientid(&mut self) {
self.src_clientid = ::std::option::Option::None;
}
pub fn has_src_clientid(&self) -> bool {
self.src_clientid.is_some()
}
pub fn set_src_clientid(&mut self, v: u64) {
self.src_clientid = ::std::option::Option::Some(v);
}
pub fn get_dst_clientid(&self) -> u64 {
self.dst_clientid.unwrap_or(0)
}
pub fn clear_dst_clientid(&mut self) {
self.dst_clientid = ::std::option::Option::None;
}
pub fn has_dst_clientid(&self) -> bool {
self.dst_clientid.is_some()
}
pub fn set_dst_clientid(&mut self, v: u64) {
self.dst_clientid = ::std::option::Option::Some(v);
}
pub fn get_secretid(&self) -> u32 {
self.secretid.unwrap_or(0)
}
pub fn clear_secretid(&mut self) {
self.secretid = ::std::option::Option::None;
}
pub fn has_secretid(&self) -> bool {
self.secretid.is_some()
}
pub fn set_secretid(&mut self, v: u32) {
self.secretid = ::std::option::Option::Some(v);
}
pub fn get_encrypted_payload(&self) -> &[u8] {
match self.encrypted_payload.as_ref() {
Some(v) => &v,
None => &[],
}
}
pub fn clear_encrypted_payload(&mut self) {
self.encrypted_payload.clear();
}
pub fn has_encrypted_payload(&self) -> bool {
self.encrypted_payload.is_some()
}
pub fn set_encrypted_payload(&mut self, v: ::std::vec::Vec<u8>) {
self.encrypted_payload = ::protobuf::SingularField::some(v);
}
pub fn mut_encrypted_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.encrypted_payload.is_none() {
self.encrypted_payload.set_default();
}
self.encrypted_payload.as_mut().unwrap()
}
pub fn take_encrypted_payload(&mut self) -> ::std::vec::Vec<u8> {
self.encrypted_payload.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CRemoteClient_SteamToSteam_Notification {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.src_clientid = ::std::option::Option::Some(tmp);
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.dst_clientid = ::std::option::Option::Some(tmp);
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.secretid = ::std::option::Option::Some(tmp);
},
5 => {
::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.encrypted_payload)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
if let Some(v) = self.src_clientid {
my_size += 9;
}
if let Some(v) = self.dst_clientid {
my_size += 9;
}
if let Some(v) = self.secretid {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.encrypted_payload.as_ref() {
my_size += ::protobuf::rt::bytes_size(5, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.steamid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.src_clientid {
os.write_fixed64(2, v)?;
}
if let Some(v) = self.dst_clientid {
os.write_fixed64(3, v)?;
}
if let Some(v) = self.secretid {
os.write_uint32(4, v)?;
}
if let Some(ref v) = self.encrypted_payload.as_ref() {
os.write_bytes(5, &v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemoteClient_SteamToSteam_Notification {
CRemoteClient_SteamToSteam_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"steamid",
|m: &CRemoteClient_SteamToSteam_Notification| { &m.steamid },
|m: &mut CRemoteClient_SteamToSteam_Notification| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"src_clientid",
|m: &CRemoteClient_SteamToSteam_Notification| { &m.src_clientid },
|m: &mut CRemoteClient_SteamToSteam_Notification| { &mut m.src_clientid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"dst_clientid",
|m: &CRemoteClient_SteamToSteam_Notification| { &m.dst_clientid },
|m: &mut CRemoteClient_SteamToSteam_Notification| { &mut m.dst_clientid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"secretid",
|m: &CRemoteClient_SteamToSteam_Notification| { &m.secretid },
|m: &mut CRemoteClient_SteamToSteam_Notification| { &mut m.secretid },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"encrypted_payload",
|m: &CRemoteClient_SteamToSteam_Notification| { &m.encrypted_payload },
|m: &mut CRemoteClient_SteamToSteam_Notification| { &mut m.encrypted_payload },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemoteClient_SteamToSteam_Notification>(
"CRemoteClient_SteamToSteam_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemoteClient_SteamToSteam_Notification {
static instance: ::protobuf::rt::LazyV2<CRemoteClient_SteamToSteam_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemoteClient_SteamToSteam_Notification::new)
}
}
impl ::protobuf::Clear for CRemoteClient_SteamToSteam_Notification {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.src_clientid = ::std::option::Option::None;
self.dst_clientid = ::std::option::Option::None;
self.secretid = ::std::option::Option::None;
self.encrypted_payload.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemoteClient_SteamToSteam_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemoteClient_SteamToSteam_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemotePlay_SessionStarted_Request {
host_account_id: ::std::option::Option<u32>,
client_account_id: ::std::option::Option<u32>,
appid: ::std::option::Option<u32>,
device_form_factor: ::std::option::Option<i32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemotePlay_SessionStarted_Request {
fn default() -> &'a CRemotePlay_SessionStarted_Request {
<CRemotePlay_SessionStarted_Request as ::protobuf::Message>::default_instance()
}
}
impl CRemotePlay_SessionStarted_Request {
pub fn new() -> CRemotePlay_SessionStarted_Request {
::std::default::Default::default()
}
pub fn get_host_account_id(&self) -> u32 {
self.host_account_id.unwrap_or(0)
}
pub fn clear_host_account_id(&mut self) {
self.host_account_id = ::std::option::Option::None;
}
pub fn has_host_account_id(&self) -> bool {
self.host_account_id.is_some()
}
pub fn set_host_account_id(&mut self, v: u32) {
self.host_account_id = ::std::option::Option::Some(v);
}
pub fn get_client_account_id(&self) -> u32 {
self.client_account_id.unwrap_or(0)
}
pub fn clear_client_account_id(&mut self) {
self.client_account_id = ::std::option::Option::None;
}
pub fn has_client_account_id(&self) -> bool {
self.client_account_id.is_some()
}
pub fn set_client_account_id(&mut self, v: u32) {
self.client_account_id = ::std::option::Option::Some(v);
}
pub fn get_appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn get_device_form_factor(&self) -> i32 {
self.device_form_factor.unwrap_or(0)
}
pub fn clear_device_form_factor(&mut self) {
self.device_form_factor = ::std::option::Option::None;
}
pub fn has_device_form_factor(&self) -> bool {
self.device_form_factor.is_some()
}
pub fn set_device_form_factor(&mut self, v: i32) {
self.device_form_factor = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemotePlay_SessionStarted_Request {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.host_account_id = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.client_account_id = ::std::option::Option::Some(tmp);
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.appid = ::std::option::Option::Some(tmp);
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int32()?;
self.device_form_factor = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.host_account_id {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.client_account_id {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.appid {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.device_form_factor {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.host_account_id {
os.write_uint32(1, v)?;
}
if let Some(v) = self.client_account_id {
os.write_uint32(2, v)?;
}
if let Some(v) = self.appid {
os.write_uint32(3, v)?;
}
if let Some(v) = self.device_form_factor {
os.write_int32(4, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemotePlay_SessionStarted_Request {
CRemotePlay_SessionStarted_Request::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"host_account_id",
|m: &CRemotePlay_SessionStarted_Request| { &m.host_account_id },
|m: &mut CRemotePlay_SessionStarted_Request| { &mut m.host_account_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"client_account_id",
|m: &CRemotePlay_SessionStarted_Request| { &m.client_account_id },
|m: &mut CRemotePlay_SessionStarted_Request| { &mut m.client_account_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"appid",
|m: &CRemotePlay_SessionStarted_Request| { &m.appid },
|m: &mut CRemotePlay_SessionStarted_Request| { &mut m.appid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"device_form_factor",
|m: &CRemotePlay_SessionStarted_Request| { &m.device_form_factor },
|m: &mut CRemotePlay_SessionStarted_Request| { &mut m.device_form_factor },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemotePlay_SessionStarted_Request>(
"CRemotePlay_SessionStarted_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemotePlay_SessionStarted_Request {
static instance: ::protobuf::rt::LazyV2<CRemotePlay_SessionStarted_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemotePlay_SessionStarted_Request::new)
}
}
impl ::protobuf::Clear for CRemotePlay_SessionStarted_Request {
fn clear(&mut self) {
self.host_account_id = ::std::option::Option::None;
self.client_account_id = ::std::option::Option::None;
self.appid = ::std::option::Option::None;
self.device_form_factor = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemotePlay_SessionStarted_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemotePlay_SessionStarted_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemotePlay_SessionStarted_Response {
record_id: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemotePlay_SessionStarted_Response {
fn default() -> &'a CRemotePlay_SessionStarted_Response {
<CRemotePlay_SessionStarted_Response as ::protobuf::Message>::default_instance()
}
}
impl CRemotePlay_SessionStarted_Response {
pub fn new() -> CRemotePlay_SessionStarted_Response {
::std::default::Default::default()
}
pub fn get_record_id(&self) -> u64 {
self.record_id.unwrap_or(0)
}
pub fn clear_record_id(&mut self) {
self.record_id = ::std::option::Option::None;
}
pub fn has_record_id(&self) -> bool {
self.record_id.is_some()
}
pub fn set_record_id(&mut self, v: u64) {
self.record_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemotePlay_SessionStarted_Response {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.record_id = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.record_id {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.record_id {
os.write_fixed64(1, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemotePlay_SessionStarted_Response {
CRemotePlay_SessionStarted_Response::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"record_id",
|m: &CRemotePlay_SessionStarted_Response| { &m.record_id },
|m: &mut CRemotePlay_SessionStarted_Response| { &mut m.record_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemotePlay_SessionStarted_Response>(
"CRemotePlay_SessionStarted_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemotePlay_SessionStarted_Response {
static instance: ::protobuf::rt::LazyV2<CRemotePlay_SessionStarted_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemotePlay_SessionStarted_Response::new)
}
}
impl ::protobuf::Clear for CRemotePlay_SessionStarted_Response {
fn clear(&mut self) {
self.record_id = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemotePlay_SessionStarted_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemotePlay_SessionStarted_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemotePlay_SessionStopped_Notification {
record_id: ::std::option::Option<u64>,
used_x264: ::std::option::Option<bool>,
used_h264: ::std::option::Option<bool>,
used_hevc: ::std::option::Option<bool>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemotePlay_SessionStopped_Notification {
fn default() -> &'a CRemotePlay_SessionStopped_Notification {
<CRemotePlay_SessionStopped_Notification as ::protobuf::Message>::default_instance()
}
}
impl CRemotePlay_SessionStopped_Notification {
pub fn new() -> CRemotePlay_SessionStopped_Notification {
::std::default::Default::default()
}
pub fn get_record_id(&self) -> u64 {
self.record_id.unwrap_or(0)
}
pub fn clear_record_id(&mut self) {
self.record_id = ::std::option::Option::None;
}
pub fn has_record_id(&self) -> bool {
self.record_id.is_some()
}
pub fn set_record_id(&mut self, v: u64) {
self.record_id = ::std::option::Option::Some(v);
}
pub fn get_used_x264(&self) -> bool {
self.used_x264.unwrap_or(false)
}
pub fn clear_used_x264(&mut self) {
self.used_x264 = ::std::option::Option::None;
}
pub fn has_used_x264(&self) -> bool {
self.used_x264.is_some()
}
pub fn set_used_x264(&mut self, v: bool) {
self.used_x264 = ::std::option::Option::Some(v);
}
pub fn get_used_h264(&self) -> bool {
self.used_h264.unwrap_or(false)
}
pub fn clear_used_h264(&mut self) {
self.used_h264 = ::std::option::Option::None;
}
pub fn has_used_h264(&self) -> bool {
self.used_h264.is_some()
}
pub fn set_used_h264(&mut self, v: bool) {
self.used_h264 = ::std::option::Option::Some(v);
}
pub fn get_used_hevc(&self) -> bool {
self.used_hevc.unwrap_or(false)
}
pub fn clear_used_hevc(&mut self) {
self.used_hevc = ::std::option::Option::None;
}
pub fn has_used_hevc(&self) -> bool {
self.used_hevc.is_some()
}
pub fn set_used_hevc(&mut self, v: bool) {
self.used_hevc = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemotePlay_SessionStopped_Notification {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.record_id = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.used_x264 = ::std::option::Option::Some(tmp);
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.used_h264 = ::std::option::Option::Some(tmp);
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.used_hevc = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.record_id {
my_size += 9;
}
if let Some(v) = self.used_x264 {
my_size += 2;
}
if let Some(v) = self.used_h264 {
my_size += 2;
}
if let Some(v) = self.used_hevc {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.record_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.used_x264 {
os.write_bool(2, v)?;
}
if let Some(v) = self.used_h264 {
os.write_bool(3, v)?;
}
if let Some(v) = self.used_hevc {
os.write_bool(4, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemotePlay_SessionStopped_Notification {
CRemotePlay_SessionStopped_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"record_id",
|m: &CRemotePlay_SessionStopped_Notification| { &m.record_id },
|m: &mut CRemotePlay_SessionStopped_Notification| { &mut m.record_id },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"used_x264",
|m: &CRemotePlay_SessionStopped_Notification| { &m.used_x264 },
|m: &mut CRemotePlay_SessionStopped_Notification| { &mut m.used_x264 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"used_h264",
|m: &CRemotePlay_SessionStopped_Notification| { &m.used_h264 },
|m: &mut CRemotePlay_SessionStopped_Notification| { &mut m.used_h264 },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"used_hevc",
|m: &CRemotePlay_SessionStopped_Notification| { &m.used_hevc },
|m: &mut CRemotePlay_SessionStopped_Notification| { &mut m.used_hevc },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemotePlay_SessionStopped_Notification>(
"CRemotePlay_SessionStopped_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemotePlay_SessionStopped_Notification {
static instance: ::protobuf::rt::LazyV2<CRemotePlay_SessionStopped_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemotePlay_SessionStopped_Notification::new)
}
}
impl ::protobuf::Clear for CRemotePlay_SessionStopped_Notification {
fn clear(&mut self) {
self.record_id = ::std::option::Option::None;
self.used_x264 = ::std::option::Option::None;
self.used_h264 = ::std::option::Option::None;
self.used_hevc = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemotePlay_SessionStopped_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemotePlay_SessionStopped_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemotePlayTogether_Notification {
steamid: ::std::option::Option<u64>,
pub Message: ::std::option::Option<CRemotePlayTogether_Notification_oneof_Message>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemotePlayTogether_Notification {
fn default() -> &'a CRemotePlayTogether_Notification {
<CRemotePlayTogether_Notification as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum CRemotePlayTogether_Notification_oneof_Message {
group_updated(CRemotePlayTogether_Notification_GroupUpdated),
}
impl CRemotePlayTogether_Notification {
pub fn new() -> CRemotePlayTogether_Notification {
::std::default::Default::default()
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn get_group_updated(&self) -> &CRemotePlayTogether_Notification_GroupUpdated {
match self.Message {
::std::option::Option::Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(ref v)) => v,
_ => <CRemotePlayTogether_Notification_GroupUpdated as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_group_updated(&mut self) {
self.Message = ::std::option::Option::None;
}
pub fn has_group_updated(&self) -> bool {
match self.Message {
::std::option::Option::Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(..)) => true,
_ => false,
}
}
pub fn set_group_updated(&mut self, v: CRemotePlayTogether_Notification_GroupUpdated) {
self.Message = ::std::option::Option::Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(v))
}
pub fn mut_group_updated(&mut self) -> &mut CRemotePlayTogether_Notification_GroupUpdated {
if let ::std::option::Option::Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(_)) = self.Message {
} else {
self.Message = ::std::option::Option::Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(CRemotePlayTogether_Notification_GroupUpdated::new()));
}
match self.Message {
::std::option::Option::Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_group_updated(&mut self) -> CRemotePlayTogether_Notification_GroupUpdated {
if self.has_group_updated() {
match self.Message.take() {
::std::option::Option::Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(v)) => v,
_ => panic!(),
}
} else {
CRemotePlayTogether_Notification_GroupUpdated::new()
}
}
}
impl ::protobuf::Message for CRemotePlayTogether_Notification {
fn is_initialized(&self) -> bool {
if let Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(ref v)) = self.Message {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.Message = ::std::option::Option::Some(CRemotePlayTogether_Notification_oneof_Message::group_updated(is.read_message()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.steamid {
my_size += 9;
}
if let ::std::option::Option::Some(ref v) = self.Message {
match v {
&CRemotePlayTogether_Notification_oneof_Message::group_updated(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.steamid {
os.write_fixed64(1, v)?;
}
if let ::std::option::Option::Some(ref v) = self.Message {
match v {
&CRemotePlayTogether_Notification_oneof_Message::group_updated(ref v) => {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
};
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemotePlayTogether_Notification {
CRemotePlayTogether_Notification::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"steamid",
|m: &CRemotePlayTogether_Notification| { &m.steamid },
|m: &mut CRemotePlayTogether_Notification| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, CRemotePlayTogether_Notification_GroupUpdated>(
"group_updated",
CRemotePlayTogether_Notification::has_group_updated,
CRemotePlayTogether_Notification::get_group_updated,
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemotePlayTogether_Notification>(
"CRemotePlayTogether_Notification",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemotePlayTogether_Notification {
static instance: ::protobuf::rt::LazyV2<CRemotePlayTogether_Notification> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemotePlayTogether_Notification::new)
}
}
impl ::protobuf::Clear for CRemotePlayTogether_Notification {
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.Message = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemotePlayTogether_Notification {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemotePlayTogether_Notification {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemotePlayTogether_Notification_ControllerSlots {
slotid: ::std::option::Option<u32>,
steamid: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemotePlayTogether_Notification_ControllerSlots {
fn default() -> &'a CRemotePlayTogether_Notification_ControllerSlots {
<CRemotePlayTogether_Notification_ControllerSlots as ::protobuf::Message>::default_instance()
}
}
impl CRemotePlayTogether_Notification_ControllerSlots {
pub fn new() -> CRemotePlayTogether_Notification_ControllerSlots {
::std::default::Default::default()
}
pub fn get_slotid(&self) -> u32 {
self.slotid.unwrap_or(0)
}
pub fn clear_slotid(&mut self) {
self.slotid = ::std::option::Option::None;
}
pub fn has_slotid(&self) -> bool {
self.slotid.is_some()
}
pub fn set_slotid(&mut self, v: u32) {
self.slotid = ::std::option::Option::Some(v);
}
pub fn get_steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CRemotePlayTogether_Notification_ControllerSlots {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.slotid = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.slotid {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.steamid {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.slotid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.steamid {
os.write_fixed64(2, v)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemotePlayTogether_Notification_ControllerSlots {
CRemotePlayTogether_Notification_ControllerSlots::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"slotid",
|m: &CRemotePlayTogether_Notification_ControllerSlots| { &m.slotid },
|m: &mut CRemotePlayTogether_Notification_ControllerSlots| { &mut m.slotid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"steamid",
|m: &CRemotePlayTogether_Notification_ControllerSlots| { &m.steamid },
|m: &mut CRemotePlayTogether_Notification_ControllerSlots| { &mut m.steamid },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemotePlayTogether_Notification_ControllerSlots>(
"CRemotePlayTogether_Notification.ControllerSlots",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemotePlayTogether_Notification_ControllerSlots {
static instance: ::protobuf::rt::LazyV2<CRemotePlayTogether_Notification_ControllerSlots> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemotePlayTogether_Notification_ControllerSlots::new)
}
}
impl ::protobuf::Clear for CRemotePlayTogether_Notification_ControllerSlots {
fn clear(&mut self) {
self.slotid = ::std::option::Option::None;
self.steamid = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemotePlayTogether_Notification_ControllerSlots {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemotePlayTogether_Notification_ControllerSlots {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CRemotePlayTogether_Notification_GroupUpdated {
host_steamid: ::std::option::Option<u64>,
host_clientid: ::std::option::Option<u64>,
pub players: ::std::vec::Vec<u64>,
host_gameid: ::std::option::Option<u64>,
pub controller_slots: ::protobuf::RepeatedField<CRemotePlayTogether_Notification_ControllerSlots>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CRemotePlayTogether_Notification_GroupUpdated {
fn default() -> &'a CRemotePlayTogether_Notification_GroupUpdated {
<CRemotePlayTogether_Notification_GroupUpdated as ::protobuf::Message>::default_instance()
}
}
impl CRemotePlayTogether_Notification_GroupUpdated {
pub fn new() -> CRemotePlayTogether_Notification_GroupUpdated {
::std::default::Default::default()
}
pub fn get_host_steamid(&self) -> u64 {
self.host_steamid.unwrap_or(0)
}
pub fn clear_host_steamid(&mut self) {
self.host_steamid = ::std::option::Option::None;
}
pub fn has_host_steamid(&self) -> bool {
self.host_steamid.is_some()
}
pub fn set_host_steamid(&mut self, v: u64) {
self.host_steamid = ::std::option::Option::Some(v);
}
pub fn get_host_clientid(&self) -> u64 {
self.host_clientid.unwrap_or(0)
}
pub fn clear_host_clientid(&mut self) {
self.host_clientid = ::std::option::Option::None;
}
pub fn has_host_clientid(&self) -> bool {
self.host_clientid.is_some()
}
pub fn set_host_clientid(&mut self, v: u64) {
self.host_clientid = ::std::option::Option::Some(v);
}
pub fn get_players(&self) -> &[u64] {
&self.players
}
pub fn clear_players(&mut self) {
self.players.clear();
}
pub fn set_players(&mut self, v: ::std::vec::Vec<u64>) {
self.players = v;
}
pub fn mut_players(&mut self) -> &mut ::std::vec::Vec<u64> {
&mut self.players
}
pub fn take_players(&mut self) -> ::std::vec::Vec<u64> {
::std::mem::replace(&mut self.players, ::std::vec::Vec::new())
}
pub fn get_host_gameid(&self) -> u64 {
self.host_gameid.unwrap_or(0)
}
pub fn clear_host_gameid(&mut self) {
self.host_gameid = ::std::option::Option::None;
}
pub fn has_host_gameid(&self) -> bool {
self.host_gameid.is_some()
}
pub fn set_host_gameid(&mut self, v: u64) {
self.host_gameid = ::std::option::Option::Some(v);
}
pub fn get_controller_slots(&self) -> &[CRemotePlayTogether_Notification_ControllerSlots] {
&self.controller_slots
}
pub fn clear_controller_slots(&mut self) {
self.controller_slots.clear();
}
pub fn set_controller_slots(&mut self, v: ::protobuf::RepeatedField<CRemotePlayTogether_Notification_ControllerSlots>) {
self.controller_slots = v;
}
pub fn mut_controller_slots(&mut self) -> &mut ::protobuf::RepeatedField<CRemotePlayTogether_Notification_ControllerSlots> {
&mut self.controller_slots
}
pub fn take_controller_slots(&mut self) -> ::protobuf::RepeatedField<CRemotePlayTogether_Notification_ControllerSlots> {
::std::mem::replace(&mut self.controller_slots, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for CRemotePlayTogether_Notification_GroupUpdated {
fn is_initialized(&self) -> bool {
for v in &self.controller_slots {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.host_steamid = ::std::option::Option::Some(tmp);
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.host_clientid = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_repeated_fixed64_into(wire_type, is, &mut self.players)?;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.host_gameid = ::std::option::Option::Some(tmp);
},
5 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.controller_slots)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(v) = self.host_steamid {
my_size += 9;
}
if let Some(v) = self.host_clientid {
my_size += 9;
}
my_size += 9 * self.players.len() as u32;
if let Some(v) = self.host_gameid {
my_size += 9;
}
for value in &self.controller_slots {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(v) = self.host_steamid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.host_clientid {
os.write_fixed64(2, v)?;
}
for v in &self.players {
os.write_fixed64(3, *v)?;
};
if let Some(v) = self.host_gameid {
os.write_fixed64(4, v)?;
}
for v in &self.controller_slots {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CRemotePlayTogether_Notification_GroupUpdated {
CRemotePlayTogether_Notification_GroupUpdated::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"host_steamid",
|m: &CRemotePlayTogether_Notification_GroupUpdated| { &m.host_steamid },
|m: &mut CRemotePlayTogether_Notification_GroupUpdated| { &mut m.host_steamid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"host_clientid",
|m: &CRemotePlayTogether_Notification_GroupUpdated| { &m.host_clientid },
|m: &mut CRemotePlayTogether_Notification_GroupUpdated| { &mut m.host_clientid },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"players",
|m: &CRemotePlayTogether_Notification_GroupUpdated| { &m.players },
|m: &mut CRemotePlayTogether_Notification_GroupUpdated| { &mut m.players },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"host_gameid",
|m: &CRemotePlayTogether_Notification_GroupUpdated| { &m.host_gameid },
|m: &mut CRemotePlayTogether_Notification_GroupUpdated| { &mut m.host_gameid },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CRemotePlayTogether_Notification_ControllerSlots>>(
"controller_slots",
|m: &CRemotePlayTogether_Notification_GroupUpdated| { &m.controller_slots },
|m: &mut CRemotePlayTogether_Notification_GroupUpdated| { &mut m.controller_slots },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CRemotePlayTogether_Notification_GroupUpdated>(
"CRemotePlayTogether_Notification.GroupUpdated",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CRemotePlayTogether_Notification_GroupUpdated {
static instance: ::protobuf::rt::LazyV2<CRemotePlayTogether_Notification_GroupUpdated> = ::protobuf::rt::LazyV2::INIT;
instance.get(CRemotePlayTogether_Notification_GroupUpdated::new)
}
}
impl ::protobuf::Clear for CRemotePlayTogether_Notification_GroupUpdated {
fn clear(&mut self) {
self.host_steamid = ::std::option::Option::None;
self.host_clientid = ::std::option::Option::None;
self.players.clear();
self.host_gameid = ::std::option::Option::None;
self.controller_slots.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CRemotePlayTogether_Notification_GroupUpdated {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CRemotePlayTogether_Notification_GroupUpdated {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n1steammessages_remoteclient_service_messages.proto\"%\n#CRemoteClient_\
CreateSession_Request\"c\n$CRemoteClient_CreateSession_Response\x12\x1d\
\n\nsession_id\x18\x01\x20\x01(\x06R\tsessionId\x12\x1c\n\teuniverse\x18\
\x02\x20\x01(\x05R\teuniverse\"C\n\"CRemoteClient_StartPairing_Request\
\x12\x1d\n\nsession_id\x18\x01\x20\x01(\x06R\tsessionId\"7\n#CRemoteClie\
nt_StartPairing_Response\x12\x10\n\x03pin\x18\x01\x20\x01(\rR\x03pin\"|\
\n$CRemoteClient_SetPairingInfo_Request\x12\x1d\n\nsession_id\x18\x01\
\x20\x01(\x06R\tsessionId\x12\x1b\n\tdevice_id\x18\x02\x20\x01(\x06R\x08\
deviceId\x12\x18\n\x07request\x18\x03\x20\x01(\x0cR\x07request\"'\n%CRem\
oteClient_SetPairingInfo_Response\"8\n$CRemoteClient_GetPairingInfo_Requ\
est\x12\x10\n\x03pin\x18\x01\x20\x01(\rR\x03pin\"}\n%CRemoteClient_GetPa\
iringInfo_Response\x12\x1d\n\nsession_id\x18\x01\x20\x01(\x06R\tsessionI\
d\x12\x1b\n\tdevice_id\x18\x02\x20\x01(\x06R\x08deviceId\x12\x18\n\x07re\
quest\x18\x03\x20\x01(\x0cR\x07request\"D\n#CRemoteClient_CancelPairing_\
Request\x12\x1d\n\nsession_id\x18\x01\x20\x01(\x06R\tsessionId\"&\n$CRem\
oteClient_CancelPairing_Response\"\x87\x01\n/CRemoteClient_RegisterStatu\
sUpdate_Notification\x12\x1d\n\nsession_id\x18\x01\x20\x01(\x06R\tsessio\
nId\x12\x18\n\x07steamid\x18\x02\x20\x01(\x06R\x07steamid\x12\x1b\n\tdev\
ice_id\x18\x03\x20\x01(\x06R\x08deviceId\"l\n1CRemoteClient_UnregisterSt\
atusUpdate_Notification\x12\x1d\n\nsession_id\x18\x01\x20\x01(\x06R\tses\
sionId\x12\x18\n\x07steamid\x18\x02\x20\x01(\x06R\x07steamid\"=\n!CRemot\
eClient_Online_Notification\x12\x18\n\x07steamid\x18\x01\x20\x01(\x06R\
\x07steamid\"|\n'CRemoteClient_RemotePacket_Notification\x12\x1d\n\nsess\
ion_id\x18\x01\x20\x01(\x06R\tsessionId\x12\x18\n\x07steamid\x18\x02\x20\
\x01(\x06R\x07steamid\x12\x18\n\x07payload\x18\x04\x20\x01(\x0cR\x07payl\
oad\"a\n&CRemoteClient_ReplyPacket_Notification\x12\x1d\n\nsession_id\
\x18\x01\x20\x01(\x06R\tsessionId\x12\x18\n\x07payload\x18\x02\x20\x01(\
\x0cR\x07payload\"A\n\x20CRemoteClient_GetReplies_Request\x12\x1d\n\nses\
sion_id\x18\x01\x20\x01(\x06R\tsessionId\"=\n!CRemoteClient_GetReplies_R\
esponse\x12\x18\n\x07payload\x18\x01\x20\x03(\x0cR\x07payload\"d\n(CRemo\
teClient_AllocateTURNServer_Request\x12\x16\n\x06cellid\x18\x01\x20\x01(\
\rR\x06cellid\x12\x20\n\x0bcredentials\x18\x02\x20\x01(\tR\x0bcredential\
s\"L\n)CRemoteClient_AllocateTURNServer_Response\x12\x1f\n\x0bturn_serve\
r\x18\x01\x20\x01(\tR\nturnServer\"e\n)CRemoteClient_AllocateRelayServer\
_Request\x12\x16\n\x06cellid\x18\x01\x20\x01(\rR\x06cellid\x12\x20\n\x0b\
credentials\x18\x02\x20\x01(\tR\x0bcredentials\"O\n*CRemoteClient_Alloca\
teRelayServer_Response\x12!\n\x0crelay_server\x18\x01\x20\x01(\tR\x0brel\
ayServer\"9\n!CRemoteClient_AllocateSDR_Request\x12\x14\n\x05appid\x18\
\x01\x20\x01(\rR\x05appid\"$\n\"CRemoteClient_AllocateSDR_Response\"{\n)\
CRemoteClient_SteamBroadcast_Notification\x12\x18\n\x07steamid\x18\x01\
\x20\x01(\x06R\x07steamid\x12\x1a\n\x08clientid\x18\x02\x20\x01(\x06R\
\x08clientid\x12\x18\n\x07payload\x18\x03\x20\x01(\x0cR\x07payload\"\xd2\
\x01\n'CRemoteClient_SteamToSteam_Notification\x12\x18\n\x07steamid\x18\
\x01\x20\x01(\x06R\x07steamid\x12!\n\x0csrc_clientid\x18\x02\x20\x01(\
\x06R\x0bsrcClientid\x12!\n\x0cdst_clientid\x18\x03\x20\x01(\x06R\x0bdst\
Clientid\x12\x1a\n\x08secretid\x18\x04\x20\x01(\rR\x08secretid\x12+\n\
\x11encrypted_payload\x18\x05\x20\x01(\x0cR\x10encryptedPayload\"\xbc\
\x01\n\"CRemotePlay_SessionStarted_Request\x12&\n\x0fhost_account_id\x18\
\x01\x20\x01(\rR\rhostAccountId\x12*\n\x11client_account_id\x18\x02\x20\
\x01(\rR\x0fclientAccountId\x12\x14\n\x05appid\x18\x03\x20\x01(\rR\x05ap\
pid\x12,\n\x12device_form_factor\x18\x04\x20\x01(\x05R\x10deviceFormFact\
or\"B\n#CRemotePlay_SessionStarted_Response\x12\x1b\n\trecord_id\x18\x01\
\x20\x01(\x06R\x08recordId\"\x9d\x01\n'CRemotePlay_SessionStopped_Notifi\
cation\x12\x1b\n\trecord_id\x18\x01\x20\x01(\x06R\x08recordId\x12\x1b\n\
\tused_x264\x18\x02\x20\x01(\x08R\x08usedX264\x12\x1b\n\tused_h264\x18\
\x03\x20\x01(\x08R\x08usedH264\x12\x1b\n\tused_hevc\x18\x04\x20\x01(\x08\
R\x08usedHevc\"\xd5\x03\n\x20CRemotePlayTogether_Notification\x12\x18\n\
\x07steamid\x18\x01\x20\x01(\x06R\x07steamid\x12U\n\rgroup_updated\x18\
\x02\x20\x01(\x0b2..CRemotePlayTogether_Notification.GroupUpdatedH\0R\
\x0cgroupUpdated\x1aC\n\x0fControllerSlots\x12\x16\n\x06slotid\x18\x01\
\x20\x01(\rR\x06slotid\x12\x18\n\x07steamid\x18\x02\x20\x01(\x06R\x07ste\
amid\x1a\xef\x01\n\x0cGroupUpdated\x12!\n\x0chost_steamid\x18\x01\x20\
\x01(\x06R\x0bhostSteamid\x12#\n\rhost_clientid\x18\x02\x20\x01(\x06R\
\x0chostClientid\x12\x18\n\x07players\x18\x03\x20\x03(\x06R\x07players\
\x12\x1f\n\x0bhost_gameid\x18\x04\x20\x01(\x06R\nhostGameid\x12\\\n\x10c\
ontroller_slots\x18\x05\x20\x03(\x0b21.CRemotePlayTogether_Notification.\
ControllerSlotsR\x0fcontrollerSlotsB\t\n\x07MessageJ\xb7&\n\x07\x12\x05\
\0\0\x98\x01\x01\n\n\n\x02\x04\0\x12\x04\0\0\x01\x01\n\n\n\x03\x04\0\x01\
\x12\x03\0\x08+\n\n\n\x02\x04\x01\x12\x04\x03\0\x06\x01\n\n\n\x03\x04\
\x01\x01\x12\x03\x03\x08,\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x04\x08(\n\
\x0c\n\x05\x04\x01\x02\0\x04\x12\x03\x04\x08\x10\n\x0c\n\x05\x04\x01\x02\
\0\x05\x12\x03\x04\x11\x18\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\x04\x19\
#\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x04&'\n\x0b\n\x04\x04\x01\x02\
\x01\x12\x03\x05\x08%\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03\x05\x08\
\x10\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\x05\x11\x16\n\x0c\n\x05\x04\
\x01\x02\x01\x01\x12\x03\x05\x17\x20\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\
\x03\x05#$\n\n\n\x02\x04\x02\x12\x04\x08\0\n\x01\n\n\n\x03\x04\x02\x01\
\x12\x03\x08\x08*\n\x0b\n\x04\x04\x02\x02\0\x12\x03\t\x08(\n\x0c\n\x05\
\x04\x02\x02\0\x04\x12\x03\t\x08\x10\n\x0c\n\x05\x04\x02\x02\0\x05\x12\
\x03\t\x11\x18\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\t\x19#\n\x0c\n\x05\
\x04\x02\x02\0\x03\x12\x03\t&'\n\n\n\x02\x04\x03\x12\x04\x0c\0\x0e\x01\n\
\n\n\x03\x04\x03\x01\x12\x03\x0c\x08+\n\x0b\n\x04\x04\x03\x02\0\x12\x03\
\r\x08\x20\n\x0c\n\x05\x04\x03\x02\0\x04\x12\x03\r\x08\x10\n\x0c\n\x05\
\x04\x03\x02\0\x05\x12\x03\r\x11\x17\n\x0c\n\x05\x04\x03\x02\0\x01\x12\
\x03\r\x18\x1b\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03\r\x1e\x1f\n\n\n\x02\
\x04\x04\x12\x04\x10\0\x14\x01\n\n\n\x03\x04\x04\x01\x12\x03\x10\x08,\n\
\x0b\n\x04\x04\x04\x02\0\x12\x03\x11\x08(\n\x0c\n\x05\x04\x04\x02\0\x04\
\x12\x03\x11\x08\x10\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03\x11\x11\x18\n\
\x0c\n\x05\x04\x04\x02\0\x01\x12\x03\x11\x19#\n\x0c\n\x05\x04\x04\x02\0\
\x03\x12\x03\x11&'\n\x0b\n\x04\x04\x04\x02\x01\x12\x03\x12\x08'\n\x0c\n\
\x05\x04\x04\x02\x01\x04\x12\x03\x12\x08\x10\n\x0c\n\x05\x04\x04\x02\x01\
\x05\x12\x03\x12\x11\x18\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03\x12\x19\
\"\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03\x12%&\n\x0b\n\x04\x04\x04\x02\
\x02\x12\x03\x13\x08#\n\x0c\n\x05\x04\x04\x02\x02\x04\x12\x03\x13\x08\
\x10\n\x0c\n\x05\x04\x04\x02\x02\x05\x12\x03\x13\x11\x16\n\x0c\n\x05\x04\
\x04\x02\x02\x01\x12\x03\x13\x17\x1e\n\x0c\n\x05\x04\x04\x02\x02\x03\x12\
\x03\x13!\"\n\n\n\x02\x04\x05\x12\x04\x16\0\x17\x01\n\n\n\x03\x04\x05\
\x01\x12\x03\x16\x08-\n\n\n\x02\x04\x06\x12\x04\x19\0\x1b\x01\n\n\n\x03\
\x04\x06\x01\x12\x03\x19\x08,\n\x0b\n\x04\x04\x06\x02\0\x12\x03\x1a\x08\
\x20\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x03\x1a\x08\x10\n\x0c\n\x05\x04\
\x06\x02\0\x05\x12\x03\x1a\x11\x17\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03\
\x1a\x18\x1b\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03\x1a\x1e\x1f\n\n\n\x02\
\x04\x07\x12\x04\x1d\0!\x01\n\n\n\x03\x04\x07\x01\x12\x03\x1d\x08-\n\x0b\
\n\x04\x04\x07\x02\0\x12\x03\x1e\x08(\n\x0c\n\x05\x04\x07\x02\0\x04\x12\
\x03\x1e\x08\x10\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03\x1e\x11\x18\n\x0c\
\n\x05\x04\x07\x02\0\x01\x12\x03\x1e\x19#\n\x0c\n\x05\x04\x07\x02\0\x03\
\x12\x03\x1e&'\n\x0b\n\x04\x04\x07\x02\x01\x12\x03\x1f\x08'\n\x0c\n\x05\
\x04\x07\x02\x01\x04\x12\x03\x1f\x08\x10\n\x0c\n\x05\x04\x07\x02\x01\x05\
\x12\x03\x1f\x11\x18\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\x03\x1f\x19\"\n\
\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03\x1f%&\n\x0b\n\x04\x04\x07\x02\x02\
\x12\x03\x20\x08#\n\x0c\n\x05\x04\x07\x02\x02\x04\x12\x03\x20\x08\x10\n\
\x0c\n\x05\x04\x07\x02\x02\x05\x12\x03\x20\x11\x16\n\x0c\n\x05\x04\x07\
\x02\x02\x01\x12\x03\x20\x17\x1e\n\x0c\n\x05\x04\x07\x02\x02\x03\x12\x03\
\x20!\"\n\n\n\x02\x04\x08\x12\x04#\0%\x01\n\n\n\x03\x04\x08\x01\x12\x03#\
\x08+\n\x0b\n\x04\x04\x08\x02\0\x12\x03$\x08(\n\x0c\n\x05\x04\x08\x02\0\
\x04\x12\x03$\x08\x10\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03$\x11\x18\n\
\x0c\n\x05\x04\x08\x02\0\x01\x12\x03$\x19#\n\x0c\n\x05\x04\x08\x02\0\x03\
\x12\x03$&'\n\n\n\x02\x04\t\x12\x04'\0(\x01\n\n\n\x03\x04\t\x01\x12\x03'\
\x08,\n\n\n\x02\x04\n\x12\x04*\0.\x01\n\n\n\x03\x04\n\x01\x12\x03*\x087\
\n\x0b\n\x04\x04\n\x02\0\x12\x03+\x08(\n\x0c\n\x05\x04\n\x02\0\x04\x12\
\x03+\x08\x10\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03+\x11\x18\n\x0c\n\x05\
\x04\n\x02\0\x01\x12\x03+\x19#\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03+&'\n\
\x0b\n\x04\x04\n\x02\x01\x12\x03,\x08%\n\x0c\n\x05\x04\n\x02\x01\x04\x12\
\x03,\x08\x10\n\x0c\n\x05\x04\n\x02\x01\x05\x12\x03,\x11\x18\n\x0c\n\x05\
\x04\n\x02\x01\x01\x12\x03,\x19\x20\n\x0c\n\x05\x04\n\x02\x01\x03\x12\
\x03,#$\n\x0b\n\x04\x04\n\x02\x02\x12\x03-\x08'\n\x0c\n\x05\x04\n\x02\
\x02\x04\x12\x03-\x08\x10\n\x0c\n\x05\x04\n\x02\x02\x05\x12\x03-\x11\x18\
\n\x0c\n\x05\x04\n\x02\x02\x01\x12\x03-\x19\"\n\x0c\n\x05\x04\n\x02\x02\
\x03\x12\x03-%&\n\n\n\x02\x04\x0b\x12\x040\03\x01\n\n\n\x03\x04\x0b\x01\
\x12\x030\x089\n\x0b\n\x04\x04\x0b\x02\0\x12\x031\x08(\n\x0c\n\x05\x04\
\x0b\x02\0\x04\x12\x031\x08\x10\n\x0c\n\x05\x04\x0b\x02\0\x05\x12\x031\
\x11\x18\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\x031\x19#\n\x0c\n\x05\x04\x0b\
\x02\0\x03\x12\x031&'\n\x0b\n\x04\x04\x0b\x02\x01\x12\x032\x08%\n\x0c\n\
\x05\x04\x0b\x02\x01\x04\x12\x032\x08\x10\n\x0c\n\x05\x04\x0b\x02\x01\
\x05\x12\x032\x11\x18\n\x0c\n\x05\x04\x0b\x02\x01\x01\x12\x032\x19\x20\n\
\x0c\n\x05\x04\x0b\x02\x01\x03\x12\x032#$\n\n\n\x02\x04\x0c\x12\x045\07\
\x01\n\n\n\x03\x04\x0c\x01\x12\x035\x08)\n\x0b\n\x04\x04\x0c\x02\0\x12\
\x036\x08%\n\x0c\n\x05\x04\x0c\x02\0\x04\x12\x036\x08\x10\n\x0c\n\x05\
\x04\x0c\x02\0\x05\x12\x036\x11\x18\n\x0c\n\x05\x04\x0c\x02\0\x01\x12\
\x036\x19\x20\n\x0c\n\x05\x04\x0c\x02\0\x03\x12\x036#$\n\n\n\x02\x04\r\
\x12\x049\0=\x01\n\n\n\x03\x04\r\x01\x12\x039\x08/\n\x0b\n\x04\x04\r\x02\
\0\x12\x03:\x08(\n\x0c\n\x05\x04\r\x02\0\x04\x12\x03:\x08\x10\n\x0c\n\
\x05\x04\r\x02\0\x05\x12\x03:\x11\x18\n\x0c\n\x05\x04\r\x02\0\x01\x12\
\x03:\x19#\n\x0c\n\x05\x04\r\x02\0\x03\x12\x03:&'\n\x0b\n\x04\x04\r\x02\
\x01\x12\x03;\x08%\n\x0c\n\x05\x04\r\x02\x01\x04\x12\x03;\x08\x10\n\x0c\
\n\x05\x04\r\x02\x01\x05\x12\x03;\x11\x18\n\x0c\n\x05\x04\r\x02\x01\x01\
\x12\x03;\x19\x20\n\x0c\n\x05\x04\r\x02\x01\x03\x12\x03;#$\n\x0b\n\x04\
\x04\r\x02\x02\x12\x03<\x08#\n\x0c\n\x05\x04\r\x02\x02\x04\x12\x03<\x08\
\x10\n\x0c\n\x05\x04\r\x02\x02\x05\x12\x03<\x11\x16\n\x0c\n\x05\x04\r\
\x02\x02\x01\x12\x03<\x17\x1e\n\x0c\n\x05\x04\r\x02\x02\x03\x12\x03<!\"\
\n\n\n\x02\x04\x0e\x12\x04?\0B\x01\n\n\n\x03\x04\x0e\x01\x12\x03?\x08.\n\
\x0b\n\x04\x04\x0e\x02\0\x12\x03@\x08(\n\x0c\n\x05\x04\x0e\x02\0\x04\x12\
\x03@\x08\x10\n\x0c\n\x05\x04\x0e\x02\0\x05\x12\x03@\x11\x18\n\x0c\n\x05\
\x04\x0e\x02\0\x01\x12\x03@\x19#\n\x0c\n\x05\x04\x0e\x02\0\x03\x12\x03@&\
'\n\x0b\n\x04\x04\x0e\x02\x01\x12\x03A\x08#\n\x0c\n\x05\x04\x0e\x02\x01\
\x04\x12\x03A\x08\x10\n\x0c\n\x05\x04\x0e\x02\x01\x05\x12\x03A\x11\x16\n\
\x0c\n\x05\x04\x0e\x02\x01\x01\x12\x03A\x17\x1e\n\x0c\n\x05\x04\x0e\x02\
\x01\x03\x12\x03A!\"\n\n\n\x02\x04\x0f\x12\x04D\0F\x01\n\n\n\x03\x04\x0f\
\x01\x12\x03D\x08(\n\x0b\n\x04\x04\x0f\x02\0\x12\x03E\x08(\n\x0c\n\x05\
\x04\x0f\x02\0\x04\x12\x03E\x08\x10\n\x0c\n\x05\x04\x0f\x02\0\x05\x12\
\x03E\x11\x18\n\x0c\n\x05\x04\x0f\x02\0\x01\x12\x03E\x19#\n\x0c\n\x05\
\x04\x0f\x02\0\x03\x12\x03E&'\n\n\n\x02\x04\x10\x12\x04H\0J\x01\n\n\n\
\x03\x04\x10\x01\x12\x03H\x08)\n\x0b\n\x04\x04\x10\x02\0\x12\x03I\x08#\n\
\x0c\n\x05\x04\x10\x02\0\x04\x12\x03I\x08\x10\n\x0c\n\x05\x04\x10\x02\0\
\x05\x12\x03I\x11\x16\n\x0c\n\x05\x04\x10\x02\0\x01\x12\x03I\x17\x1e\n\
\x0c\n\x05\x04\x10\x02\0\x03\x12\x03I!\"\n\n\n\x02\x04\x11\x12\x04L\0O\
\x01\n\n\n\x03\x04\x11\x01\x12\x03L\x080\n\x0b\n\x04\x04\x11\x02\0\x12\
\x03M\x08#\n\x0c\n\x05\x04\x11\x02\0\x04\x12\x03M\x08\x10\n\x0c\n\x05\
\x04\x11\x02\0\x05\x12\x03M\x11\x17\n\x0c\n\x05\x04\x11\x02\0\x01\x12\
\x03M\x18\x1e\n\x0c\n\x05\x04\x11\x02\0\x03\x12\x03M!\"\n\x0b\n\x04\x04\
\x11\x02\x01\x12\x03N\x08(\n\x0c\n\x05\x04\x11\x02\x01\x04\x12\x03N\x08\
\x10\n\x0c\n\x05\x04\x11\x02\x01\x05\x12\x03N\x11\x17\n\x0c\n\x05\x04\
\x11\x02\x01\x01\x12\x03N\x18#\n\x0c\n\x05\x04\x11\x02\x01\x03\x12\x03N&\
'\n\n\n\x02\x04\x12\x12\x04Q\0S\x01\n\n\n\x03\x04\x12\x01\x12\x03Q\x081\
\n\x0b\n\x04\x04\x12\x02\0\x12\x03R\x08(\n\x0c\n\x05\x04\x12\x02\0\x04\
\x12\x03R\x08\x10\n\x0c\n\x05\x04\x12\x02\0\x05\x12\x03R\x11\x17\n\x0c\n\
\x05\x04\x12\x02\0\x01\x12\x03R\x18#\n\x0c\n\x05\x04\x12\x02\0\x03\x12\
\x03R&'\n\n\n\x02\x04\x13\x12\x04U\0X\x01\n\n\n\x03\x04\x13\x01\x12\x03U\
\x081\n\x0b\n\x04\x04\x13\x02\0\x12\x03V\x08#\n\x0c\n\x05\x04\x13\x02\0\
\x04\x12\x03V\x08\x10\n\x0c\n\x05\x04\x13\x02\0\x05\x12\x03V\x11\x17\n\
\x0c\n\x05\x04\x13\x02\0\x01\x12\x03V\x18\x1e\n\x0c\n\x05\x04\x13\x02\0\
\x03\x12\x03V!\"\n\x0b\n\x04\x04\x13\x02\x01\x12\x03W\x08(\n\x0c\n\x05\
\x04\x13\x02\x01\x04\x12\x03W\x08\x10\n\x0c\n\x05\x04\x13\x02\x01\x05\
\x12\x03W\x11\x17\n\x0c\n\x05\x04\x13\x02\x01\x01\x12\x03W\x18#\n\x0c\n\
\x05\x04\x13\x02\x01\x03\x12\x03W&'\n\n\n\x02\x04\x14\x12\x04Z\0\\\x01\n\
\n\n\x03\x04\x14\x01\x12\x03Z\x082\n\x0b\n\x04\x04\x14\x02\0\x12\x03[\
\x08)\n\x0c\n\x05\x04\x14\x02\0\x04\x12\x03[\x08\x10\n\x0c\n\x05\x04\x14\
\x02\0\x05\x12\x03[\x11\x17\n\x0c\n\x05\x04\x14\x02\0\x01\x12\x03[\x18$\
\n\x0c\n\x05\x04\x14\x02\0\x03\x12\x03['(\n\n\n\x02\x04\x15\x12\x04^\0`\
\x01\n\n\n\x03\x04\x15\x01\x12\x03^\x08)\n\x0b\n\x04\x04\x15\x02\0\x12\
\x03_\x08\"\n\x0c\n\x05\x04\x15\x02\0\x04\x12\x03_\x08\x10\n\x0c\n\x05\
\x04\x15\x02\0\x05\x12\x03_\x11\x17\n\x0c\n\x05\x04\x15\x02\0\x01\x12\
\x03_\x18\x1d\n\x0c\n\x05\x04\x15\x02\0\x03\x12\x03_\x20!\n\n\n\x02\x04\
\x16\x12\x04b\0c\x01\n\n\n\x03\x04\x16\x01\x12\x03b\x08*\n\n\n\x02\x04\
\x17\x12\x04e\0i\x01\n\n\n\x03\x04\x17\x01\x12\x03e\x081\n\x0b\n\x04\x04\
\x17\x02\0\x12\x03f\x08%\n\x0c\n\x05\x04\x17\x02\0\x04\x12\x03f\x08\x10\
\n\x0c\n\x05\x04\x17\x02\0\x05\x12\x03f\x11\x18\n\x0c\n\x05\x04\x17\x02\
\0\x01\x12\x03f\x19\x20\n\x0c\n\x05\x04\x17\x02\0\x03\x12\x03f#$\n\x0b\n\
\x04\x04\x17\x02\x01\x12\x03g\x08&\n\x0c\n\x05\x04\x17\x02\x01\x04\x12\
\x03g\x08\x10\n\x0c\n\x05\x04\x17\x02\x01\x05\x12\x03g\x11\x18\n\x0c\n\
\x05\x04\x17\x02\x01\x01\x12\x03g\x19!\n\x0c\n\x05\x04\x17\x02\x01\x03\
\x12\x03g$%\n\x0b\n\x04\x04\x17\x02\x02\x12\x03h\x08#\n\x0c\n\x05\x04\
\x17\x02\x02\x04\x12\x03h\x08\x10\n\x0c\n\x05\x04\x17\x02\x02\x05\x12\
\x03h\x11\x16\n\x0c\n\x05\x04\x17\x02\x02\x01\x12\x03h\x17\x1e\n\x0c\n\
\x05\x04\x17\x02\x02\x03\x12\x03h!\"\n\n\n\x02\x04\x18\x12\x04k\0q\x01\n\
\n\n\x03\x04\x18\x01\x12\x03k\x08/\n\x0b\n\x04\x04\x18\x02\0\x12\x03l\
\x08%\n\x0c\n\x05\x04\x18\x02\0\x04\x12\x03l\x08\x10\n\x0c\n\x05\x04\x18\
\x02\0\x05\x12\x03l\x11\x18\n\x0c\n\x05\x04\x18\x02\0\x01\x12\x03l\x19\
\x20\n\x0c\n\x05\x04\x18\x02\0\x03\x12\x03l#$\n\x0b\n\x04\x04\x18\x02\
\x01\x12\x03m\x08*\n\x0c\n\x05\x04\x18\x02\x01\x04\x12\x03m\x08\x10\n\
\x0c\n\x05\x04\x18\x02\x01\x05\x12\x03m\x11\x18\n\x0c\n\x05\x04\x18\x02\
\x01\x01\x12\x03m\x19%\n\x0c\n\x05\x04\x18\x02\x01\x03\x12\x03m()\n\x0b\
\n\x04\x04\x18\x02\x02\x12\x03n\x08*\n\x0c\n\x05\x04\x18\x02\x02\x04\x12\
\x03n\x08\x10\n\x0c\n\x05\x04\x18\x02\x02\x05\x12\x03n\x11\x18\n\x0c\n\
\x05\x04\x18\x02\x02\x01\x12\x03n\x19%\n\x0c\n\x05\x04\x18\x02\x02\x03\
\x12\x03n()\n\x0b\n\x04\x04\x18\x02\x03\x12\x03o\x08%\n\x0c\n\x05\x04\
\x18\x02\x03\x04\x12\x03o\x08\x10\n\x0c\n\x05\x04\x18\x02\x03\x05\x12\
\x03o\x11\x17\n\x0c\n\x05\x04\x18\x02\x03\x01\x12\x03o\x18\x20\n\x0c\n\
\x05\x04\x18\x02\x03\x03\x12\x03o#$\n\x0b\n\x04\x04\x18\x02\x04\x12\x03p\
\x08-\n\x0c\n\x05\x04\x18\x02\x04\x04\x12\x03p\x08\x10\n\x0c\n\x05\x04\
\x18\x02\x04\x05\x12\x03p\x11\x16\n\x0c\n\x05\x04\x18\x02\x04\x01\x12\
\x03p\x17(\n\x0c\n\x05\x04\x18\x02\x04\x03\x12\x03p+,\n\n\n\x02\x04\x19\
\x12\x04s\0x\x01\n\n\n\x03\x04\x19\x01\x12\x03s\x08*\n\x0b\n\x04\x04\x19\
\x02\0\x12\x03t\x08,\n\x0c\n\x05\x04\x19\x02\0\x04\x12\x03t\x08\x10\n\
\x0c\n\x05\x04\x19\x02\0\x05\x12\x03t\x11\x17\n\x0c\n\x05\x04\x19\x02\0\
\x01\x12\x03t\x18'\n\x0c\n\x05\x04\x19\x02\0\x03\x12\x03t*+\n\x0b\n\x04\
\x04\x19\x02\x01\x12\x03u\x08.\n\x0c\n\x05\x04\x19\x02\x01\x04\x12\x03u\
\x08\x10\n\x0c\n\x05\x04\x19\x02\x01\x05\x12\x03u\x11\x17\n\x0c\n\x05\
\x04\x19\x02\x01\x01\x12\x03u\x18)\n\x0c\n\x05\x04\x19\x02\x01\x03\x12\
\x03u,-\n\x0b\n\x04\x04\x19\x02\x02\x12\x03v\x08\"\n\x0c\n\x05\x04\x19\
\x02\x02\x04\x12\x03v\x08\x10\n\x0c\n\x05\x04\x19\x02\x02\x05\x12\x03v\
\x11\x17\n\x0c\n\x05\x04\x19\x02\x02\x01\x12\x03v\x18\x1d\n\x0c\n\x05\
\x04\x19\x02\x02\x03\x12\x03v\x20!\n\x0b\n\x04\x04\x19\x02\x03\x12\x03w\
\x08.\n\x0c\n\x05\x04\x19\x02\x03\x04\x12\x03w\x08\x10\n\x0c\n\x05\x04\
\x19\x02\x03\x05\x12\x03w\x11\x16\n\x0c\n\x05\x04\x19\x02\x03\x01\x12\
\x03w\x17)\n\x0c\n\x05\x04\x19\x02\x03\x03\x12\x03w,-\n\n\n\x02\x04\x1a\
\x12\x04z\0|\x01\n\n\n\x03\x04\x1a\x01\x12\x03z\x08+\n\x0b\n\x04\x04\x1a\
\x02\0\x12\x03{\x08'\n\x0c\n\x05\x04\x1a\x02\0\x04\x12\x03{\x08\x10\n\
\x0c\n\x05\x04\x1a\x02\0\x05\x12\x03{\x11\x18\n\x0c\n\x05\x04\x1a\x02\0\
\x01\x12\x03{\x19\"\n\x0c\n\x05\x04\x1a\x02\0\x03\x12\x03{%&\n\x0b\n\x02\
\x04\x1b\x12\x05~\0\x83\x01\x01\n\n\n\x03\x04\x1b\x01\x12\x03~\x08/\n\
\x0b\n\x04\x04\x1b\x02\0\x12\x03\x7f\x08'\n\x0c\n\x05\x04\x1b\x02\0\x04\
\x12\x03\x7f\x08\x10\n\x0c\n\x05\x04\x1b\x02\0\x05\x12\x03\x7f\x11\x18\n\
\x0c\n\x05\x04\x1b\x02\0\x01\x12\x03\x7f\x19\"\n\x0c\n\x05\x04\x1b\x02\0\
\x03\x12\x03\x7f%&\n\x0c\n\x04\x04\x1b\x02\x01\x12\x04\x80\x01\x08$\n\r\
\n\x05\x04\x1b\x02\x01\x04\x12\x04\x80\x01\x08\x10\n\r\n\x05\x04\x1b\x02\
\x01\x05\x12\x04\x80\x01\x11\x15\n\r\n\x05\x04\x1b\x02\x01\x01\x12\x04\
\x80\x01\x16\x1f\n\r\n\x05\x04\x1b\x02\x01\x03\x12\x04\x80\x01\"#\n\x0c\
\n\x04\x04\x1b\x02\x02\x12\x04\x81\x01\x08$\n\r\n\x05\x04\x1b\x02\x02\
\x04\x12\x04\x81\x01\x08\x10\n\r\n\x05\x04\x1b\x02\x02\x05\x12\x04\x81\
\x01\x11\x15\n\r\n\x05\x04\x1b\x02\x02\x01\x12\x04\x81\x01\x16\x1f\n\r\n\
\x05\x04\x1b\x02\x02\x03\x12\x04\x81\x01\"#\n\x0c\n\x04\x04\x1b\x02\x03\
\x12\x04\x82\x01\x08$\n\r\n\x05\x04\x1b\x02\x03\x04\x12\x04\x82\x01\x08\
\x10\n\r\n\x05\x04\x1b\x02\x03\x05\x12\x04\x82\x01\x11\x15\n\r\n\x05\x04\
\x1b\x02\x03\x01\x12\x04\x82\x01\x16\x1f\n\r\n\x05\x04\x1b\x02\x03\x03\
\x12\x04\x82\x01\"#\n\x0c\n\x02\x04\x1c\x12\x06\x85\x01\0\x98\x01\x01\n\
\x0b\n\x03\x04\x1c\x01\x12\x04\x85\x01\x08(\n\x0e\n\x04\x04\x1c\x03\0\
\x12\x06\x86\x01\x08\x89\x01\t\n\r\n\x05\x04\x1c\x03\0\x01\x12\x04\x86\
\x01\x10\x1f\n\x0e\n\x06\x04\x1c\x03\0\x02\0\x12\x04\x87\x01\x10+\n\x0f\
\n\x07\x04\x1c\x03\0\x02\0\x04\x12\x04\x87\x01\x10\x18\n\x0f\n\x07\x04\
\x1c\x03\0\x02\0\x05\x12\x04\x87\x01\x19\x1f\n\x0f\n\x07\x04\x1c\x03\0\
\x02\0\x01\x12\x04\x87\x01\x20&\n\x0f\n\x07\x04\x1c\x03\0\x02\0\x03\x12\
\x04\x87\x01)*\n\x0e\n\x06\x04\x1c\x03\0\x02\x01\x12\x04\x88\x01\x10-\n\
\x0f\n\x07\x04\x1c\x03\0\x02\x01\x04\x12\x04\x88\x01\x10\x18\n\x0f\n\x07\
\x04\x1c\x03\0\x02\x01\x05\x12\x04\x88\x01\x19\x20\n\x0f\n\x07\x04\x1c\
\x03\0\x02\x01\x01\x12\x04\x88\x01!(\n\x0f\n\x07\x04\x1c\x03\0\x02\x01\
\x03\x12\x04\x88\x01+,\n\x0e\n\x04\x04\x1c\x03\x01\x12\x06\x8b\x01\x08\
\x91\x01\t\n\r\n\x05\x04\x1c\x03\x01\x01\x12\x04\x8b\x01\x10\x1c\n\x0e\n\
\x06\x04\x1c\x03\x01\x02\0\x12\x04\x8c\x01\x102\n\x0f\n\x07\x04\x1c\x03\
\x01\x02\0\x04\x12\x04\x8c\x01\x10\x18\n\x0f\n\x07\x04\x1c\x03\x01\x02\0\
\x05\x12\x04\x8c\x01\x19\x20\n\x0f\n\x07\x04\x1c\x03\x01\x02\0\x01\x12\
\x04\x8c\x01!-\n\x0f\n\x07\x04\x1c\x03\x01\x02\0\x03\x12\x04\x8c\x0101\n\
\x0e\n\x06\x04\x1c\x03\x01\x02\x01\x12\x04\x8d\x01\x103\n\x0f\n\x07\x04\
\x1c\x03\x01\x02\x01\x04\x12\x04\x8d\x01\x10\x18\n\x0f\n\x07\x04\x1c\x03\
\x01\x02\x01\x05\x12\x04\x8d\x01\x19\x20\n\x0f\n\x07\x04\x1c\x03\x01\x02\
\x01\x01\x12\x04\x8d\x01!.\n\x0f\n\x07\x04\x1c\x03\x01\x02\x01\x03\x12\
\x04\x8d\x0112\n\x0e\n\x06\x04\x1c\x03\x01\x02\x02\x12\x04\x8e\x01\x10-\
\n\x0f\n\x07\x04\x1c\x03\x01\x02\x02\x04\x12\x04\x8e\x01\x10\x18\n\x0f\n\
\x07\x04\x1c\x03\x01\x02\x02\x05\x12\x04\x8e\x01\x19\x20\n\x0f\n\x07\x04\
\x1c\x03\x01\x02\x02\x01\x12\x04\x8e\x01!(\n\x0f\n\x07\x04\x1c\x03\x01\
\x02\x02\x03\x12\x04\x8e\x01+,\n\x0e\n\x06\x04\x1c\x03\x01\x02\x03\x12\
\x04\x8f\x01\x101\n\x0f\n\x07\x04\x1c\x03\x01\x02\x03\x04\x12\x04\x8f\
\x01\x10\x18\n\x0f\n\x07\x04\x1c\x03\x01\x02\x03\x05\x12\x04\x8f\x01\x19\
\x20\n\x0f\n\x07\x04\x1c\x03\x01\x02\x03\x01\x12\x04\x8f\x01!,\n\x0f\n\
\x07\x04\x1c\x03\x01\x02\x03\x03\x12\x04\x8f\x01/0\n\x0e\n\x06\x04\x1c\
\x03\x01\x02\x04\x12\x04\x90\x01\x10`\n\x0f\n\x07\x04\x1c\x03\x01\x02\
\x04\x04\x12\x04\x90\x01\x10\x18\n\x0f\n\x07\x04\x1c\x03\x01\x02\x04\x06\
\x12\x04\x90\x01\x19J\n\x0f\n\x07\x04\x1c\x03\x01\x02\x04\x01\x12\x04\
\x90\x01K[\n\x0f\n\x07\x04\x1c\x03\x01\x02\x04\x03\x12\x04\x90\x01^_\n\
\x0c\n\x04\x04\x1c\x02\0\x12\x04\x93\x01\x08%\n\r\n\x05\x04\x1c\x02\0\
\x04\x12\x04\x93\x01\x08\x10\n\r\n\x05\x04\x1c\x02\0\x05\x12\x04\x93\x01\
\x11\x18\n\r\n\x05\x04\x1c\x02\0\x01\x12\x04\x93\x01\x19\x20\n\r\n\x05\
\x04\x1c\x02\0\x03\x12\x04\x93\x01#$\n\x0e\n\x04\x04\x1c\x08\0\x12\x06\
\x95\x01\x08\x97\x01\t\n\r\n\x05\x04\x1c\x08\0\x01\x12\x04\x95\x01\x0e\
\x15\n\x0c\n\x04\x04\x1c\x02\x01\x12\x04\x96\x01\x10Q\n\r\n\x05\x04\x1c\
\x02\x01\x06\x12\x04\x96\x01\x10>\n\r\n\x05\x04\x1c\x02\x01\x01\x12\x04\
\x96\x01?L\n\r\n\x05\x04\x1c\x02\x01\x03\x12\x04\x96\x01OP\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}